Remove filtered completion list usage in completion tests

14 files changed, 1746 insertions, 1346 deletions

diff --git a/crates/ide_completion/src/completions/dot.rs b/crates/ide_completion/src/completions/dot.rs
index 213cb701704..9649667bd76 100644
--- a/crates/ide_completion/src/completions/dot.rs
+++ b/crates/ide_completion/src/completions/dot.rs
@@ -99,13 +99,10 @@ fn complete_methods(
 mod tests {
     use expect_test::{expect, Expect};
 
-    use crate::{
-        tests::{check_edit, filtered_completion_list},
-        CompletionKind,
-    };
+    use crate::tests::{check_edit, completion_list_no_kw};
 
     fn check(ra_fixture: &str, expect: Expect) {
-        let actual = filtered_completion_list(ra_fixture, CompletionKind::Reference);
+        let actual = completion_list_no_kw(ra_fixture);
         expect.assert_eq(&actual);
     }
 
@@ -122,6 +119,18 @@ fn foo(s: S) { s.$0 }
             expect![[r#"
                 fd foo   u32
                 me bar() fn(&self)
+                sn ref   &expr
+                sn refm  &mut expr
+                sn match match expr {}
+                sn box   Box::new(expr)
+                sn ok    Ok(expr)
+                sn err   Err(expr)
+                sn some  Some(expr)
+                sn dbg   dbg!(expr)
+                sn dbgr  dbg!(&expr)
+                sn call  function(expr)
+                sn let   let
+                sn letm  let mut
             "#]],
         );
     }
@@ -138,6 +147,18 @@ impl S {
             expect![[r#"
                 fd the_field (u32,)
                 me foo()     fn(self)
+                sn ref       &expr
+                sn refm      &mut expr
+                sn match     match expr {}
+                sn box       Box::new(expr)
+                sn ok        Ok(expr)
+                sn err       Err(expr)
+                sn some      Some(expr)
+                sn dbg       dbg!(expr)
+                sn dbgr      dbg!(&expr)
+                sn call      function(expr)
+                sn let       let
+                sn letm      let mut
             "#]],
         )
     }
@@ -154,6 +175,18 @@ impl A {
             expect![[r#"
                 fd the_field (u32, i32)
                 me foo()     fn(&self)
+                sn ref       &expr
+                sn refm      &mut expr
+                sn match     match expr {}
+                sn box       Box::new(expr)
+                sn ok        Ok(expr)
+                sn err       Err(expr)
+                sn some      Some(expr)
+                sn dbg       dbg!(expr)
+                sn dbgr      dbg!(&expr)
+                sn call      function(expr)
+                sn let       let
+                sn letm      let mut
             "#]],
         )
     }
@@ -166,7 +199,18 @@ impl A {
 struct A { the_field: u32 }
 fn foo(a: A) { a.$0() }
 "#,
-            expect![[""]],
+            expect![[r#"
+                sn ref   &expr
+                sn refm  &mut expr
+                sn match match expr {}
+                sn box   Box::new(expr)
+                sn ok    Ok(expr)
+                sn err   Err(expr)
+                sn some  Some(expr)
+                sn dbg   dbg!(expr)
+                sn dbgr  dbg!(&expr)
+                sn call  function(expr)
+            "#]],
         );
     }
 
@@ -191,6 +235,18 @@ fn foo(a: lib::m::A) { a.$0 }
                 fd pub_field     u32
                 fd crate_field   u32
                 fd super_field   u32
+                sn ref           &expr
+                sn refm          &mut expr
+                sn match         match expr {}
+                sn box           Box::new(expr)
+                sn ok            Ok(expr)
+                sn err           Err(expr)
+                sn some          Some(expr)
+                sn dbg           dbg!(expr)
+                sn dbgr          dbg!(&expr)
+                sn call          function(expr)
+                sn let           let
+                sn letm          let mut
             "#]],
         );
 
@@ -210,6 +266,18 @@ fn foo(a: lib::m::A) { a.$0 }
 "#,
             expect![[r#"
                 fd pub_field u32
+                sn ref       &expr
+                sn refm      &mut expr
+                sn match     match expr {}
+                sn box       Box::new(expr)
+                sn ok        Ok(expr)
+                sn err       Err(expr)
+                sn some      Some(expr)
+                sn dbg       dbg!(expr)
+                sn dbgr      dbg!(&expr)
+                sn call      function(expr)
+                sn let       let
+                sn letm      let mut
             "#]],
         );
 
@@ -226,7 +294,19 @@ pub mod m {
 fn foo(a: lib::m::A) { a.$0 }
 "#,
             expect![[r#"
-                fd 1 f64
+                fd 1     f64
+                sn ref   &expr
+                sn refm  &mut expr
+                sn match match expr {}
+                sn box   Box::new(expr)
+                sn ok    Ok(expr)
+                sn err   Err(expr)
+                sn some  Some(expr)
+                sn dbg   dbg!(expr)
+                sn dbgr  dbg!(&expr)
+                sn call  function(expr)
+                sn let   let
+                sn letm  let mut
             "#]],
         );
 
@@ -248,6 +328,18 @@ fn foo(a: lib::A) { a.$0 }
                 me private_method() fn(&self)
                 me crate_method()   fn(&self)
                 me pub_method()     fn(&self)
+                sn ref              &expr
+                sn refm             &mut expr
+                sn match            match expr {}
+                sn box              Box::new(expr)
+                sn ok               Ok(expr)
+                sn err              Err(expr)
+                sn some             Some(expr)
+                sn dbg              dbg!(expr)
+                sn dbgr             dbg!(&expr)
+                sn call             function(expr)
+                sn let              let
+                sn letm             let mut
             "#]],
         );
         check(
@@ -266,6 +358,18 @@ fn foo(a: lib::A) { a.$0 }
 "#,
             expect![[r#"
                 me pub_method() fn(&self)
+                sn ref          &expr
+                sn refm         &mut expr
+                sn match        match expr {}
+                sn box          Box::new(expr)
+                sn ok           Ok(expr)
+                sn err          Err(expr)
+                sn some         Some(expr)
+                sn dbg          dbg!(expr)
+                sn dbgr         dbg!(&expr)
+                sn call         function(expr)
+                sn let          let
+                sn letm         let mut
             "#]],
         );
     }
@@ -293,6 +397,18 @@ impl A {
             expect![[r#"
                 fd pub_field    u32
                 me pub_method() fn(&self)
+                sn ref          &expr
+                sn refm         &mut expr
+                sn match        match expr {}
+                sn box          Box::new(expr)
+                sn ok           Ok(expr)
+                sn err          Err(expr)
+                sn some         Some(expr)
+                sn dbg          dbg!(expr)
+                sn dbgr         dbg!(&expr)
+                sn call         function(expr)
+                sn let          let
+                sn letm         let mut
             "#]],
         )
     }
@@ -307,6 +423,18 @@ fn foo(u: U) { u.$0 }
             expect![[r#"
                 fd field u8
                 fd other u16
+                sn ref   &expr
+                sn refm  &mut expr
+                sn match match expr {}
+                sn box   Box::new(expr)
+                sn ok    Ok(expr)
+                sn err   Err(expr)
+                sn some  Some(expr)
+                sn dbg   dbg!(expr)
+                sn dbgr  dbg!(&expr)
+                sn call  function(expr)
+                sn let   let
+                sn letm  let mut
             "#]],
         );
     }
@@ -326,6 +454,18 @@ fn foo(a: A<u32>) { a.$0 }
 "#,
             expect![[r#"
                 me the_method() fn(&self)
+                sn ref          &expr
+                sn refm         &mut expr
+                sn match        match expr {}
+                sn box          Box::new(expr)
+                sn ok           Ok(expr)
+                sn err          Err(expr)
+                sn some         Some(expr)
+                sn dbg          dbg!(expr)
+                sn dbgr         dbg!(&expr)
+                sn call         function(expr)
+                sn let          let
+                sn letm         let mut
             "#]],
         )
     }
@@ -341,6 +481,18 @@ fn foo(a: A) { a.$0 }
 "#,
             expect![[r#"
                 me the_method() (as Trait) fn(&self)
+                sn ref                    &expr
+                sn refm                   &mut expr
+                sn match                  match expr {}
+                sn box                    Box::new(expr)
+                sn ok                     Ok(expr)
+                sn err                    Err(expr)
+                sn some                   Some(expr)
+                sn dbg                    dbg!(expr)
+                sn dbgr                   dbg!(&expr)
+                sn call                   function(expr)
+                sn let                    let
+                sn letm                   let mut
             "#]],
         );
         check_edit(
@@ -371,6 +523,18 @@ fn foo(a: &A) { a.$0 }
 ",
             expect![[r#"
                 me the_method() (as Trait) fn(&self)
+                sn ref                    &expr
+                sn refm                   &mut expr
+                sn match                  match expr {}
+                sn box                    Box::new(expr)
+                sn ok                     Ok(expr)
+                sn err                    Err(expr)
+                sn some                   Some(expr)
+                sn dbg                    dbg!(expr)
+                sn dbgr                   dbg!(&expr)
+                sn call                   function(expr)
+                sn let                    let
+                sn letm                   let mut
             "#]],
         );
     }
@@ -389,6 +553,18 @@ fn foo(a: A) { a.$0 }
 ",
             expect![[r#"
                 me the_method() (as Trait) fn(&self)
+                sn ref                    &expr
+                sn refm                   &mut expr
+                sn match                  match expr {}
+                sn box                    Box::new(expr)
+                sn ok                     Ok(expr)
+                sn err                    Err(expr)
+                sn some                   Some(expr)
+                sn dbg                    dbg!(expr)
+                sn dbgr                   dbg!(&expr)
+                sn call                   function(expr)
+                sn let                    let
+                sn letm                   let mut
             "#]],
         );
     }
@@ -405,7 +581,20 @@ fn foo(a: A) {
    a.$0
 }
 "#,
-            expect![[""]],
+            expect![[r#"
+                sn ref   &expr
+                sn refm  &mut expr
+                sn match match expr {}
+                sn box   Box::new(expr)
+                sn ok    Ok(expr)
+                sn err   Err(expr)
+                sn some  Some(expr)
+                sn dbg   dbg!(expr)
+                sn dbgr  dbg!(&expr)
+                sn call  function(expr)
+                sn let   let
+                sn letm  let mut
+            "#]],
         );
     }
 
@@ -419,8 +608,20 @@ fn foo() {
 }
 "#,
             expect![[r#"
-                fd 0 i32
-                fd 1 f64
+                fd 0     i32
+                fd 1     f64
+                sn ref   &expr
+                sn refm  &mut expr
+                sn match match expr {}
+                sn box   Box::new(expr)
+                sn ok    Ok(expr)
+                sn err   Err(expr)
+                sn some  Some(expr)
+                sn dbg   dbg!(expr)
+                sn dbgr  dbg!(&expr)
+                sn call  function(expr)
+                sn let   let
+                sn letm  let mut
             "#]],
         );
     }
@@ -436,8 +637,20 @@ fn foo() {
 }
 "#,
             expect![[r#"
-                fd 0 i32
-                fd 1 f64
+                fd 0     i32
+                fd 1     f64
+                sn ref   &expr
+                sn refm  &mut expr
+                sn match match expr {}
+                sn box   Box::new(expr)
+                sn ok    Ok(expr)
+                sn err   Err(expr)
+                sn some  Some(expr)
+                sn dbg   dbg!(expr)
+                sn dbgr  dbg!(&expr)
+                sn call  function(expr)
+                sn let   let
+                sn letm  let mut
             "#]],
         );
     }
@@ -460,6 +673,18 @@ impl T {
 "#,
             expect![[r#"
                 me blah() fn(&self)
+                sn ref    &expr
+                sn refm   &mut expr
+                sn match  match expr {}
+                sn box    Box::new(expr)
+                sn ok     Ok(expr)
+                sn err    Err(expr)
+                sn some   Some(expr)
+                sn dbg    dbg!(expr)
+                sn dbgr   dbg!(&expr)
+                sn call   function(expr)
+                sn let    let
+                sn letm   let mut
             "#]],
         );
     }
@@ -475,6 +700,18 @@ const X: u32 = {
 "#,
             expect![[r#"
                 fd the_field u32
+                sn ref       &expr
+                sn refm      &mut expr
+                sn match     match expr {}
+                sn box       Box::new(expr)
+                sn ok        Ok(expr)
+                sn err       Err(expr)
+                sn some      Some(expr)
+                sn dbg       dbg!(expr)
+                sn dbgr      dbg!(&expr)
+                sn call      function(expr)
+                sn let       let
+                sn letm      let mut
             "#]],
         );
     }
@@ -491,6 +728,16 @@ fn foo(a: A) {
 "#,
             expect![[r#"
                 fd the_field u32
+                sn ref       &expr
+                sn refm      &mut expr
+                sn match     match expr {}
+                sn box       Box::new(expr)
+                sn ok        Ok(expr)
+                sn err       Err(expr)
+                sn some      Some(expr)
+                sn dbg       dbg!(expr)
+                sn dbgr      dbg!(&expr)
+                sn call      function(expr)
             "#]],
         );
     }
@@ -508,6 +755,16 @@ fn foo(a: A) {
 "#,
             expect![[r#"
                 fd the_field u32
+                sn ref       &expr
+                sn refm      &mut expr
+                sn match     match expr {}
+                sn box       Box::new(expr)
+                sn ok        Ok(expr)
+                sn err       Err(expr)
+                sn some      Some(expr)
+                sn dbg       dbg!(expr)
+                sn dbgr      dbg!(&expr)
+                sn call      function(expr)
             "#]],
         );
     }
@@ -524,6 +781,16 @@ fn foo(a: A) {
 "#,
             expect![[r#"
                 fd the_field u32
+                sn ref       &expr
+                sn refm      &mut expr
+                sn match     match expr {}
+                sn box       Box::new(expr)
+                sn ok        Ok(expr)
+                sn err       Err(expr)
+                sn some      Some(expr)
+                sn dbg       dbg!(expr)
+                sn dbgr      dbg!(&expr)
+                sn call      function(expr)
             "#]],
         );
     }
@@ -550,6 +817,16 @@ fn foo(a: A) {
 "#,
             expect![[r#"
                 fd the_field u32
+                sn ref       &expr
+                sn refm      &mut expr
+                sn match     match expr {}
+                sn box       Box::new(expr)
+                sn ok        Ok(expr)
+                sn err       Err(expr)
+                sn some      Some(expr)
+                sn dbg       dbg!(expr)
+                sn dbgr      dbg!(&expr)
+                sn call      function(expr)
             "#]],
         );
     }
@@ -569,6 +846,18 @@ fn foo() {
 "#,
             expect![[r#"
                 me the_method() fn(&self)
+                sn ref          &expr
+                sn refm         &mut expr
+                sn match        match expr {}
+                sn box          Box::new(expr)
+                sn ok           Ok(expr)
+                sn err          Err(expr)
+                sn some         Some(expr)
+                sn dbg          dbg!(expr)
+                sn dbgr         dbg!(&expr)
+                sn call         function(expr)
+                sn let          let
+                sn letm         let mut
             "#]],
         );
     }
@@ -584,6 +873,18 @@ fn main() { make_s!().f$0; }
 "#,
             expect![[r#"
                 me foo() fn(&self)
+                sn ref   &expr
+                sn refm  &mut expr
+                sn match match expr {}
+                sn box   Box::new(expr)
+                sn ok    Ok(expr)
+                sn err   Err(expr)
+                sn some  Some(expr)
+                sn dbg   dbg!(expr)
+                sn dbgr  dbg!(&expr)
+                sn call  function(expr)
+                sn let   let
+                sn letm  let mut
             "#]],
         )
     }
@@ -612,6 +913,18 @@ mod foo {
         "#,
             expect![[r#"
                 me private() fn(&self)
+                sn ref       &expr
+                sn refm      &mut expr
+                sn match     match expr {}
+                sn box       Box::new(expr)
+                sn ok        Ok(expr)
+                sn err       Err(expr)
+                sn some      Some(expr)
+                sn dbg       dbg!(expr)
+                sn dbgr      dbg!(&expr)
+                sn call      function(expr)
+                sn let       let
+                sn letm      let mut
             "#]],
         );
     }
@@ -639,6 +952,16 @@ impl S {
         "#,
             expect![[r#"
                 me foo() fn(&self) -> &[u8]
+                sn ref   &expr
+                sn refm  &mut expr
+                sn match match expr {}
+                sn box   Box::new(expr)
+                sn ok    Ok(expr)
+                sn err   Err(expr)
+                sn some  Some(expr)
+                sn dbg   dbg!(expr)
+                sn dbgr  dbg!(&expr)
+                sn call  function(expr)
             "#]],
         );
     }
@@ -654,6 +977,7 @@ impl Foo { fn foo(&self) { $0 } }"#,
                 lc self       &Foo
                 sp Self
                 st Foo
+                bt u32
                 fd self.field i32
                 me self.foo() fn(&self)
             "#]],
@@ -667,6 +991,7 @@ impl Foo { fn foo(&mut self) { $0 } }"#,
                 lc self       &mut Foo
                 sp Self
                 st Foo
+                bt u32
                 fd self.0     i32
                 me self.foo() fn(&mut self)
             "#]],
@@ -694,6 +1019,16 @@ fn f() {
     "#,
             expect![[r#"
                 me method() fn(&self)
+                sn ref      &expr
+                sn refm     &mut expr
+                sn match    match expr {}
+                sn box      Box::new(expr)
+                sn ok       Ok(expr)
+                sn err      Err(expr)
+                sn some     Some(expr)
+                sn dbg      dbg!(expr)
+                sn dbgr     dbg!(&expr)
+                sn call     function(expr)
             "#]],
         );
     }
@@ -716,6 +1051,18 @@ fn main() {
 "#,
             expect![[r#"
                 me into_iter() (as IntoIterator) fn(self) -> <Self as IntoIterator>::IntoIter
+                sn ref                    &expr
+                sn refm                   &mut expr
+                sn match                  match expr {}
+                sn box                    Box::new(expr)
+                sn ok                     Ok(expr)
+                sn err                    Err(expr)
+                sn some                   Some(expr)
+                sn dbg                    dbg!(expr)
+                sn dbgr                   dbg!(&expr)
+                sn call                   function(expr)
+                sn let                    let
+                sn letm                   let mut
             "#]],
         )
     }
diff --git a/crates/ide_completion/src/completions/flyimport.rs b/crates/ide_completion/src/completions/flyimport.rs
index d7c8c54315c..486cbff6859 100644
--- a/crates/ide_completion/src/completions/flyimport.rs
+++ b/crates/ide_completion/src/completions/flyimport.rs
@@ -219,1018 +219,3 @@ fn compute_fuzzy_completion_order_key(
         None => usize::MAX,
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use expect_test::{expect, Expect};
-
-    use crate::{
-        item::CompletionKind,
-        tests::{check_edit, check_edit_with_config, filtered_completion_list, TEST_CONFIG},
-    };
-
-    fn check(ra_fixture: &str, expect: Expect) {
-        let actual = filtered_completion_list(ra_fixture, CompletionKind::Magic);
-        expect.assert_eq(&actual);
-    }
-
-    #[test]
-    fn function_fuzzy_completion() {
-        check_edit(
-            "stdin",
-            r#"
-//- /lib.rs crate:dep
-pub mod io {
-    pub fn stdin() {}
-};
-
-//- /main.rs crate:main deps:dep
-fn main() {
-    stdi$0
-}
-"#,
-            r#"
-use dep::io::stdin;
-
-fn main() {
-    stdin()$0
-}
-"#,
-        );
-    }
-
-    #[test]
-    fn macro_fuzzy_completion() {
-        check_edit(
-            "macro_with_curlies!",
-            r#"
-//- /lib.rs crate:dep
-/// Please call me as macro_with_curlies! {}
-#[macro_export]
-macro_rules! macro_with_curlies {
-    () => {}
-}
-
-//- /main.rs crate:main deps:dep
-fn main() {
-    curli$0
-}
-"#,
-            r#"
-use dep::macro_with_curlies;
-
-fn main() {
-    macro_with_curlies! {$0}
-}
-"#,
-        );
-    }
-
-    #[test]
-    fn struct_fuzzy_completion() {
-        check_edit(
-            "ThirdStruct",
-            r#"
-//- /lib.rs crate:dep
-pub struct FirstStruct;
-pub mod some_module {
-    pub struct SecondStruct;
-    pub struct ThirdStruct;
-}
-
-//- /main.rs crate:main deps:dep
-use dep::{FirstStruct, some_module::SecondStruct};
-
-fn main() {
-    this$0
-}
-"#,
-            r#"
-use dep::{FirstStruct, some_module::{SecondStruct, ThirdStruct}};
-
-fn main() {
-    ThirdStruct
-}
-"#,
-        );
-    }
-
-    #[test]
-    fn short_paths_are_ignored() {
-        cov_mark::check!(ignore_short_input_for_path);
-
-        check(
-            r#"
-//- /lib.rs crate:dep
-pub struct FirstStruct;
-pub mod some_module {
-    pub struct SecondStruct;
-    pub struct ThirdStruct;
-}
-
-//- /main.rs crate:main deps:dep
-use dep::{FirstStruct, some_module::SecondStruct};
-
-fn main() {
-    t$0
-}
-"#,
-            expect![[r#""#]],
-        );
-    }
-
-    #[test]
-    fn fuzzy_completions_come_in_specific_order() {
-        cov_mark::check!(certain_fuzzy_order_test);
-        check(
-            r#"
-//- /lib.rs crate:dep
-pub struct FirstStruct;
-pub mod some_module {
-    // already imported, omitted
-    pub struct SecondStruct;
-    // does not contain all letters from the query, omitted
-    pub struct UnrelatedOne;
-    // contains all letters from the query, but not in sequence, displayed last
-    pub struct ThiiiiiirdStruct;
-    // contains all letters from the query, but not in the beginning, displayed second
-    pub struct AfterThirdStruct;
-    // contains all letters from the query in the begginning, displayed first
-    pub struct ThirdStruct;
-}
-
-//- /main.rs crate:main deps:dep
-use dep::{FirstStruct, some_module::SecondStruct};
-
-fn main() {
-    hir$0
-}
-"#,
-            expect![[r#"
-                st ThirdStruct (use dep::some_module::ThirdStruct)
-                st AfterThirdStruct (use dep::some_module::AfterThirdStruct)
-                st ThiiiiiirdStruct (use dep::some_module::ThiiiiiirdStruct)
-            "#]],
-        );
-    }
-
-    #[test]
-    fn trait_function_fuzzy_completion() {
-        let fixture = r#"
-        //- /lib.rs crate:dep
-        pub mod test_mod {
-            pub trait TestTrait {
-                const SPECIAL_CONST: u8;
-                type HumbleType;
-                fn weird_function();
-                fn random_method(&self);
-            }
-            pub struct TestStruct {}
-            impl TestTrait for TestStruct {
-                const SPECIAL_CONST: u8 = 42;
-                type HumbleType = ();
-                fn weird_function() {}
-                fn random_method(&self) {}
-            }
-        }
-
-        //- /main.rs crate:main deps:dep
-        fn main() {
-            dep::test_mod::TestStruct::wei$0
-        }
-        "#;
-
-        check(
-            fixture,
-            expect![[r#"
-                fn weird_function() (use dep::test_mod::TestTrait) fn()
-            "#]],
-        );
-
-        check_edit(
-            "weird_function",
-            fixture,
-            r#"
-use dep::test_mod::TestTrait;
-
-fn main() {
-    dep::test_mod::TestStruct::weird_function()$0
-}
-"#,
-        );
-    }
-
-    #[test]
-    fn trait_const_fuzzy_completion() {
-        let fixture = r#"
-        //- /lib.rs crate:dep
-        pub mod test_mod {
-            pub trait TestTrait {
-                const SPECIAL_CONST: u8;
-                type HumbleType;
-                fn weird_function();
-                fn random_method(&self);
-            }
-            pub struct TestStruct {}
-            impl TestTrait for TestStruct {
-                const SPECIAL_CONST: u8 = 42;
-                type HumbleType = ();
-                fn weird_function() {}
-                fn random_method(&self) {}
-            }
-        }
-
-        //- /main.rs crate:main deps:dep
-        fn main() {
-            dep::test_mod::TestStruct::spe$0
-        }
-        "#;
-
-        check(
-            fixture,
-            expect![[r#"
-            ct SPECIAL_CONST (use dep::test_mod::TestTrait)
-        "#]],
-        );
-
-        check_edit(
-            "SPECIAL_CONST",
-            fixture,
-            r#"
-use dep::test_mod::TestTrait;
-
-fn main() {
-    dep::test_mod::TestStruct::SPECIAL_CONST
-}
-"#,
-        );
-    }
-
-    #[test]
-    fn trait_method_fuzzy_completion() {
-        let fixture = r#"
-        //- /lib.rs crate:dep
-        pub mod test_mod {
-            pub trait TestTrait {
-                const SPECIAL_CONST: u8;
-                type HumbleType;
-                fn weird_function();
-                fn random_method(&self);
-            }
-            pub struct TestStruct {}
-            impl TestTrait for TestStruct {
-                const SPECIAL_CONST: u8 = 42;
-                type HumbleType = ();
-                fn weird_function() {}
-                fn random_method(&self) {}
-            }
-        }
-
-        //- /main.rs crate:main deps:dep
-        fn main() {
-            let test_struct = dep::test_mod::TestStruct {};
-            test_struct.ran$0
-        }
-        "#;
-
-        check(
-            fixture,
-            expect![[r#"
-                me random_method() (use dep::test_mod::TestTrait) fn(&self)
-            "#]],
-        );
-
-        check_edit(
-            "random_method",
-            fixture,
-            r#"
-use dep::test_mod::TestTrait;
-
-fn main() {
-    let test_struct = dep::test_mod::TestStruct {};
-    test_struct.random_method()$0
-}
-"#,
-        );
-    }
-
-    #[test]
-    fn no_trait_type_fuzzy_completion() {
-        check(
-            r#"
-//- /lib.rs crate:dep
-pub mod test_mod {
-    pub trait TestTrait {
-        const SPECIAL_CONST: u8;
-        type HumbleType;
-        fn weird_function();
-        fn random_method(&self);
-    }
-    pub struct TestStruct {}
-    impl TestTrait for TestStruct {
-        const SPECIAL_CONST: u8 = 42;
-        type HumbleType = ();
-        fn weird_function() {}
-        fn random_method(&self) {}
-    }
-}
-
-//- /main.rs crate:main deps:dep
-fn main() {
-    dep::test_mod::TestStruct::hum$0
-}
-"#,
-            expect![[r#""#]],
-        );
-    }
-
-    #[test]
-    fn does_not_propose_names_in_scope() {
-        check(
-            r#"
-//- /lib.rs crate:dep
-pub mod test_mod {
-    pub trait TestTrait {
-        const SPECIAL_CONST: u8;
-        type HumbleType;
-        fn weird_function();
-        fn random_method(&self);
-    }
-    pub struct TestStruct {}
-    impl TestTrait for TestStruct {
-        const SPECIAL_CONST: u8 = 42;
-        type HumbleType = ();
-        fn weird_function() {}
-        fn random_method(&self) {}
-    }
-}
-
-//- /main.rs crate:main deps:dep
-use dep::test_mod::TestStruct;
-fn main() {
-    TestSt$0
-}
-"#,
-            expect![[r#""#]],
-        );
-    }
-
-    #[test]
-    fn does_not_propose_traits_in_scope() {
-        check(
-            r#"
-//- /lib.rs crate:dep
-pub mod test_mod {
-    pub trait TestTrait {
-        const SPECIAL_CONST: u8;
-        type HumbleType;
-        fn weird_function();
-        fn random_method(&self);
-    }
-    pub struct TestStruct {}
-    impl TestTrait for TestStruct {
-        const SPECIAL_CONST: u8 = 42;
-        type HumbleType = ();
-        fn weird_function() {}
-        fn random_method(&self) {}
-    }
-}
-
-//- /main.rs crate:main deps:dep
-use dep::test_mod::{TestStruct, TestTrait};
-fn main() {
-    dep::test_mod::TestStruct::hum$0
-}
-"#,
-            expect![[r#""#]],
-        );
-    }
-
-    #[test]
-    fn blanket_trait_impl_import() {
-        check_edit(
-            "another_function",
-            r#"
-//- /lib.rs crate:dep
-pub mod test_mod {
-    pub struct TestStruct {}
-    pub trait TestTrait {
-        fn another_function();
-    }
-    impl<T> TestTrait for T {
-        fn another_function() {}
-    }
-}
-
-//- /main.rs crate:main deps:dep
-fn main() {
-    dep::test_mod::TestStruct::ano$0
-}
-"#,
-            r#"
-use dep::test_mod::TestTrait;
-
-fn main() {
-    dep::test_mod::TestStruct::another_function()$0
-}
-"#,
-        );
-    }
-
-    #[test]
-    fn zero_input_deprecated_assoc_item_completion() {
-        check(
-            r#"
-//- /lib.rs crate:dep
-pub mod test_mod {
-    #[deprecated]
-    pub trait TestTrait {
-        const SPECIAL_CONST: u8;
-        type HumbleType;
-        fn weird_function();
-        fn random_method(&self);
-    }
-    pub struct TestStruct {}
-    impl TestTrait for TestStruct {
-        const SPECIAL_CONST: u8 = 42;
-        type HumbleType = ();
-        fn weird_function() {}
-        fn random_method(&self) {}
-    }
-}
-
-//- /main.rs crate:main deps:dep
-fn main() {
-    let test_struct = dep::test_mod::TestStruct {};
-    test_struct.$0
-}
-        "#,
-            expect![[r#"
-                me random_method() (use dep::test_mod::TestTrait) fn(&self) DEPRECATED
-            "#]],
-        );
-
-        check(
-            r#"
-//- /lib.rs crate:dep
-pub mod test_mod {
-    #[deprecated]
-    pub trait TestTrait {
-        const SPECIAL_CONST: u8;
-        type HumbleType;
-        fn weird_function();
-        fn random_method(&self);
-    }
-    pub struct TestStruct {}
-    impl TestTrait for TestStruct {
-        const SPECIAL_CONST: u8 = 42;
-        type HumbleType = ();
-        fn weird_function() {}
-        fn random_method(&self) {}
-    }
-}
-
-//- /main.rs crate:main deps:dep
-fn main() {
-    dep::test_mod::TestStruct::$0
-}
-"#,
-            expect![[r#"
-                fn weird_function() (use dep::test_mod::TestTrait) fn() DEPRECATED
-                ct SPECIAL_CONST (use dep::test_mod::TestTrait) DEPRECATED
-            "#]],
-        );
-    }
-
-    #[test]
-    fn no_completions_in_use_statements() {
-        check(
-            r#"
-//- /lib.rs crate:dep
-pub mod io {
-    pub fn stdin() {}
-};
-
-//- /main.rs crate:main deps:dep
-use stdi$0
-
-fn main() {}
-"#,
-            expect![[]],
-        );
-    }
-
-    #[test]
-    fn prefix_config_usage() {
-        let fixture = r#"
-mod foo {
-    pub mod bar {
-        pub struct Item;
-    }
-}
-
-use crate::foo::bar;
-
-fn main() {
-    Ite$0
-}"#;
-        let mut config = TEST_CONFIG;
-
-        config.insert_use.prefix_kind = hir::PrefixKind::ByCrate;
-        check_edit_with_config(
-            config.clone(),
-            "Item",
-            fixture,
-            r#"
-mod foo {
-    pub mod bar {
-        pub struct Item;
-    }
-}
-
-use crate::foo::bar::{self, Item};
-
-fn main() {
-    Item
-}"#,
-        );
-
-        config.insert_use.prefix_kind = hir::PrefixKind::BySelf;
-        check_edit_with_config(
-            config.clone(),
-            "Item",
-            fixture,
-            r#"
-mod foo {
-    pub mod bar {
-        pub struct Item;
-    }
-}
-
-use crate::foo::bar;
-
-use self::foo::bar::Item;
-
-fn main() {
-    Item
-}"#,
-        );
-
-        config.insert_use.prefix_kind = hir::PrefixKind::Plain;
-        check_edit_with_config(
-            config,
-            "Item",
-            fixture,
-            r#"
-mod foo {
-    pub mod bar {
-        pub struct Item;
-    }
-}
-
-use foo::bar::Item;
-
-use crate::foo::bar;
-
-fn main() {
-    Item
-}"#,
-        );
-    }
-
-    #[test]
-    fn unresolved_qualifier() {
-        let fixture = r#"
-mod foo {
-    pub mod bar {
-        pub mod baz {
-            pub struct Item;
-        }
-    }
-}
-
-fn main() {
-    bar::baz::Ite$0
-}"#;
-
-        check(
-            fixture,
-            expect![[r#"
-        st Item (use foo::bar::baz::Item)
-        "#]],
-        );
-
-        check_edit(
-            "Item",
-            fixture,
-            r#"
-        use foo::bar;
-
-        mod foo {
-            pub mod bar {
-                pub mod baz {
-                    pub struct Item;
-                }
-            }
-        }
-
-        fn main() {
-            bar::baz::Item
-        }"#,
-        );
-    }
-
-    #[test]
-    fn unresolved_assoc_item_container() {
-        let fixture = r#"
-mod foo {
-    pub struct Item;
-
-    impl Item {
-        pub const TEST_ASSOC: usize = 3;
-    }
-}
-
-fn main() {
-    Item::TEST_A$0
-}"#;
-
-        check(
-            fixture,
-            expect![[r#"
-        ct TEST_ASSOC (use foo::Item)
-        "#]],
-        );
-
-        check_edit(
-            "TEST_ASSOC",
-            fixture,
-            r#"
-use foo::Item;
-
-mod foo {
-    pub struct Item;
-
-    impl Item {
-        pub const TEST_ASSOC: usize = 3;
-    }
-}
-
-fn main() {
-    Item::TEST_ASSOC
-}"#,
-        );
-    }
-
-    #[test]
-    fn unresolved_assoc_item_container_with_path() {
-        let fixture = r#"
-mod foo {
-    pub mod bar {
-        pub struct Item;
-
-        impl Item {
-            pub const TEST_ASSOC: usize = 3;
-        }
-    }
-}
-
-fn main() {
-    bar::Item::TEST_A$0
-}"#;
-
-        check(
-            fixture,
-            expect![[r#"
-        ct TEST_ASSOC (use foo::bar::Item)
-    "#]],
-        );
-
-        check_edit(
-            "TEST_ASSOC",
-            fixture,
-            r#"
-use foo::bar;
-
-mod foo {
-    pub mod bar {
-        pub struct Item;
-
-        impl Item {
-            pub const TEST_ASSOC: usize = 3;
-        }
-    }
-}
-
-fn main() {
-    bar::Item::TEST_ASSOC
-}"#,
-        );
-    }
-
-    #[test]
-    fn fuzzy_unresolved_path() {
-        check(
-            r#"
-mod foo {
-    pub mod bar {
-        pub struct Item;
-
-        impl Item {
-            pub const TEST_ASSOC: usize = 3;
-        }
-    }
-}
-
-fn main() {
-    bar::ASS$0
-}"#,
-            expect![[]],
-        )
-    }
-
-    #[test]
-    fn unqualified_assoc_items_are_omitted() {
-        check(
-            r#"
-mod something {
-    pub trait BaseTrait {
-        fn test_function() -> i32;
-    }
-
-    pub struct Item1;
-    pub struct Item2;
-
-    impl BaseTrait for Item1 {
-        fn test_function() -> i32 {
-            1
-        }
-    }
-
-    impl BaseTrait for Item2 {
-        fn test_function() -> i32 {
-            2
-        }
-    }
-}
-
-fn main() {
-    test_f$0
-}"#,
-            expect![[]],
-        )
-    }
-
-    #[test]
-    fn case_matters() {
-        check(
-            r#"
-mod foo {
-    pub const TEST_CONST: usize = 3;
-    pub fn test_function() -> i32 {
-        4
-    }
-}
-
-fn main() {
-    TE$0
-}"#,
-            expect![[r#"
-        ct TEST_CONST (use foo::TEST_CONST)
-    "#]],
-        );
-
-        check(
-            r#"
-mod foo {
-    pub const TEST_CONST: usize = 3;
-    pub fn test_function() -> i32 {
-        4
-    }
-}
-
-fn main() {
-    te$0
-}"#,
-            expect![[r#"
-        ct TEST_CONST (use foo::TEST_CONST)
-        fn test_function() (use foo::test_function) fn() -> i32
-    "#]],
-        );
-
-        check(
-            r#"
-mod foo {
-    pub const TEST_CONST: usize = 3;
-    pub fn test_function() -> i32 {
-        4
-    }
-}
-
-fn main() {
-    Te$0
-}"#,
-            expect![[]],
-        );
-    }
-
-    #[test]
-    fn no_fuzzy_during_fields_of_record_lit_syntax() {
-        check(
-            r#"
-mod m {
-    pub fn some_fn() -> i32 {
-        42
-    }
-}
-struct Foo {
-    some_field: i32,
-}
-fn main() {
-    let _ = Foo { so$0 };
-}
-"#,
-            expect![[]],
-        );
-    }
-
-    #[test]
-    fn fuzzy_after_fields_of_record_lit_syntax() {
-        check(
-            r#"
-mod m {
-    pub fn some_fn() -> i32 {
-        42
-    }
-}
-struct Foo {
-    some_field: i32,
-}
-fn main() {
-    let _ = Foo { some_field: so$0 };
-}
-"#,
-            expect![[r#"
-                fn some_fn() (use m::some_fn) fn() -> i32
-            "#]],
-        );
-    }
-
-    #[test]
-    fn no_flyimports_in_traits_and_impl_declarations() {
-        check(
-            r#"
-mod m {
-    pub fn some_fn() -> i32 {
-        42
-    }
-}
-trait Foo {
-    som$0
-}
-"#,
-            expect![[r#""#]],
-        );
-
-        check(
-            r#"
-mod m {
-    pub fn some_fn() -> i32 {
-        42
-    }
-}
-struct Foo;
-impl Foo {
-    som$0
-}
-"#,
-            expect![[r#""#]],
-        );
-
-        check(
-            r#"
-mod m {
-    pub fn some_fn() -> i32 {
-        42
-    }
-}
-struct Foo;
-trait Bar {}
-impl Bar for Foo {
-    som$0
-}
-"#,
-            expect![[r#""#]],
-        );
-    }
-
-    #[test]
-    fn no_inherent_candidates_proposed() {
-        check(
-            r#"
-mod baz {
-    pub trait DefDatabase {
-        fn method1(&self);
-    }
-    pub trait HirDatabase: DefDatabase {
-        fn method2(&self);
-    }
-}
-
-mod bar {
-    fn test(db: &dyn crate::baz::HirDatabase) {
-        db.metho$0
-    }
-}
-            "#,
-            expect![[r#""#]],
-        );
-    }
-
-    #[test]
-    fn respects_doc_hidden() {
-        check(
-            r#"
-//- /lib.rs crate:lib deps:dep
-fn f() {
-    ().fro$0
-}
-
-//- /dep.rs crate:dep
-#[doc(hidden)]
-pub trait Private {
-    fn frob(&self) {}
-}
-
-impl<T> Private for T {}
-            "#,
-            expect![[r#""#]],
-        );
-        check(
-            r#"
-//- /lib.rs crate:lib deps:dep
-fn f() {
-    ().fro$0
-}
-
-//- /dep.rs crate:dep
-pub trait Private {
-    #[doc(hidden)]
-    fn frob(&self) {}
-}
-
-impl<T> Private for T {}
-            "#,
-            expect![[r#""#]],
-        );
-    }
-
-    #[test]
-    fn regression_9760() {
-        check(
-            r#"
-struct Struct;
-fn main() {}
-
-mod mud {
-    fn func() {
-        let struct_instance = Stru$0
-    }
-}
-"#,
-            expect![[r#"
-                st Struct (use crate::Struct)
-            "#]],
-        );
-    }
-
-    #[test]
-    fn flyimport_pattern() {
-        check(
-            r#"
-mod module {
-    pub struct Struct;
-}
-fn function() {
-    let Str$0
-}
-"#,
-            expect![[r#"
-                st Struct (use module::Struct)
-            "#]],
-        );
-    }
-
-    #[test]
-    fn flyimport_rename() {
-        check(
-            r#"
-mod module {
-    pub struct Struct;
-}
-use self as Str$0;
-    "#,
-            expect![[r#""#]],
-        );
-    }
-}
diff --git a/crates/ide_completion/src/completions/keyword.rs b/crates/ide_completion/src/completions/keyword.rs
index 31aabd98d3e..4fd622f3995 100644
--- a/crates/ide_completion/src/completions/keyword.rs
+++ b/crates/ide_completion/src/completions/keyword.rs
@@ -181,115 +181,15 @@ fn add_keyword(ctx: &CompletionContext, acc: &mut Completions, kw: &str, snippet
 mod tests {
     use expect_test::{expect, Expect};
 
-    use crate::{
-        tests::{check_edit, filtered_completion_list},
-        CompletionKind,
-    };
+    use crate::tests::{check_edit, completion_list};
 
     fn check(ra_fixture: &str, expect: Expect) {
-        let actual = filtered_completion_list(ra_fixture, CompletionKind::Keyword);
+        let actual = completion_list(ra_fixture);
         expect.assert_eq(&actual)
     }
 
     #[test]
-    fn test_keywords_in_function() {
-        check(
-            r"fn quux() { $0 }",
-            expect![[r#"
-                kw unsafe
-                kw fn
-                kw const
-                kw type
-                kw impl
-                kw extern
-                kw use
-                kw trait
-                kw static
-                kw mod
-                kw match
-                kw while
-                kw while let
-                kw loop
-                kw if
-                kw if let
-                kw for
-                kw true
-                kw false
-                kw let
-                kw return
-                kw self
-                kw super
-                kw crate
-            "#]],
-        );
-    }
-
-    #[test]
-    fn test_keywords_inside_block() {
-        check(
-            r"fn quux() { if true { $0 } }",
-            expect![[r#"
-                kw unsafe
-                kw fn
-                kw const
-                kw type
-                kw impl
-                kw extern
-                kw use
-                kw trait
-                kw static
-                kw mod
-                kw match
-                kw while
-                kw while let
-                kw loop
-                kw if
-                kw if let
-                kw for
-                kw true
-                kw false
-                kw let
-                kw return
-                kw self
-                kw super
-                kw crate
-            "#]],
-        );
-    }
-
-    #[test]
-    fn test_keywords_after_if() {
-        check(
-            r#"fn quux() { if true { () } $0 }"#,
-            expect![[r#"
-                kw unsafe
-                kw fn
-                kw const
-                kw type
-                kw impl
-                kw extern
-                kw use
-                kw trait
-                kw static
-                kw mod
-                kw match
-                kw while
-                kw while let
-                kw loop
-                kw if
-                kw if let
-                kw for
-                kw true
-                kw false
-                kw let
-                kw else
-                kw else if
-                kw return
-                kw self
-                kw super
-                kw crate
-            "#]],
-        );
+    fn test_else_edit_after_if() {
         check_edit(
             "else",
             r#"fn quux() { if true { () } $0 }"#,
@@ -300,68 +200,6 @@ mod tests {
     }
 
     #[test]
-    fn test_keywords_in_match_arm() {
-        check(
-            r#"
-fn quux() -> i32 {
-    match () { () => $0 }
-}
-"#,
-            expect![[r#"
-                kw unsafe
-                kw match
-                kw while
-                kw while let
-                kw loop
-                kw if
-                kw if let
-                kw for
-                kw true
-                kw false
-                kw return
-                kw self
-                kw super
-                kw crate
-            "#]],
-        );
-    }
-
-    #[test]
-    fn test_keywords_in_loop() {
-        check(
-            r"fn my() { loop { $0 } }",
-            expect![[r#"
-                kw unsafe
-                kw fn
-                kw const
-                kw type
-                kw impl
-                kw extern
-                kw use
-                kw trait
-                kw static
-                kw mod
-                kw match
-                kw while
-                kw while let
-                kw loop
-                kw if
-                kw if let
-                kw for
-                kw true
-                kw false
-                kw let
-                kw continue
-                kw break
-                kw return
-                kw self
-                kw super
-                kw crate
-            "#]],
-        );
-    }
-
-    #[test]
     fn test_keywords_after_unsafe_in_block_expr() {
         check(
             r"fn my_fn() { unsafe $0 }",
@@ -369,39 +207,13 @@ fn quux() -> i32 {
                 kw fn
                 kw trait
                 kw impl
+                sn pd
+                sn ppd
             "#]],
         );
     }
 
     #[test]
-    fn no_keyword_completion_in_comments() {
-        cov_mark::check!(no_keyword_completion_in_comments);
-        check(
-            r#"
-fn test() {
-    let x = 2; // A comment$0
-}
-"#,
-            expect![[""]],
-        );
-        check(
-            r#"
-/*
-Some multi-line comment$0
-*/
-"#,
-            expect![[""]],
-        );
-        check(
-            r#"
-/// Some doc comment
-/// let test$0 = 1
-"#,
-            expect![[""]],
-        );
-    }
-
-    #[test]
     fn test_completion_await_impls_future() {
         check(
             r#"
@@ -413,6 +225,18 @@ fn foo(a: A) { a.$0 }
 "#,
             expect![[r#"
                 kw await expr.await
+                sn ref   &expr
+                sn refm  &mut expr
+                sn match match expr {}
+                sn box   Box::new(expr)
+                sn ok    Ok(expr)
+                sn err   Err(expr)
+                sn some  Some(expr)
+                sn dbg   dbg!(expr)
+                sn dbgr  dbg!(&expr)
+                sn call  function(expr)
+                sn let   let
+                sn letm  let mut
             "#]],
         );
 
@@ -427,84 +251,23 @@ fn foo() {
 "#,
             expect![[r#"
                 kw await expr.await
+                sn ref   &expr
+                sn refm  &mut expr
+                sn match match expr {}
+                sn box   Box::new(expr)
+                sn ok    Ok(expr)
+                sn err   Err(expr)
+                sn some  Some(expr)
+                sn dbg   dbg!(expr)
+                sn dbgr  dbg!(&expr)
+                sn call  function(expr)
+                sn let   let
+                sn letm  let mut
             "#]],
         )
     }
 
     #[test]
-    fn after_let() {
-        check(
-            r#"fn main() { let _ = $0 }"#,
-            expect![[r#"
-                kw unsafe
-                kw match
-                kw while
-                kw while let
-                kw loop
-                kw if
-                kw if let
-                kw for
-                kw true
-                kw false
-                kw return
-                kw self
-                kw super
-                kw crate
-            "#]],
-        )
-    }
-
-    #[test]
-    fn skip_struct_initializer() {
-        cov_mark::check!(no_keyword_completion_in_record_lit);
-        check(
-            r#"
-struct Foo {
-    pub f: i32,
-}
-fn foo() {
-    Foo {
-        $0
-    }
-}
-"#,
-            expect![[r#""#]],
-        );
-    }
-
-    #[test]
-    fn struct_initializer_field_expr() {
-        check(
-            r#"
-struct Foo {
-    pub f: i32,
-}
-fn foo() {
-    Foo {
-        f: $0
-    }
-}
-"#,
-            expect![[r#"
-                kw unsafe
-                kw match
-                kw while
-                kw while let
-                kw loop
-                kw if
-                kw if let
-                kw for
-                kw true
-                kw false
-                kw return
-                kw self
-                kw super
-                kw crate
-            "#]],
-        );
-    }
-
-    #[test]
     fn let_semi() {
         cov_mark::check!(let_semi);
         check_edit(
diff --git a/crates/ide_completion/src/completions/mod_.rs b/crates/ide_completion/src/completions/mod_.rs
index 1c864c0e708..c26fa42d1b6 100644
--- a/crates/ide_completion/src/completions/mod_.rs
+++ b/crates/ide_completion/src/completions/mod_.rs
@@ -141,9 +141,10 @@ fn module_chain_to_containing_module_file(
 
 #[cfg(test)]
 mod tests {
-    use crate::tests::completion_list;
     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);
diff --git a/crates/ide_completion/src/completions/postfix.rs b/crates/ide_completion/src/completions/postfix.rs
index 4ace346768a..87b5d6c4720 100644
--- a/crates/ide_completion/src/completions/postfix.rs
+++ b/crates/ide_completion/src/completions/postfix.rs
@@ -270,12 +270,12 @@ mod tests {
     use expect_test::{expect, Expect};
 
     use crate::{
-        tests::{check_edit, check_edit_with_config, filtered_completion_list, TEST_CONFIG},
-        CompletionConfig, CompletionKind, Snippet,
+        tests::{check_edit, check_edit_with_config, completion_list, TEST_CONFIG},
+        CompletionConfig, Snippet,
     };
 
     fn check(ra_fixture: &str, expect: Expect) {
-        let actual = filtered_completion_list(ra_fixture, CompletionKind::Postfix);
+        let actual = completion_list(ra_fixture);
         expect.assert_eq(&actual)
     }
 
diff --git a/crates/ide_completion/src/completions/qualified_path.rs b/crates/ide_completion/src/completions/qualified_path.rs
index f61baf184bb..e9d39edc43a 100644
--- a/crates/ide_completion/src/completions/qualified_path.rs
+++ b/crates/ide_completion/src/completions/qualified_path.rs
@@ -250,13 +250,10 @@ fn add_enum_variants(acc: &mut Completions, ctx: &CompletionContext, e: hir::Enu
 mod tests {
     use expect_test::{expect, Expect};
 
-    use crate::{
-        tests::{check_edit, filtered_completion_list},
-        CompletionKind,
-    };
+    use crate::tests::{check_edit, completion_list_no_kw};
 
     fn check(ra_fixture: &str, expect: Expect) {
-        let actual = filtered_completion_list(ra_fixture, CompletionKind::Reference);
+        let actual = completion_list_no_kw(ra_fixture);
         expect.assert_eq(&actual);
     }
 
diff --git a/crates/ide_completion/src/completions/trait_impl.rs b/crates/ide_completion/src/completions/trait_impl.rs
index 31accd035f7..37fa001e0cd 100644
--- a/crates/ide_completion/src/completions/trait_impl.rs
+++ b/crates/ide_completion/src/completions/trait_impl.rs
@@ -290,13 +290,10 @@ fn replacement_range(ctx: &CompletionContext, item: &SyntaxNode) -> TextRange {
 mod tests {
     use expect_test::{expect, Expect};
 
-    use crate::{
-        tests::{check_edit, filtered_completion_list},
-        CompletionKind,
-    };
+    use crate::tests::{check_edit, completion_list_no_kw};
 
     fn check(ra_fixture: &str, expect: Expect) {
-        let actual = filtered_completion_list(ra_fixture, CompletionKind::Magic);
+        let actual = completion_list_no_kw(ra_fixture);
         expect.assert_eq(&actual)
     }
 
@@ -313,7 +310,12 @@ impl Test for T {
     }
 }
 ",
-            expect![[""]],
+            expect![[r#"
+                sp Self
+                tt Test
+                st T
+                bt u32
+            "#]],
         );
 
         check(
@@ -356,7 +358,23 @@ impl Test for T {
     }
 }
 ",
-            expect![[""]],
+            expect![[r#"
+                sn if    if expr {}
+                sn while while expr {}
+                sn not   !expr
+                sn ref   &expr
+                sn refm  &mut expr
+                sn match match expr {}
+                sn box   Box::new(expr)
+                sn ok    Ok(expr)
+                sn err   Err(expr)
+                sn some  Some(expr)
+                sn dbg   dbg!(expr)
+                sn dbgr  dbg!(&expr)
+                sn call  function(expr)
+                sn let   let
+                sn letm  let mut
+            "#]],
         );
 
         check(
@@ -368,7 +386,10 @@ impl Test for T {
     fn test(t$0)
 }
 ",
-            expect![[""]],
+            expect![[r#"
+                sp Self
+                st T
+            "#]],
         );
 
         check(
@@ -380,7 +401,10 @@ impl Test for T {
     fn test(f: fn $0)
 }
 ",
-            expect![[""]],
+            expect![[r#"
+                sp Self
+                st T
+            "#]],
         );
     }
 
@@ -395,7 +419,7 @@ impl Test for T {
     const TEST: fn $0
 }
 ",
-            expect![[""]],
+            expect![[r#""#]],
         );
 
         check(
@@ -407,7 +431,12 @@ impl Test for T {
     const TEST: T$0
 }
 ",
-            expect![[""]],
+            expect![[r#"
+                sp Self
+                tt Test
+                st T
+                bt u32
+            "#]],
         );
 
         check(
@@ -419,7 +448,12 @@ impl Test for T {
     const TEST: u32 = f$0
 }
 ",
-            expect![[""]],
+            expect![[r#"
+                sp Self
+                tt Test
+                st T
+                bt u32
+            "#]],
         );
 
         check(
@@ -433,7 +467,12 @@ impl Test for T {
     };
 }
 ",
-            expect![[""]],
+            expect![[r#"
+                sp Self
+                tt Test
+                st T
+                bt u32
+            "#]],
         );
 
         check(
@@ -476,7 +515,12 @@ impl Test for T {
     type Test = T$0;
 }
 ",
-            expect![[""]],
+            expect![[r#"
+                sp Self
+                tt Test
+                st T
+                bt u32
+            "#]],
         );
 
         check(
@@ -488,7 +532,12 @@ impl Test for T {
     type Test = fn $0;
 }
 ",
-            expect![[""]],
+            expect![[r#"
+                sp Self
+                tt Test
+                st T
+                bt u32
+            "#]],
         );
     }
 
diff --git a/crates/ide_completion/src/completions/unqualified_path.rs b/crates/ide_completion/src/completions/unqualified_path.rs
index afacf7fe03c..825fae587b1 100644
--- a/crates/ide_completion/src/completions/unqualified_path.rs
+++ b/crates/ide_completion/src/completions/unqualified_path.rs
@@ -117,24 +117,15 @@ pub(crate) fn complete_unqualified_path(acc: &mut Completions, ctx: &CompletionC
 mod tests {
     use expect_test::{expect, Expect};
 
-    use crate::{
-        tests::{check_edit, filtered_completion_list_with_config, TEST_CONFIG},
-        CompletionConfig, CompletionKind,
-    };
+    use crate::tests::{check_edit, completion_list_no_kw};
 
     fn check(ra_fixture: &str, expect: Expect) {
-        check_with_config(TEST_CONFIG, ra_fixture, expect);
-    }
-
-    fn check_with_config(config: CompletionConfig, ra_fixture: &str, expect: Expect) {
-        let actual =
-            filtered_completion_list_with_config(config, ra_fixture, CompletionKind::Reference);
+        let actual = completion_list_no_kw(ra_fixture);
         expect.assert_eq(&actual)
     }
 
     #[test]
     fn completes_if_prefix_is_keyword() {
-        cov_mark::check!(completes_if_prefix_is_keyword);
         check_edit(
             "wherewolf",
             r#"
@@ -188,6 +179,7 @@ pub mod prelude {
 "#,
             expect![[r#"
                 md std
+                bt u32
                 st Option
             "#]],
         );
@@ -217,6 +209,7 @@ mod macros {
                 fn f()        fn()
                 ma concat!(…) #[macro_export] macro_rules! concat
                 md std
+                bt u32
             "##]],
         );
     }
@@ -245,6 +238,7 @@ pub mod prelude {
             expect![[r#"
                 md std
                 md core
+                bt u32
                 st String
             "#]],
         );
@@ -273,6 +267,7 @@ pub mod prelude {
             expect![[r#"
                 fn f() fn()
                 md std
+                bt u32
             "#]],
         );
     }
diff --git a/crates/ide_completion/src/context.rs b/crates/ide_completion/src/context.rs
index 4e3abff3b3f..0cb484d5075 100644
--- a/crates/ide_completion/src/context.rs
+++ b/crates/ide_completion/src/context.rs
@@ -134,7 +134,6 @@ impl<'a> CompletionContext<'a> {
         // check kind of macro-expanded token, but use range of original token
         let kind = self.token.kind();
         if kind == IDENT || kind == LIFETIME_IDENT || kind == UNDERSCORE || kind.is_keyword() {
-            cov_mark::hit!(completes_if_prefix_is_keyword);
             self.original_token.text_range()
         } else if kind == CHAR {
             // assume we are completing a lifetime but the user has only typed the '
diff --git a/crates/ide_completion/src/tests.rs b/crates/ide_completion/src/tests.rs
index 4028fc2242f..fee61e0bfcf 100644
--- a/crates/ide_completion/src/tests.rs
+++ b/crates/ide_completion/src/tests.rs
@@ -20,6 +20,7 @@ mod record;
 mod type_pos;
 mod use_tree;
 mod visibility;
+mod flyimport;
 
 use std::mem;
 
@@ -77,10 +78,18 @@ pub(crate) const TEST_CONFIG: CompletionConfig = CompletionConfig {
 };
 
 pub(crate) fn completion_list(ra_fixture: &str) -> String {
-    completion_list_with_config(TEST_CONFIG, ra_fixture)
+    completion_list_with_config(TEST_CONFIG, ra_fixture, true)
 }
 
-fn completion_list_with_config(config: CompletionConfig, ra_fixture: &str) -> String {
+pub(crate) fn completion_list_no_kw(ra_fixture: &str) -> String {
+    completion_list_with_config(TEST_CONFIG, ra_fixture, false)
+}
+
+fn completion_list_with_config(
+    config: CompletionConfig,
+    ra_fixture: &str,
+    include_keywords: bool,
+) -> String {
     // filter out all but one builtintype completion for smaller test outputs
     let items = get_all_items(config, ra_fixture);
     let mut bt_seen = false;
@@ -89,6 +98,8 @@ fn completion_list_with_config(config: CompletionConfig, ra_fixture: &str) -> St
         .filter(|it| {
             it.completion_kind != CompletionKind::BuiltinType || !mem::replace(&mut bt_seen, true)
         })
+        .filter(|it| include_keywords || it.completion_kind != CompletionKind::Keyword)
+        .filter(|it| include_keywords || it.completion_kind != CompletionKind::Snippet)
         .collect();
     render_completion_list(items)
 }
@@ -120,20 +131,6 @@ pub(crate) fn do_completion_with_config(
         .collect()
 }
 
-pub(crate) fn filtered_completion_list(code: &str, kind: CompletionKind) -> String {
-    filtered_completion_list_with_config(TEST_CONFIG, code, kind)
-}
-
-pub(crate) fn filtered_completion_list_with_config(
-    config: CompletionConfig,
-    code: &str,
-    kind: CompletionKind,
-) -> String {
-    let kind_completions: Vec<CompletionItem> =
-        get_all_items(config, code).into_iter().filter(|c| c.completion_kind == kind).collect();
-    render_completion_list(kind_completions)
-}
-
 fn render_completion_list(completions: Vec<CompletionItem>) -> String {
     fn monospace_width(s: &str) -> usize {
         s.chars().count()
@@ -254,3 +251,37 @@ fn foo() {
 "#,
     );
 }
+
+#[test]
+fn no_completions_in_comments() {
+    cov_mark::check!(no_keyword_completion_in_comments);
+    assert_eq!(
+        completion_list(
+            r#"
+fn test() {
+let x = 2; // A comment$0
+}
+"#,
+        ),
+        String::new(),
+    );
+    assert_eq!(
+        completion_list(
+            r#"
+/*
+Some multi-line comment$0
+*/
+"#,
+        ),
+        String::new(),
+    );
+    assert_eq!(
+        completion_list(
+            r#"
+/// Some doc comment
+/// let test$0 = 1
+"#,
+        ),
+        String::new(),
+    );
+}
diff --git a/crates/ide_completion/src/tests/expression.rs b/crates/ide_completion/src/tests/expression.rs
index 9a42dd7b275..a6348087344 100644
--- a/crates/ide_completion/src/tests/expression.rs
+++ b/crates/ide_completion/src/tests/expression.rs
@@ -110,7 +110,7 @@ fn func(param0 @ (param1, param2): (i32, i32)) {
 }
 
 #[test]
-fn completes_all_the_things() {
+fn completes_all_the_things_in_fn_body() {
     cov_mark::check!(unqualified_skip_lifetime_completion);
     check(
         r#"
@@ -207,6 +207,223 @@ impl Unit {
 }
 
 #[test]
+fn complete_in_block() {
+    check_empty(
+        r#"
+    fn foo() {
+        if true {
+            $0
+        }
+    }
+"#,
+        expect![[r#"
+            kw unsafe
+            kw fn
+            kw const
+            kw type
+            kw impl
+            kw extern
+            kw use
+            kw trait
+            kw static
+            kw mod
+            kw match
+            kw while
+            kw while let
+            kw loop
+            kw if
+            kw if let
+            kw for
+            kw true
+            kw false
+            kw let
+            kw return
+            sn pd
+            sn ppd
+            kw self
+            kw super
+            kw crate
+            fn foo()     fn()
+            bt u32
+        "#]],
+    )
+}
+
+#[test]
+fn complete_after_if_expr() {
+    check_empty(
+        r#"
+    fn foo() {
+        if true {}
+        $0
+    }
+"#,
+        expect![[r#"
+            kw unsafe
+            kw fn
+            kw const
+            kw type
+            kw impl
+            kw extern
+            kw use
+            kw trait
+            kw static
+            kw mod
+            kw match
+            kw while
+            kw while let
+            kw loop
+            kw if
+            kw if let
+            kw for
+            kw true
+            kw false
+            kw let
+            kw else
+            kw else if
+            kw return
+            sn pd
+            sn ppd
+            kw self
+            kw super
+            kw crate
+            fn foo()     fn()
+            bt u32
+        "#]],
+    )
+}
+
+#[test]
+fn complete_in_match_arm() {
+    check_empty(
+        r#"
+    fn foo() {
+        match () {
+            () => $0
+        }
+    }
+"#,
+        expect![[r#"
+            kw unsafe
+            kw match
+            kw while
+            kw while let
+            kw loop
+            kw if
+            kw if let
+            kw for
+            kw true
+            kw false
+            kw return
+            kw self
+            kw super
+            kw crate
+            fn foo()     fn()
+            bt u32
+        "#]],
+    )
+}
+
+#[test]
+fn completes_in_loop_ctx() {
+    check_empty(
+        r"fn my() { loop { $0 } }",
+        expect![[r#"
+            kw unsafe
+            kw fn
+            kw const
+            kw type
+            kw impl
+            kw extern
+            kw use
+            kw trait
+            kw static
+            kw mod
+            kw match
+            kw while
+            kw while let
+            kw loop
+            kw if
+            kw if let
+            kw for
+            kw true
+            kw false
+            kw let
+            kw continue
+            kw break
+            kw return
+            sn pd
+            sn ppd
+            kw self
+            kw super
+            kw crate
+            fn my()      fn()
+            bt u32
+        "#]],
+    );
+}
+
+#[test]
+fn completes_in_let_initializer() {
+    check_empty(
+        r#"fn main() { let _ = $0 }"#,
+        expect![[r#"
+            kw unsafe
+            kw match
+            kw while
+            kw while let
+            kw loop
+            kw if
+            kw if let
+            kw for
+            kw true
+            kw false
+            kw return
+            kw self
+            kw super
+            kw crate
+            fn main()    fn()
+            bt u32
+        "#]],
+    )
+}
+
+#[test]
+fn struct_initializer_field_expr() {
+    check_empty(
+        r#"
+struct Foo {
+    pub f: i32,
+}
+fn foo() {
+    Foo {
+        f: $0
+    }
+}
+"#,
+        expect![[r#"
+            kw unsafe
+            kw match
+            kw while
+            kw while let
+            kw loop
+            kw if
+            kw if let
+            kw for
+            kw true
+            kw false
+            kw return
+            kw self
+            kw super
+            kw crate
+            st Foo
+            fn foo()     fn()
+            bt u32
+        "#]],
+    );
+}
+
+#[test]
 fn shadowing_shows_single_completion() {
     cov_mark::check!(shadowing_shows_single_completion);
 
diff --git a/crates/ide_completion/src/tests/flyimport.rs b/crates/ide_completion/src/tests/flyimport.rs
new file mode 100644
index 00000000000..201443e10c2
--- /dev/null
+++ b/crates/ide_completion/src/tests/flyimport.rs
@@ -0,0 +1,1014 @@
+use expect_test::{expect, Expect};
+
+use crate::tests::{check_edit, check_edit_with_config, TEST_CONFIG};
+
+fn check(ra_fixture: &str, expect: Expect) {
+    let config = TEST_CONFIG;
+    let (db, position) = crate::tests::position(ra_fixture);
+    let ctx = crate::context::CompletionContext::new(&db, position, &config).unwrap();
+
+    let mut acc = crate::completions::Completions::default();
+    crate::completions::flyimport::import_on_the_fly(&mut acc, &ctx);
+
+    expect.assert_eq(&super::render_completion_list(Vec::from(acc)));
+}
+
+#[test]
+fn function_fuzzy_completion() {
+    check_edit(
+        "stdin",
+        r#"
+//- /lib.rs crate:dep
+pub mod io {
+    pub fn stdin() {}
+};
+
+//- /main.rs crate:main deps:dep
+fn main() {
+    stdi$0
+}
+"#,
+        r#"
+use dep::io::stdin;
+
+fn main() {
+    stdin()$0
+}
+"#,
+    );
+}
+
+#[test]
+fn macro_fuzzy_completion() {
+    check_edit(
+        "macro_with_curlies!",
+        r#"
+//- /lib.rs crate:dep
+/// Please call me as macro_with_curlies! {}
+#[macro_export]
+macro_rules! macro_with_curlies {
+    () => {}
+}
+
+//- /main.rs crate:main deps:dep
+fn main() {
+    curli$0
+}
+"#,
+        r#"
+use dep::macro_with_curlies;
+
+fn main() {
+    macro_with_curlies! {$0}
+}
+"#,
+    );
+}
+
+#[test]
+fn struct_fuzzy_completion() {
+    check_edit(
+        "ThirdStruct",
+        r#"
+//- /lib.rs crate:dep
+pub struct FirstStruct;
+pub mod some_module {
+    pub struct SecondStruct;
+    pub struct ThirdStruct;
+}
+
+//- /main.rs crate:main deps:dep
+use dep::{FirstStruct, some_module::SecondStruct};
+
+fn main() {
+    this$0
+}
+"#,
+        r#"
+use dep::{FirstStruct, some_module::{SecondStruct, ThirdStruct}};
+
+fn main() {
+    ThirdStruct
+}
+"#,
+    );
+}
+
+#[test]
+fn short_paths_are_ignored() {
+    cov_mark::check!(ignore_short_input_for_path);
+
+    check(
+        r#"
+//- /lib.rs crate:dep
+pub struct FirstStruct;
+pub mod some_module {
+    pub struct SecondStruct;
+    pub struct ThirdStruct;
+}
+
+//- /main.rs crate:main deps:dep
+use dep::{FirstStruct, some_module::SecondStruct};
+
+fn main() {
+    t$0
+}
+"#,
+        expect![[r#""#]],
+    );
+}
+
+#[test]
+fn fuzzy_completions_come_in_specific_order() {
+    cov_mark::check!(certain_fuzzy_order_test);
+    check(
+        r#"
+//- /lib.rs crate:dep
+pub struct FirstStruct;
+pub mod some_module {
+    // already imported, omitted
+    pub struct SecondStruct;
+    // does not contain all letters from the query, omitted
+    pub struct UnrelatedOne;
+    // contains all letters from the query, but not in sequence, displayed last
+    pub struct ThiiiiiirdStruct;
+    // contains all letters from the query, but not in the beginning, displayed second
+    pub struct AfterThirdStruct;
+    // contains all letters from the query in the begginning, displayed first
+    pub struct ThirdStruct;
+}
+
+//- /main.rs crate:main deps:dep
+use dep::{FirstStruct, some_module::SecondStruct};
+
+fn main() {
+    hir$0
+}
+"#,
+        expect![[r#"
+                st ThirdStruct (use dep::some_module::ThirdStruct)
+                st AfterThirdStruct (use dep::some_module::AfterThirdStruct)
+                st ThiiiiiirdStruct (use dep::some_module::ThiiiiiirdStruct)
+            "#]],
+    );
+}
+
+#[test]
+fn trait_function_fuzzy_completion() {
+    let fixture = r#"
+        //- /lib.rs crate:dep
+        pub mod test_mod {
+            pub trait TestTrait {
+                const SPECIAL_CONST: u8;
+                type HumbleType;
+                fn weird_function();
+                fn random_method(&self);
+            }
+            pub struct TestStruct {}
+            impl TestTrait for TestStruct {
+                const SPECIAL_CONST: u8 = 42;
+                type HumbleType = ();
+                fn weird_function() {}
+                fn random_method(&self) {}
+            }
+        }
+
+        //- /main.rs crate:main deps:dep
+        fn main() {
+            dep::test_mod::TestStruct::wei$0
+        }
+        "#;
+
+    check(
+        fixture,
+        expect![[r#"
+                fn weird_function() (use dep::test_mod::TestTrait) fn()
+            "#]],
+    );
+
+    check_edit(
+        "weird_function",
+        fixture,
+        r#"
+use dep::test_mod::TestTrait;
+
+fn main() {
+    dep::test_mod::TestStruct::weird_function()$0
+}
+"#,
+    );
+}
+
+#[test]
+fn trait_const_fuzzy_completion() {
+    let fixture = r#"
+        //- /lib.rs crate:dep
+        pub mod test_mod {
+            pub trait TestTrait {
+                const SPECIAL_CONST: u8;
+                type HumbleType;
+                fn weird_function();
+                fn random_method(&self);
+            }
+            pub struct TestStruct {}
+            impl TestTrait for TestStruct {
+                const SPECIAL_CONST: u8 = 42;
+                type HumbleType = ();
+                fn weird_function() {}
+                fn random_method(&self) {}
+            }
+        }
+
+        //- /main.rs crate:main deps:dep
+        fn main() {
+            dep::test_mod::TestStruct::spe$0
+        }
+        "#;
+
+    check(
+        fixture,
+        expect![[r#"
+            ct SPECIAL_CONST (use dep::test_mod::TestTrait)
+        "#]],
+    );
+
+    check_edit(
+        "SPECIAL_CONST",
+        fixture,
+        r#"
+use dep::test_mod::TestTrait;
+
+fn main() {
+    dep::test_mod::TestStruct::SPECIAL_CONST
+}
+"#,
+    );
+}
+
+#[test]
+fn trait_method_fuzzy_completion() {
+    let fixture = r#"
+        //- /lib.rs crate:dep
+        pub mod test_mod {
+            pub trait TestTrait {
+                const SPECIAL_CONST: u8;
+                type HumbleType;
+                fn weird_function();
+                fn random_method(&self);
+            }
+            pub struct TestStruct {}
+            impl TestTrait for TestStruct {
+                const SPECIAL_CONST: u8 = 42;
+                type HumbleType = ();
+                fn weird_function() {}
+                fn random_method(&self) {}
+            }
+        }
+
+        //- /main.rs crate:main deps:dep
+        fn main() {
+            let test_struct = dep::test_mod::TestStruct {};
+            test_struct.ran$0
+        }
+        "#;
+
+    check(
+        fixture,
+        expect![[r#"
+                me random_method() (use dep::test_mod::TestTrait) fn(&self)
+            "#]],
+    );
+
+    check_edit(
+        "random_method",
+        fixture,
+        r#"
+use dep::test_mod::TestTrait;
+
+fn main() {
+    let test_struct = dep::test_mod::TestStruct {};
+    test_struct.random_method()$0
+}
+"#,
+    );
+}
+
+#[test]
+fn no_trait_type_fuzzy_completion() {
+    check(
+        r#"
+//- /lib.rs crate:dep
+pub mod test_mod {
+    pub trait TestTrait {
+        const SPECIAL_CONST: u8;
+        type HumbleType;
+        fn weird_function();
+        fn random_method(&self);
+    }
+    pub struct TestStruct {}
+    impl TestTrait for TestStruct {
+        const SPECIAL_CONST: u8 = 42;
+        type HumbleType = ();
+        fn weird_function() {}
+        fn random_method(&self) {}
+    }
+}
+
+//- /main.rs crate:main deps:dep
+fn main() {
+    dep::test_mod::TestStruct::hum$0
+}
+"#,
+        expect![[r#""#]],
+    );
+}
+
+#[test]
+fn does_not_propose_names_in_scope() {
+    check(
+        r#"
+//- /lib.rs crate:dep
+pub mod test_mod {
+    pub trait TestTrait {
+        const SPECIAL_CONST: u8;
+        type HumbleType;
+        fn weird_function();
+        fn random_method(&self);
+    }
+    pub struct TestStruct {}
+    impl TestTrait for TestStruct {
+        const SPECIAL_CONST: u8 = 42;
+        type HumbleType = ();
+        fn weird_function() {}
+        fn random_method(&self) {}
+    }
+}
+
+//- /main.rs crate:main deps:dep
+use dep::test_mod::TestStruct;
+fn main() {
+    TestSt$0
+}
+"#,
+        expect![[r#""#]],
+    );
+}
+
+#[test]
+fn does_not_propose_traits_in_scope() {
+    check(
+        r#"
+//- /lib.rs crate:dep
+pub mod test_mod {
+    pub trait TestTrait {
+        const SPECIAL_CONST: u8;
+        type HumbleType;
+        fn weird_function();
+        fn random_method(&self);
+    }
+    pub struct TestStruct {}
+    impl TestTrait for TestStruct {
+        const SPECIAL_CONST: u8 = 42;
+        type HumbleType = ();
+        fn weird_function() {}
+        fn random_method(&self) {}
+    }
+}
+
+//- /main.rs crate:main deps:dep
+use dep::test_mod::{TestStruct, TestTrait};
+fn main() {
+    dep::test_mod::TestStruct::hum$0
+}
+"#,
+        expect![[r#""#]],
+    );
+}
+
+#[test]
+fn blanket_trait_impl_import() {
+    check_edit(
+        "another_function",
+        r#"
+//- /lib.rs crate:dep
+pub mod test_mod {
+    pub struct TestStruct {}
+    pub trait TestTrait {
+        fn another_function();
+    }
+    impl<T> TestTrait for T {
+        fn another_function() {}
+    }
+}
+
+//- /main.rs crate:main deps:dep
+fn main() {
+    dep::test_mod::TestStruct::ano$0
+}
+"#,
+        r#"
+use dep::test_mod::TestTrait;
+
+fn main() {
+    dep::test_mod::TestStruct::another_function()$0
+}
+"#,
+    );
+}
+
+#[test]
+fn zero_input_deprecated_assoc_item_completion() {
+    check(
+        r#"
+//- /lib.rs crate:dep
+pub mod test_mod {
+    #[deprecated]
+    pub trait TestTrait {
+        const SPECIAL_CONST: u8;
+        type HumbleType;
+        fn weird_function();
+        fn random_method(&self);
+    }
+    pub struct TestStruct {}
+    impl TestTrait for TestStruct {
+        const SPECIAL_CONST: u8 = 42;
+        type HumbleType = ();
+        fn weird_function() {}
+        fn random_method(&self) {}
+    }
+}
+
+//- /main.rs crate:main deps:dep
+fn main() {
+    let test_struct = dep::test_mod::TestStruct {};
+    test_struct.$0
+}
+        "#,
+        expect![[r#"
+                me random_method() (use dep::test_mod::TestTrait) fn(&self) DEPRECATED
+            "#]],
+    );
+
+    check(
+        r#"
+//- /lib.rs crate:dep
+pub mod test_mod {
+    #[deprecated]
+    pub trait TestTrait {
+        const SPECIAL_CONST: u8;
+        type HumbleType;
+        fn weird_function();
+        fn random_method(&self);
+    }
+    pub struct TestStruct {}
+    impl TestTrait for TestStruct {
+        const SPECIAL_CONST: u8 = 42;
+        type HumbleType = ();
+        fn weird_function() {}
+        fn random_method(&self) {}
+    }
+}
+
+//- /main.rs crate:main deps:dep
+fn main() {
+    dep::test_mod::TestStruct::$0
+}
+"#,
+        expect![[r#"
+                fn weird_function() (use dep::test_mod::TestTrait) fn() DEPRECATED
+                ct SPECIAL_CONST (use dep::test_mod::TestTrait) DEPRECATED
+            "#]],
+    );
+}
+
+#[test]
+fn no_completions_in_use_statements() {
+    check(
+        r#"
+//- /lib.rs crate:dep
+pub mod io {
+    pub fn stdin() {}
+};
+
+//- /main.rs crate:main deps:dep
+use stdi$0
+
+fn main() {}
+"#,
+        expect![[]],
+    );
+}
+
+#[test]
+fn prefix_config_usage() {
+    let fixture = r#"
+mod foo {
+    pub mod bar {
+        pub struct Item;
+    }
+}
+
+use crate::foo::bar;
+
+fn main() {
+    Ite$0
+}"#;
+    let mut config = TEST_CONFIG;
+
+    config.insert_use.prefix_kind = hir::PrefixKind::ByCrate;
+    check_edit_with_config(
+        config.clone(),
+        "Item",
+        fixture,
+        r#"
+mod foo {
+    pub mod bar {
+        pub struct Item;
+    }
+}
+
+use crate::foo::bar::{self, Item};
+
+fn main() {
+    Item
+}"#,
+    );
+
+    config.insert_use.prefix_kind = hir::PrefixKind::BySelf;
+    check_edit_with_config(
+        config.clone(),
+        "Item",
+        fixture,
+        r#"
+mod foo {
+    pub mod bar {
+        pub struct Item;
+    }
+}
+
+use crate::foo::bar;
+
+use self::foo::bar::Item;
+
+fn main() {
+    Item
+}"#,
+    );
+
+    config.insert_use.prefix_kind = hir::PrefixKind::Plain;
+    check_edit_with_config(
+        config,
+        "Item",
+        fixture,
+        r#"
+mod foo {
+    pub mod bar {
+        pub struct Item;
+    }
+}
+
+use foo::bar::Item;
+
+use crate::foo::bar;
+
+fn main() {
+    Item
+}"#,
+    );
+}
+
+#[test]
+fn unresolved_qualifier() {
+    let fixture = r#"
+mod foo {
+    pub mod bar {
+        pub mod baz {
+            pub struct Item;
+        }
+    }
+}
+
+fn main() {
+    bar::baz::Ite$0
+}"#;
+
+    check(
+        fixture,
+        expect![[r#"
+        st Item (use foo::bar::baz::Item)
+        "#]],
+    );
+
+    check_edit(
+        "Item",
+        fixture,
+        r#"
+        use foo::bar;
+
+        mod foo {
+            pub mod bar {
+                pub mod baz {
+                    pub struct Item;
+                }
+            }
+        }
+
+        fn main() {
+            bar::baz::Item
+        }"#,
+    );
+}
+
+#[test]
+fn unresolved_assoc_item_container() {
+    let fixture = r#"
+mod foo {
+    pub struct Item;
+
+    impl Item {
+        pub const TEST_ASSOC: usize = 3;
+    }
+}
+
+fn main() {
+    Item::TEST_A$0
+}"#;
+
+    check(
+        fixture,
+        expect![[r#"
+        ct TEST_ASSOC (use foo::Item)
+        "#]],
+    );
+
+    check_edit(
+        "TEST_ASSOC",
+        fixture,
+        r#"
+use foo::Item;
+
+mod foo {
+    pub struct Item;
+
+    impl Item {
+        pub const TEST_ASSOC: usize = 3;
+    }
+}
+
+fn main() {
+    Item::TEST_ASSOC
+}"#,
+    );
+}
+
+#[test]
+fn unresolved_assoc_item_container_with_path() {
+    let fixture = r#"
+mod foo {
+    pub mod bar {
+        pub struct Item;
+
+        impl Item {
+            pub const TEST_ASSOC: usize = 3;
+        }
+    }
+}
+
+fn main() {
+    bar::Item::TEST_A$0
+}"#;
+
+    check(
+        fixture,
+        expect![[r#"
+        ct TEST_ASSOC (use foo::bar::Item)
+    "#]],
+    );
+
+    check_edit(
+        "TEST_ASSOC",
+        fixture,
+        r#"
+use foo::bar;
+
+mod foo {
+    pub mod bar {
+        pub struct Item;
+
+        impl Item {
+            pub const TEST_ASSOC: usize = 3;
+        }
+    }
+}
+
+fn main() {
+    bar::Item::TEST_ASSOC
+}"#,
+    );
+}
+
+#[test]
+fn fuzzy_unresolved_path() {
+    check(
+        r#"
+mod foo {
+    pub mod bar {
+        pub struct Item;
+
+        impl Item {
+            pub const TEST_ASSOC: usize = 3;
+        }
+    }
+}
+
+fn main() {
+    bar::ASS$0
+}"#,
+        expect![[]],
+    )
+}
+
+#[test]
+fn unqualified_assoc_items_are_omitted() {
+    check(
+        r#"
+mod something {
+    pub trait BaseTrait {
+        fn test_function() -> i32;
+    }
+
+    pub struct Item1;
+    pub struct Item2;
+
+    impl BaseTrait for Item1 {
+        fn test_function() -> i32 {
+            1
+        }
+    }
+
+    impl BaseTrait for Item2 {
+        fn test_function() -> i32 {
+            2
+        }
+    }
+}
+
+fn main() {
+    test_f$0
+}"#,
+        expect![[]],
+    )
+}
+
+#[test]
+fn case_matters() {
+    check(
+        r#"
+mod foo {
+    pub const TEST_CONST: usize = 3;
+    pub fn test_function() -> i32 {
+        4
+    }
+}
+
+fn main() {
+    TE$0
+}"#,
+        expect![[r#"
+        ct TEST_CONST (use foo::TEST_CONST)
+    "#]],
+    );
+
+    check(
+        r#"
+mod foo {
+    pub const TEST_CONST: usize = 3;
+    pub fn test_function() -> i32 {
+        4
+    }
+}
+
+fn main() {
+    te$0
+}"#,
+        expect![[r#"
+        ct TEST_CONST (use foo::TEST_CONST)
+        fn test_function() (use foo::test_function) fn() -> i32
+    "#]],
+    );
+
+    check(
+        r#"
+mod foo {
+    pub const TEST_CONST: usize = 3;
+    pub fn test_function() -> i32 {
+        4
+    }
+}
+
+fn main() {
+    Te$0
+}"#,
+        expect![[]],
+    );
+}
+
+#[test]
+fn no_fuzzy_during_fields_of_record_lit_syntax() {
+    check(
+        r#"
+mod m {
+    pub fn some_fn() -> i32 {
+        42
+    }
+}
+struct Foo {
+    some_field: i32,
+}
+fn main() {
+    let _ = Foo { so$0 };
+}
+"#,
+        expect![[]],
+    );
+}
+
+#[test]
+fn fuzzy_after_fields_of_record_lit_syntax() {
+    check(
+        r#"
+mod m {
+    pub fn some_fn() -> i32 {
+        42
+    }
+}
+struct Foo {
+    some_field: i32,
+}
+fn main() {
+    let _ = Foo { some_field: so$0 };
+}
+"#,
+        expect![[r#"
+                fn some_fn() (use m::some_fn) fn() -> i32
+            "#]],
+    );
+}
+
+#[test]
+fn no_flyimports_in_traits_and_impl_declarations() {
+    check(
+        r#"
+mod m {
+    pub fn some_fn() -> i32 {
+        42
+    }
+}
+trait Foo {
+    som$0
+}
+"#,
+        expect![[r#""#]],
+    );
+
+    check(
+        r#"
+mod m {
+    pub fn some_fn() -> i32 {
+        42
+    }
+}
+struct Foo;
+impl Foo {
+    som$0
+}
+"#,
+        expect![[r#""#]],
+    );
+
+    check(
+        r#"
+mod m {
+    pub fn some_fn() -> i32 {
+        42
+    }
+}
+struct Foo;
+trait Bar {}
+impl Bar for Foo {
+    som$0
+}
+"#,
+        expect![[r#""#]],
+    );
+}
+
+#[test]
+fn no_inherent_candidates_proposed() {
+    check(
+        r#"
+mod baz {
+    pub trait DefDatabase {
+        fn method1(&self);
+    }
+    pub trait HirDatabase: DefDatabase {
+        fn method2(&self);
+    }
+}
+
+mod bar {
+    fn test(db: &dyn crate::baz::HirDatabase) {
+        db.metho$0
+    }
+}
+            "#,
+        expect![[r#""#]],
+    );
+}
+
+#[test]
+fn respects_doc_hidden() {
+    check(
+        r#"
+//- /lib.rs crate:lib deps:dep
+fn f() {
+    ().fro$0
+}
+
+//- /dep.rs crate:dep
+#[doc(hidden)]
+pub trait Private {
+    fn frob(&self) {}
+}
+
+impl<T> Private for T {}
+            "#,
+        expect![[r#""#]],
+    );
+    check(
+        r#"
+//- /lib.rs crate:lib deps:dep
+fn f() {
+    ().fro$0
+}
+
+//- /dep.rs crate:dep
+pub trait Private {
+    #[doc(hidden)]
+    fn frob(&self) {}
+}
+
+impl<T> Private for T {}
+            "#,
+        expect![[r#""#]],
+    );
+}
+
+#[test]
+fn regression_9760() {
+    check(
+        r#"
+struct Struct;
+fn main() {}
+
+mod mud {
+    fn func() {
+        let struct_instance = Stru$0
+    }
+}
+"#,
+        expect![[r#"
+                st Struct (use crate::Struct)
+            "#]],
+    );
+}
+
+#[test]
+fn flyimport_pattern() {
+    check(
+        r#"
+mod module {
+    pub struct Struct;
+}
+fn function() {
+    let Str$0
+}
+"#,
+        expect![[r#"
+                st Struct (use module::Struct)
+            "#]],
+    );
+}
+
+#[test]
+fn flyimport_rename() {
+    check(
+        r#"
+mod module {
+    pub struct Struct;
+}
+use self as Str$0;
+    "#,
+        expect![[r#""#]],
+    );
+}
diff --git a/crates/ide_completion/src/tests/record.rs b/crates/ide_completion/src/tests/record.rs
index 30b1f2c1c97..e09e99aad5e 100644
--- a/crates/ide_completion/src/tests/record.rs
+++ b/crates/ide_completion/src/tests/record.rs
@@ -9,6 +9,7 @@ fn check(ra_fixture: &str, expect: Expect) {
 
 #[test]
 fn without_default_impl() {
+    cov_mark::check!(no_keyword_completion_in_record_lit);
     check(
         r#"
 struct Struct { foo: u32, bar: usize }
diff --git a/crates/rust-analyzer/tests/slow-tests/tidy.rs b/crates/rust-analyzer/tests/slow-tests/tidy.rs
index 9be9f3afeaf..5debb9fb3d1 100644
--- a/crates/rust-analyzer/tests/slow-tests/tidy.rs
+++ b/crates/rust-analyzer/tests/slow-tests/tidy.rs
@@ -313,6 +313,7 @@ fn check_dbg(path: &Path, text: &str) {
         "handlers/remove_dbg.rs",
         // We have .dbg postfix
         "ide_completion/src/completions/postfix.rs",
+        "ide_completion/src/completions/keyword.rs",
         "ide_completion/src/tests/proc_macros.rs",
         // The documentation in string literals may contain anything for its own purposes
         "ide_completion/src/lib.rs",