1 files changed, 1067 insertions, 0 deletions
diff --git a/crates/ra_ide/src/completion/complete_unqualified_path.rs b/crates/ra_ide/src/completion/complete_unqualified_path.rs
new file mode 100644
index 000000000..665597e4c
--- /dev/null
+++ b/crates/ra_ide/src/completion/complete_unqualified_path.rs
@@ -0,0 +1,1067 @@
+//! Completion of names from the current scope, e.g. locals and imported items.
+use crate::completion::{CompletionContext, Completions};
+pub(super) fn complete_scope(acc: &mut Completions, ctx: &CompletionContext) {
+    if !(ctx.is_trivial_path && !ctx.is_pat_binding_or_const) {
+        return;
+    }
+    ctx.scope().process_all_names(&mut |name, res| acc.add_resolution(ctx, name.to_string(), &res));
+}
+#[cfg(test)]
+mod tests {
+    use insta::assert_debug_snapshot;
+    use crate::completion::{test_utils::do_completion, CompletionItem, CompletionKind};
+    fn do_reference_completion(ra_fixture: &str) -> Vec<CompletionItem> {
+        do_completion(ra_fixture, CompletionKind::Reference)
+    }
+    #[test]
+    fn bind_pat_and_path_ignore_at() {
+        assert_debug_snapshot!(
+            do_reference_completion(
+                r"
+                enum Enum {
+                    A,
+                    B,
+                }
+                fn quux(x: Option<Enum>) {
+                    match x {
+                        None => (),
+                        Some(en<|> @ Enum::A) => (),
+                    }
+                }
+                "
+            ),
+            @r###"[]"###
+        );
+    }
+    #[test]
+    fn bind_pat_and_path_ignore_ref() {
+        assert_debug_snapshot!(
+            do_reference_completion(
+                r"
+                enum Enum {
+                    A,
+                    B,
+                }
+                fn quux(x: Option<Enum>) {
+                    match x {
+                        None => (),
+                        Some(ref en<|>) => (),
+                    }
+                }
+                "
+            ),
+            @r###"[]"###
+        );
+    }
+    #[test]
+    fn bind_pat_and_path() {
+        assert_debug_snapshot!(
+            do_reference_completion(
+                r"
+                enum Enum {
+                    A,
+                    B,
+                }
+                fn quux(x: Option<Enum>) {
+                    match x {
+                        None => (),
+                        Some(En<|>) => (),
+                    }
+                }
+                "
+            ),
+            @r###"
+            [
+                CompletionItem {
+                    label: "Enum",
+                    source_range: [231; 233),
+                    delete: [231; 233),
+                    insert: "Enum",
+                    kind: Enum,
+                },
+            ]
+            "###
+        );
+    }
+    #[test]
+    fn completes_bindings_from_let() {
+        assert_debug_snapshot!(
+            do_reference_completion(
+                r"
+                fn quux(x: i32) {
+                    let y = 92;
+                    1 + <|>;
+                    let z = ();
+                }
+                "
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "quux(…)",
+                source_range: [91; 91),
+                delete: [91; 91),
+                insert: "quux(${1:x})$0",
+                kind: Function,
+                lookup: "quux",
+                detail: "fn quux(x: i32)",
+                trigger_call_info: true,
+            },
+            CompletionItem {
+                label: "x",
+                source_range: [91; 91),
+                delete: [91; 91),
+                insert: "x",
+                kind: Binding,
+                detail: "i32",
+            },
+            CompletionItem {
+                label: "y",
+                source_range: [91; 91),
+                delete: [91; 91),
+                insert: "y",
+                kind: Binding,
+                detail: "i32",
+            },
+        ]
+        "###
+        );
+    }
+    #[test]
+    fn completes_bindings_from_if_let() {
+        assert_debug_snapshot!(
+            do_reference_completion(
+                r"
+                fn quux() {
+                    if let Some(x) = foo() {
+                        let y = 92;
+                    };
+                    if let Some(a) = bar() {
+                        let b = 62;
+                        1 + <|>
+                    }
+                }
+                "
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "a",
+                source_range: [242; 242),
+                delete: [242; 242),
+                insert: "a",
+                kind: Binding,
+            },
+            CompletionItem {
+                label: "b",
+                source_range: [242; 242),
+                delete: [242; 242),
+                insert: "b",
+                kind: Binding,
+                detail: "i32",
+            },
+            CompletionItem {
+                label: "quux()",
+                source_range: [242; 242),
+                delete: [242; 242),
+                insert: "quux()$0",
+                kind: Function,
+                lookup: "quux",
+                detail: "fn quux()",
+            },
+        ]
+        "###
+        );
+    }
+    #[test]
+    fn completes_bindings_from_for() {
+        assert_debug_snapshot!(
+            do_reference_completion(
+                r"
+                fn quux() {
+                    for x in &[1, 2, 3] {
+                        <|>
+                    }
+                }
+                "
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "quux()",
+                source_range: [95; 95),
+                delete: [95; 95),
+                insert: "quux()$0",
+                kind: Function,
+                lookup: "quux",
+                detail: "fn quux()",
+            },
+            CompletionItem {
+                label: "x",
+                source_range: [95; 95),
+                delete: [95; 95),
+                insert: "x",
+                kind: Binding,
+            },
+        ]
+        "###
+        );
+    }
+    #[test]
+    fn completes_generic_params() {
+        assert_debug_snapshot!(
+            do_reference_completion(
+                r"
+                fn quux<T>() {
+                    <|>
+                }
+                "
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "T",
+                source_range: [52; 52),
+                delete: [52; 52),
+                insert: "T",
+                kind: TypeParam,
+            },
+            CompletionItem {
+                label: "quux()",
+                source_range: [52; 52),
+                delete: [52; 52),
+                insert: "quux()$0",
+                kind: Function,
+                lookup: "quux",
+                detail: "fn quux<T>()",
+            },
+        ]
+        "###
+        );
+    }
+    #[test]
+    fn completes_generic_params_in_struct() {
+        assert_debug_snapshot!(
+            do_reference_completion(
+                r"
+                struct X<T> {
+                    x: <|>
+                }
+                "
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "Self",
+                source_range: [54; 54),
+                delete: [54; 54),
+                insert: "Self",
+                kind: TypeParam,
+            },
+            CompletionItem {
+                label: "T",
+                source_range: [54; 54),
+                delete: [54; 54),
+                insert: "T",
+                kind: TypeParam,
+            },
+            CompletionItem {
+                label: "X<…>",
+                source_range: [54; 54),
+                delete: [54; 54),
+                insert: "X<$0>",
+                kind: Struct,
+                lookup: "X",
+            },
+        ]
+        "###
+        );
+    }
+    #[test]
+    fn completes_self_in_enum() {
+        assert_debug_snapshot!(
+            do_reference_completion(
+                r"
+                enum X {
+                    Y(<|>)
+                }
+                "
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "Self",
+                source_range: [48; 48),
+                delete: [48; 48),
+                insert: "Self",
+                kind: TypeParam,
+            },
+            CompletionItem {
+                label: "X",
+                source_range: [48; 48),
+                delete: [48; 48),
+                insert: "X",
+                kind: Enum,
+            },
+        ]
+        "###
+        );
+    }
+    #[test]
+    fn completes_module_items() {
+        assert_debug_snapshot!(
+        do_reference_completion(
+            r"
+                struct Foo;
+                enum Baz {}
+                fn quux() {
+                    <|>
+                }
+                "
+        ),
+        @r###"
+        [
+            CompletionItem {
+                label: "Baz",
+                source_range: [105; 105),
+                delete: [105; 105),
+                insert: "Baz",
+                kind: Enum,
+            },
+            CompletionItem {
+                label: "Foo",
+                source_range: [105; 105),
+                delete: [105; 105),
+                insert: "Foo",
+                kind: Struct,
+            },
+            CompletionItem {
+                label: "quux()",
+                source_range: [105; 105),
+                delete: [105; 105),
+                insert: "quux()$0",
+                kind: Function,
+                lookup: "quux",
+                detail: "fn quux()",
+            },
+        ]
+        "###
+            );
+    }
+    #[test]
+    fn completes_extern_prelude() {
+        assert_debug_snapshot!(
+            do_reference_completion(
+                r"
+                //- /lib.rs
+                use <|>;
+                //- /other_crate/lib.rs
+                // nothing here
+                "
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "other_crate",
+                source_range: [4; 4),
+                delete: [4; 4),
+                insert: "other_crate",
+                kind: Module,
+            },
+        ]
+        "###
+        );
+    }
+    #[test]
+    fn completes_module_items_in_nested_modules() {
+        assert_debug_snapshot!(
+            do_reference_completion(
+                r"
+                struct Foo;
+                mod m {
+                    struct Bar;
+                    fn quux() { <|> }
+                }
+                "
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "Bar",
+                source_range: [117; 117),
+                delete: [117; 117),
+                insert: "Bar",
+                kind: Struct,
+            },
+            CompletionItem {
+                label: "quux()",
+                source_range: [117; 117),
+                delete: [117; 117),
+                insert: "quux()$0",
+                kind: Function,
+                lookup: "quux",
+                detail: "fn quux()",
+            },
+        ]
+        "###
+        );
+    }
+    #[test]
+    fn completes_return_type() {
+        assert_debug_snapshot!(
+            do_reference_completion(
+                r"
+                struct Foo;
+                fn x() -> <|>
+                "
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "Foo",
+                source_range: [55; 55),
+                delete: [55; 55),
+                insert: "Foo",
+                kind: Struct,
+            },
+            CompletionItem {
+                label: "x()",
+                source_range: [55; 55),
+                delete: [55; 55),
+                insert: "x()$0",
+                kind: Function,
+                lookup: "x",
+                detail: "fn x()",
+            },
+        ]
+        "###
+        );
+    }
+    #[test]
+    fn dont_show_both_completions_for_shadowing() {
+        assert_debug_snapshot!(
+            do_reference_completion(
+                r"
+                fn foo() {
+                    let bar = 92;
+                    {
+                        let bar = 62;
+                        <|>
+                    }
+                }
+                "
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "bar",
+                source_range: [146; 146),
+                delete: [146; 146),
+                insert: "bar",
+                kind: Binding,
+                detail: "i32",
+            },
+            CompletionItem {
+                label: "foo()",
+                source_range: [146; 146),
+                delete: [146; 146),
+                insert: "foo()$0",
+                kind: Function,
+                lookup: "foo",
+                detail: "fn foo()",
+            },
+        ]
+        "###
+        );
+    }
+    #[test]
+    fn completes_self_in_methods() {
+        assert_debug_snapshot!(
+            do_reference_completion(r"impl S { fn foo(&self) { <|> } }"),
+            @r###"
+        [
+            CompletionItem {
+                label: "Self",
+                source_range: [25; 25),
+                delete: [25; 25),
+                insert: "Self",
+                kind: TypeParam,
+            },
+            CompletionItem {
+                label: "self",
+                source_range: [25; 25),
+                delete: [25; 25),
+                insert: "self",
+                kind: Binding,
+                detail: "&{unknown}",
+            },
+        ]
+        "###
+        );
+    }
+    #[test]
+    fn completes_prelude() {
+        assert_debug_snapshot!(
+            do_reference_completion(
+                "
+                //- /main.rs
+                fn foo() { let x: <|> }
+                //- /std/lib.rs
+                #[prelude_import]
+                use prelude::*;
+                mod prelude {
+                    struct Option;
+                }
+                "
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "Option",
+                source_range: [18; 18),
+                delete: [18; 18),
+                insert: "Option",
+                kind: Struct,
+            },
+            CompletionItem {
+                label: "foo()",
+                source_range: [18; 18),
+                delete: [18; 18),
+                insert: "foo()$0",
+                kind: Function,
+                lookup: "foo",
+                detail: "fn foo()",
+            },
+            CompletionItem {
+                label: "std",
+                source_range: [18; 18),
+                delete: [18; 18),
+                insert: "std",
+                kind: Module,
+            },
+        ]
+        "###
+        );
+    }
+    #[test]
+    fn completes_std_prelude_if_core_is_defined() {
+        assert_debug_snapshot!(
+            do_reference_completion(
+                "
+                //- /main.rs
+                fn foo() { let x: <|> }
+                //- /core/lib.rs
+                #[prelude_import]
+                use prelude::*;
+                mod prelude {
+                    struct Option;
+                }
+                //- /std/lib.rs
+                #[prelude_import]
+                use prelude::*;
+                mod prelude {
+                    struct String;
+                }
+                "
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "String",
+                source_range: [18; 18),
+                delete: [18; 18),
+                insert: "String",
+                kind: Struct,
+            },
+            CompletionItem {
+                label: "core",
+                source_range: [18; 18),
+                delete: [18; 18),
+                insert: "core",
+                kind: Module,
+            },
+            CompletionItem {
+                label: "foo()",
+                source_range: [18; 18),
+                delete: [18; 18),
+                insert: "foo()$0",
+                kind: Function,
+                lookup: "foo",
+                detail: "fn foo()",
+            },
+            CompletionItem {
+                label: "std",
+                source_range: [18; 18),
+                delete: [18; 18),
+                insert: "std",
+                kind: Module,
+            },
+        ]
+        "###
+        );
+    }
+    #[test]
+    fn completes_macros_as_value() {
+        assert_debug_snapshot!(
+            do_reference_completion(
+                "
+                //- /main.rs
+                macro_rules! foo {
+                    () => {}
+                }
+                #[macro_use]
+                mod m1 {
+                    macro_rules! bar {
+                        () => {}
+                    }
+                }
+                mod m2 {
+                    macro_rules! nope {
+                        () => {}
+                    }
+                    #[macro_export]
+                    macro_rules! baz {
+                        () => {}
+                    }
+                }
+                fn main() {
+                    let v = <|>
+                }
+                "
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "bar!",
+                source_range: [252; 252),
+                delete: [252; 252),
+                insert: "bar!($0)",
+                kind: Macro,
+                detail: "macro_rules! bar",
+            },
+            CompletionItem {
+                label: "baz!",
+                source_range: [252; 252),
+                delete: [252; 252),
+                insert: "baz!($0)",
+                kind: Macro,
+                detail: "#[macro_export]\nmacro_rules! baz",
+            },
+            CompletionItem {
+                label: "foo!",
+                source_range: [252; 252),
+                delete: [252; 252),
+                insert: "foo!($0)",
+                kind: Macro,
+                detail: "macro_rules! foo",
+            },
+            CompletionItem {
+                label: "m1",
+                source_range: [252; 252),
+                delete: [252; 252),
+                insert: "m1",
+                kind: Module,
+            },
+            CompletionItem {
+                label: "m2",
+                source_range: [252; 252),
+                delete: [252; 252),
+                insert: "m2",
+                kind: Module,
+            },
+            CompletionItem {
+                label: "main()",
+                source_range: [252; 252),
+                delete: [252; 252),
+                insert: "main()$0",
+                kind: Function,
+                lookup: "main",
+                detail: "fn main()",
+            },
+        ]
+        "###
+        );
+    }
+    #[test]
+    fn completes_both_macro_and_value() {
+        assert_debug_snapshot!(
+            do_reference_completion(
+                "
+                //- /main.rs
+                macro_rules! foo {
+                    () => {}
+                }
+                fn foo() {
+                    <|>
+                }
+                "
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "foo!",
+                source_range: [49; 49),
+                delete: [49; 49),
+                insert: "foo!($0)",
+                kind: Macro,
+                detail: "macro_rules! foo",
+            },
+            CompletionItem {
+                label: "foo()",
+                source_range: [49; 49),
+                delete: [49; 49),
+                insert: "foo()$0",
+                kind: Function,
+                lookup: "foo",
+                detail: "fn foo()",
+            },
+        ]
+        "###
+        );
+    }
+    #[test]
+    fn completes_macros_as_type() {
+        assert_debug_snapshot!(
+            do_reference_completion(
+                "
+                //- /main.rs
+                macro_rules! foo {
+                    () => {}
+                }
+                fn main() {
+                    let x: <|>
+                }
+                "
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "foo!",
+                source_range: [57; 57),
+                delete: [57; 57),
+                insert: "foo!($0)",
+                kind: Macro,
+                detail: "macro_rules! foo",
+            },
+            CompletionItem {
+                label: "main()",
+                source_range: [57; 57),
+                delete: [57; 57),
+                insert: "main()$0",
+                kind: Function,
+                lookup: "main",
+                detail: "fn main()",
+            },
+        ]
+        "###
+        );
+    }
+    #[test]
+    fn completes_macros_as_stmt() {
+        assert_debug_snapshot!(
+            do_reference_completion(
+                "
+                //- /main.rs
+                macro_rules! foo {
+                    () => {}
+                }
+                fn main() {
+                    <|>
+                }
+                "
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "foo!",
+                source_range: [50; 50),
+                delete: [50; 50),
+                insert: "foo!($0)",
+                kind: Macro,
+                detail: "macro_rules! foo",
+            },
+            CompletionItem {
+                label: "main()",
+                source_range: [50; 50),
+                delete: [50; 50),
+                insert: "main()$0",
+                kind: Function,
+                lookup: "main",
+                detail: "fn main()",
+            },
+        ]
+        "###
+        );
+    }
+    #[test]
+    fn completes_local_item() {
+        assert_debug_snapshot!(
+            do_reference_completion(
+                "
+                //- /main.rs
+                fn main() {
+                    return f<|>;
+                    fn frobnicate() {}
+                }
+                "
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "frobnicate()",
+                source_range: [23; 24),
+                delete: [23; 24),
+                insert: "frobnicate()$0",
+                kind: Function,
+                lookup: "frobnicate",
+                detail: "fn frobnicate()",
+            },
+            CompletionItem {
+                label: "main()",
+                source_range: [23; 24),
+                delete: [23; 24),
+                insert: "main()$0",
+                kind: Function,
+                lookup: "main",
+                detail: "fn main()",
+            },
+        ]
+        "###
+        )
+    }
+    #[test]
+    fn completes_in_simple_macro_1() {
+        assert_debug_snapshot!(
+            do_reference_completion(
+                r"
+                macro_rules! m { ($e:expr) => { $e } }
+                fn quux(x: i32) {
+                    let y = 92;
+                    m!(<|>);
+                }
+                "
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "m!",
+                source_range: [145; 145),
+                delete: [145; 145),
+                insert: "m!($0)",
+                kind: Macro,
+                detail: "macro_rules! m",
+            },
+            CompletionItem {
+                label: "quux(…)",
+                source_range: [145; 145),
+                delete: [145; 145),
+                insert: "quux(${1:x})$0",
+                kind: Function,
+                lookup: "quux",
+                detail: "fn quux(x: i32)",
+                trigger_call_info: true,
+            },
+            CompletionItem {
+                label: "x",
+                source_range: [145; 145),
+                delete: [145; 145),
+                insert: "x",
+                kind: Binding,
+                detail: "i32",
+            },
+            CompletionItem {
+                label: "y",
+                source_range: [145; 145),
+                delete: [145; 145),
+                insert: "y",
+                kind: Binding,
+                detail: "i32",
+            },
+        ]
+        "###
+        );
+    }
+    #[test]
+    fn completes_in_simple_macro_2() {
+        assert_debug_snapshot!(
+            do_reference_completion(
+                r"
+                macro_rules! m { ($e:expr) => { $e } }
+                fn quux(x: i32) {
+                    let y = 92;
+                    m!(x<|>);
+                }
+                "
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "m!",
+                source_range: [145; 146),
+                delete: [145; 146),
+                insert: "m!($0)",
+                kind: Macro,
+                detail: "macro_rules! m",
+            },
+            CompletionItem {
+                label: "quux(…)",
+                source_range: [145; 146),
+                delete: [145; 146),
+                insert: "quux(${1:x})$0",
+                kind: Function,
+                lookup: "quux",
+                detail: "fn quux(x: i32)",
+                trigger_call_info: true,
+            },
+            CompletionItem {
+                label: "x",
+                source_range: [145; 146),
+                delete: [145; 146),
+                insert: "x",
+                kind: Binding,
+                detail: "i32",
+            },
+            CompletionItem {
+                label: "y",
+                source_range: [145; 146),
+                delete: [145; 146),
+                insert: "y",
+                kind: Binding,
+                detail: "i32",
+            },
+        ]
+        "###
+        );
+    }
+    #[test]
+    fn completes_in_simple_macro_without_closing_parens() {
+        assert_debug_snapshot!(
+                    do_reference_completion(
+                        r"
+                macro_rules! m { ($e:expr) => { $e } }
+                fn quux(x: i32) {
+                    let y = 92;
+                    m!(x<|>
+                }
+                "
+                    ),
+                    @r###"
+        [
+            CompletionItem {
+                label: "m!",
+                source_range: [145; 146),
+                delete: [145; 146),
+                insert: "m!($0)",
+                kind: Macro,
+                detail: "macro_rules! m",
+            },
+            CompletionItem {
+                label: "quux(…)",
+                source_range: [145; 146),
+                delete: [145; 146),
+                insert: "quux(${1:x})$0",
+                kind: Function,
+                lookup: "quux",
+                detail: "fn quux(x: i32)",
+                trigger_call_info: true,
+            },
+            CompletionItem {
+                label: "x",
+                source_range: [145; 146),
+                delete: [145; 146),
+                insert: "x",
+                kind: Binding,
+                detail: "i32",
+            },
+            CompletionItem {
+                label: "y",
+                source_range: [145; 146),
+                delete: [145; 146),
+                insert: "y",
+                kind: Binding,
+                detail: "i32",
+            },
+        ]
+        "###
+        );
+    }
+    #[test]
+    fn completes_unresolved_uses() {
+        assert_debug_snapshot!(
+            do_reference_completion(
+                r"
+                use spam::Quux;
+                fn main() {
+                    <|>
+                }
+                "
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "Quux",
+                source_range: [82; 82),
+                delete: [82; 82),
+                insert: "Quux",
+            },
+            CompletionItem {
+                label: "main()",
+                source_range: [82; 82),
+                delete: [82; 82),
+                insert: "main()$0",
+                kind: Function,
+                lookup: "main",
+                detail: "fn main()",
+            },
+        ]
+        "###
+        );
+    }
+}

diff --git a/crates/ra_ide/src/completion/complete_unqualified_path.rs b/crates/ra_ide/src/completion/complete_unqualified_path.rs new file mode 100644 index 000000000..665597e4c --- /dev/null +++ b/crates/ra_ide/src/completion/complete_unqualified_path.rs
@@ -0,0 +1,1067 @@
	1	//! Completion of names from the current scope, e.g. locals and imported items.
	2
	3	use crate::completion::{CompletionContext, Completions};
	4
	5	pub(super) fn complete_scope(acc: &mut Completions, ctx: &CompletionContext) {
	6	if !(ctx.is_trivial_path && !ctx.is_pat_binding_or_const) {
	7	return;
	8	}
	9
	10	ctx.scope().process_all_names(&mut \|name, res\| acc.add_resolution(ctx, name.to_string(), &res));
	11	}
	12
	13	#[cfg(test)]
	14	mod tests {
	15	use insta::assert_debug_snapshot;
	16
	17	use crate::completion::{test_utils::do_completion, CompletionItem, CompletionKind};
	18
	19	fn do_reference_completion(ra_fixture: &str) -> Vec<CompletionItem> {
	20	do_completion(ra_fixture, CompletionKind::Reference)
	21	}
	22
	23	#[test]
	24	fn bind_pat_and_path_ignore_at() {
	25	assert_debug_snapshot!(
	26	do_reference_completion(
	27	r"
	28	enum Enum {
	29	A,
	30	B,
	31	}
	32	fn quux(x: Option<Enum>) {
	33	match x {
	34	None => (),
	35	Some(en<\|> @ Enum::A) => (),
	36	}
	37	}
	38	"
	39	),
	40	@r###"[]"###
	41	);
	42	}
	43
	44	#[test]
	45	fn bind_pat_and_path_ignore_ref() {
	46	assert_debug_snapshot!(
	47	do_reference_completion(
	48	r"
	49	enum Enum {
	50	A,
	51	B,
	52	}
	53	fn quux(x: Option<Enum>) {
	54	match x {
	55	None => (),
	56	Some(ref en<\|>) => (),
	57	}
	58	}
	59	"
	60	),
	61	@r###"[]"###
	62	);
	63	}
	64
	65	#[test]
	66	fn bind_pat_and_path() {
	67	assert_debug_snapshot!(
	68	do_reference_completion(
	69	r"
	70	enum Enum {
	71	A,
	72	B,
	73	}
	74	fn quux(x: Option<Enum>) {
	75	match x {
	76	None => (),
	77	Some(En<\|>) => (),
	78	}
	79	}
	80	"
	81	),
	82	@r###"
	83	[
	84	CompletionItem {
	85	label: "Enum",
	86	source_range: [231; 233),
	87	delete: [231; 233),
	88	insert: "Enum",
	89	kind: Enum,
	90	},
	91	]
	92	"###
	93	);
	94	}
	95
	96	#[test]
	97	fn completes_bindings_from_let() {
	98	assert_debug_snapshot!(
	99	do_reference_completion(
	100	r"
	101	fn quux(x: i32) {
	102	let y = 92;
	103	1 + <\|>;
	104	let z = ();
	105	}
	106	"
	107	),
	108	@r###"
	109	[
	110	CompletionItem {
	111	label: "quux(…)",
	112	source_range: [91; 91),
	113	delete: [91; 91),
	114	insert: "quux(${1:x})$0",
	115	kind: Function,
	116	lookup: "quux",
	117	detail: "fn quux(x: i32)",
	118	trigger_call_info: true,
	119	},
	120	CompletionItem {
	121	label: "x",
	122	source_range: [91; 91),
	123	delete: [91; 91),
	124	insert: "x",
	125	kind: Binding,
	126	detail: "i32",
	127	},
	128	CompletionItem {
	129	label: "y",
	130	source_range: [91; 91),
	131	delete: [91; 91),
	132	insert: "y",
	133	kind: Binding,
	134	detail: "i32",
	135	},
	136	]
	137	"###
	138	);
	139	}
	140
	141	#[test]
	142	fn completes_bindings_from_if_let() {
	143	assert_debug_snapshot!(
	144	do_reference_completion(
	145	r"
	146	fn quux() {
	147	if let Some(x) = foo() {
	148	let y = 92;
	149	};
	150	if let Some(a) = bar() {
	151	let b = 62;
	152	1 + <\|>
	153	}
	154	}
	155	"
	156	),
	157	@r###"
	158	[
	159	CompletionItem {
	160	label: "a",
	161	source_range: [242; 242),
	162	delete: [242; 242),
	163	insert: "a",
	164	kind: Binding,
	165	},
	166	CompletionItem {
	167	label: "b",
	168	source_range: [242; 242),
	169	delete: [242; 242),
	170	insert: "b",
	171	kind: Binding,
	172	detail: "i32",
	173	},
	174	CompletionItem {
	175	label: "quux()",
	176	source_range: [242; 242),
	177	delete: [242; 242),
	178	insert: "quux()$0",
	179	kind: Function,
	180	lookup: "quux",
	181	detail: "fn quux()",
	182	},
	183	]
	184	"###
	185	);
	186	}
	187
	188	#[test]
	189	fn completes_bindings_from_for() {
	190	assert_debug_snapshot!(
	191	do_reference_completion(
	192	r"
	193	fn quux() {
	194	for x in &[1, 2, 3] {
	195	<\|>
	196	}
	197	}
	198	"
	199	),
	200	@r###"
	201	[
	202	CompletionItem {
	203	label: "quux()",
	204	source_range: [95; 95),
	205	delete: [95; 95),
	206	insert: "quux()$0",
	207	kind: Function,
	208	lookup: "quux",
	209	detail: "fn quux()",
	210	},
	211	CompletionItem {
	212	label: "x",
	213	source_range: [95; 95),
	214	delete: [95; 95),
	215	insert: "x",
	216	kind: Binding,
	217	},
	218	]
	219	"###
	220	);
	221	}
	222
	223	#[test]
	224	fn completes_generic_params() {
	225	assert_debug_snapshot!(
	226	do_reference_completion(
	227	r"
	228	fn quux<T>() {
	229	<\|>
	230	}
	231	"
	232	),
	233	@r###"
	234	[
	235	CompletionItem {
	236	label: "T",
	237	source_range: [52; 52),
	238	delete: [52; 52),
	239	insert: "T",
	240	kind: TypeParam,
	241	},
	242	CompletionItem {
	243	label: "quux()",
	244	source_range: [52; 52),
	245	delete: [52; 52),
	246	insert: "quux()$0",
	247	kind: Function,
	248	lookup: "quux",
	249	detail: "fn quux<T>()",
	250	},
	251	]
	252	"###
	253	);
	254	}
	255
	256	#[test]
	257	fn completes_generic_params_in_struct() {
	258	assert_debug_snapshot!(
	259	do_reference_completion(
	260	r"
	261	struct X<T> {
	262	x: <\|>
	263	}
	264	"
	265	),
	266	@r###"
	267	[
	268	CompletionItem {
	269	label: "Self",
	270	source_range: [54; 54),
	271	delete: [54; 54),
	272	insert: "Self",
	273	kind: TypeParam,
	274	},
	275	CompletionItem {
	276	label: "T",
	277	source_range: [54; 54),
	278	delete: [54; 54),
	279	insert: "T",
	280	kind: TypeParam,
	281	},
	282	CompletionItem {
	283	label: "X<…>",
	284	source_range: [54; 54),
	285	delete: [54; 54),
	286	insert: "X<$0>",
	287	kind: Struct,
	288	lookup: "X",
	289	},
	290	]
	291	"###
	292	);
	293	}
	294
	295	#[test]
	296	fn completes_self_in_enum() {
	297	assert_debug_snapshot!(
	298	do_reference_completion(
	299	r"
	300	enum X {
	301	Y(<\|>)
	302	}
	303	"
	304	),
	305	@r###"
	306	[
	307	CompletionItem {
	308	label: "Self",
	309	source_range: [48; 48),
	310	delete: [48; 48),
	311	insert: "Self",
	312	kind: TypeParam,
	313	},
	314	CompletionItem {
	315	label: "X",
	316	source_range: [48; 48),
	317	delete: [48; 48),
	318	insert: "X",
	319	kind: Enum,
	320	},
	321	]
	322	"###
	323	);
	324	}
	325
	326	#[test]
	327	fn completes_module_items() {
	328	assert_debug_snapshot!(
	329	do_reference_completion(
	330	r"
	331	struct Foo;
	332	enum Baz {}
	333	fn quux() {
	334	<\|>
	335	}
	336	"
	337	),
	338	@r###"
	339	[
	340	CompletionItem {
	341	label: "Baz",
	342	source_range: [105; 105),
	343	delete: [105; 105),
	344	insert: "Baz",
	345	kind: Enum,
	346	},
	347	CompletionItem {
	348	label: "Foo",
	349	source_range: [105; 105),
	350	delete: [105; 105),
	351	insert: "Foo",
	352	kind: Struct,
	353	},
	354	CompletionItem {
	355	label: "quux()",
	356	source_range: [105; 105),
	357	delete: [105; 105),
	358	insert: "quux()$0",
	359	kind: Function,
	360	lookup: "quux",
	361	detail: "fn quux()",
	362	},
	363	]
	364	"###
	365	);
	366	}
	367
	368	#[test]
	369	fn completes_extern_prelude() {
	370	assert_debug_snapshot!(
	371	do_reference_completion(
	372	r"
	373	//- /lib.rs
	374	use <\|>;
	375
	376	//- /other_crate/lib.rs
	377	// nothing here
	378	"
	379	),
	380	@r###"
	381	[
	382	CompletionItem {
	383	label: "other_crate",
	384	source_range: [4; 4),
	385	delete: [4; 4),
	386	insert: "other_crate",
	387	kind: Module,
	388	},
	389	]
	390	"###
	391	);
	392	}
	393
	394	#[test]
	395	fn completes_module_items_in_nested_modules() {
	396	assert_debug_snapshot!(
	397	do_reference_completion(
	398	r"
	399	struct Foo;
	400	mod m {
	401	struct Bar;
	402	fn quux() { <\|> }
	403	}
	404	"
	405	),
	406	@r###"
	407	[
	408	CompletionItem {
	409	label: "Bar",
	410	source_range: [117; 117),
	411	delete: [117; 117),
	412	insert: "Bar",
	413	kind: Struct,
	414	},
	415	CompletionItem {
	416	label: "quux()",
	417	source_range: [117; 117),
	418	delete: [117; 117),
	419	insert: "quux()$0",
	420	kind: Function,
	421	lookup: "quux",
	422	detail: "fn quux()",
	423	},
	424	]
	425	"###
	426	);
	427	}
	428
	429	#[test]
	430	fn completes_return_type() {
	431	assert_debug_snapshot!(
	432	do_reference_completion(
	433	r"
	434	struct Foo;
	435	fn x() -> <\|>
	436	"
	437	),
	438	@r###"
	439	[
	440	CompletionItem {
	441	label: "Foo",
	442	source_range: [55; 55),
	443	delete: [55; 55),
	444	insert: "Foo",
	445	kind: Struct,
	446	},
	447	CompletionItem {
	448	label: "x()",
	449	source_range: [55; 55),
	450	delete: [55; 55),
	451	insert: "x()$0",
	452	kind: Function,
	453	lookup: "x",
	454	detail: "fn x()",
	455	},
	456	]
	457	"###
	458	);
	459	}
	460
	461	#[test]
	462	fn dont_show_both_completions_for_shadowing() {
	463	assert_debug_snapshot!(
	464	do_reference_completion(
	465	r"
	466	fn foo() {
	467	let bar = 92;
	468	{
	469	let bar = 62;
	470	<\|>
	471	}
	472	}
	473	"
	474	),
	475	@r###"
	476	[
	477	CompletionItem {
	478	label: "bar",
	479	source_range: [146; 146),
	480	delete: [146; 146),
	481	insert: "bar",
	482	kind: Binding,
	483	detail: "i32",
	484	},
	485	CompletionItem {
	486	label: "foo()",
	487	source_range: [146; 146),
	488	delete: [146; 146),
	489	insert: "foo()$0",
	490	kind: Function,
	491	lookup: "foo",
	492	detail: "fn foo()",
	493	},
	494	]
	495	"###
	496	);
	497	}
	498
	499	#[test]
	500	fn completes_self_in_methods() {
	501	assert_debug_snapshot!(
	502	do_reference_completion(r"impl S { fn foo(&self) { <\|> } }"),
	503	@r###"
	504	[
	505	CompletionItem {
	506	label: "Self",
	507	source_range: [25; 25),
	508	delete: [25; 25),
	509	insert: "Self",
	510	kind: TypeParam,
	511	},
	512	CompletionItem {
	513	label: "self",
	514	source_range: [25; 25),
	515	delete: [25; 25),
	516	insert: "self",
	517	kind: Binding,
	518	detail: "&{unknown}",
	519	},
	520	]
	521	"###
	522	);
	523	}
	524
	525	#[test]
	526	fn completes_prelude() {
	527	assert_debug_snapshot!(
	528	do_reference_completion(
	529	"
	530	//- /main.rs
	531	fn foo() { let x: <\|> }
	532
	533	//- /std/lib.rs
	534	#[prelude_import]
	535	use prelude::*;
	536
	537	mod prelude {
	538	struct Option;
	539	}
	540	"
	541	),
	542	@r###"
	543	[
	544	CompletionItem {
	545	label: "Option",
	546	source_range: [18; 18),
	547	delete: [18; 18),
	548	insert: "Option",
	549	kind: Struct,
	550	},
	551	CompletionItem {
	552	label: "foo()",
	553	source_range: [18; 18),
	554	delete: [18; 18),
	555	insert: "foo()$0",
	556	kind: Function,
	557	lookup: "foo",
	558	detail: "fn foo()",
	559	},
	560	CompletionItem {
	561	label: "std",
	562	source_range: [18; 18),
	563	delete: [18; 18),
	564	insert: "std",
	565	kind: Module,
	566	},
	567	]
	568	"###
	569	);
	570	}
	571
	572	#[test]
	573	fn completes_std_prelude_if_core_is_defined() {
	574	assert_debug_snapshot!(
	575	do_reference_completion(
	576	"
	577	//- /main.rs
	578	fn foo() { let x: <\|> }
	579
	580	//- /core/lib.rs
	581	#[prelude_import]
	582	use prelude::*;
	583
	584	mod prelude {
	585	struct Option;
	586	}
	587
	588	//- /std/lib.rs
	589	#[prelude_import]
	590	use prelude::*;
	591
	592	mod prelude {
	593	struct String;
	594	}
	595	"
	596	),
	597	@r###"
	598	[
	599	CompletionItem {
	600	label: "String",
	601	source_range: [18; 18),
	602	delete: [18; 18),
	603	insert: "String",
	604	kind: Struct,
	605	},
	606	CompletionItem {
	607	label: "core",
	608	source_range: [18; 18),
	609	delete: [18; 18),
	610	insert: "core",
	611	kind: Module,
	612	},
	613	CompletionItem {
	614	label: "foo()",
	615	source_range: [18; 18),
	616	delete: [18; 18),
	617	insert: "foo()$0",
	618	kind: Function,
	619	lookup: "foo",
	620	detail: "fn foo()",
	621	},
	622	CompletionItem {
	623	label: "std",
	624	source_range: [18; 18),
	625	delete: [18; 18),
	626	insert: "std",
	627	kind: Module,
	628	},
	629	]
	630	"###
	631	);
	632	}
	633
	634	#[test]
	635	fn completes_macros_as_value() {
	636	assert_debug_snapshot!(
	637	do_reference_completion(
	638	"
	639	//- /main.rs
	640	macro_rules! foo {
	641	() => {}
	642	}
	643
	644	#[macro_use]
	645	mod m1 {
	646	macro_rules! bar {
	647	() => {}
	648	}
	649	}
	650
	651	mod m2 {
	652	macro_rules! nope {
	653	() => {}
	654	}
	655
	656	#[macro_export]
	657	macro_rules! baz {
	658	() => {}
	659	}
	660	}
	661
	662	fn main() {
	663	let v = <\|>
	664	}
	665	"
	666	),
	667	@r###"
	668	[
	669	CompletionItem {
	670	label: "bar!",
	671	source_range: [252; 252),
	672	delete: [252; 252),
	673	insert: "bar!($0)",
	674	kind: Macro,
	675	detail: "macro_rules! bar",
	676	},
	677	CompletionItem {
	678	label: "baz!",
	679	source_range: [252; 252),
	680	delete: [252; 252),
	681	insert: "baz!($0)",
	682	kind: Macro,
	683	detail: "#[macro_export]\nmacro_rules! baz",
	684	},
	685	CompletionItem {
	686	label: "foo!",
	687	source_range: [252; 252),
	688	delete: [252; 252),
	689	insert: "foo!($0)",
	690	kind: Macro,
	691	detail: "macro_rules! foo",
	692	},
	693	CompletionItem {
	694	label: "m1",
	695	source_range: [252; 252),
	696	delete: [252; 252),
	697	insert: "m1",
	698	kind: Module,
	699	},
	700	CompletionItem {
	701	label: "m2",
	702	source_range: [252; 252),
	703	delete: [252; 252),
	704	insert: "m2",
	705	kind: Module,
	706	},
	707	CompletionItem {
	708	label: "main()",
	709	source_range: [252; 252),
	710	delete: [252; 252),
	711	insert: "main()$0",
	712	kind: Function,
	713	lookup: "main",
	714	detail: "fn main()",
	715	},
	716	]
	717	"###
	718	);
	719	}
	720
	721	#[test]
	722	fn completes_both_macro_and_value() {
	723	assert_debug_snapshot!(
	724	do_reference_completion(
	725	"
	726	//- /main.rs
	727	macro_rules! foo {
	728	() => {}
	729	}
	730
	731	fn foo() {
	732	<\|>
	733	}
	734	"
	735	),
	736	@r###"
	737	[
	738	CompletionItem {
	739	label: "foo!",
	740	source_range: [49; 49),
	741	delete: [49; 49),
	742	insert: "foo!($0)",
	743	kind: Macro,
	744	detail: "macro_rules! foo",
	745	},
	746	CompletionItem {
	747	label: "foo()",
	748	source_range: [49; 49),
	749	delete: [49; 49),
	750	insert: "foo()$0",
	751	kind: Function,
	752	lookup: "foo",
	753	detail: "fn foo()",
	754	},
	755	]
	756	"###
	757	);
	758	}
	759
	760	#[test]
	761	fn completes_macros_as_type() {
	762	assert_debug_snapshot!(
	763	do_reference_completion(
	764	"
	765	//- /main.rs
	766	macro_rules! foo {
	767	() => {}
	768	}
	769
	770	fn main() {
	771	let x: <\|>
	772	}
	773	"
	774	),
	775	@r###"
	776	[
	777	CompletionItem {
	778	label: "foo!",
	779	source_range: [57; 57),
	780	delete: [57; 57),
	781	insert: "foo!($0)",
	782	kind: Macro,
	783	detail: "macro_rules! foo",
	784	},
	785	CompletionItem {
	786	label: "main()",
	787	source_range: [57; 57),
	788	delete: [57; 57),
	789	insert: "main()$0",
	790	kind: Function,
	791	lookup: "main",
	792	detail: "fn main()",
	793	},
	794	]
	795	"###
	796	);
	797	}
	798
	799	#[test]
	800	fn completes_macros_as_stmt() {
	801	assert_debug_snapshot!(
	802	do_reference_completion(
	803	"
	804	//- /main.rs
	805	macro_rules! foo {
	806	() => {}
	807	}
	808
	809	fn main() {
	810	<\|>
	811	}
	812	"
	813	),
	814	@r###"
	815	[
	816	CompletionItem {
	817	label: "foo!",
	818	source_range: [50; 50),
	819	delete: [50; 50),
	820	insert: "foo!($0)",
	821	kind: Macro,
	822	detail: "macro_rules! foo",
	823	},
	824	CompletionItem {
	825	label: "main()",
	826	source_range: [50; 50),
	827	delete: [50; 50),
	828	insert: "main()$0",
	829	kind: Function,
	830	lookup: "main",
	831	detail: "fn main()",
	832	},
	833	]
	834	"###
	835	);
	836	}
	837
	838	#[test]
	839	fn completes_local_item() {
	840	assert_debug_snapshot!(
	841	do_reference_completion(
	842	"
	843	//- /main.rs
	844	fn main() {
	845	return f<\|>;
	846	fn frobnicate() {}
	847	}
	848	"
	849	),
	850	@r###"
	851	[
	852	CompletionItem {
	853	label: "frobnicate()",
	854	source_range: [23; 24),
	855	delete: [23; 24),
	856	insert: "frobnicate()$0",
	857	kind: Function,
	858	lookup: "frobnicate",
	859	detail: "fn frobnicate()",
	860	},
	861	CompletionItem {
	862	label: "main()",
	863	source_range: [23; 24),
	864	delete: [23; 24),
	865	insert: "main()$0",
	866	kind: Function,
	867	lookup: "main",
	868	detail: "fn main()",
	869	},
	870	]
	871	"###
	872	)
	873	}
	874
	875	#[test]
	876	fn completes_in_simple_macro_1() {
	877	assert_debug_snapshot!(
	878	do_reference_completion(
	879	r"
	880	macro_rules! m { ($e:expr) => { $e } }
	881	fn quux(x: i32) {
	882	let y = 92;
	883	m!(<\|>);
	884	}
	885	"
	886	),
	887	@r###"
	888	[
	889	CompletionItem {
	890	label: "m!",
	891	source_range: [145; 145),
	892	delete: [145; 145),
	893	insert: "m!($0)",
	894	kind: Macro,
	895	detail: "macro_rules! m",
	896	},
	897	CompletionItem {
	898	label: "quux(…)",
	899	source_range: [145; 145),
	900	delete: [145; 145),
	901	insert: "quux(${1:x})$0",
	902	kind: Function,
	903	lookup: "quux",
	904	detail: "fn quux(x: i32)",
	905	trigger_call_info: true,
	906	},
	907	CompletionItem {
	908	label: "x",
	909	source_range: [145; 145),
	910	delete: [145; 145),
	911	insert: "x",
	912	kind: Binding,
	913	detail: "i32",
	914	},
	915	CompletionItem {
	916	label: "y",
	917	source_range: [145; 145),
	918	delete: [145; 145),
	919	insert: "y",
	920	kind: Binding,
	921	detail: "i32",
	922	},
	923	]
	924	"###
	925	);
	926	}
	927
	928	#[test]
	929	fn completes_in_simple_macro_2() {
	930	assert_debug_snapshot!(
	931	do_reference_completion(
	932	r"
	933	macro_rules! m { ($e:expr) => { $e } }
	934	fn quux(x: i32) {
	935	let y = 92;
	936	m!(x<\|>);
	937	}
	938	"
	939	),
	940	@r###"
	941	[
	942	CompletionItem {
	943	label: "m!",
	944	source_range: [145; 146),
	945	delete: [145; 146),
	946	insert: "m!($0)",
	947	kind: Macro,
	948	detail: "macro_rules! m",
	949	},
	950	CompletionItem {
	951	label: "quux(…)",
	952	source_range: [145; 146),
	953	delete: [145; 146),
	954	insert: "quux(${1:x})$0",
	955	kind: Function,
	956	lookup: "quux",
	957	detail: "fn quux(x: i32)",
	958	trigger_call_info: true,
	959	},
	960	CompletionItem {
	961	label: "x",
	962	source_range: [145; 146),
	963	delete: [145; 146),
	964	insert: "x",
	965	kind: Binding,
	966	detail: "i32",
	967	},
	968	CompletionItem {
	969	label: "y",
	970	source_range: [145; 146),
	971	delete: [145; 146),
	972	insert: "y",
	973	kind: Binding,
	974	detail: "i32",
	975	},
	976	]
	977	"###
	978	);
	979	}
	980
	981	#[test]
	982	fn completes_in_simple_macro_without_closing_parens() {
	983	assert_debug_snapshot!(
	984	do_reference_completion(
	985	r"
	986	macro_rules! m { ($e:expr) => { $e } }
	987	fn quux(x: i32) {
	988	let y = 92;
	989	m!(x<\|>
	990	}
	991	"
	992	),
	993	@r###"
	994	[
	995	CompletionItem {
	996	label: "m!",
	997	source_range: [145; 146),
	998	delete: [145; 146),
	999	insert: "m!($0)",
	1000	kind: Macro,
	1001	detail: "macro_rules! m",
	1002	},
	1003	CompletionItem {
	1004	label: "quux(…)",
	1005	source_range: [145; 146),
	1006	delete: [145; 146),
	1007	insert: "quux(${1:x})$0",
	1008	kind: Function,
	1009	lookup: "quux",
	1010	detail: "fn quux(x: i32)",
	1011	trigger_call_info: true,
	1012	},
	1013	CompletionItem {
	1014	label: "x",
	1015	source_range: [145; 146),
	1016	delete: [145; 146),
	1017	insert: "x",
	1018	kind: Binding,
	1019	detail: "i32",
	1020	},
	1021	CompletionItem {
	1022	label: "y",
	1023	source_range: [145; 146),
	1024	delete: [145; 146),
	1025	insert: "y",
	1026	kind: Binding,
	1027	detail: "i32",
	1028	},
	1029	]
	1030	"###
	1031	);
	1032	}
	1033
	1034	#[test]
	1035	fn completes_unresolved_uses() {
	1036	assert_debug_snapshot!(
	1037	do_reference_completion(
	1038	r"
	1039	use spam::Quux;
	1040
	1041	fn main() {
	1042	<\|>
	1043	}
	1044	"
	1045	),
	1046	@r###"
	1047	[
	1048	CompletionItem {
	1049	label: "Quux",
	1050	source_range: [82; 82),
	1051	delete: [82; 82),
	1052	insert: "Quux",
	1053	},
	1054	CompletionItem {
	1055	label: "main()",
	1056	source_range: [82; 82),
	1057	delete: [82; 82),
	1058	insert: "main()$0",
	1059	kind: Function,
	1060	lookup: "main",
	1061	detail: "fn main()",
	1062	},
	1063	]
	1064	"###
	1065	);
	1066	}
	1067	}