rulewright 0.1.1

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

use ra_ap_syntax::ast;

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

#[rustfmt::skip]
const EXAMPLES: &[Example] = &[
    Example {
        label: "&String parameter",
        code: "fn f(x: &String) {}",
        pass: false,
    },
    Example {
        label: "&PathBuf parameter",
        code: "fn f(x: &PathBuf) {}",
        pass: false,
    },
    Example {
        label: "&Vec parameter",
        code: "fn f(x: &Vec<u32>) {}",
        pass: false,
    },
    Example {
        label: "fully qualified &OsString parameter",
        code: "fn f(x: &std::ffi::OsString) {}",
        pass: false,
    },
    Example {
        label: "&String in impl method",
        code: "struct S;\nimpl S {\n    fn f(&self, x: &String) {}\n}",
        pass: false,
    },
    Example {
        label: "&str parameter",
        code: "fn f(x: &str) {}",
        pass: true,
    },
    Example {
        label: "&mut String needs the owned type",
        code: "fn f(x: &mut String) {}",
        pass: true,
    },
    Example {
        label: "owned String parameter",
        code: "fn f(x: String) {}",
        pass: true,
    },
    Example {
        label: "slice parameter",
        code: "fn f(x: &[u32]) {}",
        pass: true,
    },
    Example {
        label: "&String in test module",
        code: "#[cfg(test)]\nmod tests {\n    fn f(x: &String) {}\n}",
        pass: true,
    },
];

crate::ast_rule!(
    owned_ref_param,
    "Flag fn parameters typed `&String`, `&PathBuf`, `&Vec<T>`, `&OsString`.",
    "A shared reference to an owned container forces callers to materialize the owned type; borrowed forms accept more argument types for free.",
    Medium,
);

const OWNED_REF_SUGGESTIONS: &[(&str, &str)] = &[
    ("String", "`&str` or `impl AsRef<str>`"),
    ("PathBuf", "`&Path` or `impl AsRef<Path>`"),
    ("Vec", "`&[T]` or `impl AsRef<[T]>`"),
    ("OsString", "`&OsStr` or `impl AsRef<OsStr>`"),
];

fn check_owned_ref_param(ctx: &AstCtx<'_>) -> Vec<Violation> {
    ctx.nodes::<ast::Fn>()
        .filter(|function| {
            super::support::is_item_or_impl_fn(function) && !ctx.is_in_test(function)
        })
        .flat_map(|function| {
            function
                .param_list()
                .into_iter()
                .flat_map(|params| params.params())
                .filter_map(|param| {
                    let ty = param.ty()?;

                    owned_ref_target(ty.clone()).map(|(name, suggestion)| {
                        ctx.violation(
                            &ty,
                            format!("parameter typed `&{name}` — accept {suggestion} instead"),
                        )
                    })
                })
                .collect::<Vec<_>>()
        })
        .collect()
}

fn owned_ref_target(ty: ast::Type) -> Option<(&'static str, &'static str)> {
    let ast::Type::RefType(reference) = ty else {
        return None;
    };

    if reference.mut_token().is_some() {
        return None;
    }

    let ast::Type::PathType(path) = reference.ty()? else {
        return None;
    };
    let last = path.path()?.segment()?.name_ref()?;

    OWNED_REF_SUGGESTIONS
        .iter()
        .copied()
        .find(|(name, _)| last.text() == *name)
}

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