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

//! Report generation for cargo-fa.

use crate::cli::{OutputFormat, Severity};
use crate::diagnostics::Diagnostic;
use crate::output;

/// Analysis report containing all diagnostics.
#[derive(Debug, Default)]
pub struct Report {
    diagnostics: Vec<Diagnostic>,
    files_analyzed: usize,
}

impl Report {
    pub fn new() -> Self {
        Self::default()
    }
    
    /// Add diagnostics from a file analysis
    pub fn add_diagnostics(&mut self, diags: Vec<Diagnostic>) {
        self.diagnostics.extend(diags);
        self.files_analyzed += 1;
    }
    
    /// Check if there are any errors
    pub fn has_errors(&self) -> bool {
        self.diagnostics.iter().any(|d| d.severity == Severity::Error)
    }
    
    /// Check if there are any warnings
    pub fn has_warnings(&self) -> bool {
        self.diagnostics.iter().any(|d| d.severity == Severity::Warning)
    }
    
    /// Count errors
    pub fn error_count(&self) -> usize {
        self.diagnostics.iter().filter(|d| d.severity == Severity::Error).count()
    }
    
    /// Count warnings
    pub fn warning_count(&self) -> usize {
        self.diagnostics.iter().filter(|d| d.severity == Severity::Warning).count()
    }
    
    /// Count hints
    pub fn hint_count(&self) -> usize {
        self.diagnostics.iter().filter(|d| d.severity == Severity::Hint).count()
    }
    
    /// Print the report
    pub fn print(&self) {
        self.print_with_format(&OutputFormat::Terminal);
    }
    
    /// Print with specific format
    pub fn print_with_format(&self, format: &OutputFormat) {
        match format {
            OutputFormat::Sarif => {
                println!("{}", output::generate_sarif(&self.diagnostics));
            }
            OutputFormat::Junit => {
                println!("{}", output::generate_junit(&self.diagnostics));
            }
            OutputFormat::Checkstyle => {
                println!("{}", output::generate_checkstyle(&self.diagnostics));
            }
            OutputFormat::Json => {
                for diag in &self.diagnostics {
                    output::print_diagnostic(diag, format);
                }
                // Print summary as JSON
                println!("{}", serde_json::json!({
                    "summary": {
                        "files_analyzed": self.files_analyzed,
                        "errors": self.error_count(),
                        "warnings": self.warning_count(),
                        "hints": self.hint_count()
                    }
                }));
            }
            OutputFormat::Compact => {
                for diag in &self.diagnostics {
                    output::print_diagnostic(diag, format);
                }
            }
            OutputFormat::Terminal => {
                // Sort by severity (errors first)
                let mut sorted = self.diagnostics.clone();
                sorted.sort_by(|a, b| {
                    let severity_order = |s: &Severity| match s {
                        Severity::Error => 0,
                        Severity::Warning => 1,
                        Severity::Hint => 2,
                    };
                    severity_order(&a.severity).cmp(&severity_order(&b.severity))
                });
                
                for diag in &sorted {
                    output::print_diagnostic(diag, format);
                }
                
                println!();
                output::print_summary(
                    self.error_count(),
                    self.warning_count(),
                    self.hint_count()
                );
                println!("Analyzed {} files", self.files_analyzed);
            }
        }
    }
    
    /// Get all diagnostics
    pub fn diagnostics(&self) -> &[Diagnostic] {
        &self.diagnostics
    }
    
    /// Filter diagnostics by minimum severity
    pub fn filter_by_severity(&mut self, min: Severity) {
        self.diagnostics.retain(|d| d.severity >= min);
    }
}