bashrs 6.66.0

Rust-to-Shell transpiler for deterministic bootstrap scripts
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

// SC2299: Parameter expansion only allows literals here
use crate::linter::{Diagnostic, LintResult, Severity, Span};
use regex::Regex;

// Match ${var:offset} or ${var:offset:length} with variable in offset/length
// The character after : determines if it's substring (digit/var) or POSIX modifier (-+=?)
// ${var:-default}, ${var:+alt}, ${var:=val}, ${var:?err} are valid POSIX - don't flag
// ${var:$offset}, ${var:0:$len} are invalid - flag these
// Uses alternation: either $ directly after : OR non-modifier char followed by $ somewhere
static PARAM_WITH_VAR: std::sync::LazyLock<Regex> = std::sync::LazyLock::new(|| {
    Regex::new(r"\$\{[a-zA-Z_][a-zA-Z0-9_]*:(\$|[^-+=?}][^}]*\$)").unwrap()
});

pub fn check(source: &str) -> LintResult {
    let mut result = LintResult::new();
    for (line_num, line) in source.lines().enumerate() {
        let line_num = line_num + 1;
        if line.trim_start().starts_with('#') {
            continue;
        }

        if PARAM_WITH_VAR.is_match(line) {
            let diagnostic = Diagnostic::new(
                "SC2299",
                Severity::Error,
                "Parameter expansions can't use variables in offset/length".to_string(),
                Span::new(line_num, 1, line_num, line.len() + 1),
            );
            result.add(diagnostic);
        }
    }
    result
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_sc2299_variable_in_offset() {
        let code = "${var:$start:5}";
        assert_eq!(check(code).diagnostics.len(), 1);
    }

    #[test]
    fn test_sc2299_literal_ok() {
        let code = "${var:0:5}";
        assert_eq!(check(code).diagnostics.len(), 0);
    }

    #[test]
    fn test_sc2299_arithmetic_ok() {
        let code = "${var:0}";
        assert_eq!(check(code).diagnostics.len(), 0);
    }

    #[test]
    fn test_sc2299_comment() {
        let code = "# ${var:$n:5}";
        assert_eq!(check(code).diagnostics.len(), 0);
    }

    #[test]
    fn test_sc2299_empty() {
        assert_eq!(check("").diagnostics.len(), 0);
    }

    #[test]
    fn test_sc2299_normal() {
        assert_eq!(check("echo test").diagnostics.len(), 0);
    }

    #[test]
    fn test_sc2299_default_ok() {
        let code = "${var:-default}";
        assert_eq!(check(code).diagnostics.len(), 0);
    }

    #[test]
    fn test_sc2299_simple_var_ok() {
        let code = "$var";
        assert_eq!(check(code).diagnostics.len(), 0);
    }

    #[test]
    fn test_sc2299_length_ok() {
        let code = "${#var}";
        assert_eq!(check(code).diagnostics.len(), 0);
    }

    #[test]
    fn test_sc2299_variable_in_length() {
        let code = "${var:0:$len}";
        assert_eq!(check(code).diagnostics.len(), 1);
    }

    // POSIX parameter modifiers with variables should NOT trigger SC2299
    #[test]
    fn test_sc2299_default_with_var_ok() {
        // ${var:-$default} is valid POSIX - use default value
        let code = "${var:-$default}";
        assert_eq!(check(code).diagnostics.len(), 0);
    }

    #[test]
    fn test_sc2299_alternate_with_var_ok() {
        // ${var:+$alternate} is valid POSIX - use alternate value
        let code = "${var:+$alternate}";
        assert_eq!(check(code).diagnostics.len(), 0);
    }

    #[test]
    fn test_sc2299_assign_with_var_ok() {
        // ${var:=$default} is valid POSIX - assign default
        let code = "${var:=$default}";
        assert_eq!(check(code).diagnostics.len(), 0);
    }

    #[test]
    fn test_sc2299_error_with_var_ok() {
        // ${var:?$message} is valid POSIX - error if unset
        let code = "${var:?$message}";
        assert_eq!(check(code).diagnostics.len(), 0);
    }

    #[test]
    fn test_sc2299_makefile_pattern_ok() {
        // Real-world Makefile pattern from bashrs
        let code = "${PROPTEST_THREADS:-$(nproc)}";
        assert_eq!(check(code).diagnostics.len(), 0);
    }

    #[test]
    fn test_sc2299_complex_default_ok() {
        // Complex default with command substitution
        let code = "${VAR:-$(echo $OTHER)}";
        assert_eq!(check(code).diagnostics.len(), 0);
    }
}