cargo-fa 0.11.1

Static analysis tool for framealloc - detect memory intent violations before runtime
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

//! Architecture lint pass (FA8xx).
//!
//! Detects:
//! - FA801: Tag mismatch (wrong tag for module)
//! - FA802: Unknown tag
//! - FA803: Cross-module allocation

use crate::config::Config;
use crate::diagnostics::{self, Diagnostic, DiagnosticBuilder};
use crate::cli::Severity;
use crate::lints::extract_tag_from_with_tag;
use crate::parser::span_to_location;
use std::path::Path;
use syn::visit::Visit;
use syn::spanned::Spanned;

pub fn check(ast: &syn::File, path: &Path, config: &Config) -> Vec<Diagnostic> {
    let mut visitor = ArchitectureVisitor::new(path, config);
    visitor.visit_file(ast);
    visitor.diagnostics
}

struct ArchitectureVisitor<'a> {
    path: &'a Path,
    config: &'a Config,
    diagnostics: Vec<Diagnostic>,
    
    // Current module context
    current_module: Option<String>,
}

impl<'a> ArchitectureVisitor<'a> {
    fn new(path: &'a Path, config: &'a Config) -> Self {
        // Infer module from path
        let current_module = path
            .file_stem()
            .and_then(|s| s.to_str())
            .map(|s| s.to_string());
        
        Self {
            path,
            config,
            diagnostics: Vec::new(),
            current_module,
        }
    }
    
    fn check_tag(&mut self, tag: &str, span: proc_macro2::Span) {
        // FA802: Unknown tag
        if self.config.tags.warn_unknown_tags 
            && !self.config.tags.known_tags.contains(&tag.to_string())
            && self.config.is_lint_enabled("FA802")
        {
            self.diagnostics.push(diagnostics::fa802(
                span_to_location(span, self.path),
                tag,
            ));
        }
        
        // FA801: Tag mismatch
        if let Some(ref module) = self.current_module {
            if let Some(expected_tags) = self.config.tags.module_tags.get(module) {
                if !expected_tags.contains(&tag.to_string()) 
                    && self.config.is_lint_enabled("FA801")
                {
                    self.diagnostics.push(diagnostics::fa801(
                        span_to_location(span, self.path),
                        &expected_tags.join(", "),
                        tag,
                        module,
                    ));
                }
            }
        }
    }
}

impl<'a> Visit<'a> for ArchitectureVisitor<'a> {
    fn visit_item_mod(&mut self, module: &'a syn::ItemMod) {
        let prev_module = self.current_module.take();
        self.current_module = Some(module.ident.to_string());
        
        syn::visit::visit_item_mod(self, module);
        
        self.current_module = prev_module;
    }
    
    fn visit_expr(&mut self, expr: &'a syn::Expr) {
        // Check with_tag calls
        if let syn::Expr::MethodCall(call) = expr {
            if let Some(tag) = extract_tag_from_with_tag(call) {
                self.check_tag(&tag, call.span());
            }
        }
        
        syn::visit::visit_expr(self, expr);
    }
}