aboutsummaryrefslogtreecommitdiff
path: root/crates/ra_editor/src/assists/add_derive.rs
blob: 1e2cd4f300787d89b4d5fdbfe0a2fabe532f637f (plain)
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
use ra_syntax::{
    ast::{self, AstNode, AttrsOwner},
    SyntaxKind::{WHITESPACE, COMMENT},
    TextUnit,
};

use crate::assists::{AssistCtx, Assist};

pub fn add_derive(ctx: AssistCtx) -> Option<Assist> {
    let nominal = ctx.node_at_offset::<ast::NominalDef>()?;
    let node_start = derive_insertion_offset(nominal)?;
    ctx.build("add `#[derive]`", |edit| {
        let derive_attr = nominal
            .attrs()
            .filter_map(|x| x.as_call())
            .filter(|(name, _arg)| name == "derive")
            .map(|(_name, arg)| arg)
            .next();
        let offset = match derive_attr {
            None => {
                edit.insert(node_start, "#[derive()]\n");
                node_start + TextUnit::of_str("#[derive(")
            }
            Some(tt) => tt.syntax().range().end() - TextUnit::of_char(')'),
        };
        edit.set_cursor(offset)
    })
}

// Insert `derive` after doc comments.
fn derive_insertion_offset(nominal: ast::NominalDef) -> Option<TextUnit> {
    let non_ws_child = nominal
        .syntax()
        .children()
        .find(|it| it.kind() != COMMENT && it.kind() != WHITESPACE)?;
    Some(non_ws_child.range().start())
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::assists::check_assist;

    #[test]
    fn add_derive_new() {
        check_assist(
            add_derive,
            "struct Foo { a: i32, <|>}",
            "#[derive(<|>)]\nstruct Foo { a: i32, }",
        );
        check_assist(
            add_derive,
            "struct Foo { <|> a: i32, }",
            "#[derive(<|>)]\nstruct Foo {  a: i32, }",
        );
    }

    #[test]
    fn add_derive_existing() {
        check_assist(
            add_derive,
            "#[derive(Clone)]\nstruct Foo { a: i32<|>, }",
            "#[derive(Clone<|>)]\nstruct Foo { a: i32, }",
        );
    }

    #[test]
    fn add_derive_new_with_doc_comment() {
        check_assist(
            add_derive,
            "
/// `Foo` is a pretty important struct.
/// It does stuff.
struct Foo { a: i32<|>, }
            ",
            "
/// `Foo` is a pretty important struct.
/// It does stuff.
#[derive(<|>)]
struct Foo { a: i32, }
            ",
        );
    }
}