pmat 3.15.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

/// Symbolic executor.
pub struct SymbolicExecutor {
    loop_depths: Vec<Complexity>,
    recursive_depth: usize,
    function_complexities: HashMap<String, Complexity>,
    current_path_complexity: Complexity,
}

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

impl SymbolicExecutor {
    #[provable_contracts_macros::contract("pmat-core.yaml", equation = "check_compliance")]
    /// Create a new instance.
    pub fn new() -> Self {
        Self {
            loop_depths: Vec::new(),
            recursive_depth: 0,
            function_complexities: HashMap::new(),
            current_path_complexity: Complexity::O1,
        }
    }

    #[provable_contracts_macros::contract("pmat-core.yaml", equation = "check_compliance")]
    /// Analyze function.
    pub fn analyze_function(&mut self, func: &syn::ItemFn) -> Complexity {
        let name = func.sig.ident.to_string();

        // Reset state for new function
        self.loop_depths.clear();
        self.current_path_complexity = Complexity::O1;

        // Check for recursion
        let mut recursion_detector = RecursionDetector {
            function_name: name.clone(),
            is_recursive: false,
        };
        recursion_detector.visit_block(&func.block);

        if recursion_detector.is_recursive {
            self.recursive_depth = 1;
        }

        // Analyze function body
        self.visit_block(&func.block);

        // Handle recursive complexity
        let mut complexity = self.current_path_complexity.clone();
        if self.recursive_depth > 0 {
            complexity = match complexity {
                Complexity::O1 => Complexity::ON,  // Simple recursion
                Complexity::ON => Complexity::ON2, // Recursive with linear work
                _ => Complexity::OExp,             // Complex recursion
            };
        }

        self.function_complexities.insert(name, complexity.clone());
        complexity
    }

    #[provable_contracts_macros::contract("pmat-core.yaml", equation = "check_compliance")]
    /// Analyze loop pattern.
    pub fn analyze_loop_pattern(&self, loop_expr: &syn::ExprForLoop) -> Complexity {
        // Analyze loop bounds to determine complexity
        if let syn::Expr::Range(range) = &*loop_expr.expr {
            return self.analyze_range_complexity(range);
        }

        // Check for common patterns
        if self.is_iterator_pattern(&loop_expr.expr) {
            return Complexity::ON;
        }

        // Conservative estimate
        Complexity::ON
    }

    #[provable_contracts_macros::contract("pmat-core.yaml", equation = "check_compliance")]
    fn analyze_range_complexity(&self, range: &syn::ExprRange) -> Complexity {
        if self.is_logarithmic_range(range) {
            return Complexity::OLogN;
        }
        Complexity::ON
    }

    #[provable_contracts_macros::contract("pmat-core.yaml", equation = "check_compliance")]
    fn is_logarithmic_range(&self, _range: &syn::ExprRange) -> bool {
        false
    }

    #[provable_contracts_macros::contract("pmat-core.yaml", equation = "check_compliance")]
    fn is_iterator_pattern(&self, expr: &Expr) -> bool {
        match expr {
            Expr::MethodCall(call) => {
                let method = call.method.to_string();
                matches!(method.as_str(), "iter" | "into_iter" | "iter_mut")
            }
            _ => false,
        }
    }

    #[provable_contracts_macros::contract("pmat-core.yaml", equation = "check_compliance")]
    fn is_sorting_algorithm(&self, func: &syn::ItemFn) -> bool {
        let name = func.sig.ident.to_string();
        name.contains("sort") || name.contains("heap") || name.contains("quick")
    }

    #[provable_contracts_macros::contract("pmat-core.yaml", equation = "check_compliance")]
    fn is_search_algorithm(&self, func: &syn::ItemFn) -> bool {
        let name = func.sig.ident.to_string();
        name.contains("search") || name.contains("find") || name.contains("binary")
    }

    #[provable_contracts_macros::contract("pmat-core.yaml", equation = "check_compliance")]
    fn is_graph_algorithm(&self, func: &syn::ItemFn) -> bool {
        let name = func.sig.ident.to_string();
        name.contains("dfs") || name.contains("bfs") || name.contains("dijkstra")
    }
}