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

// SC2069: To redirect stdout to stderr, use >&2 or 1>&2, not 2>&1
//
// The syntax 2>&1 redirects stderr TO stdout, not the other way around.
// To redirect stdout TO stderr, use >&2 or 1>&2.
//
// Examples:
// Bad (if intent is stdout → stderr):
//   echo "Error" 2>&1           // Redirects stderr to stdout (wrong direction)
//
// Good:
//   echo "Error" >&2            // Redirects stdout to stderr
//   echo "Error" 1>&2           // Explicit: stdout to stderr
//
// Impact: Messages go to wrong stream, breaking error handling

use crate::linter::{Diagnostic, LintResult, Severity, Span};
use regex::Regex;

static ECHO_TO_STDERR_WRONG: std::sync::LazyLock<Regex> = std::sync::LazyLock::new(|| {
    // Match: echo ... 2>&1 (trying to send to stderr but using wrong syntax)
    Regex::new(r"\becho\b.*\b2>&1\b").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;
        }

        // Look for echo with 2>&1 (likely wrong - should be >&2)
        if let Some(mat) = ECHO_TO_STDERR_WRONG.find(line) {
            let start_col = mat.start() + 1;
            let end_col = mat.end() + 1;

            let diagnostic = Diagnostic::new(
                "SC2069",
                Severity::Info,
                "To redirect stdout to stderr, use >&2, not 2>&1 (which redirects stderr to stdout)"
                    .to_string(),
                Span::new(line_num, start_col, line_num, end_col),
            );

            result.add(diagnostic);
        }
    }

    result
}

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

    #[test]
    fn test_sc2069_echo_wrong_redirect() {
        let code = r#"echo "Error message" 2>&1"#;
        let result = check(code);
        assert_eq!(result.diagnostics.len(), 1);
    }

    #[test]
    fn test_sc2069_echo_correct_ok() {
        let code = r#"echo "Error message" >&2"#;
        let result = check(code);
        // Correct redirection
        assert_eq!(result.diagnostics.len(), 0);
    }

    #[test]
    fn test_sc2069_echo_explicit_ok() {
        let code = r#"echo "Error message" 1>&2"#;
        let result = check(code);
        // Explicit stdout to stderr
        assert_eq!(result.diagnostics.len(), 0);
    }

    #[test]
    fn test_sc2069_pipe_ok() {
        let code = r#"command 2>&1 | grep error"#;
        let result = check(code);
        // Combining streams for pipe is valid
        assert_eq!(result.diagnostics.len(), 0);
    }

    #[test]
    fn test_sc2069_printf_wrong() {
        let code = r#"printf "Error\n" 2>&1"#;
        let result = check(code);
        // printf also affected
        assert_eq!(result.diagnostics.len(), 0); // Only checking echo for now
    }

    #[test]
    fn test_sc2069_comment_ok() {
        let code = r#"# echo "Error" 2>&1"#;
        let result = check(code);
        assert_eq!(result.diagnostics.len(), 0);
    }

    #[test]
    fn test_sc2069_multiple() {
        let code = r#"echo "Err1" 2>&1; echo "Err2" 2>&1"#;
        let result = check(code);
        assert_eq!(result.diagnostics.len(), 1); // Matches the line
    }

    #[test]
    fn test_sc2069_stderr_to_file() {
        let code = r#"echo "Output" 2>error.log"#;
        let result = check(code);
        // Redirecting stderr to file, not related to 2>&1
        assert_eq!(result.diagnostics.len(), 0);
    }

    #[test]
    fn test_sc2069_background() {
        let code = r#"echo "Message" 2>&1 &"#;
        let result = check(code);
        assert_eq!(result.diagnostics.len(), 1);
    }

    #[test]
    fn test_sc2069_with_variable() {
        let code = r#"echo "$error_msg" 2>&1"#;
        let result = check(code);
        assert_eq!(result.diagnostics.len(), 1);
    }
}