15 files changed, 335 insertions, 167 deletions
diff --git a/crates/ide_completion/Cargo.toml b/crates/ide_completion/Cargo.toml
index c09101ccb..84aa40736 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"
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);
+    acc.add_all(
-    let mut all_mod_paths = import_assets
+        import_assets
-        .search_for_imports(&ctx.sema, ctx.config.insert_use.prefix_kind)
+            .search_for_imports(&ctx.sema, ctx.config.insert_use.prefix_kind)
-        .into_iter()
+            .into_iter()
-        .map(|(mod_path, item_in_ns)| {
+            .sorted_by_key(|located_import| {
-            let scope_item = match item_in_ns {
+                compute_fuzzy_completion_order_key(
-                hir::ItemInNs::Types(id) => ScopeDef::ModuleDef(id.into()),
+                    &located_import.import_path,
-                hir::ItemInNs::Values(id) => ScopeDef::ModuleDef(id.into()),
+                    &user_input_lowercased,
-                hir::ItemInNs::Macros(id) => ScopeDef::MacroDef(id.into()),
+                )
-            };
+            })
-            (mod_path, scope_item)
+            .filter_map(|import| {
-        })
+                render_resolution_with_import(
-        .filter(|(_, proposed_def)| !scope_definitions.contains(proposed_def))
+                    RenderContext::new(ctx),
-        .collect::<Vec<_>>();
+                    ImportEdit { import, scope: import_scope.clone() },
-    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)
-    }));
    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);
+    cov_mark::hit!(certain_fuzzy_order_test);
-    let proposed_import_name = match proposed_mod_path.segments().last() {
+    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 9b2435c4b..b16f0775a 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::{
+        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;
@@ -207,7 +208,7 @@ impl CompletionItem {
            lookup: None,
            kind: None,
            text_edit: None,
-            deprecated: None,
+            deprecated: false,
            trigger_call_info: None,
            score: None,
            ref_match: None,
@@ -272,9 +273,8 @@ impl CompletionItem {
 /// An extra import to add after the completion is applied.
 #[derive(Debug, Clone)]
 pub struct ImportEdit {
-    pub import_path: ModPath,
+    pub import: LocatedImport,
-    pub import_scope: ImportScope,
+    pub scope: ImportScope,
-    pub import_for_trait_assoc_item: bool,
 }
 impl ImportEdit {
@@ -284,7 +284,7 @@ impl ImportEdit {
        let _p = profile::span("ImportEdit::to_text_edit");
        let rewriter =
-            insert_use::insert_use(&self.import_scope, mod_path_to_ast(&self.import_path), cfg);
+            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);
@@ -308,7 +308,7 @@ 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)>,
@@ -322,20 +322,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 let Some(original_path) = self
-            if import_to_add.import_for_trait_assoc_item {
+            .import_to_add
-                lookup = lookup.or_else(|| Some(label.clone()));
+            .as_ref()
-                insert_text = insert_text.or_else(|| Some(label.clone()));
+            .and_then(|import_edit| import_edit.import.original_path.as_ref())
-                label = format!("{} ({})", label, import_to_add.import_path);
+        {
+            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();
+                format_to!(label, " ({})", original_path)
-                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);
-                }
            }
        }
@@ -356,7 +355,7 @@ 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,
            ref_match: self.ref_match,
@@ -416,7 +415,7 @@ 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 {
@@ -431,17 +430,8 @@ impl Builder {
        self.import_to_add = import_to_add;
        self
    }
-    pub(crate) fn set_ref_match(
+    pub(crate) fn ref_match(mut self, ref_match: (Mutability, CompletionScore)) -> Builder {
-        mut self,
+        self.ref_match = Some(ref_match);
-        ref_match: Option<(Mutability, CompletionScore)>,
-    ) -> Builder {
-        self.ref_match = ref_match;
        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 b0b809791..a0c8c374d 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;
@@ -139,25 +141,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)
+    let (import_path, item_to_import) =
-        .filter_map(|candidate| {
+        items_locator::with_exact_name(&ctx.sema, current_crate, imported_name)
-            let item: hir::ItemInNs = candidate.either(Into::into, Into::into);
+            .into_iter()
-            current_module.find_use_path_prefixed(db, item, config.insert_use.prefix_kind)
+            .filter_map(|candidate| {
-        })
+                current_module
-        .find(|mod_path| mod_path.to_string() == full_import_path)?;
+                    .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 }
+    ImportEdit { import, scope }.to_text_edit(config.insert_use).map(|edit| vec![edit])
-        .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..0a6ac8804 100644
--- a/crates/ide_completion/src/render.rs
+++ b/crates/ide_completion/src/render.rs
@@ -13,9 +13,11 @@ 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,
@@ -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| {
+    Render::new(ctx).render_resolution(local_name, Some(import_edit), &resolution).map(
-        item.completion_kind = CompletionKind::Magic;
+        |mut item| {
-        item
+            item.completion_kind = CompletionKind::Magic;
-    })
+            item
+        },
+    )
 }
 /// Interface for data and methods required for items rendering.
@@ -115,11 +119,11 @@ impl<'a> RenderContext<'a> {
    fn active_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
@@ -242,7 +246,6 @@ 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());
@@ -251,7 +254,11 @@ impl<'a> Render<'a> {
                {
                    item = item.set_score(score);
                }
-                ref_match = refed_type_matches(&active_type, &active_name, &ty, &local_name);
+                if let Some(ref_match) =
+                    refed_type_matches(&active_type, &active_name, &ty, &local_name)
+                {
+                    item = item.ref_match(ref_match);
+                }
            }
        }
@@ -269,7 +276,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 +288,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(),
@@ -358,7 +364,6 @@ 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},
@@ -734,7 +739,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 +763,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 +807,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#"
@@ -851,7 +856,7 @@ fn foo(xs: Vec<i128>)
    #[test]
    fn active_param_score() {
-        mark::check!(active_param_type_match);
+        cov_mark::check!(active_param_type_match);
        check_scores(
            r#"
 struct S { foo: i64, bar: u32, baz: u32 }
@@ -868,7 +873,7 @@ fn foo(s: S) { test(s.$0) }
    #[test]
    fn record_field_scores() {
-        mark::check!(record_field_type_match);
+        cov_mark::check!(record_field_type_match);
        check_scores(
            r#"
 struct A { foo: i64, bar: u32, baz: u32 }
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#"