rustqual 1.2.5

Comprehensive Rust code quality analyzer — seven dimensions: IOSP, Complexity, DRY, SRP, Coupling, Test Quality, Architecture
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

//! Per-function record consumed by the IOSP and Complexity dimensions.
//!
//! `FunctionRecord` is the typed state-of-codebase representation of a
//! single analyzed function. It carries everything reporters need to
//! render the per-function view — both classification (IOSP lens) and
//! raw complexity metrics (Complexity lens) — plus identity and a few
//! cross-cutting flags (`is_test`, `suppressed`, …).
//!
//! Violation-specific detail (logic_locations, call_locations) lives on
//! `IospFinding`, not here. `FunctionRecord` is state, not findings.

use crate::domain::Severity;

/// Classification of a function according to IOSP. Mirrors the analyzer's
/// `Classification` but without the `Violation` variant's per-occurrence
/// payload, which lives on `IospFinding` instead.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum FunctionClassification {
    Integration,
    Operation,
    Trivial,
    Violation,
}

/// One nesting hotspot inside a function (line + depth + construct kind).
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct NestingHotspot {
    pub line: usize,
    pub nesting_depth: usize,
    pub construct: String,
}

/// One magic-number occurrence (line + value).
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct MagicNumberOccurrence {
    pub line: usize,
    pub value: String,
}

/// One logic occurrence — used for TQ-005 mapping (which logic lines are
/// covered).
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct LogicOccurrenceRecord {
    pub line: usize,
    pub kind: String,
}

/// Raw complexity metrics for a function (set when the function is
/// non-trivial; absent for `Trivial` functions).
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ComplexityMetricsRecord {
    pub cognitive_complexity: usize,
    pub cyclomatic_complexity: usize,
    pub max_nesting: usize,
    pub function_lines: usize,
    pub unsafe_blocks: usize,
    pub unwrap_count: usize,
    pub expect_count: usize,
    pub panic_count: usize,
    pub todo_count: usize,
    /// IOSP-classifier counts. Carried here so reporters that show
    /// per-function complexity surface them as part of the same
    /// record (legacy JSON schema exposes them under `complexity`).
    pub logic_count: usize,
    pub call_count: usize,
    pub hotspots: Vec<NestingHotspot>,
    pub magic_numbers: Vec<MagicNumberOccurrence>,
    pub logic_occurrences: Vec<LogicOccurrenceRecord>,
}

/// State record for a single analyzed function.
#[derive(Debug, Clone, PartialEq)]
pub struct FunctionRecord {
    /// Function identity.
    pub name: String,
    pub file: String,
    pub line: usize,
    /// Pre-computed `MyStruct::method` or `free_fn` form.
    pub qualified_name: String,
    /// Parent impl type when the function is a method (e.g. `MyStruct`).
    pub parent_type: Option<String>,

    /// IOSP classification.
    pub classification: FunctionClassification,

    /// Severity of the IOSP violation, if any (mirrors what the IOSP
    /// finding carries — present here too so reporters that show the
    /// per-function lens don't need to cross-reference findings).
    pub severity: Option<Severity>,

    /// Raw complexity metrics. `None` for `Trivial` functions.
    pub complexity: Option<ComplexityMetricsRecord>,

    /// Function shape.
    pub parameter_count: usize,
    pub own_calls: Vec<String>,
    pub is_trait_impl: bool,
    pub is_test: bool,
    /// Refactoring effort estimate, populated for violations only.
    pub effort_score: Option<f64>,

    /// Suppression state — any-dimension `// qual:allow` matched here.
    pub suppressed: bool,
    /// Complexity-specific suppression state — `// qual:allow(complexity)`.
    pub complexity_suppressed: bool,
}