rustqual 0.4.4

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

use super::BoilerplateFind;
use crate::config::sections::BoilerplateConfig;
use std::collections::HashMap;
use syn::spanned::Spanned;
use syn::visit::Visit;

/// Minimum named fields per construction to be worth flagging.
const MIN_FIELDS: usize = 3;
/// Minimum same-type constructions in one function body.
const MIN_CONSTRUCTIONS: usize = 2;
/// Minimum field overlap ratio between any two constructions.
const MIN_OVERLAP_RATIO: f64 = 0.5;

struct Collector {
    entries: Vec<(String, Vec<String>, usize)>,
}

impl<'ast> Visit<'ast> for Collector {
    fn visit_expr_struct(&mut self, node: &'ast syn::ExprStruct) {
        if node.rest.is_some() {
            syn::visit::visit_expr_struct(self, node);
            return;
        }
        let type_name = node
            .path
            .segments
            .iter()
            .map(|s| s.ident.to_string())
            .collect::<Vec<_>>()
            .join("::");
        let fields: Vec<String> = node
            .fields
            .iter()
            .filter_map(|f| match &f.member {
                syn::Member::Named(ident) => Some(ident.to_string()),
                _ => None,
            })
            .collect();
        if fields.len() >= MIN_FIELDS {
            self.entries
                .push((type_name, fields, node.path.span().start().line));
        }
        syn::visit::visit_expr_struct(self, node);
    }
}

/// Detect functions with multiple struct constructions sharing fields.
/// Operation: block-level visitor + grouping + overlap analysis.
pub(super) fn check_repetitive_struct_update(
    parsed: &[(String, String, syn::File)],
    config: &BoilerplateConfig,
) -> Vec<BoilerplateFind> {
    pattern_guard!("BP-009", config);

    let mut findings = Vec::new();
    let analyze = |block: &syn::Block, file: &str, fn_line: usize| -> Option<BoilerplateFind> {
        let mut c = Collector {
            entries: Vec::new(),
        };
        syn::visit::visit_block(&mut c, block);

        let mut by_type: HashMap<&str, Vec<&[String]>> = HashMap::new();
        c.entries
            .iter()
            .for_each(|(t, f, _)| by_type.entry(t.as_str()).or_default().push(f.as_slice()));

        by_type.into_iter().find_map(|(type_name, groups)| {
            if groups.len() < MIN_CONSTRUCTIONS {
                return None;
            }
            let a: std::collections::HashSet<&str> = groups[0].iter().map(|s| s.as_str()).collect();
            let b: std::collections::HashSet<&str> = groups[1].iter().map(|s| s.as_str()).collect();
            let overlap = a.intersection(&b).count();
            let min_len = a.len().min(b.len()).max(1);
            (overlap as f64 / min_len as f64 >= MIN_OVERLAP_RATIO).then(|| BoilerplateFind {
                pattern_id: "BP-009".to_string(),
                file: file.to_string(),
                line: fn_line,
                struct_name: Some(type_name.to_string()),
                description: format!(
                    "{} constructions of `{}` with overlapping fields",
                    groups.len(),
                    type_name
                ),
                suggestion: "Use struct update syntax: `Type { changed, ..base }`".to_string(),
            })
        })
    };

    parsed.iter().for_each(|(file, _, syntax)| {
        syntax.items.iter().for_each(|item| match item {
            syn::Item::Fn(f) => {
                if let Some(finding) = analyze(&f.block, file, f.sig.ident.span().start().line) {
                    findings.push(finding);
                }
            }
            syn::Item::Impl(imp) => imp.items.iter().for_each(|sub| {
                if let syn::ImplItem::Fn(m) = sub {
                    if let Some(finding) = analyze(&m.block, file, m.sig.ident.span().start().line)
                    {
                        findings.push(finding);
                    }
                }
            }),
            _ => {}
        });
    });
    findings
}