debtmap 0.16.6

Code complexity and technical debt analyzer
Documentation 
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

//! Confidence score calculation
//!
//! Pure functions for calculating confidence scores in purity analysis.

use super::types::{LocalMutation, UpvalueMutation};

/// Parameters for confidence calculation
pub struct ConfidenceParams<'a> {
    pub has_side_effects: bool,
    pub has_io_operations: bool,
    pub has_unsafe_blocks: bool,
    pub modifies_external_state: bool,
    pub accesses_external_state: bool,
    pub local_mutations: &'a [LocalMutation],
    pub upvalue_mutations: &'a [UpvalueMutation],
    pub unknown_macros_count: usize,
    pub has_pure_unsafe: bool,
}

/// Calculate confidence score for purity analysis
pub fn calculate_confidence_score(params: &ConfidenceParams) -> f32 {
    let mut confidence: f32 = 1.0;

    // Reduce confidence if we only access external state
    if params.accesses_external_state && !params.modifies_external_state {
        confidence *= 0.8;
    }

    // Reduce confidence for upvalue mutations (closures)
    if !params.upvalue_mutations.is_empty() {
        confidence *= 0.85;
    }

    // High confidence for simple local mutations
    if !params.local_mutations.is_empty() && params.local_mutations.len() < 5 {
        confidence *= 0.95;
    }

    // Reduce confidence for unknown macros (conservative approach)
    for _ in 0..params.unknown_macros_count {
        confidence *= 0.95;
    }

    // Reduce confidence for pure unsafe operations (Spec 161)
    if params.has_pure_unsafe {
        confidence *= 0.85;
    }

    // If no impurities detected and no confidence-reducing factors, set high confidence
    if !params.has_side_effects
        && !params.has_io_operations
        && !params.has_unsafe_blocks
        && !params.modifies_external_state
        && !params.has_pure_unsafe
        && !params.accesses_external_state
        && params.unknown_macros_count == 0
        && params.local_mutations.is_empty()
        && params.upvalue_mutations.is_empty()
    {
        confidence = 0.95;
    }

    confidence.clamp(0.5, 1.0)
}

#[cfg(test)]
mod tests {
    use super::*;

    fn default_params<'a>() -> ConfidenceParams<'a> {
        ConfidenceParams {
            has_side_effects: false,
            has_io_operations: false,
            has_unsafe_blocks: false,
            modifies_external_state: false,
            accesses_external_state: false,
            local_mutations: &[],
            upvalue_mutations: &[],
            unknown_macros_count: 0,
            has_pure_unsafe: false,
        }
    }

    #[test]
    fn test_high_confidence_for_pure() {
        let params = default_params();
        let confidence = calculate_confidence_score(&params);
        assert!(confidence >= 0.9);
    }

    #[test]
    fn test_reduced_confidence_for_external_access() {
        let mut params = default_params();
        params.accesses_external_state = true;
        let confidence = calculate_confidence_score(&params);
        assert!(confidence < 0.95);
    }

    #[test]
    fn test_reduced_confidence_for_pure_unsafe() {
        let mut params = default_params();
        params.has_pure_unsafe = true;
        let confidence = calculate_confidence_score(&params);
        assert!(confidence < 0.9);
    }

    #[test]
    fn test_reduced_confidence_for_unknown_macros() {
        let mut params = default_params();
        params.unknown_macros_count = 3;
        let confidence = calculate_confidence_score(&params);
        assert!(confidence < 0.95);
    }
}