Move out and rewrite UseTree completion tests

crates/ide_completion/src/completions/keyword.rs

@@ -199,41 +199,6 @@ mod tests {
         expect.assert_eq(&actual)
     }
 
-    #[test]
-    fn test_keywords_in_use_stmt() {
-        check(
-            r"use $0",
-            expect![[r#"
-                kw crate::
-                kw self
-                kw super::
-            "#]],
-        );
-
-        // FIXME: `self` shouldn't be shown here and the check below
-        check(
-            r"use a::$0",
-            expect![[r#"
-            kw self
-        "#]],
-        );
-
-        check(
-            r"use super::$0",
-            expect![[r#"
-                kw self
-                kw super::
-            "#]],
-        );
-
-        check(
-            r"use a::{b, $0}",
-            expect![[r#"
-            kw self
-        "#]],
-        );
-    }
-
     #[test]
     fn test_keywords_in_function() {
         check(

crates/ide_completion/src/completions/qualified_path.rs

@@ -212,12 +212,6 @@ mod tests {
         expect.assert_eq(&actual);
     }
 
-    #[test]
-    fn dont_complete_current_use() {
-        cov_mark::check!(dont_complete_current_use);
-        check(r#"use self::foo$0;"#, expect![[""]]);
-    }
-
     #[test]
     fn dont_complete_values_in_type_pos() {
         check(
@@ -248,20 +242,6 @@ fn foo() {
         );
     }
 
-    #[test]
-    fn dont_complete_current_use_in_braces_with_glob() {
-        check(
-            r#"
-mod foo { pub struct S; }
-use self::{foo::*, bar$0};
-"#,
-            expect![[r#"
-                st S
-                md foo
-            "#]],
-        );
-    }
-
     #[test]
     fn dont_complete_primitive_in_use() {
         check_builtin(r#"use self::$0;"#, expect![[""]]);
@@ -298,108 +278,6 @@ use self::{foo::*, bar$0};
         );
     }
 
-    #[test]
-    fn completes_mod_with_same_name_as_function() {
-        check(
-            r#"
-use self::my::$0;
-
-mod my { pub struct Bar; }
-fn my() {}
-"#,
-            expect![[r#"
-                st Bar
-            "#]],
-        );
-    }
-
-    #[test]
-    fn filters_visibility() {
-        check(
-            r#"
-use self::my::$0;
-
-mod my {
-    struct Bar;
-    pub struct Foo;
-    pub use Bar as PublicBar;
-}
-"#,
-            expect![[r#"
-                st Foo
-                st PublicBar
-            "#]],
-        );
-    }
-
-    #[test]
-    fn completes_use_item_starting_with_self() {
-        check(
-            r#"
-use self::m::$0;
-
-mod m { pub struct Bar; }
-"#,
-            expect![[r#"
-                st Bar
-            "#]],
-        );
-    }
-
-    #[test]
-    fn completes_use_item_starting_with_crate() {
-        check(
-            r#"
-//- /lib.rs
-mod foo;
-struct Spam;
-//- /foo.rs
-use crate::Sp$0
-"#,
-            expect![[r#"
-                md foo
-                st Spam
-            "#]],
-        );
-    }
-
-    #[test]
-    fn completes_nested_use_tree() {
-        check(
-            r#"
-//- /lib.rs
-mod foo;
-struct Spam;
-//- /foo.rs
-use crate::{Sp$0};
-"#,
-            expect![[r#"
-                md foo
-                st Spam
-            "#]],
-        );
-    }
-
-    #[test]
-    fn completes_deeply_nested_use_tree() {
-        check(
-            r#"
-//- /lib.rs
-mod foo;
-pub mod bar {
-    pub mod baz {
-        pub struct Spam;
-    }
-}
-//- /foo.rs
-use crate::{bar::{baz::Sp$0}};
-"#,
-            expect![[r#"
-                st Spam
-            "#]],
-        );
-    }
-
     #[test]
     fn completes_enum_variant() {
         check(
@@ -496,22 +374,6 @@ fn foo() { let _ = U::$0 }
         );
     }
 
-    #[test]
-    fn completes_use_paths_across_crates() {
-        check(
-            r#"
-//- /main.rs crate:main deps:foo
-use foo::$0;
-
-//- /foo/lib.rs crate:foo
-pub mod bar { pub struct S; }
-"#,
-            expect![[r#"
-                md bar
-            "#]],
-        );
-    }
-
     #[test]
     fn completes_trait_associated_method_1() {
         check(
@@ -713,25 +575,6 @@ impl MyStruct {
         );
     }
 
-    #[test]
-    fn test_super_super_completion() {
-        check(
-            r#"
-mod a {
-    const A: usize = 0;
-    mod b {
-        const B: usize = 0;
-        mod c { use super::super::$0 }
-    }
-}
-"#,
-            expect![[r#"
-                md b
-                ct A
-            "#]],
-        );
-    }
-
     #[test]
     fn completes_reexported_items_under_correct_name() {
         check(

crates/ide_completion/src/completions/unqualified_path.rs

@@ -129,22 +129,6 @@ fn foo() {
         );
     }
 
-    #[test]
-    fn only_completes_modules_in_import() {
-        cov_mark::check!(only_completes_modules_in_import);
-        check(
-            r#"
-use f$0
-
-struct Foo;
-mod foo {}
-"#,
-            expect![[r#"
-                md foo
-            "#]],
-        );
-    }
-
     #[test]
     fn bind_pat_and_path_ignore_at() {
         check(
@@ -358,22 +342,6 @@ fn _alpha() {}
         )
     }
 
-    #[test]
-    fn completes_extern_prelude() {
-        check(
-            r#"
-//- /lib.rs crate:main deps:other_crate
-use $0;
-
-//- /other_crate/lib.rs crate:other_crate
-// nothing here
-"#,
-            expect![[r#"
-                md other_crate
-            "#]],
-        );
-    }
-
     #[test]
     fn completes_module_items_in_nested_modules() {
         check(

crates/ide_completion/src/tests.rs

@@ -1,4 +1,5 @@
 mod item_list;
+mod use_tree;
 
 use hir::{PrefixKind, Semantics};
 use ide_db::{

crates/ide_completion/src/tests/use_tree.rs

@@ -0,0 +1,261 @@
+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
+"#,
+        // FIXME: self in this case should also get the colons
+        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);
+    // FIXME: self shouldn't be here
+    check(
+        r#"use self::foo$0;"#,
+        expect![[r#"
+        kw self
+    "#]],
+    );
+    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() {
+    // FIXME: self shouldn't be here
+    check(
+        r#"
+mod foo {
+    pub mod bar {
+        pub struct FooBar;
+    }
+}
+use foo::{bar::$0}
+"#,
+        expect![[r#"
+            kw self
+            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() {
+    // FIXME: self shouldn't be here
+    check(
+        r#"
+mod foo {
+    pub mod bar {
+        pub mod baz {
+            pub struct FooBarBaz;
+        }
+    }
+}
+use foo::{bar::{baz::$0}}
+"#,
+        expect![[r#"
+            kw self
+            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() {
+    // FIXME: self shouldn't be here
+    check(
+        r#"
+use foo::$0
+
+mod foo {
+    struct Private;
+    pub struct Foo;
+}
+struct Bar;
+"#,
+        expect![[r#"
+            kw self
+            st Foo
+        "#]],
+    );
+}
+
+#[test]
+fn self_qualified_use_tree() {
+    // FIXME: self shouldn't be here
+    check(
+        r#"
+use self::$0
+
+mod foo {}
+struct Bar;
+"#,
+        expect![[r#"
+            kw self
+            md foo
+            st Bar
+        "#]],
+    );
+}
+
+#[test]
+fn super_qualified_use_tree() {
+    // FIXME: self shouldn't be here
+    check(
+        r#"
+mod bar {
+    use super::$0
+}
+
+mod foo {}
+struct Bar;
+"#,
+        expect![[r#"
+            kw self
+            kw super::
+            st Bar
+            md bar
+            md foo
+        "#]],
+    );
+}
+
+#[test]
+fn super_super_qualified_use_tree() {
+    // FIXME: self shouldn't be here
+    check(
+        r#"
+mod a {
+    const A: usize = 0;
+    mod b {
+        const B: usize = 0;
+        mod c { use super::super::$0 }
+    }
+}
+"#,
+        expect![[r#"
+            kw self
+            kw super::
+            md b
+            ct A
+        "#]],
+    );
+}
+
+#[test]
+fn crate_qualified_use_tree() {
+    // FIXME: self shouldn't be here
+    check(
+        r#"
+use crate::$0
+
+mod foo {}
+struct Bar;
+"#,
+        expect![[r#"
+            kw self
+            md foo
+            st Bar
+        "#]],
+    );
+}
+
+#[test]
+fn extern_crate_qualified_use_tree() {
+    // FIXME: self shouldn't be here
+    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#"
+            kw self
+            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
+        "#]],
+    );
+}