dictator-rust 0.25.1

Rust language decree for Dictator structural linter
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

//! Cargo.toml manifest linting.

use dictator_decree_abi::{Diagnostic, Diagnostics, Span};

use crate::RustConfig;

/// Lint Cargo.toml for edition and rust-version compliance
#[must_use]
pub fn lint_cargo_toml(source: &str, config: &RustConfig) -> Diagnostics {
    let mut diags = Diagnostics::new();

    if let Some(ref min_edition) = config.min_edition {
        check_cargo_edition(source, min_edition, &mut diags);
    }

    if let Some(ref min_rust_version) = config.min_rust_version {
        check_rust_version(source, min_rust_version, &mut diags);
    }

    diags
}

/// Check Cargo.toml edition against minimum required
fn check_cargo_edition(source: &str, min_edition: &str, diags: &mut Diagnostics) {
    // Simple line-based parsing to find edition
    let mut found_edition: Option<(String, usize, usize)> = None;

    for (line_idx, line) in source.lines().enumerate() {
        let trimmed = line.trim();
        // Skip workspace inheritance: edition.workspace = true
        if trimmed.starts_with("edition.workspace") {
            return; // Can't validate without parsing workspace Cargo.toml
        }
        if trimmed.starts_with("edition") && !trimmed.contains(".workspace") {
            // Parse: edition = "2021" or edition="2021"
            if let Some(eq_pos) = trimmed.find('=') {
                let value_part = trimmed[eq_pos + 1..].trim();
                let edition = value_part.trim_matches('"').trim_matches('\'').trim();
                let line_start: usize = source.lines().take(line_idx).map(|l| l.len() + 1).sum();
                found_edition = Some((edition.to_string(), line_start, line_start + line.len()));
                break;
            }
        }
    }

    match found_edition {
        Some((edition, start, end)) => {
            if edition_ord(&edition) < edition_ord(min_edition) {
                diags.push(Diagnostic {
                    rule: "rust/fossil-edition".to_string(),
                    message: format!(
                        "edition {edition} is fossilized, the Dictator demands {min_edition}"
                    ),
                    enforced: true,
                    span: Span::new(start, end),
                });
            }
        }
        None => {
            diags.push(Diagnostic {
                rule: "rust/missing-edition".to_string(),
                message: format!("no edition declared, the Dictator demands {min_edition}"),
                enforced: false,
                span: Span::new(0, source.len().min(50)),
            });
        }
    }
}

/// Convert edition string to comparable ordinal
fn edition_ord(edition: &str) -> u32 {
    match edition {
        "2015" => 1,
        "2018" => 2,
        "2021" => 3,
        "2024" => 4,
        _ => 0,
    }
}

/// Check Cargo.toml rust-version against minimum required
fn check_rust_version(source: &str, min_version: &str, diags: &mut Diagnostics) {
    let mut found_version: Option<(String, usize, usize)> = None;

    for (line_idx, line) in source.lines().enumerate() {
        let trimmed = line.trim();
        // Skip workspace inheritance: rust-version.workspace = true
        if trimmed.starts_with("rust-version.workspace") {
            return; // Can't validate without parsing workspace Cargo.toml
        }
        if trimmed.starts_with("rust-version")
            && !trimmed.contains(".workspace")
            && let Some(eq_pos) = trimmed.find('=')
        {
            let value_part = trimmed[eq_pos + 1..].trim();
            let version = value_part.trim_matches('"').trim_matches('\'').trim();
            let line_start: usize = source.lines().take(line_idx).map(|l| l.len() + 1).sum();
            found_version = Some((version.to_string(), line_start, line_start + line.len()));
            break;
        }
    }

    match found_version {
        Some((version, start, end)) => {
            if version_cmp(&version, min_version) == std::cmp::Ordering::Less {
                diags.push(Diagnostic {
                    rule: "rust/fossil-rust-version".to_string(),
                    message: format!(
                        "rust-version {version} is prehistoric, the Dictator demands {min_version}+"
                    ),
                    enforced: true,
                    span: Span::new(start, end),
                });
            }
        }
        None => {
            diags.push(Diagnostic {
                rule: "rust/missing-rust-version".to_string(),
                message: format!("no rust-version declared, the Dictator demands {min_version}+"),
                enforced: false,
                span: Span::new(0, source.len().min(50)),
            });
        }
    }
}

/// Compare semver-like versions (1.70 vs 1.83, 1.70.0 vs 1.70.1)
fn version_cmp(a: &str, b: &str) -> std::cmp::Ordering {
    let parse = |v: &str| -> Vec<u32> { v.split('.').filter_map(|p| p.parse().ok()).collect() };
    let a_parts = parse(a);
    let b_parts = parse(b);

    for i in 0..3 {
        let a_val = a_parts.get(i).copied().unwrap_or(0);
        let b_val = b_parts.get(i).copied().unwrap_or(0);
        match a_val.cmp(&b_val) {
            std::cmp::Ordering::Equal => {}
            other => return other,
        }
    }
    std::cmp::Ordering::Equal
}

#[cfg(test)]
mod tests;