5 files changed, 1098 insertions, 0 deletions

diff --git a/crates/ide_completion/src/tests/item_list.rs b/crates/ide_completion/src/tests/item_list.rs
new file mode 100644
index 000000000..7c124ac37
--- /dev/null
+++ b/crates/ide_completion/src/tests/item_list.rs
@@ -0,0 +1,223 @@
+use expect_test::{expect, Expect};
+
+use crate::tests::completion_list;
+
+fn check(ra_fixture: &str, expect: Expect) {
+    let base = r#"#[rustc_builtin_macro]
+pub macro Clone {}
+enum Enum { Variant }
+struct Struct {}
+#[macro_export]
+macro_rules! foo {}
+mod bar {}
+const CONST: () = ();
+trait Trait {}
+"#;
+    let actual = completion_list(&format!("{}{}", base, ra_fixture));
+    expect.assert_eq(&actual)
+}
+
+#[test]
+fn in_mod_item_list() {
+    check(
+        r#"mod tests { $0 }"#,
+        expect![[r##"
+            kw pub(crate)
+            kw pub
+            kw unsafe
+            kw fn
+            kw const
+            kw type
+            kw impl
+            kw extern
+            kw use
+            kw trait
+            kw static
+            kw mod
+            kw enum
+            kw struct
+            kw union
+            sn tmod (Test module)
+            sn tfn (Test function)
+            sn macro_rules
+            ma foo!(…)          #[macro_export] macro_rules! foo
+        "##]],
+    )
+}
+
+#[test]
+fn in_source_file_item_list() {
+    check(
+        r#"$0"#,
+        expect![[r##"
+            kw pub(crate)
+            kw pub
+            kw unsafe
+            kw fn
+            kw const
+            kw type
+            kw impl
+            kw extern
+            kw use
+            kw trait
+            kw static
+            kw mod
+            kw enum
+            kw struct
+            kw union
+            sn tmod (Test module)
+            sn tfn (Test function)
+            sn macro_rules
+            md bar
+            ma foo!(…)          #[macro_export] macro_rules! foo
+            ma foo!(…)          #[macro_export] macro_rules! foo
+        "##]],
+    )
+}
+
+#[test]
+fn in_item_list_after_attr() {
+    check(
+        r#"#[attr] $0"#,
+        expect![[r#"
+            kw pub(crate)
+            kw pub
+            kw unsafe
+            kw fn
+            kw const
+            kw type
+            kw impl
+            kw extern
+            kw use
+            kw trait
+            kw static
+            kw mod
+            kw enum
+            kw struct
+            kw union
+            sn tmod (Test module)
+            sn tfn (Test function)
+            sn macro_rules
+        "#]],
+    )
+}
+
+#[test]
+fn in_qualified_path() {
+    check(
+        r#"crate::$0"#,
+        expect![[r##"
+            kw pub(crate)
+            kw pub
+            kw unsafe
+            kw fn
+            kw const
+            kw type
+            kw impl
+            kw extern
+            kw use
+            kw trait
+            kw static
+            kw mod
+            kw enum
+            kw struct
+            kw union
+            md bar
+            ma foo!(…)    #[macro_export] macro_rules! foo
+        "##]],
+    )
+}
+
+#[test]
+fn after_unsafe_token() {
+    check(
+        r#"unsafe $0"#,
+        expect![[r#"
+            kw fn
+            kw trait
+            kw impl
+        "#]],
+    );
+}
+
+#[test]
+fn after_visibility() {
+    check(
+        r#"pub $0"#,
+        expect![[r#"
+            kw unsafe
+            kw fn
+            kw const
+            kw type
+            kw use
+            kw trait
+            kw static
+            kw mod
+            kw enum
+            kw struct
+            kw union
+        "#]],
+    );
+}
+
+#[test]
+fn after_visibility_unsafe() {
+    // FIXME this shouldn't show `impl`
+    check(
+        r#"pub unsafe $0"#,
+        expect![[r#"
+            kw fn
+            kw trait
+            kw impl
+        "#]],
+    );
+}
+
+#[test]
+fn in_impl_assoc_item_list() {
+    check(
+        r#"impl Struct { $0 }"#,
+        expect![[r##"
+            kw pub(crate)
+            kw pub
+            kw unsafe
+            kw fn
+            kw const
+            kw type
+            md bar
+            ma foo!(…)    #[macro_export] macro_rules! foo
+            ma foo!(…)    #[macro_export] macro_rules! foo
+        "##]],
+    )
+}
+
+#[test]
+fn in_impl_assoc_item_list_after_attr() {
+    check(
+        r#"impl Struct { #[attr] $0 }"#,
+        expect![[r#"
+            kw pub(crate)
+            kw pub
+            kw unsafe
+            kw fn
+            kw const
+            kw type
+        "#]],
+    )
+}
+
+#[test]
+fn in_trait_assoc_item_list() {
+    check(
+        r"trait Foo { $0 }",
+        expect![[r##"
+            kw unsafe
+            kw fn
+            kw const
+            kw type
+            md bar
+            ma foo!(…) #[macro_export] macro_rules! foo
+            ma foo!(…) #[macro_export] macro_rules! foo
+        "##]],
+    );
+}
diff --git a/crates/ide_completion/src/tests/items.rs b/crates/ide_completion/src/tests/items.rs
new file mode 100644
index 000000000..b98baffd6
--- /dev/null
+++ b/crates/ide_completion/src/tests/items.rs
@@ -0,0 +1,95 @@
+//! Completions tests for item specifics overall.
+//!
+//! Except for use items which are tested in [super::use_tree] and mod declarations with are tested
+//! in [crate::completions::mod_].
+use expect_test::{expect, Expect};
+
+use crate::tests::completion_list;
+
+fn check(ra_fixture: &str, expect: Expect) {
+    let base = r#"#[rustc_builtin_macro]
+pub macro Clone {}
+enum Enum { Variant }
+struct Struct {}
+#[macro_export]
+macro_rules! foo {}
+mod bar {}
+const CONST: () = ();
+trait Trait {}
+"#;
+    let actual = completion_list(&format!("{}{}", base, ra_fixture));
+    expect.assert_eq(&actual)
+}
+
+#[test]
+fn target_type_or_trait_in_impl_block() {
+    check(
+        r#"
+impl Tra$0
+"#,
+        expect![[r##"
+            tt Trait
+            en Enum
+            st Struct
+            md bar
+            ma foo!(…) #[macro_export] macro_rules! foo
+            ma foo!(…) #[macro_export] macro_rules! foo
+            bt u32
+        "##]],
+    )
+}
+
+#[test]
+fn target_type_in_trait_impl_block() {
+    check(
+        r#"
+impl Trait for Str$0
+"#,
+        expect![[r##"
+            tt Trait
+            en Enum
+            st Struct
+            md bar
+            ma foo!(…) #[macro_export] macro_rules! foo
+            ma foo!(…) #[macro_export] macro_rules! foo
+            bt u32
+        "##]],
+    )
+}
+
+#[test]
+fn after_trait_name_in_trait_def() {
+    check(
+        r"trait A $0",
+        expect![[r#"
+            kw where
+        "#]],
+    );
+}
+
+#[test]
+fn after_trait_or_target_name_in_impl() {
+    check(
+        r"impl Trait $0",
+        expect![[r#"
+            kw where
+            kw for
+        "#]],
+    );
+}
+
+#[test]
+fn before_record_field() {
+    check(
+        r#"
+struct Foo {
+    $0
+    pub f: i32,
+}
+"#,
+        expect![[r#"
+            kw pub(crate)
+            kw pub
+        "#]],
+    )
+}
diff --git a/crates/ide_completion/src/tests/pattern.rs b/crates/ide_completion/src/tests/pattern.rs
new file mode 100644
index 000000000..1ad5ccd97
--- /dev/null
+++ b/crates/ide_completion/src/tests/pattern.rs
@@ -0,0 +1,348 @@
+//! Completions tests for pattern position.
+use expect_test::{expect, Expect};
+
+use crate::tests::completion_list;
+
+fn check(ra_fixture: &str, expect: Expect) {
+    let actual = completion_list(ra_fixture);
+    expect.assert_eq(&actual)
+}
+
+fn check_with(ra_fixture: &str, expect: Expect) {
+    let base = r#"
+enum Enum { TupleV(u32), RecordV { field: u32 }, UnitV }
+use self::Enum::TupleV;
+mod module {}
+
+static STATIC: Unit = Unit;
+const CONST: Unit = Unit;
+struct Record { field: u32 }
+struct Tuple(u32);
+struct Unit
+macro_rules! makro {}
+"#;
+    let actual = completion_list(&format!("{}\n{}", base, ra_fixture));
+    expect.assert_eq(&actual)
+}
+
+#[test]
+fn ident_rebind_pat() {
+    check(
+        r#"
+fn quux() {
+    let en$0 @ x
+}
+"#,
+        expect![[r#"
+            kw mut
+        "#]],
+    );
+}
+
+#[test]
+fn ident_ref_pat() {
+    check(
+        r#"
+fn quux() {
+    let ref en$0
+}
+"#,
+        expect![[r#"
+            kw mut
+        "#]],
+    );
+    check(
+        r#"
+fn quux() {
+    let ref en$0 @ x
+}
+"#,
+        expect![[r#"
+            kw mut
+        "#]],
+    );
+}
+
+#[test]
+fn ident_ref_mut_pat() {
+    // FIXME mut is already here, don't complete it again
+    check(
+        r#"
+fn quux() {
+    let ref mut en$0
+}
+"#,
+        expect![[r#"
+            kw mut
+        "#]],
+    );
+    check(
+        r#"
+fn quux() {
+    let ref mut en$0 @ x
+}
+"#,
+        expect![[r#"
+            kw mut
+        "#]],
+    );
+}
+
+#[test]
+fn ref_pat() {
+    check(
+        r#"
+fn quux() {
+    let &en$0
+}
+"#,
+        expect![[r#"
+            kw mut
+        "#]],
+    );
+    // FIXME mut is already here, don't complete it again
+    check(
+        r#"
+fn quux() {
+    let &mut en$0
+}
+"#,
+        expect![[r#"
+            kw mut
+        "#]],
+    );
+}
+
+#[test]
+fn refutable() {
+    check_with(
+        r#"
+fn foo() {
+    if let a$0
+}
+"#,
+        expect![[r#"
+            kw mut
+            bn Record    Record { field$1 }$0
+            st Record
+            en Enum
+            bn Tuple     Tuple($1)$0
+            st Tuple
+            md module
+            bn TupleV    TupleV($1)$0
+            ev TupleV
+            st Unit
+            ct CONST
+            ma makro!(…) macro_rules! makro
+        "#]],
+    );
+}
+
+#[test]
+fn irrefutable() {
+    check_with(
+        r#"
+fn foo() {
+   let a$0
+}
+"#,
+        expect![[r#"
+            kw mut
+            bn Record    Record { field$1 }$0
+            st Record
+            bn Tuple     Tuple($1)$0
+            st Tuple
+            st Unit
+            ma makro!(…) macro_rules! makro
+        "#]],
+    );
+}
+
+#[test]
+fn in_param() {
+    check_with(
+        r#"
+fn foo(a$0) {
+}
+"#,
+        expect![[r#"
+            kw mut
+            bn Record    Record { field$1 }: Record$0
+            st Record
+            bn Tuple     Tuple($1): Tuple$0
+            st Tuple
+            st Unit
+            ma makro!(…) macro_rules! makro
+        "#]],
+    );
+}
+
+#[test]
+fn only_fn_like_macros() {
+    check(
+        r#"
+macro_rules! m { ($e:expr) => { $e } }
+
+#[rustc_builtin_macro]
+macro Clone {}
+
+fn foo() {
+    let x$0
+}
+"#,
+        expect![[r#"
+            kw mut
+            ma m!(…) macro_rules! m
+        "#]],
+    );
+}
+
+#[test]
+fn in_simple_macro_call() {
+    check(
+        r#"
+macro_rules! m { ($e:expr) => { $e } }
+enum E { X }
+
+fn foo() {
+   m!(match E::X { a$0 })
+}
+"#,
+        expect![[r#"
+            kw mut
+            ev E::X  ()
+            en E
+            ma m!(…) macro_rules! m
+        "#]],
+    );
+}
+
+#[test]
+fn omits_private_fields_pat() {
+    check(
+        r#"
+mod foo {
+    pub struct Record { pub field: i32, _field: i32 }
+    pub struct Tuple(pub u32, u32);
+    pub struct Invisible(u32, u32);
+}
+use foo::*;
+
+fn outer() {
+    if let a$0
+}
+"#,
+        expect![[r#"
+            kw mut
+            bn Record    Record { field$1, .. }$0
+            st Record
+            bn Tuple     Tuple($1, ..)$0
+            st Tuple
+            st Invisible
+            md foo
+        "#]],
+    )
+}
+
+// #[test]
+// fn only_shows_ident_completion() {
+//     check_edit(
+//         "Foo",
+//         r#"
+// struct Foo(i32);
+// fn main() {
+//     match Foo(92) {
+//         a$0(92) => (),
+//     }
+// }
+// "#,
+//         r#"
+// struct Foo(i32);
+// fn main() {
+//     match Foo(92) {
+//         Foo(92) => (),
+//     }
+// }
+// "#,
+//     );
+// }
+
+#[test]
+fn completes_self_pats() {
+    check(
+        r#"
+struct Foo(i32);
+impl Foo {
+    fn foo() {
+        match Foo(0) {
+            a$0
+        }
+    }
+}
+    "#,
+        expect![[r#"
+            kw mut
+            bn Self Self($1)$0
+            sp Self
+            bn Foo  Foo($1)$0
+            st Foo
+        "#]],
+    )
+}
+
+#[test]
+fn completes_qualified_variant() {
+    check(
+        r#"
+enum Foo {
+    Bar { baz: i32 }
+}
+impl Foo {
+    fn foo() {
+        match {Foo::Bar { baz: 0 }} {
+            B$0
+        }
+    }
+}
+    "#,
+        expect![[r#"
+            kw mut
+            bn Self::Bar Self::Bar { baz$1 }$0
+            ev Self::Bar { baz: i32 }
+            bn Foo::Bar  Foo::Bar { baz$1 }$0
+            ev Foo::Bar  { baz: i32 }
+            sp Self
+            en Foo
+        "#]],
+    )
+}
+
+#[test]
+fn completes_in_record_field_pat() {
+    check(
+        r#"
+struct Foo { bar: Bar }
+struct Bar(u32);
+fn outer(Foo { bar: $0 }: Foo) {}
+"#,
+        expect![[r#"
+            kw mut
+            bn Foo Foo { bar$1 }$0
+            st Foo
+            bn Bar Bar($1)$0
+            st Bar
+        "#]],
+    )
+}
+
+#[test]
+fn skips_in_record_field_pat_name() {
+    check(
+        r#"
+struct Foo { bar: Bar }
+struct Bar(u32);
+fn outer(Foo { bar$0 }: Foo) {}
+"#,
+        expect![[r#""#]],
+    )
+}
diff --git a/crates/ide_completion/src/tests/type_pos.rs b/crates/ide_completion/src/tests/type_pos.rs
new file mode 100644
index 000000000..1ab47b27e
--- /dev/null
+++ b/crates/ide_completion/src/tests/type_pos.rs
@@ -0,0 +1,177 @@
+//! Completions tests for type position.
+use expect_test::{expect, Expect};
+
+use crate::tests::completion_list;
+
+fn check_with(ra_fixture: &str, expect: Expect) {
+    let base = r#"
+enum Enum { TupleV(u32), RecordV { field: u32 }, UnitV }
+use self::Enum::TupleV;
+mod module {}
+
+trait Trait {}
+static STATIC: Unit = Unit;
+const CONST: Unit = Unit;
+struct Record { field: u32 }
+struct Tuple(u32);
+struct Unit
+macro_rules! makro {}
+"#;
+    let actual = completion_list(&format!("{}\n{}", base, ra_fixture));
+    expect.assert_eq(&actual)
+}
+
+#[test]
+fn record_field_ty() {
+    check_with(
+        r#"
+struct Foo<'lt, T, const C: usize> {
+    f: $0
+}
+"#,
+        expect![[r#"
+            sp Self
+            tp T
+            tt Trait
+            en Enum
+            st Record
+            st Tuple
+            md module
+            st Foo<…>
+            st Unit
+            ma makro!(…) macro_rules! makro
+            bt u32
+        "#]],
+    )
+}
+
+#[test]
+fn tuple_struct_field() {
+    check_with(
+        r#"
+struct Foo<'lt, T, const C: usize>(f$0);
+"#,
+        expect![[r#"
+            kw pub(crate)
+            kw pub
+            sp Self
+            tp T
+            tt Trait
+            en Enum
+            st Record
+            st Tuple
+            md module
+            st Foo<…>
+            st Unit
+            ma makro!(…)  macro_rules! makro
+            bt u32
+        "#]],
+    )
+}
+
+#[test]
+fn fn_return_type() {
+    check_with(
+        r#"
+fn x<'lt, T, const C: usize>() -> $0
+"#,
+        expect![[r#"
+            tp T
+            tt Trait
+            en Enum
+            st Record
+            st Tuple
+            md module
+            st Unit
+            ma makro!(…) macro_rules! makro
+            bt u32
+        "#]],
+    );
+}
+
+#[test]
+fn body_type_pos() {
+    check_with(
+        r#"
+fn foo<'lt, T, const C: usize>() {
+    let local = ();
+    let _: $0;
+}
+"#,
+        expect![[r#"
+            tp T
+            tt Trait
+            en Enum
+            st Record
+            st Tuple
+            md module
+            st Unit
+            ma makro!(…) macro_rules! makro
+            bt u32
+        "#]],
+    );
+    check_with(
+        r#"
+fn foo<'lt, T, const C: usize>() {
+    let local = ();
+    let _: self::$0;
+}
+"#,
+        expect![[r#"
+            tt Trait
+            en Enum
+            st Record
+            st Tuple
+            md module
+            st Unit
+        "#]],
+    );
+}
+
+#[test]
+fn completes_types_and_const_in_arg_list() {
+    // FIXME: we should complete the lifetime here for now
+    check_with(
+        r#"
+trait Trait2 {
+    type Foo;
+}
+
+fn foo<'lt, T: Trait2<$0>, const CONST_PARAM: usize>(_: T) {}
+"#,
+        expect![[r#"
+            ta Foo =       type Foo;
+            tp T
+            cp CONST_PARAM
+            tt Trait
+            en Enum
+            st Record
+            st Tuple
+            tt Trait2
+            md module
+            st Unit
+            ct CONST
+            ma makro!(…)   macro_rules! makro
+            bt u32
+        "#]],
+    );
+    check_with(
+        r#"
+trait Trait2 {
+    type Foo;
+}
+
+fn foo<'lt, T: Trait2<self::$0>, const CONST_PARAM: usize>(_: T) {}
+    "#,
+        expect![[r#"
+            tt Trait
+            en Enum
+            st Record
+            st Tuple
+            tt Trait2
+            md module
+            st Unit
+            ct CONST
+        "#]],
+    );
+}
diff --git a/crates/ide_completion/src/tests/use_tree.rs b/crates/ide_completion/src/tests/use_tree.rs
new file mode 100644
index 000000000..7e6748ccc
--- /dev/null
+++ b/crates/ide_completion/src/tests/use_tree.rs
@@ -0,0 +1,255 @@
+use expect_test::{expect, Expect};
+
+use crate::tests::completion_list;
+
+fn check(ra_fixture: &str, expect: Expect) {
+    let actual = completion_list(ra_fixture);
+    expect.assert_eq(&actual)
+}
+
+#[test]
+fn use_tree_start() {
+    cov_mark::check!(only_completes_modules_in_import);
+    check(
+        r#"
+//- /lib.rs crate:main deps:other_crate
+use f$0
+
+struct Foo;
+mod foo {}
+//- /other_crate/lib.rs crate:other_crate
+// nothing here
+"#,
+        expect![[r#"
+            kw crate::
+            kw self::
+            kw super::
+            md foo
+            md other_crate
+        "#]],
+    );
+}
+
+#[test]
+fn dont_complete_current_use() {
+    cov_mark::check!(dont_complete_current_use);
+    check(r#"use self::foo$0;"#, expect![[r#""#]]);
+    check(
+        r#"
+mod foo { pub struct S; }
+use self::{foo::*, bar$0};
+"#,
+        expect![[r#"
+            kw self
+            st S
+            md foo
+        "#]],
+    );
+}
+
+#[test]
+fn nested_use_tree() {
+    check(
+        r#"
+mod foo {
+    pub mod bar {
+        pub struct FooBar;
+    }
+}
+use foo::{bar::$0}
+"#,
+        expect![[r#"
+            st FooBar
+        "#]],
+    );
+    check(
+        r#"
+mod foo {
+    pub mod bar {
+        pub struct FooBar;
+    }
+}
+use foo::{$0}
+"#,
+        expect![[r#"
+            kw self
+            md bar
+        "#]],
+    );
+}
+
+#[test]
+fn deeply_nested_use_tree() {
+    check(
+        r#"
+mod foo {
+    pub mod bar {
+        pub mod baz {
+            pub struct FooBarBaz;
+        }
+    }
+}
+use foo::{bar::{baz::$0}}
+"#,
+        expect![[r#"
+            st FooBarBaz
+        "#]],
+    );
+    check(
+        r#"
+mod foo {
+    pub mod bar {
+        pub mod baz {
+            pub struct FooBarBaz;
+        }
+    }
+}
+use foo::{bar::{$0}}
+"#,
+        expect![[r#"
+            kw self
+            md baz
+        "#]],
+    );
+}
+
+#[test]
+fn plain_qualified_use_tree() {
+    check(
+        r#"
+use foo::$0
+
+mod foo {
+    struct Private;
+    pub struct Foo;
+}
+struct Bar;
+"#,
+        expect![[r#"
+            st Foo
+        "#]],
+    );
+}
+
+#[test]
+fn self_qualified_use_tree() {
+    check(
+        r#"
+use self::$0
+
+mod foo {}
+struct Bar;
+"#,
+        expect![[r#"
+            md foo
+            st Bar
+        "#]],
+    );
+}
+
+#[test]
+fn super_qualified_use_tree() {
+    check(
+        r#"
+mod bar {
+    use super::$0
+}
+
+mod foo {}
+struct Bar;
+"#,
+        expect![[r#"
+            kw super::
+            st Bar
+            md bar
+            md foo
+        "#]],
+    );
+}
+
+#[test]
+fn super_super_qualified_use_tree() {
+    check(
+        r#"
+mod a {
+    const A: usize = 0;
+    mod b {
+        const B: usize = 0;
+        mod c { use super::super::$0 }
+    }
+}
+"#,
+        expect![[r#"
+            kw super::
+            md b
+            ct A
+        "#]],
+    );
+}
+
+#[test]
+fn crate_qualified_use_tree() {
+    check(
+        r#"
+use crate::$0
+
+mod foo {}
+struct Bar;
+"#,
+        expect![[r#"
+            md foo
+            st Bar
+        "#]],
+    );
+}
+
+#[test]
+fn extern_crate_qualified_use_tree() {
+    check(
+        r#"
+//- /lib.rs crate:main deps:other_crate
+use other_crate::$0
+//- /other_crate/lib.rs crate:other_crate
+pub struct Foo;
+pub mod foo {}
+"#,
+        expect![[r#"
+            st Foo
+            md foo
+        "#]],
+    );
+}
+
+#[test]
+fn pub_use_tree() {
+    check(
+        r#"
+pub struct X;
+pub mod bar {}
+pub use $0;
+"#,
+        expect![[r#"
+            kw crate::
+            kw self::
+            kw super::
+            md bar
+        "#]],
+    );
+}
+
+#[test]
+fn use_tree_braces_at_start() {
+    check(
+        r#"
+struct X;
+mod bar {}
+use {$0};
+"#,
+        expect![[r#"
+            kw crate::
+            kw self::
+            kw super::
+            md bar
+        "#]],
+    );
+}