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

//! Threading lint pass (FA2xx).
//!
//! Detects:
//! - FA201: Cross-thread frame access
//! - FA202: Missing thread-local initialization

use crate::config::Config;
use crate::diagnostics::{Diagnostic, DiagnosticBuilder};
use crate::cli::Severity;
use crate::lints::{is_framealloc_call, FrameallocCall};
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 = ThreadingVisitor::new(path, config);
    visitor.visit_file(ast);
    visitor.diagnostics
}

struct ThreadingVisitor<'a> {
    path: &'a Path,
    config: &'a Config,
    diagnostics: Vec<Diagnostic>,
    
    // Context tracking
    in_thread_spawn: bool,
    in_rayon_scope: bool,
}

impl<'a> ThreadingVisitor<'a> {
    fn new(path: &'a Path, config: &'a Config) -> Self {
        Self {
            path,
            config,
            diagnostics: Vec::new(),
            in_thread_spawn: false,
            in_rayon_scope: false,
        }
    }
    
    fn is_thread_context(&self) -> bool {
        self.in_thread_spawn || self.in_rayon_scope
    }
}

impl<'a> Visit<'a> for ThreadingVisitor<'a> {
    fn visit_expr(&mut self, expr: &'a syn::Expr) {
        match expr {
            syn::Expr::MethodCall(call) => {
                let method_name = call.method.to_string();
                
                // Detect thread::spawn patterns
                if method_name == "spawn" {
                    let was_in_thread = self.in_thread_spawn;
                    self.in_thread_spawn = true;
                    
                    syn::visit::visit_expr_method_call(self, call);
                    
                    self.in_thread_spawn = was_in_thread;
                    return;
                }
                
                // Detect rayon patterns
                if method_name == "par_iter" || method_name == "par_bridge" 
                    || method_name == "into_par_iter" 
                {
                    let was_in_rayon = self.in_rayon_scope;
                    self.in_rayon_scope = true;
                    
                    syn::visit::visit_expr_method_call(self, call);
                    
                    self.in_rayon_scope = was_in_rayon;
                    return;
                }
                
                // Check for frame allocations in thread context
                if let Some(fa_call) = is_framealloc_call(expr) {
                    if fa_call.is_frame_allocation() && self.is_thread_context() {
                        if self.config.is_lint_enabled("FA201") {
                            self.diagnostics.push(
                                DiagnosticBuilder::new("FA201")
                                    .severity(Severity::Error)
                                    .message("frame allocation in spawned thread context")
                                    .location(span_to_location(call.span(), self.path))
                                    .note("frame allocations are thread-local and cannot be shared")
                                    .note("the spawned thread will have its own frame arena")
                                    .suggestion("use pool_box() or heap_box() for data shared between threads")
                                    .build()
                            );
                        }
                    }
                }
            }
            
            syn::Expr::Call(call) => {
                // Check for std::thread::spawn
                if let syn::Expr::Path(path) = call.func.as_ref() {
                    let path_str = path_to_string(&path.path);
                    
                    if path_str.ends_with("thread::spawn") || path_str == "spawn" {
                        let was_in_thread = self.in_thread_spawn;
                        self.in_thread_spawn = true;
                        
                        syn::visit::visit_expr_call(self, call);
                        
                        self.in_thread_spawn = was_in_thread;
                        return;
                    }
                    
                    // Check for rayon::scope
                    if path_str.ends_with("rayon::scope") || path_str == "scope" {
                        let was_in_rayon = self.in_rayon_scope;
                        self.in_rayon_scope = true;
                        
                        syn::visit::visit_expr_call(self, call);
                        
                        self.in_rayon_scope = was_in_rayon;
                        return;
                    }
                }
            }
            
            _ => {}
        }
        
        syn::visit::visit_expr(self, expr);
    }
}

fn path_to_string(path: &syn::Path) -> String {
    path.segments
        .iter()
        .map(|s| s.ident.to_string())
        .collect::<Vec<_>>()
        .join("::")
}