rustqual 1.0.0

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

//! `forbid_method_call` matcher — detects calls to banned method names
//! in both direct dot-notation and UFCS form.
//!
//! Coverage:
//! - `x.unwrap()` → direct method call
//! - `Option::unwrap(x)` → UFCS form, matched by final path segment
//!
//! The UFCS match is conservative: any `Path::name(...)` call with two or
//! more path segments triggers when its tail segment matches a banned
//! name — including deeper paths like `std::option::Option::unwrap(x)`.
//! False positives on free functions with matching names (e.g.
//! `my_utils::unwrap(x)`) are rare and addressable by `qual:allow`.

use crate::adapters::analyzers::architecture::{MatchLocation, ViolationKind};
use syn::spanned::Spanned;
use syn::visit::{self, Visit};

/// Find all method-call matches in the given parsed file.
pub fn find_method_call_matches(
    file: &str,
    ast: &syn::File,
    names: &[String],
) -> Vec<MatchLocation> {
    let mut visitor = MethodCallVisitor {
        file,
        names,
        hits: Vec::new(),
    };
    visitor.visit_file(ast);
    visitor.hits
}

struct MethodCallVisitor<'a> {
    file: &'a str,
    names: &'a [String],
    hits: Vec<MatchLocation>,
}

impl MethodCallVisitor<'_> {
    fn record(&mut self, name: &str, syntax: &'static str, span: proc_macro2::Span) {
        let start = span.start();
        self.hits.push(MatchLocation {
            file: self.file.to_string(),
            line: start.line,
            column: start.column,
            kind: ViolationKind::MethodCall {
                name: name.to_string(),
                syntax,
            },
        });
    }
}

impl<'ast> Visit<'ast> for MethodCallVisitor<'_> {
    fn visit_expr_method_call(&mut self, node: &'ast syn::ExprMethodCall) {
        let called = node.method.to_string();
        if self.names.iter().any(|n| n == &called) {
            self.record(&called, "direct", node.method.span());
        }
        // Descend so receiver expressions (e.g. `a.b().c()`) are still visited.
        visit::visit_expr_method_call(self, node);
    }

    fn visit_expr_call(&mut self, node: &'ast syn::ExprCall) {
        // UFCS: `Type::method(args)` → func is ExprPath with ≥2 segments and
        // the final segment matches a banned name.
        if let syn::Expr::Path(ep) = &*node.func {
            let segs = &ep.path.segments;
            if segs.len() >= 2 {
                if let Some(last) = segs.last() {
                    let name = last.ident.to_string();
                    if self.names.iter().any(|n| n == &name) {
                        self.record(&name, "ufcs", last.ident.span());
                    }
                }
            }
        }
        // Descend so inner calls in args are visited.
        visit::visit_expr_call(self, node);
    }

    fn visit_macro(&mut self, node: &'ast syn::Macro) {
        // Macro token streams are not parsed by syn's default visitor, but
        // we want to catch method calls inside `format!("{}", x.unwrap())`
        // and similar. Parse the token stream as a comma-separated list of
        // expressions (works for most function-like macros).
        use syn::punctuated::Punctuated;
        if let Ok(args) = syn::parse::Parser::parse2(
            Punctuated::<syn::Expr, syn::Token![,]>::parse_terminated,
            node.tokens.clone(),
        ) {
            args.iter().for_each(|expr| visit::visit_expr(self, expr));
        }
        visit::visit_macro(self, node);
    }
}