sqc 0.4.13

Software Code Quality - CERT C compliance checker
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
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169

//! MSC07-C: Detect and remove code that is never executed
//!
//! Detects unreachable code patterns:
//! 1. Statements after unconditional return in the same block
//! 2. Statements after noreturn function calls (exit, abort, _Exit, longjmp, etc.)
//! 3. Statements after unconditional break/continue/goto in the same block

use super::super::{CertRule, RuleViolation};
use crate::manifest::{RuleCategory, Severity};
use crate::utility::cert_c::ast_utils::get_node_text;
use tree_sitter::Node;

pub struct Msc07C;

impl Msc07C {
    pub fn new() -> Self {
        Self
    }

    fn walk_node(&self, node: &Node, source: &str, violations: &mut Vec<RuleViolation>) {
        if node.kind() == "compound_statement" {
            self.check_unreachable_after_terminal(node, source, violations);
        }

        for i in 0..node.child_count() {
            if let Some(child) = node.child(i) {
                self.walk_node(&child, source, violations);
            }
        }
    }

    /// Scan children of a compound_statement. When we hit a terminal statement
    /// (return, break, continue, goto, or noreturn call), flag all subsequent
    /// non-trivial siblings as unreachable.
    fn check_unreachable_after_terminal(
        &self,
        compound: &Node,
        source: &str,
        violations: &mut Vec<RuleViolation>,
    ) {
        let mut seen_terminal: Option<(&str, usize)> = None; // (kind_label, line)

        for i in 0..compound.child_count() {
            let child = match compound.child(i) {
                Some(c) => c,
                None => continue,
            };

            // Skip braces, comments, and preprocessor directives
            if is_skippable(&child) {
                continue;
            }

            if let Some((terminal_kind, _)) = seen_terminal {
                // This statement is unreachable
                violations.push(RuleViolation {
                    rule_id: self.rule_id().to_string(),
                    severity: self.severity(),
                    message: format!("Unreachable code after unconditional '{}'.", terminal_kind,),
                    file_path: String::new(),
                    line: child.start_position().row + 1,
                    column: child.start_position().column + 1,
                    suggestion: Some(
                        "Remove the unreachable code or restructure the control flow".to_string(),
                    ),
                    ..Default::default()
                });
                // Only report the first unreachable statement per terminal
                break;
            }

            // Check if this child is a terminal statement
            if let Some(label) = terminal_label(&child, source) {
                seen_terminal = Some((label, child.start_position().row + 1));
            }
        }
    }
}

/// Returns a human-readable label if the node is a terminal (control never
/// passes to the next sibling).
fn terminal_label(node: &Node, source: &str) -> Option<&'static str> {
    match node.kind() {
        "return_statement" => Some("return"),
        "break_statement" => Some("break"),
        "continue_statement" => Some("continue"),
        "goto_statement" => Some("goto"),
        "expression_statement" => {
            if is_noreturn_call(node, source) {
                Some("noreturn function call")
            } else {
                None
            }
        }
        _ => None,
    }
}

/// Check if an expression_statement contains a call to a known noreturn function.
fn is_noreturn_call(node: &Node, source: &str) -> bool {
    let expr = match node.child(0) {
        Some(e) => e,
        None => return false,
    };
    if expr.kind() != "call_expression" {
        return false;
    }
    let func = match expr.child_by_field_name("function") {
        Some(f) => f,
        None => return false,
    };
    let name = get_node_text(&func, source);
    matches!(
        name.trim(),
        "exit"
            | "_exit"
            | "_Exit"
            | "abort"
            | "longjmp"
            | "quick_exit"
            | "thrd_exit"
            | "ExitProcess"
            | "ExitThread"
    )
}

/// Nodes that should be skipped when scanning for unreachable code.
fn is_skippable(node: &Node) -> bool {
    matches!(
        node.kind(),
        "{" | "}"
            | "comment"
            | "preproc_ifdef"
            | "preproc_if"
            | "preproc_else"
            | "preproc_elif"
            | "preproc_def"
            | "preproc_include"
            | "preproc_call"
    )
}

impl CertRule for Msc07C {
    fn rule_id(&self) -> &'static str {
        "MSC07-C"
    }

    fn description(&self) -> &'static str {
        "Detect and remove code that is never executed"
    }

    fn severity(&self) -> Severity {
        Severity::Low
    }

    fn category(&self) -> RuleCategory {
        RuleCategory::Recommendation
    }

    fn cert_id(&self) -> &'static str {
        "MSC07-C"
    }

    fn check(&self, node: &Node, source: &str) -> Vec<RuleViolation> {
        let mut violations = Vec::new();
        self.walk_node(node, source, &mut violations);
        violations
    }
}