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

// DCL16-C: Use "L," not "l," to indicate a long value
//
// This rule detects integer literals that use lowercase 'l' suffix instead
// of uppercase 'L', which can be confused with the digit '1'.
//
// Detection strategy:
// 1. Find all number literals in the code
// 2. Check if they end with lowercase 'l' or 'll'
// 3. Flag violations and suggest using uppercase 'L' or 'LL'

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 Dcl16C;

impl Dcl16C {
    #[allow(dead_code)]
    pub fn new() -> Self {
        Dcl16C
    }

    /// Check a node and all its descendants for violations
    fn check_node<'a>(
        &self,
        node: &Node<'a>,
        source: &'a str,
        violations: &mut Vec<RuleViolation>,
    ) {
        // Look for number literals
        if node.kind() == "number_literal" {
            let text = get_node_text(node, source);

            // Check for lowercase 'l' or 'll' suffix
            if self.has_lowercase_long_suffix(text) {
                let suggested = self.fix_lowercase_suffix(text);

                violations.push(RuleViolation {
                    rule_id: self.rule_id().to_string(),
                    line: node.start_position().row + 1,
                    column: node.start_position().column + 1,
                    message: format!(
                        "Integer literal '{}' uses lowercase 'l' suffix which can be confused with digit '1'",
                        text
                    ),
                    severity: self.severity(),
                    file_path: String::new(),
                    suggestion: Some(format!(
                        "Use uppercase 'L': {}",
                        suggested
                    )),
                    requires_manual_review: None,
                });
            }
        }

        // Recurse into children
        for i in 0..node.child_count() {
            if let Some(child) = node.child(i) {
                self.check_node(&child, source, violations);
            }
        }
    }

    /// Check if number has lowercase 'l' or 'll' suffix
    fn has_lowercase_long_suffix(&self, text: &str) -> bool {
        // Remove any unsigned suffix first
        let text = text.trim_end_matches('u').trim_end_matches('U');

        // Check for lowercase 'l' or 'll' at the end
        text.ends_with("ll") || (text.ends_with('l') && !text.ends_with('L'))
    }

    /// Fix lowercase suffix to uppercase
    fn fix_lowercase_suffix(&self, text: &str) -> String {
        let mut result = text.to_string();

        // Handle unsigned suffix
        let has_u_suffix = result.ends_with('u') || result.ends_with('U');
        let u_suffix = if has_u_suffix {
            let suffix = result.chars().last().unwrap();
            result.pop();
            Some(suffix)
        } else {
            None
        };

        // Replace lowercase 'l' with 'L'
        if result.ends_with("ll") {
            result = result[..result.len() - 2].to_string() + "LL";
        } else if result.ends_with('l') {
            result = result[..result.len() - 1].to_string() + "L";
        }

        // Restore unsigned suffix
        if let Some(u) = u_suffix {
            result.push(u);
        }

        result
    }
}

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

    fn description(&self) -> &'static str {
        "Use \"L,\" not \"l,\" to indicate a long value"
    }

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

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

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

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