pmat 3.11.0

PMAT - Zero-config AI context generation and code quality toolkit (CLI, MCP, HTTP)
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

// DeadCodeDefectAnalyzer: constructors, trait impl, and helper methods for
// dead/unreachable code detection.

impl DeadCodeDefectAnalyzer {
    #[must_use]
    pub fn new() -> Self {
        Self {}
    }
}

impl Default for DeadCodeDefectAnalyzer {
    fn default() -> Self {
        Self::new()
    }
}

#[async_trait]
impl DefectAnalyzer for DeadCodeDefectAnalyzer {
    type Config = DeadCodeConfig;

    async fn analyze(&self, project_path: &Path, config: Self::Config) -> Result<Vec<Defect>> {
        let mut defects = Vec::new();

        // Build dependency graph
        let project = crate::services::project_analyzer::Project::new(project_path)?;
        let dag = project.build_dependency_graph().await?;
        let mut analyzer = crate::services::dead_code_analyzer::DeadCodeAnalyzer::new(1000);
        let report = analyzer.analyze_dependency_graph(&dag);

        // Convert dead functions
        for (index, item) in report.dead_functions.iter().enumerate() {
            if f64::from(item.confidence) >= config.min_confidence {
                defects.push(self.dead_code_item_to_defect(item, "DEAD-FN", index + 1));
            }
        }

        // Convert dead classes
        for (index, item) in report.dead_classes.iter().enumerate() {
            if f64::from(item.confidence) >= config.min_confidence {
                defects.push(self.dead_code_item_to_defect(item, "DEAD-CLS", index + 1));
            }
        }

        // Convert unreachable code
        for (index, block) in report.unreachable_code.iter().enumerate() {
            defects.push(self.unreachable_block_to_defect(block, index + 1));
        }

        Ok(defects)
    }

    fn category(&self) -> DefectCategory {
        DefectCategory::DeadCode
    }

    fn supports_incremental(&self) -> bool {
        false // Requires full graph analysis
    }
}

impl DeadCodeDefectAnalyzer {
    fn dead_code_item_to_defect(&self, item: &DeadCodeItem, prefix: &str, index: usize) -> Defect {
        let severity = if item.confidence > 0.9 {
            Severity::High
        } else if item.confidence > 0.7 {
            Severity::Medium
        } else {
            Severity::Low
        };

        let mut metrics = HashMap::new();
        metrics.insert("confidence".to_string(), f64::from(item.confidence));

        Defect {
            id: format!("{prefix}-{index:04}"),
            severity,
            category: DefectCategory::DeadCode,
            file_path: PathBuf::from(&item.file_path),
            line_start: item.line_number,
            line_end: None,
            column_start: None,
            column_end: None,
            message: format!(
                "Dead {}: '{}' is never used (confidence: {:.0}%)",
                format!("{:?}", item.dead_type).to_lowercase(),
                item.name,
                item.confidence * 100.0
            ),
            rule_id: format!("dead-{}", format!("{:?}", item.dead_type).to_lowercase()),
            fix_suggestion: Some(format!(
                "Remove unused {} '{}'",
                format!("{:?}", item.dead_type).to_lowercase(),
                item.name
            )),
            metrics,
        }
    }

    fn unreachable_block_to_defect(&self, block: &UnreachableBlock, index: usize) -> Defect {
        let mut metrics = HashMap::new();
        metrics.insert(
            "lines".to_string(),
            f64::from(block.end_line - block.start_line + 1),
        );

        Defect {
            id: format!("UNREACH-{index:04}"),
            severity: Severity::High,
            category: DefectCategory::DeadCode,
            file_path: PathBuf::from(&block.file_path),
            line_start: block.start_line,
            line_end: Some(block.end_line),
            column_start: None,
            column_end: None,
            message: format!(
                "Unreachable code block ({} lines) - {}",
                block.end_line - block.start_line + 1,
                block.reason
            ),
            rule_id: "unreachable-code".to_string(),
            fix_suggestion: Some("Remove unreachable code".to_string()),
            metrics,
        }
    }
}