rulewright 0.1.2

Executable engineering standards for Rust workspaces
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
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

use ra_ap_syntax::{
    AstNode,
    ast::{self, HasName},
};

use crate::{AstCtx, Example, Violation};

#[rustfmt::skip]
const EXAMPLES: &[Example] = &[
    Example {
        label: "get_ method",
        code: "struct S;\nimpl S {\n    fn get_name(&self) {}\n}",
        pass: false,
    },
    Example {
        label: "get_ trait method",
        code: "trait T {\n    fn get_len(&self) -> usize;\n}",
        pass: false,
    },
    Example {
        label: "plain get passes",
        code: "struct S;\nimpl S {\n    fn get(&self) {}\n}",
        pass: true,
    },
    Example {
        label: "get_mut passes",
        code: "struct S;\nimpl S {\n    fn get_mut(&mut self) {}\n}",
        pass: true,
    },
    Example {
        label: "get_unchecked_mut passes",
        code: "struct S;\nimpl S {\n    fn get_unchecked_mut(&mut self) {}\n}",
        pass: true,
    },
    Example {
        label: "get_or_insert_with passes",
        code: "struct S;\nimpl S {\n    fn get_or_insert_with(&mut self) {}\n}",
        pass: true,
    },
    Example {
        label: "free fn is not a getter",
        code: "fn get_config() {}",
        pass: true,
    },
    Example {
        label: "associated fn without receiver",
        code: "struct S;\nimpl S {\n    fn get_default() -> S { S }\n}",
        pass: true,
    },
    Example {
        label: "keyed lookup method",
        code: "struct S;\nimpl S {\n    fn get_name(&self, id: u32) -> &str { todo!() }\n}",
        pass: true,
    },
    Example {
        label: "builder setter",
        code: "struct S;\nimpl S {\n    fn get_name(self, callback: impl Fn()) -> Self { self }\n}",
        pass: true,
    },
    Example {
        label: "async retrieval method",
        code: "struct S;\nimpl S {\n    async fn get_name(&self) -> String { todo!() }\n}",
        pass: true,
    },
    Example {
        label: "trait implementation method",
        code: "struct S;\nimpl External for S {\n    fn get_name(&self) -> &str { \"name\" }\n}",
        pass: true,
    },
    Example {
        label: "getter in test module",
        code: "#[cfg(test)]\nmod tests {\n    struct S;\n    impl S {\n        fn get_name(&self) {}\n    }\n}",
        pass: true,
    },
];

crate::ast_rule!(
    getter_prefix,
    "Flag receiver-only accessor methods named `get_something` — Rust getters are named after the field (C-GETTER).",
    "The `get_` prefix is noise on a zero-argument accessor: the std convention is `fn name(&self)`. Methods that accept a key, query, callback, or other argument are operations rather than simple getters and are left alone.",
    Low,
);

const ALLOWED: &[&str] = &[
    "get",
    "get_mut",
    "get_unchecked",
    "get_unchecked_mut",
    "get_or_insert_with",
    "get_or_init",
];

fn check_getter_prefix(ctx: &AstCtx<'_>) -> Vec<Violation> {
    ctx.nodes::<ast::Fn>()
        .filter(|function| {
            !ctx.is_in_test(function)
                && function.async_token().is_none()
                && !is_trait_impl_method(function)
                && function.param_list().is_some_and(|params| {
                    params.self_param().is_some() && params.params().next().is_none()
                })
        })
        .filter_map(|function| {
            let name = function.name()?;
            let name_text = name.text();
            let field = name_text.strip_prefix("get_")?;

            (!field.is_empty() && !ALLOWED.contains(&name_text.as_str())).then(|| {
                ctx.violation(
                    &name,
                    format!(
                        "getter `{name_text}` — name it `{field}` after what it returns (C-GETTER)"
                    ),
                )
            })
        })
        .collect()
}

fn is_trait_impl_method(function: &ast::Fn) -> bool {
    function
        .syntax()
        .ancestors()
        .find_map(ast::Impl::cast)
        .is_some_and(|item_impl| item_impl.trait_().is_some())
}

crate::rulewright_ast_test!(check_getter_prefix, {
    crate::example_tests!(EXAMPLES, check_getter_prefix);
});