mun_language_server 0.4.0

Provides a language server protocol server for the Mun language
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

use super::{CompletionContext, Completions};
use mun_hir::Upcast;

/// Complete dot accesses, i.e. fields. Adds `CompletionItems` to `result.
pub(super) fn complete_dot(result: &mut Completions, ctx: &CompletionContext) {
    // Get the expression that we want to get the fields of
    let dot_receiver = match &ctx.dot_receiver {
        Some(expr) => expr,
        _ => return,
    };

    // Figure out the type of the expression
    let receiver_ty = match ctx.sema.type_of_expr(dot_receiver) {
        Some(ty) => ty,
        _ => return,
    };

    // Get all the fields of the expression
    if let Some(strukt) = receiver_ty.as_struct() {
        for field in strukt.fields(ctx.db.upcast()) {
            result.add_field(ctx, field)
        }
    };
}

#[cfg(test)]
mod tests {
    use crate::completion::{test_utils::completion_string, CompletionKind};

    #[test]
    fn test_struct_fields() {
        insta::assert_snapshot!(completion_string(
            r#"
        struct FooBar {
            foo: i32,
            bar: i32,
        };
        
        fn foo() {
            let bar = FooBar { foo: 0, bar: 0 };
            bar.$0
        }
        "#,
            Some(CompletionKind::Reference)
        ))
    }

    #[test]
    fn test_tuple_struct() {
        insta::assert_snapshot!(completion_string(
            r#"
        struct FooBar(i32, i32)
        
        fn foo() {
            let bar = FooBar(0,0);
            bar.$0
        }
        "#,
            Some(CompletionKind::Reference)
        ))
    }

    #[test]
    fn test_nested_struct() {
        insta::assert_snapshot!(completion_string(
            r#"
        struct Foo { baz: i32 }
        struct Bar(Foo)
        
        fn foo() {
            let bar = Bar(Foo{baz:0});
            bar.0.$0
        }
        "#,
            Some(CompletionKind::Reference)
        ))
    }

    #[test]
    fn test_incomplete_struct() {
        insta::assert_snapshot!(completion_string(
            r#"
        struct Foo { bar: i32 }
        
        fn foo() {
            let bar = Foo;
            bar.$0
        }
        "#,
            Some(CompletionKind::Reference)
        ))
    }
}