rustqual 1.5.1

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

//! Pattern-level normalization: per-category `syn::Pat` handlers.

use super::{NormalizedToken, Normalizer};
use syn::visit::Visit;

impl Normalizer {
    /// Binding patterns: `ident` (with optional `mut` / `@` subpattern) and `_`.
    /// Operation: per-variant emission.
    pub(super) fn norm_pat_bind(&mut self, pat: &syn::Pat) {
        match pat {
            syn::Pat::Ident(p) => {
                if p.mutability.is_some() {
                    self.tokens.push(NormalizedToken::Keyword("mut"));
                }
                let id = self.resolve_ident(&p.ident.to_string());
                self.tokens.push(NormalizedToken::Ident(id));
                if let Some((_, sub)) = &p.subpat {
                    self.tokens.push(NormalizedToken::Operator("@"));
                    self.visit_pat(sub);
                }
            }
            syn::Pat::Wild(_) => self.tokens.push(NormalizedToken::Keyword("_")),
            _ => {}
        }
    }

    /// Sequence patterns: tuples, tuple structs, slices. Operation: emission.
    pub(super) fn norm_pat_seq(&mut self, pat: &syn::Pat) {
        match pat {
            syn::Pat::Tuple(t) => {
                self.tokens.push(NormalizedToken::Keyword("tuple"));
                for elem in &t.elems {
                    self.visit_pat(elem);
                }
            }
            syn::Pat::TupleStruct(ts) => {
                self.tokens.push(NormalizedToken::Keyword("tuple"));
                for elem in &ts.elems {
                    self.visit_pat(elem);
                }
            }
            syn::Pat::Slice(s) => {
                self.tokens.push(NormalizedToken::Keyword("array"));
                for elem in &s.elems {
                    self.visit_pat(elem);
                }
            }
            _ => {}
        }
    }

    /// Struct, reference, and or-patterns. Operation: per-variant emission.
    pub(super) fn norm_pat_compound(&mut self, pat: &syn::Pat) {
        match pat {
            syn::Pat::Struct(s) => {
                self.tokens.push(NormalizedToken::Keyword("struct"));
                for field in &s.fields {
                    if let syn::Member::Named(ident) = &field.member {
                        self.tokens
                            .push(NormalizedToken::FieldAccess(ident.to_string()));
                    }
                    self.visit_pat(&field.pat);
                }
            }
            syn::Pat::Reference(r) => {
                self.tokens.push(NormalizedToken::Operator("&"));
                if r.mutability.is_some() {
                    self.tokens.push(NormalizedToken::Keyword("mut"));
                }
                self.visit_pat(&r.pat);
            }
            syn::Pat::Or(o) => {
                for (i, case) in o.cases.iter().enumerate() {
                    if i > 0 {
                        self.tokens.push(NormalizedToken::Operator("|"));
                    }
                    self.visit_pat(case);
                }
            }
            _ => {}
        }
    }

    /// Leaf patterns: literals, ranges, rest (`..`). Operation: per-variant emission.
    pub(super) fn norm_pat_leaf(&mut self, pat: &syn::Pat) {
        match pat {
            syn::Pat::Lit(l) => self.norm_lit_kind(&l.lit),
            syn::Pat::Range(r) => {
                if let Some(start) = &r.start {
                    self.visit_expr(start);
                }
                self.tokens.push(NormalizedToken::Operator(".."));
                if let Some(end) = &r.end {
                    self.visit_expr(end);
                }
            }
            syn::Pat::Rest(_) => self.tokens.push(NormalizedToken::Operator("..")),
            _ => {}
        }
    }
}