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

use ra_ap_syntax::{AstNode, ast};
use std::collections::HashMap;

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

#[rustfmt::skip]
const EXAMPLES: &[Example] = &[
    Example {
        label: "inherent impl first",
        code: "struct Item;\nimpl Item { fn new() -> Self { Self } }\nimpl Default for Item { fn default() -> Self { Self } }",
        pass: true,
    },
    Example {
        label: "trait impl first",
        code: "struct Item;\nimpl Default for Item { fn default() -> Self { Self } }\nimpl Item { fn new() -> Self { Self } }",
        pass: false,
    },
    Example {
        label: "different types",
        code: "struct One; struct Two;\nimpl Default for One { fn default() -> Self { Self } }\nimpl Two {}",
        pass: true,
    },
    Example {
        label: "trait impl only",
        code: "struct Item;\nimpl Default for Item { fn default() -> Self { Self } }",
        pass: true,
    },
];

crate::ast_rule!(
    inherent_before_trait_impl,
    "Require an inherent impl to precede trait impls for the same local type.",
    "Putting the type's own API first makes its primary behavior easier to discover.",
    Low,
);

// #rw(fn: rust_alloc_in_loop) normalized self-type keys are owned by the cross-impl index
fn check_inherent_before_trait_impl(ctx: &AstCtx<'_>) -> Vec<Violation> {
    let mut first_inherent = HashMap::<String, usize>::default();
    let mut trait_impls = Vec::new();

    for item_impl in ctx.nodes::<ast::Impl>() {
        let Some(self_type) = item_impl.self_ty() else {
            continue;
        };
        let key: String = self_type
            .syntax()
            .text()
            .to_string()
            .chars()
            .filter(|ch| !ch.is_whitespace())
            .collect();
        let offset: usize = item_impl.syntax().text_range().start().into();

        if item_impl.trait_().is_none() {
            first_inherent.entry(key).or_insert(offset);
        } else {
            trait_impls.push((key, offset, item_impl));
        }
    }

    trait_impls
        .into_iter()
        .filter_map(|(key, offset, item_impl)| {
            first_inherent
                .get(&key)
                .is_some_and(|inherent_offset| offset < *inherent_offset)
                .then(|| {
                    ctx.violation(
                        &item_impl,
                        "trait impl appears before the inherent impl for this type",
                    )
                })
        })
        .collect()
}

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