16 files changed, 504 insertions, 257 deletions

diff --git a/crates/ide_completion/Cargo.toml b/crates/ide_completion/Cargo.toml
index c09101ccb..585ecca50 100644
--- a/crates/ide_completion/Cargo.toml
+++ b/crates/ide_completion/Cargo.toml
@@ -10,6 +10,7 @@ edition = "2018"
 doctest = false
 
 [dependencies]
+cov-mark = "1.1"
 itertools = "0.10.0"
 log = "0.4.8"
 rustc-hash = "1.1.0"
@@ -21,11 +22,11 @@ text_edit = { path = "../text_edit", version = "0.0.0" }
 base_db = { path = "../base_db", version = "0.0.0" }
 ide_db = { path = "../ide_db", version = "0.0.0" }
 profile = { path = "../profile", version = "0.0.0" }
-test_utils = { path = "../test_utils", version = "0.0.0" }
 
 # completions crate should depend only on the top-level `hir` package. if you need
 # something from some `hir_xxx` subpackage, reexport the API via `hir`.
 hir = { path = "../hir", version = "0.0.0" }
 
 [dev-dependencies]
+test_utils = { path = "../test_utils" }
 expect-test = "1.1"
diff --git a/crates/ide_completion/src/completions/dot.rs b/crates/ide_completion/src/completions/dot.rs
index 084d7721d..5ee9a9f07 100644
--- a/crates/ide_completion/src/completions/dot.rs
+++ b/crates/ide_completion/src/completions/dot.rs
@@ -2,7 +2,6 @@
 
 use hir::{HasVisibility, Type};
 use rustc_hash::FxHashSet;
-use test_utils::mark;
 
 use crate::{context::CompletionContext, Completions};
 
@@ -19,7 +18,7 @@ pub(crate) fn complete_dot(acc: &mut Completions, ctx: &CompletionContext) {
     };
 
     if ctx.is_call {
-        mark::hit!(test_no_struct_field_completion_for_method_call);
+        cov_mark::hit!(test_no_struct_field_completion_for_method_call);
     } else {
         complete_fields(acc, ctx, &receiver_ty);
     }
@@ -62,7 +61,6 @@ fn complete_methods(acc: &mut Completions, ctx: &CompletionContext, receiver: &T
 #[cfg(test)]
 mod tests {
     use expect_test::{expect, Expect};
-    use test_utils::mark;
 
     use crate::{test_utils::completion_list, CompletionKind};
 
@@ -122,7 +120,7 @@ impl A {
 
     #[test]
     fn test_no_struct_field_completion_for_method_call() {
-        mark::check!(test_no_struct_field_completion_for_method_call);
+        cov_mark::check!(test_no_struct_field_completion_for_method_call);
         check(
             r#"
 struct A { the_field: u32 }
diff --git a/crates/ide_completion/src/completions/flyimport.rs b/crates/ide_completion/src/completions/flyimport.rs
index da8375af9..391a11c91 100644
--- a/crates/ide_completion/src/completions/flyimport.rs
+++ b/crates/ide_completion/src/completions/flyimport.rs
@@ -21,6 +21,46 @@
 //! ```
 //!
 //! Also completes associated items, that require trait imports.
+//! If any unresolved and/or partially-qualified path predeces the input, it will be taken into account.
+//! Currently, only the imports with their import path ending with the whole qialifier will be proposed
+//! (no fuzzy matching for qualifier).
+//!
+//! ```
+//! mod foo {
+//!     pub mod bar {
+//!         pub struct Item;
+//!
+//!         impl Item {
+//!             pub const TEST_ASSOC: usize = 3;
+//!         }
+//!     }
+//! }
+//!
+//! fn main() {
+//!     bar::Item::TEST_A$0
+//! }
+//! ```
+//! ->
+//! ```
+//! 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
+//! }
+//! ```
+//!
+//! NOTE: currently, if an assoc item comes from a trait that's not currently imported and it also has an unresolved and/or partially-qualified path,
+//! no imports will be proposed.
 //!
 //! .Fuzzy search details
 //!
@@ -48,14 +88,13 @@
 //! Note that having this flag set to `true` does not guarantee that the feature is enabled: your client needs to have the corredponding
 //! capability enabled.
 
-use hir::{AsAssocItem, ModPath, ScopeDef};
+use hir::ModPath;
 use ide_db::helpers::{
     import_assets::{ImportAssets, ImportCandidate},
     insert_use::ImportScope,
 };
-use rustc_hash::FxHashSet;
+use itertools::Itertools;
 use syntax::{AstNode, SyntaxNode, T};
-use test_utils::mark;
 
 use crate::{
     context::CompletionContext,
@@ -93,50 +132,26 @@ pub(crate) fn import_on_the_fly(acc: &mut Completions, ctx: &CompletionContext)
         &ctx.sema,
     )?;
 
-    let scope_definitions = scope_definitions(ctx);
-    let mut all_mod_paths = import_assets
-        .search_for_imports(&ctx.sema, ctx.config.insert_use.prefix_kind)
-        .into_iter()
-        .map(|(mod_path, item_in_ns)| {
-            let scope_item = match item_in_ns {
-                hir::ItemInNs::Types(id) => ScopeDef::ModuleDef(id.into()),
-                hir::ItemInNs::Values(id) => ScopeDef::ModuleDef(id.into()),
-                hir::ItemInNs::Macros(id) => ScopeDef::MacroDef(id.into()),
-            };
-            (mod_path, scope_item)
-        })
-        .filter(|(_, proposed_def)| !scope_definitions.contains(proposed_def))
-        .collect::<Vec<_>>();
-    all_mod_paths.sort_by_cached_key(|(mod_path, _)| {
-        compute_fuzzy_completion_order_key(mod_path, &user_input_lowercased)
-    });
-
-    acc.add_all(all_mod_paths.into_iter().filter_map(|(import_path, definition)| {
-        let import_for_trait_assoc_item = match definition {
-            ScopeDef::ModuleDef(module_def) => module_def
-                .as_assoc_item(ctx.db)
-                .and_then(|assoc| assoc.containing_trait(ctx.db))
-                .is_some(),
-            _ => false,
-        };
-        let import_edit = ImportEdit {
-            import_path,
-            import_scope: import_scope.clone(),
-            import_for_trait_assoc_item,
-        };
-        render_resolution_with_import(RenderContext::new(ctx), import_edit, &definition)
-    }));
+    acc.add_all(
+        import_assets
+            .search_for_imports(&ctx.sema, ctx.config.insert_use.prefix_kind)
+            .into_iter()
+            .sorted_by_key(|located_import| {
+                compute_fuzzy_completion_order_key(
+                    &located_import.import_path,
+                    &user_input_lowercased,
+                )
+            })
+            .filter_map(|import| {
+                render_resolution_with_import(
+                    RenderContext::new(ctx),
+                    ImportEdit { import, scope: import_scope.clone() },
+                )
+            }),
+    );
     Some(())
 }
 
-fn scope_definitions(ctx: &CompletionContext) -> FxHashSet<ScopeDef> {
-    let mut scope_definitions = FxHashSet::default();
-    ctx.scope.process_all_names(&mut |_, scope_def| {
-        scope_definitions.insert(scope_def);
-    });
-    scope_definitions
-}
-
 pub(crate) fn position_for_import<'a>(
     ctx: &'a CompletionContext,
     import_candidate: Option<&ImportCandidate>,
@@ -161,23 +176,30 @@ fn import_assets(ctx: &CompletionContext, fuzzy_name: String) -> Option<ImportAs
             current_module,
             ctx.sema.type_of_expr(dot_receiver)?,
             fuzzy_name,
+            dot_receiver.syntax().clone(),
         )
     } else {
         let fuzzy_name_length = fuzzy_name.len();
+        let approximate_node = match current_module.definition_source(ctx.db).value {
+            hir::ModuleSource::SourceFile(s) => s.syntax().clone(),
+            hir::ModuleSource::Module(m) => m.syntax().clone(),
+            hir::ModuleSource::BlockExpr(b) => b.syntax().clone(),
+        };
         let assets_for_path = ImportAssets::for_fuzzy_path(
             current_module,
             ctx.path_qual.clone(),
             fuzzy_name,
             &ctx.sema,
-        );
+            approximate_node,
+        )?;
 
-        if matches!(assets_for_path.as_ref()?.import_candidate(), ImportCandidate::Path(_))
+        if matches!(assets_for_path.import_candidate(), ImportCandidate::Path(_))
             && fuzzy_name_length < 2
         {
-            mark::hit!(ignore_short_input_for_path);
+            cov_mark::hit!(ignore_short_input_for_path);
             None
         } else {
-            assets_for_path
+            Some(assets_for_path)
         }
     }
 }
@@ -186,12 +208,12 @@ fn compute_fuzzy_completion_order_key(
     proposed_mod_path: &ModPath,
     user_input_lowercased: &str,
 ) -> usize {
-    mark::hit!(certain_fuzzy_order_test);
-    let proposed_import_name = match proposed_mod_path.segments().last() {
+    cov_mark::hit!(certain_fuzzy_order_test);
+    let import_name = match proposed_mod_path.segments().last() {
         Some(name) => name.to_string().to_lowercase(),
         None => return usize::MAX,
     };
-    match proposed_import_name.match_indices(user_input_lowercased).next() {
+    match import_name.match_indices(user_input_lowercased).next() {
         Some((first_matching_index, _)) => first_matching_index,
         None => usize::MAX,
     }
@@ -200,7 +222,6 @@ fn compute_fuzzy_completion_order_key(
 #[cfg(test)]
 mod tests {
     use expect_test::{expect, Expect};
-    use test_utils::mark;
 
     use crate::{
         item::CompletionKind,
@@ -295,7 +316,7 @@ fn main() {
 
     #[test]
     fn short_paths_are_ignored() {
-        mark::check!(ignore_short_input_for_path);
+        cov_mark::check!(ignore_short_input_for_path);
 
         check(
             r#"
@@ -319,7 +340,7 @@ fn main() {
 
     #[test]
     fn fuzzy_completions_come_in_specific_order() {
-        mark::check!(certain_fuzzy_order_test);
+        cov_mark::check!(certain_fuzzy_order_test);
         check(
             r#"
 //- /lib.rs crate:dep
@@ -775,4 +796,155 @@ fn main() {
 }"#,
         );
     }
+
+    #[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 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 (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 (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![[]],
+        )
+    }
 }
diff --git a/crates/ide_completion/src/completions/keyword.rs b/crates/ide_completion/src/completions/keyword.rs
index 03c6dd454..80aa9fb06 100644
--- a/crates/ide_completion/src/completions/keyword.rs
+++ b/crates/ide_completion/src/completions/keyword.rs
@@ -3,7 +3,6 @@
 use std::iter;
 
 use syntax::SyntaxKind;
-use test_utils::mark;
 
 use crate::{CompletionContext, CompletionItem, CompletionItemKind, CompletionKind, Completions};
 
@@ -47,11 +46,11 @@ pub(crate) fn complete_use_tree_keyword(acc: &mut Completions, ctx: &CompletionC
 
 pub(crate) fn complete_expr_keyword(acc: &mut Completions, ctx: &CompletionContext) {
     if ctx.token.kind() == SyntaxKind::COMMENT {
-        mark::hit!(no_keyword_completion_in_comments);
+        cov_mark::hit!(no_keyword_completion_in_comments);
         return;
     }
     if ctx.record_lit_syntax.is_some() {
-        mark::hit!(no_keyword_completion_in_record_lit);
+        cov_mark::hit!(no_keyword_completion_in_record_lit);
         return;
     }
 
@@ -172,7 +171,7 @@ fn add_keyword(ctx: &CompletionContext, acc: &mut Completions, kw: &str, snippet
         Some(cap) => {
             let tmp;
             let snippet = if snippet.ends_with('}') && ctx.incomplete_let {
-                mark::hit!(let_semi);
+                cov_mark::hit!(let_semi);
                 tmp = format!("{};", snippet);
                 &tmp
             } else {
@@ -188,7 +187,6 @@ fn add_keyword(ctx: &CompletionContext, acc: &mut Completions, kw: &str, snippet
 #[cfg(test)]
 mod tests {
     use expect_test::{expect, Expect};
-    use test_utils::mark;
 
     use crate::{
         test_utils::{check_edit, completion_list},
@@ -494,7 +492,7 @@ fn quux() -> i32 {
 
     #[test]
     fn no_keyword_completion_in_comments() {
-        mark::check!(no_keyword_completion_in_comments);
+        cov_mark::check!(no_keyword_completion_in_comments);
         check(
             r#"
 fn test() {
@@ -599,7 +597,7 @@ struct Foo {
 
     #[test]
     fn skip_struct_initializer() {
-        mark::check!(no_keyword_completion_in_record_lit);
+        cov_mark::check!(no_keyword_completion_in_record_lit);
         check(
             r#"
 struct Foo {
@@ -643,7 +641,7 @@ fn foo() {
 
     #[test]
     fn let_semi() {
-        mark::check!(let_semi);
+        cov_mark::check!(let_semi);
         check_edit(
             "match",
             r#"
diff --git a/crates/ide_completion/src/completions/postfix.rs b/crates/ide_completion/src/completions/postfix.rs
index 9c34ed0b6..d45ad7944 100644
--- a/crates/ide_completion/src/completions/postfix.rs
+++ b/crates/ide_completion/src/completions/postfix.rs
@@ -187,6 +187,16 @@ pub(crate) fn complete_postfix(acc: &mut Completions, ctx: &CompletionContext) {
         ctx,
         cap,
         &dot_receiver,
+        "err",
+        "Err(expr)",
+        &format!("Err({})", receiver_text),
+    )
+    .add_to(acc);
+
+    postfix_snippet(
+        ctx,
+        cap,
+        &dot_receiver,
         "some",
         "Some(expr)",
         &format!("Some({})", receiver_text),
@@ -325,6 +335,7 @@ fn main() {
                 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)
@@ -357,6 +368,7 @@ fn main() {
                 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)
@@ -380,6 +392,7 @@ fn main() {
                 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)
@@ -408,6 +421,7 @@ fn main() {
                 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)
diff --git a/crates/ide_completion/src/completions/qualified_path.rs b/crates/ide_completion/src/completions/qualified_path.rs
index 72fb757b1..df74b739e 100644
--- a/crates/ide_completion/src/completions/qualified_path.rs
+++ b/crates/ide_completion/src/completions/qualified_path.rs
@@ -3,7 +3,6 @@
 use hir::{Adt, HasVisibility, PathResolution, ScopeDef};
 use rustc_hash::FxHashSet;
 use syntax::AstNode;
-use test_utils::mark;
 
 use crate::{CompletionContext, Completions};
 
@@ -39,7 +38,7 @@ pub(crate) fn complete_qualified_path(acc: &mut Completions, ctx: &CompletionCon
                         if let Some(name_ref) = ctx.name_ref_syntax.as_ref() {
                             if name_ref.syntax().text() == name.to_string().as_str() {
                                 // for `use self::foo$0`, don't suggest `foo` as a completion
-                                mark::hit!(dont_complete_current_use);
+                                cov_mark::hit!(dont_complete_current_use);
                                 continue;
                             }
                         }
@@ -155,7 +154,6 @@ pub(crate) fn complete_qualified_path(acc: &mut Completions, ctx: &CompletionCon
 #[cfg(test)]
 mod tests {
     use expect_test::{expect, Expect};
-    use test_utils::mark;
 
     use crate::{
         test_utils::{check_edit, completion_list},
@@ -174,7 +172,7 @@ mod tests {
 
     #[test]
     fn dont_complete_current_use() {
-        mark::check!(dont_complete_current_use);
+        cov_mark::check!(dont_complete_current_use);
         check(r#"use self::foo$0;"#, expect![[""]]);
     }
 
diff --git a/crates/ide_completion/src/completions/unqualified_path.rs b/crates/ide_completion/src/completions/unqualified_path.rs
index e9d0ff665..044dfd160 100644
--- a/crates/ide_completion/src/completions/unqualified_path.rs
+++ b/crates/ide_completion/src/completions/unqualified_path.rs
@@ -2,7 +2,6 @@
 
 use hir::ScopeDef;
 use syntax::AstNode;
-use test_utils::mark;
 
 use crate::{CompletionContext, Completions};
 
@@ -30,13 +29,13 @@ pub(crate) fn complete_unqualified_path(acc: &mut Completions, ctx: &CompletionC
 
     ctx.scope.process_all_names(&mut |name, res| {
         if let ScopeDef::GenericParam(hir::GenericParam::LifetimeParam(_)) = res {
-            mark::hit!(skip_lifetime_completion);
+            cov_mark::hit!(skip_lifetime_completion);
             return;
         }
         if ctx.use_item_syntax.is_some() {
             if let (ScopeDef::Unknown, Some(name_ref)) = (&res, &ctx.name_ref_syntax) {
                 if name_ref.syntax().text() == name.to_string().as_str() {
-                    mark::hit!(self_fulfilling_completion);
+                    cov_mark::hit!(self_fulfilling_completion);
                     return;
                 }
             }
@@ -48,7 +47,6 @@ pub(crate) fn complete_unqualified_path(acc: &mut Completions, ctx: &CompletionC
 #[cfg(test)]
 mod tests {
     use expect_test::{expect, Expect};
-    use test_utils::mark;
 
     use crate::{
         test_utils::{check_edit, completion_list_with_config, TEST_CONFIG},
@@ -66,7 +64,7 @@ mod tests {
 
     #[test]
     fn self_fulfilling_completion() {
-        mark::check!(self_fulfilling_completion);
+        cov_mark::check!(self_fulfilling_completion);
         check(
             r#"
 use foo$0
@@ -185,7 +183,7 @@ fn quux() {
 
     #[test]
     fn completes_if_prefix_is_keyword() {
-        mark::check!(completes_if_prefix_is_keyword);
+        cov_mark::check!(completes_if_prefix_is_keyword);
         check_edit(
             "wherewolf",
             r#"
@@ -223,7 +221,7 @@ fn main() {
 
     #[test]
     fn does_not_complete_lifetimes() {
-        mark::check!(skip_lifetime_completion);
+        cov_mark::check!(skip_lifetime_completion);
         check(
             r#"fn quux<'a>() { $0 }"#,
             expect![[r#"
diff --git a/crates/ide_completion/src/context.rs b/crates/ide_completion/src/context.rs
index 3db357855..17d9a3adf 100644
--- a/crates/ide_completion/src/context.rs
+++ b/crates/ide_completion/src/context.rs
@@ -7,7 +7,7 @@ use syntax::{
     algo::find_node_at_offset, ast, match_ast, AstNode, NodeOrToken, SyntaxKind::*, SyntaxNode,
     SyntaxToken, TextRange, TextSize,
 };
-use test_utils::mark;
+
 use text_edit::Indel;
 
 use crate::{
@@ -240,7 +240,7 @@ 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 == UNDERSCORE || kind.is_keyword() {
-            mark::hit!(completes_if_prefix_is_keyword);
+            cov_mark::hit!(completes_if_prefix_is_keyword);
             self.original_token.text_range()
         } else {
             TextRange::empty(self.position.offset)
diff --git a/crates/ide_completion/src/item.rs b/crates/ide_completion/src/item.rs
index 884711f11..14afec603 100644
--- a/crates/ide_completion/src/item.rs
+++ b/crates/ide_completion/src/item.rs
@@ -2,15 +2,16 @@
 
 use std::fmt;
 
-use hir::{Documentation, ModPath, Mutability};
+use hir::{Documentation, Mutability};
 use ide_db::{
     helpers::{
-        insert_use::{self, ImportScope, MergeBehavior},
+        import_assets::LocatedImport,
+        insert_use::{self, ImportScope, InsertUseConfig},
         mod_path_to_ast, SnippetCap,
     },
     SymbolKind,
 };
-use stdx::{impl_from, never};
+use stdx::{format_to, impl_from, never};
 use syntax::{algo, TextRange};
 use text_edit::TextEdit;
 
@@ -62,12 +63,18 @@ pub struct CompletionItem {
     /// after completion.
     trigger_call_info: bool,
 
-    /// Score is useful to pre select or display in better order completion items
-    score: Option<CompletionScore>,
+    /// We use this to sort completion. Relevance records facts like "do the
+    /// types align precisely?". We can't sort by relevances directly, they are
+    /// only partially ordered.
+    ///
+    /// Note that Relevance ignores fuzzy match score. We compute Relevance for
+    /// all possible items, and then separately build an ordered completion list
+    /// based on relevance and fuzzy matching with the already typed identifier.
+    relevance: Relevance,
 
     /// Indicates that a reference or mutable reference to this variable is a
     /// possible match.
-    ref_match: Option<(Mutability, CompletionScore)>,
+    ref_match: Option<Mutability>,
 
     /// The import data to add to completion's edits.
     import_to_add: Option<ImportEdit>,
@@ -100,8 +107,11 @@ impl fmt::Debug for CompletionItem {
         if self.deprecated {
             s.field("deprecated", &true);
         }
-        if let Some(score) = &self.score {
-            s.field("score", score);
+        if self.relevance.is_relevant() {
+            s.field("relevance", &self.relevance);
+        }
+        if let Some(mutability) = &self.ref_match {
+            s.field("ref_match", &format!("&{}", mutability.as_keyword_for_ref()));
         }
         if self.trigger_call_info {
             s.field("trigger_call_info", &true);
@@ -118,6 +128,36 @@ pub enum CompletionScore {
     TypeAndNameMatch,
 }
 
+#[derive(Debug, Clone, Copy, Ord, PartialOrd, Eq, PartialEq, Default)]
+pub struct Relevance {
+    /// This is set in cases like these:
+    ///
+    /// ```
+    /// fn f(spam: String) {}
+    /// fn main {
+    ///     let spam = 92;
+    ///     f($0) // name of local matches the name of param
+    /// }
+    /// ```
+    pub exact_name_match: bool,
+    /// This is set in cases like these:
+    ///
+    /// ```
+    /// fn f(spam: String) {}
+    /// fn main {
+    ///     let foo = String::new();
+    ///     f($0) // type of local matches the type of param
+    /// }
+    /// ```
+    pub exact_type_match: bool,
+}
+
+impl Relevance {
+    pub fn is_relevant(&self) -> bool {
+        self != &Relevance::default()
+    }
+}
+
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum CompletionItemKind {
     SymbolKind(SymbolKind),
@@ -207,9 +247,9 @@ impl CompletionItem {
             lookup: None,
             kind: None,
             text_edit: None,
-            deprecated: None,
+            deprecated: false,
             trigger_call_info: None,
-            score: None,
+            relevance: Relevance::default(),
             ref_match: None,
             import_to_add: None,
         }
@@ -252,15 +292,15 @@ impl CompletionItem {
         self.deprecated
     }
 
-    pub fn score(&self) -> Option<CompletionScore> {
-        self.score
+    pub fn relevance(&self) -> Relevance {
+        self.relevance
     }
 
     pub fn trigger_call_info(&self) -> bool {
         self.trigger_call_info
     }
 
-    pub fn ref_match(&self) -> Option<(Mutability, CompletionScore)> {
+    pub fn ref_match(&self) -> Option<Mutability> {
         self.ref_match
     }
 
@@ -272,22 +312,18 @@ impl CompletionItem {
 /// An extra import to add after the completion is applied.
 #[derive(Debug, Clone)]
 pub struct ImportEdit {
-    pub import_path: ModPath,
-    pub import_scope: ImportScope,
-    pub import_for_trait_assoc_item: bool,
+    pub import: LocatedImport,
+    pub scope: ImportScope,
 }
 
 impl ImportEdit {
     /// Attempts to insert the import to the given scope, producing a text edit.
     /// May return no edit in edge cases, such as scope already containing the import.
-    pub fn to_text_edit(&self, merge_behavior: Option<MergeBehavior>) -> Option<TextEdit> {
+    pub fn to_text_edit(&self, cfg: InsertUseConfig) -> Option<TextEdit> {
         let _p = profile::span("ImportEdit::to_text_edit");
 
-        let rewriter = insert_use::insert_use(
-            &self.import_scope,
-            mod_path_to_ast(&self.import_path),
-            merge_behavior,
-        );
+        let rewriter =
+            insert_use::insert_use(&self.scope, mod_path_to_ast(&self.import.import_path), cfg);
         let old_ast = rewriter.rewrite_root()?;
         let mut import_insert = TextEdit::builder();
         algo::diff(&old_ast, &rewriter.rewrite(&old_ast)).into_text_edit(&mut import_insert);
@@ -311,10 +347,10 @@ pub(crate) struct Builder {
     lookup: Option<String>,
     kind: Option<CompletionItemKind>,
     text_edit: Option<TextEdit>,
-    deprecated: Option<bool>,
+    deprecated: bool,
     trigger_call_info: Option<bool>,
-    score: Option<CompletionScore>,
-    ref_match: Option<(Mutability, CompletionScore)>,
+    relevance: Relevance,
+    ref_match: Option<Mutability>,
 }
 
 impl Builder {
@@ -325,20 +361,19 @@ impl Builder {
         let mut lookup = self.lookup;
         let mut insert_text = self.insert_text;
 
-        if let Some(import_to_add) = self.import_to_add.as_ref() {
-            if import_to_add.import_for_trait_assoc_item {
-                lookup = lookup.or_else(|| Some(label.clone()));
-                insert_text = insert_text.or_else(|| Some(label.clone()));
-                label = format!("{} ({})", label, import_to_add.import_path);
+        if let Some(original_path) = self
+            .import_to_add
+            .as_ref()
+            .and_then(|import_edit| import_edit.import.original_path.as_ref())
+        {
+            lookup = lookup.or_else(|| Some(label.clone()));
+            insert_text = insert_text.or_else(|| Some(label.clone()));
+
+            let original_path_label = original_path.to_string();
+            if original_path_label.ends_with(&label) {
+                label = original_path_label;
             } else {
-                let mut import_path_without_last_segment = import_to_add.import_path.to_owned();
-                let _ = import_path_without_last_segment.pop_segment();
-
-                if !import_path_without_last_segment.segments().is_empty() {
-                    lookup = lookup.or_else(|| Some(label.clone()));
-                    insert_text = insert_text.or_else(|| Some(label.clone()));
-                    label = format!("{}::{}", import_path_without_last_segment, label);
-                }
+                format_to!(label, " ({})", original_path)
             }
         }
 
@@ -359,9 +394,9 @@ impl Builder {
             lookup,
             kind: self.kind,
             completion_kind: self.completion_kind,
-            deprecated: self.deprecated.unwrap_or(false),
+            deprecated: self.deprecated,
             trigger_call_info: self.trigger_call_info.unwrap_or(false),
-            score: self.score,
+            relevance: self.relevance,
             ref_match: self.ref_match,
             import_to_add: self.import_to_add,
         }
@@ -419,11 +454,11 @@ impl Builder {
         self
     }
     pub(crate) fn set_deprecated(mut self, deprecated: bool) -> Builder {
-        self.deprecated = Some(deprecated);
+        self.deprecated = deprecated;
         self
     }
-    pub(crate) fn set_score(mut self, score: CompletionScore) -> Builder {
-        self.score = Some(score);
+    pub(crate) fn set_relevance(mut self, relevance: Relevance) -> Builder {
+        self.relevance = relevance;
         self
     }
     pub(crate) fn trigger_call_info(mut self) -> Builder {
@@ -434,17 +469,8 @@ impl Builder {
         self.import_to_add = import_to_add;
         self
     }
-    pub(crate) fn set_ref_match(
-        mut self,
-        ref_match: Option<(Mutability, CompletionScore)>,
-    ) -> Builder {
-        self.ref_match = ref_match;
+    pub(crate) fn ref_match(mut self, mutability: Mutability) -> Builder {
+        self.ref_match = Some(mutability);
         self
     }
 }
-
-impl<'a> Into<CompletionItem> for Builder {
-    fn into(self) -> CompletionItem {
-        self.build()
-    }
-}
diff --git a/crates/ide_completion/src/lib.rs b/crates/ide_completion/src/lib.rs
index 76f31de9e..d46f521a0 100644
--- a/crates/ide_completion/src/lib.rs
+++ b/crates/ide_completion/src/lib.rs
@@ -13,7 +13,9 @@ mod completions;
 
 use completions::flyimport::position_for_import;
 use ide_db::{
-    base_db::FilePosition, helpers::insert_use::ImportScope, imports_locator, RootDatabase,
+    base_db::FilePosition,
+    helpers::{import_assets::LocatedImport, insert_use::ImportScope},
+    items_locator, RootDatabase,
 };
 use text_edit::TextEdit;
 
@@ -21,7 +23,10 @@ use crate::{completions::Completions, context::CompletionContext, item::Completi
 
 pub use crate::{
     config::CompletionConfig,
-    item::{CompletionItem, CompletionItemKind, CompletionScore, ImportEdit, InsertTextFormat},
+    item::{
+        CompletionItem, CompletionItemKind, CompletionScore, ImportEdit, InsertTextFormat,
+        Relevance,
+    },
 };
 
 //FIXME: split the following feature into fine-grained features.
@@ -139,25 +144,27 @@ pub fn resolve_completion_edits(
     position: FilePosition,
     full_import_path: &str,
     imported_name: String,
-    import_for_trait_assoc_item: bool,
 ) -> Option<Vec<TextEdit>> {
     let ctx = CompletionContext::new(db, position, config)?;
     let position_for_import = position_for_import(&ctx, None)?;
-    let import_scope = ImportScope::find_insert_use_container(position_for_import, &ctx.sema)?;
+    let scope = ImportScope::find_insert_use_container(position_for_import, &ctx.sema)?;
 
     let current_module = ctx.sema.scope(position_for_import).module()?;
     let current_crate = current_module.krate();
 
-    let import_path = imports_locator::find_exact_imports(&ctx.sema, current_crate, imported_name)
-        .filter_map(|candidate| {
-            let item: hir::ItemInNs = candidate.either(Into::into, Into::into);
-            current_module.find_use_path_prefixed(db, item, config.insert_use.prefix_kind)
-        })
-        .find(|mod_path| mod_path.to_string() == full_import_path)?;
+    let (import_path, item_to_import) =
+        items_locator::with_exact_name(&ctx.sema, current_crate, imported_name)
+            .into_iter()
+            .filter_map(|candidate| {
+                current_module
+                    .find_use_path_prefixed(db, candidate, config.insert_use.prefix_kind)
+                    .zip(Some(candidate))
+            })
+            .find(|(mod_path, _)| mod_path.to_string() == full_import_path)?;
+    let import =
+        LocatedImport::new(import_path.clone(), item_to_import, item_to_import, Some(import_path));
 
-    ImportEdit { import_path, import_scope, import_for_trait_assoc_item }
-        .to_text_edit(config.insert_use.merge)
-        .map(|edit| vec![edit])
+    ImportEdit { import, scope }.to_text_edit(config.insert_use).map(|edit| vec![edit])
 }
 
 #[cfg(test)]
diff --git a/crates/ide_completion/src/render.rs b/crates/ide_completion/src/render.rs
index eddaaa6f3..8c8b149a1 100644
--- a/crates/ide_completion/src/render.rs
+++ b/crates/ide_completion/src/render.rs
@@ -13,13 +13,15 @@ mod builder_ext;
 use hir::{
     AsAssocItem, Documentation, HasAttrs, HirDisplay, ModuleDef, Mutability, ScopeDef, Type,
 };
-use ide_db::{helpers::SnippetCap, RootDatabase, SymbolKind};
+use ide_db::{
+    helpers::{item_name, SnippetCap},
+    RootDatabase, SymbolKind,
+};
 use syntax::TextRange;
-use test_utils::mark;
 
 use crate::{
-    item::ImportEdit, CompletionContext, CompletionItem, CompletionItemKind, CompletionKind,
-    CompletionScore,
+    item::{ImportEdit, Relevance},
+    CompletionContext, CompletionItem, CompletionItemKind, CompletionKind,
 };
 
 use crate::render::{enum_variant::render_variant, function::render_fn, macro_::render_macro};
@@ -51,18 +53,20 @@ pub(crate) fn render_resolution<'a>(
 pub(crate) fn render_resolution_with_import<'a>(
     ctx: RenderContext<'a>,
     import_edit: ImportEdit,
-    resolution: &ScopeDef,
 ) -> Option<CompletionItem> {
+    let resolution = ScopeDef::from(import_edit.import.original_item);
     let local_name = match resolution {
         ScopeDef::ModuleDef(ModuleDef::Function(f)) => f.name(ctx.completion.db).to_string(),
         ScopeDef::ModuleDef(ModuleDef::Const(c)) => c.name(ctx.completion.db)?.to_string(),
         ScopeDef::ModuleDef(ModuleDef::TypeAlias(t)) => t.name(ctx.completion.db).to_string(),
-        _ => import_edit.import_path.segments().last()?.to_string(),
+        _ => item_name(ctx.db(), import_edit.import.original_item)?.to_string(),
     };
-    Render::new(ctx).render_resolution(local_name, Some(import_edit), resolution).map(|mut item| {
-        item.completion_kind = CompletionKind::Magic;
-        item
-    })
+    Render::new(ctx).render_resolution(local_name, Some(import_edit), &resolution).map(
+        |mut item| {
+            item.completion_kind = CompletionKind::Magic;
+            item
+        },
+    )
 }
 
 /// Interface for data and methods required for items rendering.
@@ -113,13 +117,13 @@ impl<'a> RenderContext<'a> {
         node.docs(self.db())
     }
 
-    fn active_name_and_type(&self) -> Option<(String, Type)> {
+    fn expected_name_and_type(&self) -> Option<(String, Type)> {
         if let Some(record_field) = &self.completion.record_field_syntax {
-            mark::hit!(record_field_type_match);
+            cov_mark::hit!(record_field_type_match);
             let (struct_field, _local) = self.completion.sema.resolve_record_field(record_field)?;
             Some((struct_field.name(self.db()).to_string(), struct_field.signature_ty(self.db())))
         } else if let Some(active_parameter) = &self.completion.active_parameter {
-            mark::hit!(active_param_type_match);
+            cov_mark::hit!(active_param_type_match);
             Some((active_parameter.name.clone(), active_parameter.ty.clone()))
         } else {
             None
@@ -151,8 +155,8 @@ impl<'a> Render<'a> {
         .set_documentation(field.docs(self.ctx.db()))
         .set_deprecated(is_deprecated);
 
-        if let Some(score) = compute_score(&self.ctx, &ty, &name.to_string()) {
-            item = item.set_score(score);
+        if let Some(relevance) = compute_relevance(&self.ctx, &ty, &name.to_string()) {
+            item = item.set_relevance(relevance);
         }
 
         item.build()
@@ -242,16 +246,23 @@ impl<'a> Render<'a> {
             }
         };
 
-        let mut ref_match = None;
         if let ScopeDef::Local(local) = resolution {
-            if let Some((active_name, active_type)) = self.ctx.active_name_and_type() {
-                let ty = local.ty(self.ctx.db());
-                if let Some(score) =
-                    compute_score_from_active(&active_type, &active_name, &ty, &local_name)
-                {
-                    item = item.set_score(score);
+            let ty = local.ty(self.ctx.db());
+            if let Some(relevance) = compute_relevance(&self.ctx, &ty, &local_name) {
+                item = item.set_relevance(relevance)
+            }
+            if let Some((_expected_name, expected_type)) = self.ctx.expected_name_and_type() {
+                if let Some(ty_without_ref) = expected_type.remove_ref() {
+                    if ty_without_ref == ty {
+                        cov_mark::hit!(suggest_ref);
+                        let mutability = if expected_type.is_mutable_reference() {
+                            Mutability::Mut
+                        } else {
+                            Mutability::Shared
+                        };
+                        item = item.ref_match(mutability)
+                    }
                 }
-                ref_match = refed_type_matches(&active_type, &active_name, &ty, &local_name);
             }
         }
 
@@ -269,7 +280,7 @@ impl<'a> Render<'a> {
                     _ => false,
                 };
                 if has_non_default_type_params {
-                    mark::hit!(inserts_angle_brackets_for_generics);
+                    cov_mark::hit!(inserts_angle_brackets_for_generics);
                     item = item
                         .lookup_by(local_name.clone())
                         .label(format!("{}<…>", local_name))
@@ -281,7 +292,6 @@ impl<'a> Render<'a> {
         Some(
             item.kind(kind)
                 .add_import(import_to_add)
-                .set_ref_match(ref_match)
                 .set_documentation(self.docs(resolution))
                 .set_deprecated(self.is_deprecated(resolution))
                 .build(),
@@ -313,56 +323,23 @@ impl<'a> Render<'a> {
     }
 }
 
-fn compute_score_from_active(
-    active_type: &Type,
-    active_name: &str,
-    ty: &Type,
-    name: &str,
-) -> Option<CompletionScore> {
-    // Compute score
-    // For the same type
-    if active_type != ty {
-        return None;
-    }
-
-    let mut res = CompletionScore::TypeMatch;
-
-    // If same type + same name then go top position
-    if active_name == name {
-        res = CompletionScore::TypeAndNameMatch
-    }
-
+fn compute_relevance(ctx: &RenderContext, ty: &Type, name: &str) -> Option<Relevance> {
+    let (expected_name, expected_type) = ctx.expected_name_and_type()?;
+    let mut res = Relevance::default();
+    res.exact_type_match = ty == &expected_type;
+    res.exact_name_match = name == &expected_name;
     Some(res)
 }
-fn refed_type_matches(
-    active_type: &Type,
-    active_name: &str,
-    ty: &Type,
-    name: &str,
-) -> Option<(Mutability, CompletionScore)> {
-    let derefed_active = active_type.remove_ref()?;
-    let score = compute_score_from_active(&derefed_active, &active_name, &ty, &name)?;
-    Some((
-        if active_type.is_mutable_reference() { Mutability::Mut } else { Mutability::Shared },
-        score,
-    ))
-}
-
-fn compute_score(ctx: &RenderContext, ty: &Type, name: &str) -> Option<CompletionScore> {
-    let (active_name, active_type) = ctx.active_name_and_type()?;
-    compute_score_from_active(&active_type, &active_name, ty, name)
-}
 
 #[cfg(test)]
 mod tests {
     use std::cmp::Reverse;
 
     use expect_test::{expect, Expect};
-    use test_utils::mark;
 
     use crate::{
         test_utils::{check_edit, do_completion, get_all_items, TEST_CONFIG},
-        CompletionKind, CompletionScore,
+        CompletionKind, Relevance,
     };
 
     fn check(ra_fixture: &str, expect: Expect) {
@@ -370,24 +347,25 @@ mod tests {
         expect.assert_debug_eq(&actual);
     }
 
-    fn check_scores(ra_fixture: &str, expect: Expect) {
-        fn display_score(score: Option<CompletionScore>) -> &'static str {
-            match score {
-                Some(CompletionScore::TypeMatch) => "[type]",
-                Some(CompletionScore::TypeAndNameMatch) => "[type+name]",
-                None => "[]".into(),
+    fn check_relevance(ra_fixture: &str, expect: Expect) {
+        fn display_relevance(relevance: Relevance) -> &'static str {
+            match relevance {
+                Relevance { exact_type_match: true, exact_name_match: true } => "[type+name]",
+                Relevance { exact_type_match: true, exact_name_match: false } => "[type]",
+                Relevance { exact_type_match: false, exact_name_match: true } => "[name]",
+                Relevance { exact_type_match: false, exact_name_match: false } => "[]",
             }
         }
 
         let mut completions = get_all_items(TEST_CONFIG, ra_fixture);
-        completions.sort_by_key(|it| (Reverse(it.score()), it.label().to_string()));
+        completions.sort_by_key(|it| (Reverse(it.relevance()), it.label().to_string()));
         let actual = completions
             .into_iter()
             .filter(|it| it.completion_kind == CompletionKind::Reference)
             .map(|it| {
                 let tag = it.kind().unwrap().tag();
-                let score = display_score(it.score());
-                format!("{} {} {}\n", tag, it.label(), score)
+                let relevance = display_relevance(it.relevance());
+                format!("{} {} {}\n", tag, it.label(), relevance)
             })
             .collect::<String>();
         expect.assert_eq(&actual);
@@ -734,7 +712,7 @@ fn foo(s: S) { s.$0 }
 
     #[test]
     fn no_call_parens_if_fn_ptr_needed() {
-        mark::check!(no_call_parens_if_fn_ptr_needed);
+        cov_mark::check!(no_call_parens_if_fn_ptr_needed);
         check_edit(
             "foo",
             r#"
@@ -758,7 +736,7 @@ fn main() -> ManualVtable {
 
     #[test]
     fn no_parens_in_use_item() {
-        mark::check!(no_parens_in_use_item);
+        cov_mark::check!(no_parens_in_use_item);
         check_edit(
             "foo",
             r#"
@@ -802,7 +780,7 @@ fn f(foo: &Foo) { foo.foo(); }
 
     #[test]
     fn inserts_angle_brackets_for_generics() {
-        mark::check!(inserts_angle_brackets_for_generics);
+        cov_mark::check!(inserts_angle_brackets_for_generics);
         check_edit(
             "Vec",
             r#"
@@ -850,9 +828,9 @@ fn foo(xs: Vec<i128>)
     }
 
     #[test]
-    fn active_param_score() {
-        mark::check!(active_param_type_match);
-        check_scores(
+    fn active_param_relevance() {
+        cov_mark::check!(active_param_type_match);
+        check_relevance(
             r#"
 struct S { foo: i64, bar: u32, baz: u32 }
 fn test(bar: u32) { }
@@ -867,9 +845,9 @@ fn foo(s: S) { test(s.$0) }
     }
 
     #[test]
-    fn record_field_scores() {
-        mark::check!(record_field_type_match);
-        check_scores(
+    fn record_field_relevances() {
+        cov_mark::check!(record_field_type_match);
+        check_relevance(
             r#"
 struct A { foo: i64, bar: u32, baz: u32 }
 struct B { x: (), y: f32, bar: u32 }
@@ -884,8 +862,8 @@ fn foo(a: A) { B { bar: a.$0 }; }
     }
 
     #[test]
-    fn record_field_and_call_scores() {
-        check_scores(
+    fn record_field_and_call_relevances() {
+        check_relevance(
             r#"
 struct A { foo: i64, bar: u32, baz: u32 }
 struct B { x: (), y: f32, bar: u32 }
@@ -898,7 +876,7 @@ fn foo(a: A) { B { bar: f(a.$0) }; }
                 fd baz []
             "#]],
         );
-        check_scores(
+        check_relevance(
             r#"
 struct A { foo: i64, bar: u32, baz: u32 }
 struct B { x: (), y: f32, bar: u32 }
@@ -915,7 +893,7 @@ fn foo(a: A) { f(B { bar: a.$0 }); }
 
     #[test]
     fn prioritize_exact_ref_match() {
-        check_scores(
+        check_relevance(
             r#"
 struct WorldSnapshot { _f: () };
 fn go(world: &WorldSnapshot) { go(w$0) }
@@ -930,7 +908,7 @@ fn go(world: &WorldSnapshot) { go(w$0) }
 
     #[test]
     fn too_many_arguments() {
-        check_scores(
+        check_relevance(
             r#"
 struct Foo;
 fn f(foo: &Foo) { f(foo, w$0) }
@@ -942,4 +920,70 @@ fn f(foo: &Foo) { f(foo, w$0) }
             "#]],
         );
     }
+
+    #[test]
+    fn suggest_ref_mut() {
+        cov_mark::check!(suggest_ref);
+        check(
+            r#"
+struct S;
+fn foo(s: &mut S) {}
+fn main() {
+    let mut s = S;
+    foo($0);
+}
+            "#,
+            expect![[r#"
+                [
+                    CompletionItem {
+                        label: "S",
+                        source_range: 70..70,
+                        delete: 70..70,
+                        insert: "S",
+                        kind: SymbolKind(
+                            Struct,
+                        ),
+                    },
+                    CompletionItem {
+                        label: "foo(…)",
+                        source_range: 70..70,
+                        delete: 70..70,
+                        insert: "foo(${1:&mut s})$0",
+                        kind: SymbolKind(
+                            Function,
+                        ),
+                        lookup: "foo",
+                        detail: "-> ()",
+                        trigger_call_info: true,
+                    },
+                    CompletionItem {
+                        label: "main()",
+                        source_range: 70..70,
+                        delete: 70..70,
+                        insert: "main()$0",
+                        kind: SymbolKind(
+                            Function,
+                        ),
+                        lookup: "main",
+                        detail: "-> ()",
+                    },
+                    CompletionItem {
+                        label: "s",
+                        source_range: 70..70,
+                        delete: 70..70,
+                        insert: "s",
+                        kind: SymbolKind(
+                            Local,
+                        ),
+                        detail: "S",
+                        relevance: Relevance {
+                            exact_name_match: true,
+                            exact_type_match: false,
+                        },
+                        ref_match: "&mut ",
+                    },
+                ]
+            "#]],
+        )
+    }
 }
diff --git a/crates/ide_completion/src/render/builder_ext.rs b/crates/ide_completion/src/render/builder_ext.rs
index d053a988b..95a7596c1 100644
--- a/crates/ide_completion/src/render/builder_ext.rs
+++ b/crates/ide_completion/src/render/builder_ext.rs
@@ -1,7 +1,6 @@
 //! Extensions for `Builder` structure required for item rendering.
 
 use itertools::Itertools;
-use test_utils::mark;
 
 use crate::{item::Builder, CompletionContext};
 
@@ -30,7 +29,7 @@ impl Builder {
             return false;
         }
         if ctx.use_item_syntax.is_some() {
-            mark::hit!(no_parens_in_use_item);
+            cov_mark::hit!(no_parens_in_use_item);
             return false;
         }
         if ctx.is_pattern_call {
@@ -43,7 +42,7 @@ impl Builder {
         // Don't add parentheses if the expected type is some function reference.
         if let Some(ty) = &ctx.expected_type {
             if ty.is_fn() {
-                mark::hit!(no_call_parens_if_fn_ptr_needed);
+                cov_mark::hit!(no_call_parens_if_fn_ptr_needed);
                 return false;
             }
         }
@@ -67,7 +66,7 @@ impl Builder {
             None => return self,
         };
         // If not an import, add parenthesis automatically.
-        mark::hit!(inserts_parens_for_function_calls);
+        cov_mark::hit!(inserts_parens_for_function_calls);
 
         let (snippet, label) = if params.is_empty() {
             (format!("{}()$0", name), format!("{}()", name))
@@ -82,7 +81,7 @@ impl Builder {
                     format!("{}({})$0", name, function_params_snippet)
                 }
                 _ => {
-                    mark::hit!(suppress_arg_snippets);
+                    cov_mark::hit!(suppress_arg_snippets);
                     format!("{}($0)", name)
                 }
             };
diff --git a/crates/ide_completion/src/render/enum_variant.rs b/crates/ide_completion/src/render/enum_variant.rs
index 9214193b4..ed055c1fb 100644
--- a/crates/ide_completion/src/render/enum_variant.rs
+++ b/crates/ide_completion/src/render/enum_variant.rs
@@ -3,7 +3,6 @@
 use hir::{HasAttrs, HirDisplay, ModPath, StructKind};
 use ide_db::SymbolKind;
 use itertools::Itertools;
-use test_utils::mark;
 
 use crate::{
     item::{CompletionItem, CompletionKind, ImportEdit},
@@ -68,7 +67,7 @@ impl<'a> EnumRender<'a> {
         .detail(self.detail());
 
         if self.variant_kind == StructKind::Tuple {
-            mark::hit!(inserts_parens_for_tuple_enums);
+            cov_mark::hit!(inserts_parens_for_tuple_enums);
             let params = Params::Anonymous(self.variant.fields(self.ctx.db()).len());
             builder =
                 builder.add_call_parens(self.ctx.completion, self.short_qualified_name, params);
@@ -103,13 +102,11 @@ impl<'a> EnumRender<'a> {
 
 #[cfg(test)]
 mod tests {
-    use test_utils::mark;
-
     use crate::test_utils::check_edit;
 
     #[test]
     fn inserts_parens_for_tuple_enums() {
-        mark::check!(inserts_parens_for_tuple_enums);
+        cov_mark::check!(inserts_parens_for_tuple_enums);
         check_edit(
             "Some",
             r#"
diff --git a/crates/ide_completion/src/render/function.rs b/crates/ide_completion/src/render/function.rs
index e46e21d24..5931945a8 100644
--- a/crates/ide_completion/src/render/function.rs
+++ b/crates/ide_completion/src/render/function.rs
@@ -3,7 +3,6 @@
 use hir::{HasSource, HirDisplay, Type};
 use ide_db::SymbolKind;
 use syntax::ast::Fn;
-use test_utils::mark;
 
 use crate::{
     item::{CompletionItem, CompletionItemKind, CompletionKind, ImportEdit},
@@ -82,7 +81,7 @@ impl<'a> FunctionRender<'a> {
             self.func.method_params(self.ctx.db()).unwrap_or_default()
         } else {
             if let Some(s) = ast_params.self_param() {
-                mark::hit!(parens_for_method_call_as_assoc_fn);
+                cov_mark::hit!(parens_for_method_call_as_assoc_fn);
                 params_pats.push(Some(s.to_string()));
             }
             self.func.assoc_fn_params(self.ctx.db())
@@ -114,8 +113,6 @@ impl<'a> FunctionRender<'a> {
 
 #[cfg(test)]
 mod tests {
-    use test_utils::mark;
-
     use crate::{
         test_utils::{check_edit, check_edit_with_config, TEST_CONFIG},
         CompletionConfig,
@@ -123,7 +120,7 @@ mod tests {
 
     #[test]
     fn inserts_parens_for_function_calls() {
-        mark::check!(inserts_parens_for_function_calls);
+        cov_mark::check!(inserts_parens_for_function_calls);
         check_edit(
             "no_args",
             r#"
@@ -191,7 +188,7 @@ fn bar(s: &S) {
 
     #[test]
     fn parens_for_method_call_as_assoc_fn() {
-        mark::check!(parens_for_method_call_as_assoc_fn);
+        cov_mark::check!(parens_for_method_call_as_assoc_fn);
         check_edit(
             "foo",
             r#"
@@ -213,7 +210,7 @@ fn main() { S::foo(${1:&self})$0 }
 
     #[test]
     fn suppress_arg_snippets() {
-        mark::check!(suppress_arg_snippets);
+        cov_mark::check!(suppress_arg_snippets);
         check_edit_with_config(
             CompletionConfig { add_call_argument_snippets: false, ..TEST_CONFIG },
             "with_args",
diff --git a/crates/ide_completion/src/render/macro_.rs b/crates/ide_completion/src/render/macro_.rs
index a4535786f..a6cf3e479 100644
--- a/crates/ide_completion/src/render/macro_.rs
+++ b/crates/ide_completion/src/render/macro_.rs
@@ -3,7 +3,6 @@
 use hir::{Documentation, HasSource};
 use ide_db::SymbolKind;
 use syntax::display::macro_label;
-use test_utils::mark;
 
 use crate::{
     item::{CompletionItem, CompletionKind, ImportEdit},
@@ -57,7 +56,7 @@ impl<'a> MacroRender<'a> {
             }
             None if needs_bang => builder.insert_text(self.banged_name()),
             _ => {
-                mark::hit!(dont_insert_macro_call_parens_unncessary);
+                cov_mark::hit!(dont_insert_macro_call_parens_unncessary);
                 builder.insert_text(&self.name)
             }
         };
@@ -125,13 +124,11 @@ fn guess_macro_braces(macro_name: &str, docs: &str) -> (&'static str, &'static s
 
 #[cfg(test)]
 mod tests {
-    use test_utils::mark;
-
     use crate::test_utils::check_edit;
 
     #[test]
     fn dont_insert_macro_call_parens_unncessary() {
-        mark::check!(dont_insert_macro_call_parens_unncessary);
+        cov_mark::check!(dont_insert_macro_call_parens_unncessary);
         check_edit(
             "frobnicate!",
             r#"
diff --git a/crates/ide_completion/src/test_utils.rs b/crates/ide_completion/src/test_utils.rs
index baff83305..9da844031 100644
--- a/crates/ide_completion/src/test_utils.rs
+++ b/crates/ide_completion/src/test_utils.rs
@@ -25,6 +25,7 @@ pub(crate) const TEST_CONFIG: CompletionConfig = CompletionConfig {
     insert_use: InsertUseConfig {
         merge: Some(MergeBehavior::Full),
         prefix_kind: PrefixKind::Plain,
+        group: true,
     },
 };
 
@@ -119,7 +120,7 @@ pub(crate) fn check_edit_with_config(
 
     let mut combined_edit = completion.text_edit().to_owned();
     if let Some(import_text_edit) =
-        completion.import_to_add().and_then(|edit| edit.to_text_edit(config.insert_use.merge))
+        completion.import_to_add().and_then(|edit| edit.to_text_edit(config.insert_use))
     {
         combined_edit.union(import_text_edit).expect(
             "Failed to apply completion resolve changes: change ranges overlap, but should not",