93 files changed, 2245 insertions, 739 deletions

diff --git a/.github/actions/github-release/main.js b/.github/actions/github-release/main.js
index b499cd0fd..a08e59a91 100644
--- a/.github/actions/github-release/main.js
+++ b/.github/actions/github-release/main.js
@@ -70,6 +70,7 @@ async function runOnce() {
     repo,
     name,
     tag_name: name,
+    target_commitish: sha,
     prerelease: name === 'nightly',
   });
 
diff --git a/.github/workflows/release.yaml b/.github/workflows/release.yaml
index 1ae8ed1b6..c1d56a8e0 100644
--- a/.github/workflows/release.yaml
+++ b/.github/workflows/release.yaml
@@ -79,16 +79,16 @@ jobs:
       with:
         node-version: 12.x
 
-    - run: echo "::set-env name=TAG::$(date --iso --utc)"
+    - run: echo "TAG=$(date --iso --utc)" >> $GITHUB_ENV
       if: github.ref == 'refs/heads/release'
-    - run: echo "::set-env name=TAG::nightly"
+    - run: echo "TAG=nightly" >> $GITHUB_ENV
       if: github.ref != 'refs/heads/release'
     - run: 'echo "TAG: $TAG"'
 
     - name: Checkout repository
       uses: actions/checkout@v2
 
-    - run: echo "::set-env name=HEAD_SHA::$(git rev-parse HEAD)"
+    - run: echo "HEAD_SHA=$(git rev-parse HEAD)" >> $GITHUB_ENV
     - run: 'echo "HEAD_SHA: $HEAD_SHA"'
 
     - uses: actions/download-artifact@v1
diff --git a/.gitignore b/.gitignore
index 472fe1a13..b205bf3fb 100644
--- a/.gitignore
+++ b/.gitignore
@@ -9,3 +9,4 @@ crates/*/target
 .vscode/settings.json
 generated_assists.adoc
 generated_features.adoc
+generated_diagnostic.adoc
diff --git a/Cargo.lock b/Cargo.lock
index d470d84f2..65c8de719 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -128,6 +128,20 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "08c48aae112d48ed9f069b33538ea9e3e90aa263cfa3d1c24309612b1f7472de"
 
 [[package]]
+name = "call_info"
+version = "0.0.0"
+dependencies = [
+ "base_db",
+ "either",
+ "expect-test",
+ "hir",
+ "ide_db",
+ "stdx",
+ "syntax",
+ "test_utils",
+]
+
+[[package]]
 name = "cargo_metadata"
 version = "0.11.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -250,6 +264,26 @@ dependencies = [
 ]
 
 [[package]]
+name = "completion"
+version = "0.0.0"
+dependencies = [
+ "assists",
+ "base_db",
+ "call_info",
+ "expect-test",
+ "hir",
+ "ide_db",
+ "itertools",
+ "log",
+ "profile",
+ "rustc-hash",
+ "stdx",
+ "syntax",
+ "test_utils",
+ "text_edit",
+]
+
+[[package]]
 name = "const_fn"
 version = "0.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -362,9 +396,9 @@ dependencies = [
 
 [[package]]
 name = "env_logger"
-version = "0.7.1"
+version = "0.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "44533bbbb3bb3c1fa17d9f2e4e38bbbaf8396ba82193c4cb1b6445d711445d36"
+checksum = "54532e3223c5af90a6a757c90b5c5521564b07e5e7a958681bcd2afad421cdcd"
 dependencies = [
  "log",
 ]
@@ -422,12 +456,6 @@ dependencies = [
 ]
 
 [[package]]
-name = "fs-err"
-version = "2.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bcd1163ae48bda72a20ae26d66a04d3094135cadab911cff418ae5e33f253431"
-
-[[package]]
 name = "fsevent"
 version = "2.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -615,7 +643,9 @@ version = "0.0.0"
 dependencies = [
  "assists",
  "base_db",
+ "call_info",
  "cfg",
+ "completion",
  "either",
  "expect-test",
  "hir",
@@ -802,9 +832,9 @@ dependencies = [
 
 [[package]]
 name = "lsp-server"
-version = "0.4.0"
+version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ff7452ee21b8de64f10ceb4e9fee1212e1a9579cd717226613333e751676c86a"
+checksum = "9c85acaf36c53bf15da2b8b35afeea56747707261f59eb0b77229081dd72b04e"
 dependencies = [
  "crossbeam-channel 0.5.0",
  "log",
@@ -1447,18 +1477,18 @@ checksum = "388a1df253eca08550bef6c72392cfe7c30914bf41df5269b68cbd6ff8f570a3"
 
 [[package]]
 name = "serde"
-version = "1.0.116"
+version = "1.0.117"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "96fe57af81d28386a513cbc6858332abc6117cfdb5999647c6444b8f43a370a5"
+checksum = "b88fa983de7720629c9387e9f517353ed404164b1e482c970a90c1a4aaf7dc1a"
 dependencies = [
  "serde_derive",
 ]
 
 [[package]]
 name = "serde_derive"
-version = "1.0.116"
+version = "1.0.117"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f630a6370fd8e457873b4bd2ffdae75408bc291ba72be773772a4c2a065d9ae8"
+checksum = "cbd1ae72adb44aab48f325a02444a5fc079349a8d804c1fc922aed3f7454c74e"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -1538,9 +1568,9 @@ version = "0.0.0"
 
 [[package]]
 name = "syn"
-version = "1.0.44"
+version = "1.0.45"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e03e57e4fcbfe7749842d53e24ccb9aa12b7252dbe5e91d2acad31834c8b8fdd"
+checksum = "ea9c5432ff16d6152371f808fb5a871cd67368171b09bb21b43df8e4a47a3556"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -1921,16 +1951,31 @@ dependencies = [
 ]
 
 [[package]]
+name = "xshell"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3e9bbfccbb2233e6b0473b7870d4b0811a402e9e249a5e8394e768e5a5c9c37d"
+dependencies = [
+ "xshell-macros",
+]
+
+[[package]]
+name = "xshell-macros"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b94f1c632d730a1704b21dc551a4c74fbed713cfa59593708f94943548206134"
+
+[[package]]
 name = "xtask"
 version = "0.1.0"
 dependencies = [
  "anyhow",
  "flate2",
- "fs-err",
  "pico-args",
  "proc-macro2",
  "quote",
  "ungrammar",
  "walkdir",
  "write-json",
+ "xshell",
 ]
diff --git a/crates/assists/src/handlers/auto_import.rs b/crates/assists/src/handlers/auto_import.rs
index 4a7059c83..e49e641b3 100644
--- a/crates/assists/src/handlers/auto_import.rs
+++ b/crates/assists/src/handlers/auto_import.rs
@@ -6,7 +6,7 @@ use crate::{
     AssistContext, AssistId, AssistKind, Assists, GroupLabel,
 };
 
-// Feature: Import Insertion
+// Feature: Auto Import
 //
 // Using the `auto-import` assist it is possible to insert missing imports for unresolved items.
 // When inserting an import it will do so in a structured manner by keeping imports grouped,
@@ -100,7 +100,7 @@ pub(crate) fn auto_import(acc: &mut Assists, ctx: &AssistContext) -> Option<()>
     let group = import_group_message(import_assets.import_candidate());
     let scope = ImportScope::find_insert_use_container(import_assets.syntax_under_caret(), ctx)?;
     let syntax = scope.as_syntax_node();
-    for import in proposed_imports {
+    for (import, _) in proposed_imports {
         acc.add_group(
             &group,
             AssistId("auto_import", AssistKind::QuickFix),
diff --git a/crates/assists/src/handlers/change_visibility.rs b/crates/assists/src/handlers/change_visibility.rs
index 32dc05378..22d7c95d9 100644
--- a/crates/assists/src/handlers/change_visibility.rs
+++ b/crates/assists/src/handlers/change_visibility.rs
@@ -1,7 +1,7 @@
 use syntax::{
     ast::{self, NameOwner, VisibilityOwner},
     AstNode,
-    SyntaxKind::{CONST, ENUM, FN, MODULE, STATIC, STRUCT, TRAIT, VISIBILITY},
+    SyntaxKind::{CONST, ENUM, FN, MODULE, STATIC, STRUCT, TRAIT, TYPE_ALIAS, VISIBILITY},
     T,
 };
 use test_utils::mark;
@@ -30,13 +30,20 @@ fn add_vis(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
     let item_keyword = ctx.token_at_offset().find(|leaf| {
         matches!(
             leaf.kind(),
-            T![const] | T![static] | T![fn] | T![mod] | T![struct] | T![enum] | T![trait]
+            T![const]
+                | T![static]
+                | T![fn]
+                | T![mod]
+                | T![struct]
+                | T![enum]
+                | T![trait]
+                | T![type]
         )
     });
 
     let (offset, target) = if let Some(keyword) = item_keyword {
         let parent = keyword.parent();
-        let def_kws = vec![CONST, STATIC, FN, MODULE, STRUCT, ENUM, TRAIT];
+        let def_kws = vec![CONST, STATIC, TYPE_ALIAS, FN, MODULE, STRUCT, ENUM, TRAIT];
         // Parent is not a definition, can't add visibility
         if !def_kws.iter().any(|&def_kw| def_kw == parent.kind()) {
             return None;
@@ -160,6 +167,11 @@ mod tests {
     }
 
     #[test]
+    fn change_visibility_type_alias() {
+        check_assist(change_visibility, "<|>type T = ();", "pub(crate) type T = ();");
+    }
+
+    #[test]
     fn change_visibility_handles_comment_attrs() {
         check_assist(
             change_visibility,
diff --git a/crates/assists/src/handlers/fill_match_arms.rs b/crates/assists/src/handlers/fill_match_arms.rs
index 676f5ad92..eda45f5b3 100644
--- a/crates/assists/src/handlers/fill_match_arms.rs
+++ b/crates/assists/src/handlers/fill_match_arms.rs
@@ -59,7 +59,7 @@ pub(crate) fn fill_match_arms(acc: &mut Assists, ctx: &AssistContext) -> Option<
             .filter(|variant_pat| is_variant_missing(&mut arms, variant_pat))
             .map(|pat| make::match_arm(iter::once(pat), make::expr_empty_block()))
             .collect::<Vec<_>>();
-        if Some(enum_def) == FamousDefs(&ctx.sema, module.krate()).core_option_Option() {
+        if Some(enum_def) == FamousDefs(&ctx.sema, Some(module.krate())).core_option_Option() {
             // Match `Some` variant first.
             mark::hit!(option_order);
             variants.reverse()
diff --git a/crates/assists/src/handlers/fix_visibility.rs b/crates/assists/src/handlers/fix_visibility.rs
index d505e9444..66f74150c 100644
--- a/crates/assists/src/handlers/fix_visibility.rs
+++ b/crates/assists/src/handlers/fix_visibility.rs
@@ -1,9 +1,11 @@
 use base_db::FileId;
 use hir::{db::HirDatabase, HasSource, HasVisibility, PathResolution};
-use syntax::{ast, AstNode, TextRange, TextSize};
+use syntax::{
+    ast::{self, VisibilityOwner},
+    AstNode, TextRange, TextSize,
+};
 
 use crate::{utils::vis_offset, AssistContext, AssistId, AssistKind, Assists};
-use ast::VisibilityOwner;
 
 // FIXME: this really should be a fix for diagnostic, rather than an assist.
 
diff --git a/crates/assists/src/handlers/generate_from_impl_for_enum.rs b/crates/assists/src/handlers/generate_from_impl_for_enum.rs
index 7f04b9572..674e5a175 100644
--- a/crates/assists/src/handlers/generate_from_impl_for_enum.rs
+++ b/crates/assists/src/handlers/generate_from_impl_for_enum.rs
@@ -75,7 +75,7 @@ fn existing_from_impl(
     let enum_ = variant.parent_enum(sema.db);
     let krate = enum_.module(sema.db).krate();
 
-    let from_trait = FamousDefs(sema, krate).core_convert_From()?;
+    let from_trait = FamousDefs(sema, Some(krate)).core_convert_From()?;
 
     let enum_type = enum_.ty(sema.db);
 
diff --git a/crates/assists/src/handlers/qualify_path.rs b/crates/assists/src/handlers/qualify_path.rs
new file mode 100644
index 000000000..f436bdbbf
--- /dev/null
+++ b/crates/assists/src/handlers/qualify_path.rs
@@ -0,0 +1,1048 @@
+use std::iter;
+
+use hir::AsName;
+use ide_db::RootDatabase;
+use syntax::{
+    ast,
+    ast::{make, ArgListOwner},
+    AstNode,
+};
+use test_utils::mark;
+
+use crate::{
+    assist_context::{AssistContext, Assists},
+    utils::import_assets::{ImportAssets, ImportCandidate},
+    utils::mod_path_to_ast,
+    AssistId, AssistKind, GroupLabel,
+};
+
+// Assist: qualify_path
+//
+// If the name is unresolved, provides all possible qualified paths for it.
+//
+// ```
+// fn main() {
+//     let map = HashMap<|>::new();
+// }
+// # pub mod std { pub mod collections { pub struct HashMap { } } }
+// ```
+// ->
+// ```
+// fn main() {
+//     let map = std::collections::HashMap::new();
+// }
+// # pub mod std { pub mod collections { pub struct HashMap { } } }
+// ```
+pub(crate) fn qualify_path(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
+    let import_assets =
+        if let Some(path_under_caret) = ctx.find_node_at_offset_with_descend::<ast::Path>() {
+            ImportAssets::for_regular_path(path_under_caret, &ctx.sema)
+        } else if let Some(method_under_caret) =
+            ctx.find_node_at_offset_with_descend::<ast::MethodCallExpr>()
+        {
+            ImportAssets::for_method_call(method_under_caret, &ctx.sema)
+        } else {
+            None
+        }?;
+    let proposed_imports = import_assets.search_for_relative_paths(&ctx.sema);
+    if proposed_imports.is_empty() {
+        return None;
+    }
+
+    let candidate = import_assets.import_candidate();
+    let range = ctx.sema.original_range(import_assets.syntax_under_caret()).range;
+
+    let qualify_candidate = match candidate {
+        ImportCandidate::QualifierStart(_) => {
+            mark::hit!(qualify_path_qualifier_start);
+            let path = ast::Path::cast(import_assets.syntax_under_caret().clone())?;
+            let segment = path.segment()?;
+            QualifyCandidate::QualifierStart(segment)
+        }
+        ImportCandidate::UnqualifiedName(_) => {
+            mark::hit!(qualify_path_unqualified_name);
+            QualifyCandidate::UnqualifiedName
+        }
+        ImportCandidate::TraitAssocItem(_) => {
+            mark::hit!(qualify_path_trait_assoc_item);
+            let path = ast::Path::cast(import_assets.syntax_under_caret().clone())?;
+            let (qualifier, segment) = (path.qualifier()?, path.segment()?);
+            QualifyCandidate::TraitAssocItem(qualifier, segment)
+        }
+        ImportCandidate::TraitMethod(_) => {
+            mark::hit!(qualify_path_trait_method);
+            let mcall_expr = ast::MethodCallExpr::cast(import_assets.syntax_under_caret().clone())?;
+            QualifyCandidate::TraitMethod(ctx.sema.db, mcall_expr)
+        }
+    };
+
+    let group_label = group_label(candidate);
+    for (import, item) in proposed_imports {
+        acc.add_group(
+            &group_label,
+            AssistId("qualify_path", AssistKind::QuickFix),
+            label(candidate, &import),
+            range,
+            |builder| {
+                qualify_candidate.qualify(
+                    |replace_with: String| builder.replace(range, replace_with),
+                    import,
+                    item,
+                )
+            },
+        );
+    }
+    Some(())
+}
+
+enum QualifyCandidate<'db> {
+    QualifierStart(ast::PathSegment),
+    UnqualifiedName,
+    TraitAssocItem(ast::Path, ast::PathSegment),
+    TraitMethod(&'db RootDatabase, ast::MethodCallExpr),
+}
+
+impl QualifyCandidate<'_> {
+    fn qualify(&self, mut replacer: impl FnMut(String), import: hir::ModPath, item: hir::ItemInNs) {
+        match self {
+            QualifyCandidate::QualifierStart(segment) => {
+                let import = mod_path_to_ast(&import);
+                replacer(format!("{}::{}", import, segment));
+            }
+            QualifyCandidate::UnqualifiedName => replacer(mod_path_to_ast(&import).to_string()),
+            QualifyCandidate::TraitAssocItem(qualifier, segment) => {
+                let import = mod_path_to_ast(&import);
+                replacer(format!("<{} as {}>::{}", qualifier, import, segment));
+            }
+            &QualifyCandidate::TraitMethod(db, ref mcall_expr) => {
+                Self::qualify_trait_method(db, mcall_expr, replacer, import, item);
+            }
+        }
+    }
+
+    fn qualify_trait_method(
+        db: &RootDatabase,
+        mcall_expr: &ast::MethodCallExpr,
+        mut replacer: impl FnMut(String),
+        import: hir::ModPath,
+        item: hir::ItemInNs,
+    ) -> Option<()> {
+        let receiver = mcall_expr.receiver()?;
+        let trait_method_name = mcall_expr.name_ref()?;
+        let arg_list = mcall_expr.arg_list().map(|arg_list| arg_list.args());
+        let trait_ = item_as_trait(item)?;
+        let method = find_trait_method(db, trait_, &trait_method_name)?;
+        if let Some(self_access) = method.self_param(db).map(|sp| sp.access(db)) {
+            let import = mod_path_to_ast(&import);
+            let receiver = match self_access {
+                hir::Access::Shared => make::expr_ref(receiver, false),
+                hir::Access::Exclusive => make::expr_ref(receiver, true),
+                hir::Access::Owned => receiver,
+            };
+            replacer(format!(
+                "{}::{}{}",
+                import,
+                trait_method_name,
+                match arg_list.clone() {
+                    Some(args) => make::arg_list(iter::once(receiver).chain(args)),
+                    None => make::arg_list(iter::once(receiver)),
+                }
+            ));
+        }
+        Some(())
+    }
+}
+
+fn find_trait_method(
+    db: &RootDatabase,
+    trait_: hir::Trait,
+    trait_method_name: &ast::NameRef,
+) -> Option<hir::Function> {
+    if let Some(hir::AssocItem::Function(method)) =
+        trait_.items(db).into_iter().find(|item: &hir::AssocItem| {
+            item.name(db).map(|name| name == trait_method_name.as_name()).unwrap_or(false)
+        })
+    {
+        Some(method)
+    } else {
+        None
+    }
+}
+
+fn item_as_trait(item: hir::ItemInNs) -> Option<hir::Trait> {
+    if let hir::ModuleDef::Trait(trait_) = hir::ModuleDef::from(item.as_module_def_id()?) {
+        Some(trait_)
+    } else {
+        None
+    }
+}
+
+fn group_label(candidate: &ImportCandidate) -> GroupLabel {
+    let name = match candidate {
+        ImportCandidate::UnqualifiedName(it) | ImportCandidate::QualifierStart(it) => &it.name,
+        ImportCandidate::TraitAssocItem(it) | ImportCandidate::TraitMethod(it) => &it.name,
+    };
+    GroupLabel(format!("Qualify {}", name))
+}
+
+fn label(candidate: &ImportCandidate, import: &hir::ModPath) -> String {
+    match candidate {
+        ImportCandidate::UnqualifiedName(_) => format!("Qualify as `{}`", &import),
+        ImportCandidate::QualifierStart(_) => format!("Qualify with `{}`", &import),
+        ImportCandidate::TraitAssocItem(_) => format!("Qualify `{}`", &import),
+        ImportCandidate::TraitMethod(_) => format!("Qualify with cast as `{}`", &import),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::tests::{check_assist, check_assist_not_applicable, check_assist_target};
+
+    use super::*;
+
+    #[test]
+    fn applicable_when_found_an_import_partial() {
+        mark::check!(qualify_path_unqualified_name);
+        check_assist(
+            qualify_path,
+            r"
+            mod std {
+                pub mod fmt {
+                    pub struct Formatter;
+                }
+            }
+
+            use std::fmt;
+
+            <|>Formatter
+            ",
+            r"
+            mod std {
+                pub mod fmt {
+                    pub struct Formatter;
+                }
+            }
+
+            use std::fmt;
+
+            fmt::Formatter
+            ",
+        );
+    }
+
+    #[test]
+    fn applicable_when_found_an_import() {
+        check_assist(
+            qualify_path,
+            r"
+            <|>PubStruct
+
+            pub mod PubMod {
+                pub struct PubStruct;
+            }
+            ",
+            r"
+            PubMod::PubStruct
+
+            pub mod PubMod {
+                pub struct PubStruct;
+            }
+            ",
+        );
+    }
+
+    #[test]
+    fn applicable_in_macros() {
+        check_assist(
+            qualify_path,
+            r"
+            macro_rules! foo {
+                ($i:ident) => { fn foo(a: $i) {} }
+            }
+            foo!(Pub<|>Struct);
+
+            pub mod PubMod {
+                pub struct PubStruct;
+            }
+            ",
+            r"
+            macro_rules! foo {
+                ($i:ident) => { fn foo(a: $i) {} }
+            }
+            foo!(PubMod::PubStruct);
+
+            pub mod PubMod {
+                pub struct PubStruct;
+            }
+            ",
+        );
+    }
+
+    #[test]
+    fn applicable_when_found_multiple_imports() {
+        check_assist(
+            qualify_path,
+            r"
+            PubSt<|>ruct
+
+            pub mod PubMod1 {
+                pub struct PubStruct;
+            }
+            pub mod PubMod2 {
+                pub struct PubStruct;
+            }
+            pub mod PubMod3 {
+                pub struct PubStruct;
+            }
+            ",
+            r"
+            PubMod3::PubStruct
+
+            pub mod PubMod1 {
+                pub struct PubStruct;
+            }
+            pub mod PubMod2 {
+                pub struct PubStruct;
+            }
+            pub mod PubMod3 {
+                pub struct PubStruct;
+            }
+            ",
+        );
+    }
+
+    #[test]
+    fn not_applicable_for_already_imported_types() {
+        check_assist_not_applicable(
+            qualify_path,
+            r"
+            use PubMod::PubStruct;
+
+            PubStruct<|>
+
+            pub mod PubMod {
+                pub struct PubStruct;
+            }
+            ",
+        );
+    }
+
+    #[test]
+    fn not_applicable_for_types_with_private_paths() {
+        check_assist_not_applicable(
+            qualify_path,
+            r"
+            PrivateStruct<|>
+
+            pub mod PubMod {
+                struct PrivateStruct;
+            }
+            ",
+        );
+    }
+
+    #[test]
+    fn not_applicable_when_no_imports_found() {
+        check_assist_not_applicable(
+            qualify_path,
+            "
+            PubStruct<|>",
+        );
+    }
+
+    #[test]
+    fn not_applicable_in_import_statements() {
+        check_assist_not_applicable(
+            qualify_path,
+            r"
+            use PubStruct<|>;
+
+            pub mod PubMod {
+                pub struct PubStruct;
+            }",
+        );
+    }
+
+    #[test]
+    fn qualify_function() {
+        check_assist(
+            qualify_path,
+            r"
+            test_function<|>
+
+            pub mod PubMod {
+                pub fn test_function() {};
+            }
+            ",
+            r"
+            PubMod::test_function
+
+            pub mod PubMod {
+                pub fn test_function() {};
+            }
+            ",
+        );
+    }
+
+    #[test]
+    fn qualify_macro() {
+        check_assist(
+            qualify_path,
+            r"
+//- /lib.rs crate:crate_with_macro
+#[macro_export]
+macro_rules! foo {
+    () => ()
+}
+
+//- /main.rs crate:main deps:crate_with_macro
+fn main() {
+    foo<|>
+}
+",
+            r"
+fn main() {
+    crate_with_macro::foo
+}
+",
+        );
+    }
+
+    #[test]
+    fn qualify_path_target() {
+        check_assist_target(
+            qualify_path,
+            r"
+            struct AssistInfo {
+                group_label: Option<<|>GroupLabel>,
+            }
+
+            mod m { pub struct GroupLabel; }
+            ",
+            "GroupLabel",
+        )
+    }
+
+    #[test]
+    fn not_applicable_when_path_start_is_imported() {
+        check_assist_not_applicable(
+            qualify_path,
+            r"
+            pub mod mod1 {
+                pub mod mod2 {
+                    pub mod mod3 {
+                        pub struct TestStruct;
+                    }
+                }
+            }
+
+            use mod1::mod2;
+            fn main() {
+                mod2::mod3::TestStruct<|>
+            }
+            ",
+        );
+    }
+
+    #[test]
+    fn not_applicable_for_imported_function() {
+        check_assist_not_applicable(
+            qualify_path,
+            r"
+            pub mod test_mod {
+                pub fn test_function() {}
+            }
+
+            use test_mod::test_function;
+            fn main() {
+                test_function<|>
+            }
+            ",
+        );
+    }
+
+    #[test]
+    fn associated_struct_function() {
+        check_assist(
+            qualify_path,
+            r"
+            mod test_mod {
+                pub struct TestStruct {}
+                impl TestStruct {
+                    pub fn test_function() {}
+                }
+            }
+
+            fn main() {
+                TestStruct::test_function<|>
+            }
+            ",
+            r"
+            mod test_mod {
+                pub struct TestStruct {}
+                impl TestStruct {
+                    pub fn test_function() {}
+                }
+            }
+
+            fn main() {
+                test_mod::TestStruct::test_function
+            }
+            ",
+        );
+    }
+
+    #[test]
+    fn associated_struct_const() {
+        mark::check!(qualify_path_qualifier_start);
+        check_assist(
+            qualify_path,
+            r"
+            mod test_mod {
+                pub struct TestStruct {}
+                impl TestStruct {
+                    const TEST_CONST: u8 = 42;
+                }
+            }
+
+            fn main() {
+                TestStruct::TEST_CONST<|>
+            }
+            ",
+            r"
+            mod test_mod {
+                pub struct TestStruct {}
+                impl TestStruct {
+                    const TEST_CONST: u8 = 42;
+                }
+            }
+
+            fn main() {
+                test_mod::TestStruct::TEST_CONST
+            }
+            ",
+        );
+    }
+
+    #[test]
+    fn associated_trait_function() {
+        check_assist(
+            qualify_path,
+            r"
+            mod test_mod {
+                pub trait TestTrait {
+                    fn test_function();
+                }
+                pub struct TestStruct {}
+                impl TestTrait for TestStruct {
+                    fn test_function() {}
+                }
+            }
+
+            fn main() {
+                test_mod::TestStruct::test_function<|>
+            }
+            ",
+            r"
+            mod test_mod {
+                pub trait TestTrait {
+                    fn test_function();
+                }
+                pub struct TestStruct {}
+                impl TestTrait for TestStruct {
+                    fn test_function() {}
+                }
+            }
+
+            fn main() {
+                <test_mod::TestStruct as test_mod::TestTrait>::test_function
+            }
+            ",
+        );
+    }
+
+    #[test]
+    fn not_applicable_for_imported_trait_for_function() {
+        check_assist_not_applicable(
+            qualify_path,
+            r"
+            mod test_mod {
+                pub trait TestTrait {
+                    fn test_function();
+                }
+                pub trait TestTrait2 {
+                    fn test_function();
+                }
+                pub enum TestEnum {
+                    One,
+                    Two,
+                }
+                impl TestTrait2 for TestEnum {
+                    fn test_function() {}
+                }
+                impl TestTrait for TestEnum {
+                    fn test_function() {}
+                }
+            }
+
+            use test_mod::TestTrait2;
+            fn main() {
+                test_mod::TestEnum::test_function<|>;
+            }
+            ",
+        )
+    }
+
+    #[test]
+    fn associated_trait_const() {
+        mark::check!(qualify_path_trait_assoc_item);
+        check_assist(
+            qualify_path,
+            r"
+            mod test_mod {
+                pub trait TestTrait {
+                    const TEST_CONST: u8;
+                }
+                pub struct TestStruct {}
+                impl TestTrait for TestStruct {
+                    const TEST_CONST: u8 = 42;
+                }
+            }
+
+            fn main() {
+                test_mod::TestStruct::TEST_CONST<|>
+            }
+            ",
+            r"
+            mod test_mod {
+                pub trait TestTrait {
+                    const TEST_CONST: u8;
+                }
+                pub struct TestStruct {}
+                impl TestTrait for TestStruct {
+                    const TEST_CONST: u8 = 42;
+                }
+            }
+
+            fn main() {
+                <test_mod::TestStruct as test_mod::TestTrait>::TEST_CONST
+            }
+            ",
+        );
+    }
+
+    #[test]
+    fn not_applicable_for_imported_trait_for_const() {
+        check_assist_not_applicable(
+            qualify_path,
+            r"
+            mod test_mod {
+                pub trait TestTrait {
+                    const TEST_CONST: u8;
+                }
+                pub trait TestTrait2 {
+                    const TEST_CONST: f64;
+                }
+                pub enum TestEnum {
+                    One,
+                    Two,
+                }
+                impl TestTrait2 for TestEnum {
+                    const TEST_CONST: f64 = 42.0;
+                }
+                impl TestTrait for TestEnum {
+                    const TEST_CONST: u8 = 42;
+                }
+            }
+
+            use test_mod::TestTrait2;
+            fn main() {
+                test_mod::TestEnum::TEST_CONST<|>;
+            }
+            ",
+        )
+    }
+
+    #[test]
+    fn trait_method() {
+        mark::check!(qualify_path_trait_method);
+        check_assist(
+            qualify_path,
+            r"
+            mod test_mod {
+                pub trait TestTrait {
+                    fn test_method(&self);
+                }
+                pub struct TestStruct {}
+                impl TestTrait for TestStruct {
+                    fn test_method(&self) {}
+                }
+            }
+
+            fn main() {
+                let test_struct = test_mod::TestStruct {};
+                test_struct.test_meth<|>od()
+            }
+            ",
+            r"
+            mod test_mod {
+                pub trait TestTrait {
+                    fn test_method(&self);
+                }
+                pub struct TestStruct {}
+                impl TestTrait for TestStruct {
+                    fn test_method(&self) {}
+                }
+            }
+
+            fn main() {
+                let test_struct = test_mod::TestStruct {};
+                test_mod::TestTrait::test_method(&test_struct)
+            }
+            ",
+        );
+    }
+
+    #[test]
+    fn trait_method_multi_params() {
+        check_assist(
+            qualify_path,
+            r"
+            mod test_mod {
+                pub trait TestTrait {
+                    fn test_method(&self, test: i32);
+                }
+                pub struct TestStruct {}
+                impl TestTrait for TestStruct {
+                    fn test_method(&self, test: i32) {}
+                }
+            }
+
+            fn main() {
+                let test_struct = test_mod::TestStruct {};
+                test_struct.test_meth<|>od(42)
+            }
+            ",
+            r"
+            mod test_mod {
+                pub trait TestTrait {
+                    fn test_method(&self, test: i32);
+                }
+                pub struct TestStruct {}
+                impl TestTrait for TestStruct {
+                    fn test_method(&self, test: i32) {}
+                }
+            }
+
+            fn main() {
+                let test_struct = test_mod::TestStruct {};
+                test_mod::TestTrait::test_method(&test_struct, 42)
+            }
+            ",
+        );
+    }
+
+    #[test]
+    fn trait_method_consume() {
+        check_assist(
+            qualify_path,
+            r"
+            mod test_mod {
+                pub trait TestTrait {
+                    fn test_method(self);
+                }
+                pub struct TestStruct {}
+                impl TestTrait for TestStruct {
+                    fn test_method(self) {}
+                }
+            }
+
+            fn main() {
+                let test_struct = test_mod::TestStruct {};
+                test_struct.test_meth<|>od()
+            }
+            ",
+            r"
+            mod test_mod {
+                pub trait TestTrait {
+                    fn test_method(self);
+                }
+                pub struct TestStruct {}
+                impl TestTrait for TestStruct {
+                    fn test_method(self) {}
+                }
+            }
+
+            fn main() {
+                let test_struct = test_mod::TestStruct {};
+                test_mod::TestTrait::test_method(test_struct)
+            }
+            ",
+        );
+    }
+
+    #[test]
+    fn trait_method_cross_crate() {
+        check_assist(
+            qualify_path,
+            r"
+            //- /main.rs crate:main deps:dep
+            fn main() {
+                let test_struct = dep::test_mod::TestStruct {};
+                test_struct.test_meth<|>od()
+            }
+            //- /dep.rs crate:dep
+            pub mod test_mod {
+                pub trait TestTrait {
+                    fn test_method(&self);
+                }
+                pub struct TestStruct {}
+                impl TestTrait for TestStruct {
+                    fn test_method(&self) {}
+                }
+            }
+            ",
+            r"
+            fn main() {
+                let test_struct = dep::test_mod::TestStruct {};
+                dep::test_mod::TestTrait::test_method(&test_struct)
+            }
+            ",
+        );
+    }
+
+    #[test]
+    fn assoc_fn_cross_crate() {
+        check_assist(
+            qualify_path,
+            r"
+            //- /main.rs crate:main deps:dep
+            fn main() {
+                dep::test_mod::TestStruct::test_func<|>tion
+            }
+            //- /dep.rs crate:dep
+            pub mod test_mod {
+                pub trait TestTrait {
+                    fn test_function();
+                }
+                pub struct TestStruct {}
+                impl TestTrait for TestStruct {
+                    fn test_function() {}
+                }
+            }
+            ",
+            r"
+            fn main() {
+                <dep::test_mod::TestStruct as dep::test_mod::TestTrait>::test_function
+            }
+            ",
+        );
+    }
+
+    #[test]
+    fn assoc_const_cross_crate() {
+        check_assist(
+            qualify_path,
+            r"
+            //- /main.rs crate:main deps:dep
+            fn main() {
+                dep::test_mod::TestStruct::CONST<|>
+            }
+            //- /dep.rs crate:dep
+            pub mod test_mod {
+                pub trait TestTrait {
+                    const CONST: bool;
+                }
+                pub struct TestStruct {}
+                impl TestTrait for TestStruct {
+                    const CONST: bool = true;
+                }
+            }
+            ",
+            r"
+            fn main() {
+                <dep::test_mod::TestStruct as dep::test_mod::TestTrait>::CONST
+            }
+            ",
+        );
+    }
+
+    #[test]
+    fn assoc_fn_as_method_cross_crate() {
+        check_assist_not_applicable(
+            qualify_path,
+            r"
+            //- /main.rs crate:main deps:dep
+            fn main() {
+                let test_struct = dep::test_mod::TestStruct {};
+                test_struct.test_func<|>tion()
+            }
+            //- /dep.rs crate:dep
+            pub mod test_mod {
+                pub trait TestTrait {
+                    fn test_function();
+                }
+                pub struct TestStruct {}
+                impl TestTrait for TestStruct {
+                    fn test_function() {}
+                }
+            }
+            ",
+        );
+    }
+
+    #[test]
+    fn private_trait_cross_crate() {
+        check_assist_not_applicable(
+            qualify_path,
+            r"
+            //- /main.rs crate:main deps:dep
+            fn main() {
+                let test_struct = dep::test_mod::TestStruct {};
+                test_struct.test_meth<|>od()
+            }
+            //- /dep.rs crate:dep
+            pub mod test_mod {
+                trait TestTrait {
+                    fn test_method(&self);
+                }
+                pub struct TestStruct {}
+                impl TestTrait for TestStruct {
+                    fn test_method(&self) {}
+                }
+            }
+            ",
+        );
+    }
+
+    #[test]
+    fn not_applicable_for_imported_trait_for_method() {
+        check_assist_not_applicable(
+            qualify_path,
+            r"
+            mod test_mod {
+                pub trait TestTrait {
+                    fn test_method(&self);
+                }
+                pub trait TestTrait2 {
+                    fn test_method(&self);
+                }
+                pub enum TestEnum {
+                    One,
+                    Two,
+                }
+                impl TestTrait2 for TestEnum {
+                    fn test_method(&self) {}
+                }
+                impl TestTrait for TestEnum {
+                    fn test_method(&self) {}
+                }
+            }
+
+            use test_mod::TestTrait2;
+            fn main() {
+                let one = test_mod::TestEnum::One;
+                one.test<|>_method();
+            }
+            ",
+        )
+    }
+
+    #[test]
+    fn dep_import() {
+        check_assist(
+            qualify_path,
+            r"
+//- /lib.rs crate:dep
+pub struct Struct;
+
+//- /main.rs crate:main deps:dep
+fn main() {
+    Struct<|>
+}
+",
+            r"
+fn main() {
+    dep::Struct
+}
+",
+        );
+    }
+
+    #[test]
+    fn whole_segment() {
+        // Tests that only imports whose last segment matches the identifier get suggested.
+        check_assist(
+            qualify_path,
+            r"
+//- /lib.rs crate:dep
+pub mod fmt {
+    pub trait Display {}
+}
+
+pub fn panic_fmt() {}
+
+//- /main.rs crate:main deps:dep
+struct S;
+
+impl f<|>mt::Display for S {}
+",
+            r"
+struct S;
+
+impl dep::fmt::Display for S {}
+",
+        );
+    }
+
+    #[test]
+    fn macro_generated() {
+        // Tests that macro-generated items are suggested from external crates.
+        check_assist(
+            qualify_path,
+            r"
+//- /lib.rs crate:dep
+macro_rules! mac {
+    () => {
+        pub struct Cheese;
+    };
+}
+
+mac!();
+
+//- /main.rs crate:main deps:dep
+fn main() {
+    Cheese<|>;
+}
+",
+            r"
+fn main() {
+    dep::Cheese;
+}
+",
+        );
+    }
+
+    #[test]
+    fn casing() {
+        // Tests that differently cased names don't interfere and we only suggest the matching one.
+        check_assist(
+            qualify_path,
+            r"
+//- /lib.rs crate:dep
+pub struct FMT;
+pub struct fmt;
+
+//- /main.rs crate:main deps:dep
+fn main() {
+    FMT<|>;
+}
+",
+            r"
+fn main() {
+    dep::FMT;
+}
+",
+        );
+    }
+}
diff --git a/crates/assists/src/lib.rs b/crates/assists/src/lib.rs
index 2a98cccc0..8a664f654 100644
--- a/crates/assists/src/lib.rs
+++ b/crates/assists/src/lib.rs
@@ -150,6 +150,7 @@ mod handlers {
     mod merge_match_arms;
     mod move_bounds;
     mod move_guard;
+    mod qualify_path;
     mod raw_string;
     mod remove_dbg;
     mod remove_mut;
@@ -197,6 +198,7 @@ mod handlers {
             move_bounds::move_bounds_to_where_clause,
             move_guard::move_arm_cond_to_match_guard,
             move_guard::move_guard_to_arm_body,
+            qualify_path::qualify_path,
             raw_string::add_hash,
             raw_string::make_raw_string,
             raw_string::make_usual_string,
diff --git a/crates/assists/src/tests/generated.rs b/crates/assists/src/tests/generated.rs
index 6fb2a7cac..acbf5b652 100644
--- a/crates/assists/src/tests/generated.rs
+++ b/crates/assists/src/tests/generated.rs
@@ -713,6 +713,25 @@ fn handle(action: Action) {
 }
 
 #[test]
+fn doctest_qualify_path() {
+    check_doc_test(
+        "qualify_path",
+        r#####"
+fn main() {
+    let map = HashMap<|>::new();
+}
+pub mod std { pub mod collections { pub struct HashMap { } } }
+"#####,
+        r#####"
+fn main() {
+    let map = std::collections::HashMap::new();
+}
+pub mod std { pub mod collections { pub struct HashMap { } } }
+"#####,
+    )
+}
+
+#[test]
 fn doctest_remove_dbg() {
     check_doc_test(
         "remove_dbg",
diff --git a/crates/assists/src/utils.rs b/crates/assists/src/utils.rs
index b37b0d2b6..1a6b48b45 100644
--- a/crates/assists/src/utils.rs
+++ b/crates/assists/src/utils.rs
@@ -275,7 +275,7 @@ impl TryEnum {
 /// somewhat similar to the known paths infra inside hir, but it different; We
 /// want to make sure that IDE specific paths don't become interesting inside
 /// the compiler itself as well.
-pub struct FamousDefs<'a, 'b>(pub &'a Semantics<'b, RootDatabase>, pub Crate);
+pub struct FamousDefs<'a, 'b>(pub &'a Semantics<'b, RootDatabase>, pub Option<Crate>);
 
 #[allow(non_snake_case)]
 impl FamousDefs<'_, '_> {
@@ -362,6 +362,10 @@ pub mod prelude {
 pub use prelude::*;
 "#;
 
+    pub fn core(&self) -> Option<Crate> {
+        self.find_crate("core")
+    }
+
     pub(crate) fn core_convert_From(&self) -> Option<Trait> {
         self.find_trait("core:convert:From")
     }
@@ -399,21 +403,20 @@ pub use prelude::*;
         }
     }
 
+    fn find_crate(&self, name: &str) -> Option<Crate> {
+        let krate = self.1?;
+        let db = self.0.db;
+        let res =
+            krate.dependencies(db).into_iter().find(|dep| dep.name.to_string() == name)?.krate;
+        Some(res)
+    }
+
     fn find_def(&self, path: &str) -> Option<ScopeDef> {
         let db = self.0.db;
         let mut path = path.split(':');
         let trait_ = path.next_back()?;
         let std_crate = path.next()?;
-        let std_crate = if self
-            .1
-            .declaration_name(db)
-            .map(|name| name.to_string() == std_crate)
-            .unwrap_or(false)
-        {
-            self.1
-        } else {
-            self.1.dependencies(db).into_iter().find(|dep| dep.name.to_string() == std_crate)?.krate
-        };
+        let std_crate = self.find_crate(std_crate)?;
         let mut module = std_crate.root_module(db);
         for segment in path {
             module = module.children(db).find_map(|child| {
diff --git a/crates/assists/src/utils/import_assets.rs b/crates/assists/src/utils/import_assets.rs
index 601f51098..23db3a74b 100644
--- a/crates/assists/src/utils/import_assets.rs
+++ b/crates/assists/src/utils/import_assets.rs
@@ -1,6 +1,4 @@
 //! Look up accessible paths for items.
-use std::collections::BTreeSet;
-
 use either::Either;
 use hir::{AsAssocItem, AssocItemContainer, ModuleDef, Semantics};
 use ide_db::{imports_locator, RootDatabase};
@@ -29,12 +27,12 @@ pub(crate) enum ImportCandidate {
 #[derive(Debug)]
 pub(crate) struct TraitImportCandidate {
     pub ty: hir::Type,
-    pub name: String,
+    pub name: ast::NameRef,
 }
 
 #[derive(Debug)]
 pub(crate) struct PathImportCandidate {
-    pub name: String,
+    pub name: ast::NameRef,
 }
 
 #[derive(Debug)]
@@ -86,9 +84,9 @@ impl ImportAssets {
     fn get_search_query(&self) -> &str {
         match &self.import_candidate {
             ImportCandidate::UnqualifiedName(candidate)
-            | ImportCandidate::QualifierStart(candidate) => &candidate.name,
+            | ImportCandidate::QualifierStart(candidate) => candidate.name.text(),
             ImportCandidate::TraitAssocItem(candidate)
-            | ImportCandidate::TraitMethod(candidate) => &candidate.name,
+            | ImportCandidate::TraitMethod(candidate) => candidate.name.text(),
         }
     }
 
@@ -96,7 +94,7 @@ impl ImportAssets {
         &self,
         sema: &Semantics<RootDatabase>,
         config: &InsertUseConfig,
-    ) -> BTreeSet<hir::ModPath> {
+    ) -> Vec<(hir::ModPath, hir::ItemInNs)> {
         let _p = profile::span("import_assists::search_for_imports");
         self.search_for(sema, Some(config.prefix_kind))
     }
@@ -106,7 +104,7 @@ impl ImportAssets {
     pub(crate) fn search_for_relative_paths(
         &self,
         sema: &Semantics<RootDatabase>,
-    ) -> BTreeSet<hir::ModPath> {
+    ) -> Vec<(hir::ModPath, hir::ItemInNs)> {
         let _p = profile::span("import_assists::search_for_relative_paths");
         self.search_for(sema, None)
     }
@@ -115,7 +113,7 @@ impl ImportAssets {
         &self,
         sema: &Semantics<RootDatabase>,
         prefixed: Option<hir::PrefixKind>,
-    ) -> BTreeSet<hir::ModPath> {
+    ) -> Vec<(hir::ModPath, hir::ItemInNs)> {
         let db = sema.db;
         let mut trait_candidates = FxHashSet::default();
         let current_crate = self.module_with_name_to_import.krate();
@@ -181,7 +179,7 @@ impl ImportAssets {
             }
         };
 
-        imports_locator::find_imports(sema, current_crate, &self.get_search_query())
+        let mut res = imports_locator::find_imports(sema, current_crate, &self.get_search_query())
             .into_iter()
             .filter_map(filter)
             .filter_map(|candidate| {
@@ -191,10 +189,13 @@ impl ImportAssets {
                 } else {
                     self.module_with_name_to_import.find_use_path(db, item)
                 }
+                .map(|path| (path, item))
             })
-            .filter(|use_path| !use_path.segments.is_empty())
+            .filter(|(use_path, _)| !use_path.segments.is_empty())
             .take(20)
-            .collect::<BTreeSet<_>>()
+            .collect::<Vec<_>>();
+        res.sort_by_key(|(path, _)| path.clone());
+        res
     }
 
     fn assoc_to_trait(assoc: AssocItemContainer) -> Option<hir::Trait> {
@@ -215,7 +216,7 @@ impl ImportCandidate {
             Some(_) => None,
             None => Some(Self::TraitMethod(TraitImportCandidate {
                 ty: sema.type_of_expr(&method_call.receiver()?)?,
-                name: method_call.name_ref()?.syntax().to_string(),
+                name: method_call.name_ref()?,
             })),
         }
     }
@@ -243,24 +244,17 @@ impl ImportCandidate {
                     hir::PathResolution::Def(hir::ModuleDef::Adt(assoc_item_path)) => {
                         ImportCandidate::TraitAssocItem(TraitImportCandidate {
                             ty: assoc_item_path.ty(sema.db),
-                            name: segment.syntax().to_string(),
+                            name: segment.name_ref()?,
                         })
                     }
                     _ => return None,
                 }
             } else {
-                ImportCandidate::QualifierStart(PathImportCandidate {
-                    name: qualifier_start.syntax().to_string(),
-                })
+                ImportCandidate::QualifierStart(PathImportCandidate { name: qualifier_start })
             }
         } else {
             ImportCandidate::UnqualifiedName(PathImportCandidate {
-                name: segment
-                    .syntax()
-                    .descendants()
-                    .find_map(ast::NameRef::cast)?
-                    .syntax()
-                    .to_string(),
+                name: segment.syntax().descendants().find_map(ast::NameRef::cast)?,
             })
         };
         Some(candidate)
diff --git a/crates/base_db/src/fixture.rs b/crates/base_db/src/fixture.rs
index 72f1fd667..66e6443cb 100644
--- a/crates/base_db/src/fixture.rs
+++ b/crates/base_db/src/fixture.rs
@@ -158,7 +158,7 @@ impl ChangeFixture {
                 let crate_id = crate_graph.add_crate_root(
                     file_id,
                     meta.edition,
-                    Some(crate_name.clone()),
+                    Some(crate_name.clone().into()),
                     meta.cfg,
                     meta.env,
                     Default::default(),
@@ -187,7 +187,7 @@ impl ChangeFixture {
             crate_graph.add_crate_root(
                 crate_root,
                 Edition::Edition2018,
-                Some(CrateName::new("test").unwrap()),
+                Some(CrateName::new("test").unwrap().into()),
                 default_cfg,
                 Env::default(),
                 Default::default(),
diff --git a/crates/base_db/src/input.rs b/crates/base_db/src/input.rs
index 215ac4b41..87f0a0ce5 100644
--- a/crates/base_db/src/input.rs
+++ b/crates/base_db/src/input.rs
@@ -102,11 +102,46 @@ impl fmt::Display for CrateName {
 
 impl ops::Deref for CrateName {
     type Target = str;
-    fn deref(&self) -> &Self::Target {
+    fn deref(&self) -> &str {
         &*self.0
     }
 }
 
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct CrateDisplayName {
+    // The name we use to display various paths (with `_`).
+    crate_name: CrateName,
+    // The name as specified in Cargo.toml (with `-`).
+    canonical_name: String,
+}
+
+impl From<CrateName> for CrateDisplayName {
+    fn from(crate_name: CrateName) -> CrateDisplayName {
+        let canonical_name = crate_name.to_string();
+        CrateDisplayName { crate_name, canonical_name }
+    }
+}
+
+impl fmt::Display for CrateDisplayName {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{}", self.crate_name)
+    }
+}
+
+impl ops::Deref for CrateDisplayName {
+    type Target = str;
+    fn deref(&self) -> &str {
+        &*self.crate_name
+    }
+}
+
+impl CrateDisplayName {
+    pub fn from_canonical_name(canonical_name: String) -> CrateDisplayName {
+        let crate_name = CrateName::normalize_dashes(&canonical_name);
+        CrateDisplayName { crate_name, canonical_name }
+    }
+}
+
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 pub struct ProcMacroId(pub u32);
 
@@ -127,11 +162,13 @@ impl PartialEq for ProcMacro {
 pub struct CrateData {
     pub root_file_id: FileId,
     pub edition: Edition,
-    /// A name used in the package's project declaration: for Cargo projects, it's [package].name,
-    /// can be different for other project types or even absent (a dummy crate for the code snippet, for example).
-    /// NOTE: The crate can be referenced as a dependency under a different name,
-    /// this one should be used when working with crate hierarchies.
-    pub declaration_name: Option<CrateName>,
+    /// A name used in the package's project declaration: for Cargo projects,
+    /// it's [package].name, can be different for other project types or even
+    /// absent (a dummy crate for the code snippet, for example).
+    ///
+    /// For purposes of analysis, crates are anonymous (only names in
+    /// `Dependency` matters), this name should only be used for UI.
+    pub display_name: Option<CrateDisplayName>,
     pub cfg_options: CfgOptions,
     pub env: Env,
     pub dependencies: Vec<Dependency>,
@@ -160,7 +197,7 @@ impl CrateGraph {
         &mut self,
         file_id: FileId,
         edition: Edition,
-        declaration_name: Option<CrateName>,
+        display_name: Option<CrateDisplayName>,
         cfg_options: CfgOptions,
         env: Env,
         proc_macro: Vec<(SmolStr, Arc<dyn tt::TokenExpander>)>,
@@ -171,7 +208,7 @@ impl CrateGraph {
         let data = CrateData {
             root_file_id: file_id,
             edition,
-            declaration_name,
+            display_name,
             cfg_options,
             env,
             proc_macro,
@@ -290,6 +327,29 @@ impl CrateGraph {
         }
         false
     }
+
+    // Work around for https://github.com/rust-analyzer/rust-analyzer/issues/6038.
+    // As hacky as it gets.
+    pub fn patch_cfg_if(&mut self) -> bool {
+        let cfg_if = self.hacky_find_crate("cfg_if");
+        let std = self.hacky_find_crate("std");
+        match (cfg_if, std) {
+            (Some(cfg_if), Some(std)) => {
+                self.arena.get_mut(&cfg_if).unwrap().dependencies.clear();
+                self.arena
+                    .get_mut(&std)
+                    .unwrap()
+                    .dependencies
+                    .push(Dependency { crate_id: cfg_if, name: CrateName::new("cfg_if").unwrap() });
+                true
+            }
+            _ => false,
+        }
+    }
+
+    fn hacky_find_crate(&self, display_name: &str) -> Option<CrateId> {
+        self.iter().find(|it| self[*it].display_name.as_deref() == Some(display_name))
+    }
 }
 
 impl ops::Index<CrateId> for CrateGraph {
diff --git a/crates/base_db/src/lib.rs b/crates/base_db/src/lib.rs
index e38aa7257..0804202d6 100644
--- a/crates/base_db/src/lib.rs
+++ b/crates/base_db/src/lib.rs
@@ -13,8 +13,8 @@ pub use crate::{
     cancellation::Canceled,
     change::Change,
     input::{
-        CrateData, CrateGraph, CrateId, CrateName, Dependency, Edition, Env, FileId, ProcMacroId,
-        SourceRoot, SourceRootId,
+        CrateData, CrateDisplayName, CrateGraph, CrateId, CrateName, Dependency, Edition, Env,
+        FileId, ProcMacroId, SourceRoot, SourceRootId,
     },
 };
 pub use salsa;
diff --git a/crates/call_info/Cargo.toml b/crates/call_info/Cargo.toml
new file mode 100644
index 000000000..98c0bd6db
--- /dev/null
+++ b/crates/call_info/Cargo.toml
@@ -0,0 +1,26 @@
+[package]
+name = "call_info"
+version = "0.0.0"
+description = "TBD"
+license = "MIT OR Apache-2.0"
+authors = ["rust-analyzer developers"]
+edition = "2018"
+
+[lib]
+doctest = false
+
+[dependencies]
+either = "1.5.3"
+
+stdx = { path = "../stdx", version = "0.0.0" }
+syntax = { path = "../syntax", version = "0.0.0" }
+base_db = { path = "../base_db", version = "0.0.0" }
+ide_db = { path = "../ide_db", version = "0.0.0" }
+test_utils = { path = "../test_utils", version = "0.0.0" }
+
+# call_info 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]
+expect-test = "1.0"
diff --git a/crates/ide/src/call_info.rs b/crates/call_info/src/lib.rs
index d7b2b926e..c45406c25 100644
--- a/crates/ide/src/call_info.rs
+++ b/crates/call_info/src/lib.rs
@@ -1,4 +1,5 @@
-//! FIXME: write short doc here
+//! This crate provides primitives for tracking the information about a call site.
+use base_db::FilePosition;
 use either::Either;
 use hir::{HasAttrs, HirDisplay, Semantics, Type};
 use ide_db::RootDatabase;
@@ -9,8 +10,6 @@ use syntax::{
 };
 use test_utils::mark;
 
-use crate::FilePosition;
-
 /// Contains information about a call site. Specifically the
 /// `FunctionSignature`and current parameter.
 #[derive(Debug)]
@@ -40,7 +39,7 @@ impl CallInfo {
 }
 
 /// Computes parameter information for the given call expression.
-pub(crate) fn call_info(db: &RootDatabase, position: FilePosition) -> Option<CallInfo> {
+pub fn call_info(db: &RootDatabase, position: FilePosition) -> Option<CallInfo> {
     let sema = Semantics::new(db);
     let file = sema.parse(position.file_id);
     let file = file.syntax();
@@ -141,13 +140,13 @@ fn call_info_impl(
 }
 
 #[derive(Debug)]
-pub(crate) struct ActiveParameter {
-    pub(crate) ty: Type,
-    pub(crate) name: String,
+pub struct ActiveParameter {
+    pub ty: Type,
+    pub name: String,
 }
 
 impl ActiveParameter {
-    pub(crate) fn at(db: &RootDatabase, position: FilePosition) -> Option<Self> {
+    pub fn at(db: &RootDatabase, position: FilePosition) -> Option<Self> {
         let sema = Semantics::new(db);
         let file = sema.parse(position.file_id);
         let file = file.syntax();
@@ -156,7 +155,7 @@ impl ActiveParameter {
         Self::at_token(&sema, token)
     }
 
-    pub(crate) fn at_token(sema: &Semantics<RootDatabase>, token: SyntaxToken) -> Option<Self> {
+    pub fn at_token(sema: &Semantics<RootDatabase>, token: SyntaxToken) -> Option<Self> {
         let (signature, active_parameter) = call_info_impl(&sema, token)?;
 
         let idx = active_parameter?;
@@ -172,7 +171,7 @@ impl ActiveParameter {
 }
 
 #[derive(Debug)]
-pub(crate) enum FnCallNode {
+pub enum FnCallNode {
     CallExpr(ast::CallExpr),
     MethodCallExpr(ast::MethodCallExpr),
 }
@@ -196,7 +195,7 @@ impl FnCallNode {
         })
     }
 
-    pub(crate) fn with_node_exact(node: &SyntaxNode) -> Option<FnCallNode> {
+    pub fn with_node_exact(node: &SyntaxNode) -> Option<FnCallNode> {
         match_ast! {
             match node {
                 ast::CallExpr(it) => Some(FnCallNode::CallExpr(it)),
@@ -206,7 +205,7 @@ impl FnCallNode {
         }
     }
 
-    pub(crate) fn name_ref(&self) -> Option<ast::NameRef> {
+    pub fn name_ref(&self) -> Option<ast::NameRef> {
         match self {
             FnCallNode::CallExpr(call_expr) => Some(match call_expr.expr()? {
                 ast::Expr::PathExpr(path_expr) => path_expr.path()?.segment()?.name_ref()?,
@@ -229,14 +228,28 @@ impl FnCallNode {
 
 #[cfg(test)]
 mod tests {
+    use base_db::{fixture::ChangeFixture, FilePosition};
     use expect_test::{expect, Expect};
-    use test_utils::mark;
-
-    use crate::fixture;
+    use ide_db::RootDatabase;
+    use test_utils::{mark, RangeOrOffset};
+
+    /// Creates analysis from a multi-file fixture, returns positions marked with <|>.
+    pub(crate) fn position(ra_fixture: &str) -> (RootDatabase, FilePosition) {
+        let change_fixture = ChangeFixture::parse(ra_fixture);
+        let mut database = RootDatabase::default();
+        database.apply_change(change_fixture.change);
+        let (file_id, range_or_offset) =
+            change_fixture.file_position.expect("expected a marker (<|>)");
+        let offset = match range_or_offset {
+            RangeOrOffset::Range(_) => panic!(),
+            RangeOrOffset::Offset(it) => it,
+        };
+        (database, FilePosition { file_id, offset })
+    }
 
     fn check(ra_fixture: &str, expect: Expect) {
-        let (analysis, position) = fixture::position(ra_fixture);
-        let call_info = analysis.call_info(position).unwrap();
+        let (db, position) = position(ra_fixture);
+        let call_info = crate::call_info(&db, position);
         let actual = match call_info {
             Some(call_info) => {
                 let docs = match &call_info.doc {
diff --git a/crates/completion/Cargo.toml b/crates/completion/Cargo.toml
new file mode 100644
index 000000000..25192456a
--- /dev/null
+++ b/crates/completion/Cargo.toml
@@ -0,0 +1,32 @@
+[package]
+name = "completion"
+version = "0.0.0"
+description = "TBD"
+license = "MIT OR Apache-2.0"
+authors = ["rust-analyzer developers"]
+edition = "2018"
+
+[lib]
+doctest = false
+
+[dependencies]
+itertools = "0.9.0"
+log = "0.4.8"
+rustc-hash = "1.1.0"
+
+stdx = { path = "../stdx", version = "0.0.0" }
+syntax = { path = "../syntax", version = "0.0.0" }
+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" }
+assists = { path = "../assists", version = "0.0.0" }
+call_info = { path = "../call_info", 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]
+expect-test = "1.0"
diff --git a/crates/ide/src/completion/complete_attribute.rs b/crates/completion/src/complete_attribute.rs
index f4a9864d1..ea8ad256a 100644
--- a/crates/ide/src/completion/complete_attribute.rs
+++ b/crates/completion/src/complete_attribute.rs
@@ -6,7 +6,7 @@
 use rustc_hash::FxHashSet;
 use syntax::{ast, AstNode, SyntaxKind};
 
-use crate::completion::{
+use crate::{
     completion_context::CompletionContext,
     completion_item::{CompletionItem, CompletionItemKind, CompletionKind, Completions},
     generated_features::FEATURES,
@@ -389,7 +389,7 @@ const DEFAULT_LINT_COMPLETIONS: &[LintCompletion] = &[
 mod tests {
     use expect_test::{expect, Expect};
 
-    use crate::completion::{test_utils::completion_list, CompletionKind};
+    use crate::{test_utils::completion_list, CompletionKind};
 
     fn check(ra_fixture: &str, expect: Expect) {
         let actual = completion_list(ra_fixture, CompletionKind::Attribute);
diff --git a/crates/ide/src/completion/complete_dot.rs b/crates/completion/src/complete_dot.rs
index 0b9f1798a..0eabb48ae 100644
--- a/crates/ide/src/completion/complete_dot.rs
+++ b/crates/completion/src/complete_dot.rs
@@ -4,7 +4,7 @@ use hir::{HasVisibility, Type};
 use rustc_hash::FxHashSet;
 use test_utils::mark;
 
-use crate::completion::{completion_context::CompletionContext, completion_item::Completions};
+use crate::{completion_context::CompletionContext, completion_item::Completions};
 
 /// Complete dot accesses, i.e. fields or methods.
 pub(super) fn complete_dot(acc: &mut Completions, ctx: &CompletionContext) {
@@ -64,7 +64,7 @@ mod tests {
     use expect_test::{expect, Expect};
     use test_utils::mark;
 
-    use crate::completion::{test_utils::completion_list, CompletionKind};
+    use crate::{test_utils::completion_list, CompletionKind};
 
     fn check(ra_fixture: &str, expect: Expect) {
         let actual = completion_list(ra_fixture, CompletionKind::Reference);
@@ -413,4 +413,19 @@ fn foo() {
             "#]],
         );
     }
+
+    #[test]
+    fn completes_method_call_when_receiver_is_a_macro_call() {
+        check(
+            r#"
+struct S;
+impl S { fn foo(&self) {} }
+macro_rules! make_s { () => { S }; }
+fn main() { make_s!().f<|>; }
+"#,
+            expect![[r#"
+                me foo() fn foo(&self)
+            "#]],
+        )
+    }
 }
diff --git a/crates/ide/src/completion/complete_fn_param.rs b/crates/completion/src/complete_fn_param.rs
index 9efe25461..918996727 100644
--- a/crates/ide/src/completion/complete_fn_param.rs
+++ b/crates/completion/src/complete_fn_param.rs
@@ -6,7 +6,7 @@ use syntax::{
     match_ast, AstNode,
 };
 
-use crate::completion::{CompletionContext, CompletionItem, CompletionKind, Completions};
+use crate::{CompletionContext, CompletionItem, CompletionKind, Completions};
 
 /// Complete repeated parameters, both name and type. For example, if all
 /// functions in a file have a `spam: &mut Spam` parameter, a completion with
@@ -68,7 +68,7 @@ pub(super) fn complete_fn_param(acc: &mut Completions, ctx: &CompletionContext)
 mod tests {
     use expect_test::{expect, Expect};
 
-    use crate::completion::{test_utils::completion_list, CompletionKind};
+    use crate::{test_utils::completion_list, CompletionKind};
 
     fn check(ra_fixture: &str, expect: Expect) {
         let actual = completion_list(ra_fixture, CompletionKind::Magic);
diff --git a/crates/ide/src/completion/complete_keyword.rs b/crates/completion/src/complete_keyword.rs
index e59747095..ace914f3f 100644
--- a/crates/ide/src/completion/complete_keyword.rs
+++ b/crates/completion/src/complete_keyword.rs
@@ -1,11 +1,9 @@
-//! FIXME: write short doc here
+//! Completes keywords.
 
 use syntax::{ast, SyntaxKind};
 use test_utils::mark;
 
-use crate::completion::{
-    CompletionContext, CompletionItem, CompletionItemKind, CompletionKind, Completions,
-};
+use crate::{CompletionContext, CompletionItem, CompletionItemKind, CompletionKind, Completions};
 
 pub(super) fn complete_use_tree_keyword(acc: &mut Completions, ctx: &CompletionContext) {
     // complete keyword "crate" in use stmt
@@ -177,7 +175,7 @@ fn complete_return(
 mod tests {
     use expect_test::{expect, Expect};
 
-    use crate::completion::{
+    use crate::{
         test_utils::{check_edit, completion_list},
         CompletionKind,
     };
diff --git a/crates/ide/src/completion/complete_macro_in_item_position.rs b/crates/completion/src/complete_macro_in_item_position.rs
index fc8625d8e..d1d8c23d2 100644
--- a/crates/ide/src/completion/complete_macro_in_item_position.rs
+++ b/crates/completion/src/complete_macro_in_item_position.rs
@@ -1,6 +1,6 @@
-//! FIXME: write short doc here
+//! Completes macro invocations used in item position.
 
-use crate::completion::{CompletionContext, Completions};
+use crate::{CompletionContext, Completions};
 
 pub(super) fn complete_macro_in_item_position(acc: &mut Completions, ctx: &CompletionContext) {
     // Show only macros in top level.
@@ -17,7 +17,7 @@ pub(super) fn complete_macro_in_item_position(acc: &mut Completions, ctx: &Compl
 mod tests {
     use expect_test::{expect, Expect};
 
-    use crate::completion::{test_utils::completion_list, CompletionKind};
+    use crate::{test_utils::completion_list, CompletionKind};
 
     fn check(ra_fixture: &str, expect: Expect) {
         let actual = completion_list(ra_fixture, CompletionKind::Reference);
diff --git a/crates/ide/src/completion/complete_mod.rs b/crates/completion/src/complete_mod.rs
index c7a99bdc3..35a57aba3 100644
--- a/crates/ide/src/completion/complete_mod.rs
+++ b/crates/completion/src/complete_mod.rs
@@ -150,7 +150,7 @@ fn module_chain_to_containing_module_file(
 
 #[cfg(test)]
 mod tests {
-    use crate::completion::{test_utils::completion_list, CompletionKind};
+    use crate::{test_utils::completion_list, CompletionKind};
     use expect_test::{expect, Expect};
 
     fn check(ra_fixture: &str, expect: Expect) {
diff --git a/crates/ide/src/completion/complete_pattern.rs b/crates/completion/src/complete_pattern.rs
index 5a13574d4..5606dcdd9 100644
--- a/crates/ide/src/completion/complete_pattern.rs
+++ b/crates/completion/src/complete_pattern.rs
@@ -1,6 +1,6 @@
-//! FIXME: write short doc here
+//! Completes constats and paths in patterns.
 
-use crate::completion::{CompletionContext, Completions};
+use crate::{CompletionContext, Completions};
 
 /// Completes constats and paths in patterns.
 pub(super) fn complete_pattern(acc: &mut Completions, ctx: &CompletionContext) {
@@ -35,7 +35,7 @@ pub(super) fn complete_pattern(acc: &mut Completions, ctx: &CompletionContext) {
 mod tests {
     use expect_test::{expect, Expect};
 
-    use crate::completion::{test_utils::completion_list, CompletionKind};
+    use crate::{test_utils::completion_list, CompletionKind};
 
     fn check(ra_fixture: &str, expect: Expect) {
         let actual = completion_list(ra_fixture, CompletionKind::Reference);
diff --git a/crates/ide/src/completion/complete_postfix.rs b/crates/completion/src/complete_postfix.rs
index db5319618..700573cf2 100644
--- a/crates/ide/src/completion/complete_postfix.rs
+++ b/crates/completion/src/complete_postfix.rs
@@ -1,4 +1,4 @@
-//! FIXME: write short doc here
+//! Postfix completions, like `Ok(10).ifl<|>` => `if let Ok() = Ok(10) { <|> }`.
 
 mod format_like;
 
@@ -11,11 +11,9 @@ use text_edit::TextEdit;
 
 use self::format_like::add_format_like_completions;
 use crate::{
-    completion::{
-        completion_config::SnippetCap,
-        completion_context::CompletionContext,
-        completion_item::{Builder, CompletionKind, Completions},
-    },
+    completion_config::SnippetCap,
+    completion_context::CompletionContext,
+    completion_item::{Builder, CompletionKind, Completions},
     CompletionItem, CompletionItemKind,
 };
 
@@ -263,7 +261,7 @@ fn postfix_snippet(
 mod tests {
     use expect_test::{expect, Expect};
 
-    use crate::completion::{
+    use crate::{
         test_utils::{check_edit, completion_list},
         CompletionKind,
     };
diff --git a/crates/ide/src/completion/complete_postfix/format_like.rs b/crates/completion/src/complete_postfix/format_like.rs
index 50d1e5c81..205c384e2 100644
--- a/crates/ide/src/completion/complete_postfix/format_like.rs
+++ b/crates/completion/src/complete_postfix/format_like.rs
@@ -14,7 +14,7 @@
 //   + `logw` -> `log::warn!(...)`
 //   + `loge` -> `log::error!(...)`
 
-use crate::completion::{
+use crate::{
     complete_postfix::postfix_snippet, completion_config::SnippetCap,
     completion_context::CompletionContext, completion_item::Completions,
 };
diff --git a/crates/ide/src/completion/complete_qualified_path.rs b/crates/completion/src/complete_qualified_path.rs
index 2fafedd47..80b271fdf 100644
--- a/crates/ide/src/completion/complete_qualified_path.rs
+++ b/crates/completion/src/complete_qualified_path.rs
@@ -5,7 +5,7 @@ use rustc_hash::FxHashSet;
 use syntax::AstNode;
 use test_utils::mark;
 
-use crate::completion::{CompletionContext, Completions};
+use crate::{CompletionContext, Completions};
 
 pub(super) fn complete_qualified_path(acc: &mut Completions, ctx: &CompletionContext) {
     let path = match &ctx.path_qual {
@@ -149,7 +149,7 @@ mod tests {
     use expect_test::{expect, Expect};
     use test_utils::mark;
 
-    use crate::completion::{
+    use crate::{
         test_utils::{check_edit, completion_list},
         CompletionKind,
     };
diff --git a/crates/ide/src/completion/complete_record.rs b/crates/completion/src/complete_record.rs
index ceb8d16c1..129ddc055 100644
--- a/crates/ide/src/completion/complete_record.rs
+++ b/crates/completion/src/complete_record.rs
@@ -1,5 +1,5 @@
 //! Complete fields in record literals and patterns.
-use crate::completion::{CompletionContext, Completions};
+use crate::{CompletionContext, Completions};
 
 pub(super) fn complete_record(acc: &mut Completions, ctx: &CompletionContext) -> Option<()> {
     let missing_fields = match (ctx.record_pat_syntax.as_ref(), ctx.record_lit_syntax.as_ref()) {
@@ -20,7 +20,7 @@ pub(super) fn complete_record(acc: &mut Completions, ctx: &CompletionContext) ->
 mod tests {
     use expect_test::{expect, Expect};
 
-    use crate::completion::{test_utils::completion_list, CompletionKind};
+    use crate::{test_utils::completion_list, CompletionKind};
 
     fn check(ra_fixture: &str, expect: Expect) {
         let actual = completion_list(ra_fixture, CompletionKind::Reference);
diff --git a/crates/ide/src/completion/complete_snippet.rs b/crates/completion/src/complete_snippet.rs
index 4837d2910..06096722b 100644
--- a/crates/ide/src/completion/complete_snippet.rs
+++ b/crates/completion/src/complete_snippet.rs
@@ -1,6 +1,6 @@
-//! FIXME: write short doc here
+//! This file provides snippet completions, like `pd` => `eprintln!(...)`.
 
-use crate::completion::{
+use crate::{
     completion_config::SnippetCap, completion_item::Builder, CompletionContext, CompletionItem,
     CompletionItemKind, CompletionKind, Completions,
 };
@@ -71,7 +71,7 @@ fn ${1:feature}() {
 mod tests {
     use expect_test::{expect, Expect};
 
-    use crate::completion::{test_utils::completion_list, CompletionKind};
+    use crate::{test_utils::completion_list, CompletionKind};
 
     fn check(ra_fixture: &str, expect: Expect) {
         let actual = completion_list(ra_fixture, CompletionKind::Snippet);
diff --git a/crates/ide/src/completion/complete_trait_impl.rs b/crates/completion/src/complete_trait_impl.rs
index ff115df92..c06af99e2 100644
--- a/crates/ide/src/completion/complete_trait_impl.rs
+++ b/crates/completion/src/complete_trait_impl.rs
@@ -35,15 +35,18 @@ use assists::utils::get_missing_assoc_items;
 use hir::{self, HasAttrs, HasSource};
 use syntax::{
     ast::{self, edit, Impl},
+    display::function_declaration,
     AstNode, SyntaxKind, SyntaxNode, TextRange, T,
 };
 use text_edit::TextEdit;
 
 use crate::{
-    completion::{
-        CompletionContext, CompletionItem, CompletionItemKind, CompletionKind, Completions,
-    },
-    display::function_declaration,
+    CompletionContext,
+    CompletionItem,
+    CompletionItemKind,
+    CompletionKind,
+    Completions,
+    // display::function_declaration,
 };
 
 #[derive(Debug, PartialEq, Eq)]
@@ -237,7 +240,7 @@ fn make_const_compl_syntax(const_: &ast::Const) -> String {
 mod tests {
     use expect_test::{expect, Expect};
 
-    use crate::completion::{
+    use crate::{
         test_utils::{check_edit, completion_list},
         CompletionKind,
     };
diff --git a/crates/ide/src/completion/complete_unqualified_path.rs b/crates/completion/src/complete_unqualified_path.rs
index 8b6757195..5464a160d 100644
--- a/crates/ide/src/completion/complete_unqualified_path.rs
+++ b/crates/completion/src/complete_unqualified_path.rs
@@ -4,7 +4,7 @@ use hir::{Adt, ModuleDef, ScopeDef, Type};
 use syntax::AstNode;
 use test_utils::mark;
 
-use crate::completion::{CompletionContext, Completions};
+use crate::{CompletionContext, Completions};
 
 pub(super) fn complete_unqualified_path(acc: &mut Completions, ctx: &CompletionContext) {
     if !(ctx.is_trivial_path || ctx.is_pat_binding_or_const) {
@@ -68,7 +68,7 @@ mod tests {
     use expect_test::{expect, Expect};
     use test_utils::mark;
 
-    use crate::completion::{
+    use crate::{
         test_utils::{check_edit, completion_list},
         CompletionKind,
     };
diff --git a/crates/ide/src/completion/completion_config.rs b/crates/completion/src/completion_config.rs
index 71b49ace8..71b49ace8 100644
--- a/crates/ide/src/completion/completion_config.rs
+++ b/crates/completion/src/completion_config.rs
diff --git a/crates/ide/src/completion/completion_context.rs b/crates/completion/src/completion_context.rs
index 8dea8a4bf..dc4e136c6 100644
--- a/crates/ide/src/completion/completion_context.rs
+++ b/crates/completion/src/completion_context.rs
@@ -1,6 +1,7 @@
-//! FIXME: write short doc here
+//! See `CompletionContext` structure.
 
-use base_db::SourceDatabase;
+use base_db::{FilePosition, SourceDatabase};
+use call_info::ActiveParameter;
 use hir::{Local, ScopeDef, Semantics, SemanticsScope, Type};
 use ide_db::RootDatabase;
 use syntax::{
@@ -13,17 +14,14 @@ use test_utils::mark;
 use text_edit::Indel;
 
 use crate::{
-    call_info::ActiveParameter,
-    completion::{
-        patterns::{
-            has_bind_pat_parent, has_block_expr_parent, has_field_list_parent,
-            has_impl_as_prev_sibling, has_impl_parent, has_item_list_or_source_file_parent,
-            has_ref_parent, has_trait_as_prev_sibling, has_trait_parent, if_is_prev,
-            is_in_loop_body, is_match_arm, unsafe_is_prev,
-        },
-        CompletionConfig,
+    patterns::{
+        fn_is_prev, for_is_prev2, has_bind_pat_parent, has_block_expr_parent,
+        has_field_list_parent, has_impl_as_prev_sibling, has_impl_parent,
+        has_item_list_or_source_file_parent, has_ref_parent, has_trait_as_prev_sibling,
+        has_trait_parent, if_is_prev, inside_impl_trait_block, is_in_loop_body, is_match_arm,
+        unsafe_is_prev,
     },
-    FilePosition,
+    CompletionConfig,
 };
 
 /// `CompletionContext` is created early during completion to figure out, where
@@ -86,11 +84,14 @@ pub(crate) struct CompletionContext<'a> {
     pub(super) in_loop_body: bool,
     pub(super) has_trait_parent: bool,
     pub(super) has_impl_parent: bool,
+    pub(super) inside_impl_trait_block: bool,
     pub(super) has_field_list_parent: bool,
     pub(super) trait_as_prev_sibling: bool,
     pub(super) impl_as_prev_sibling: bool,
     pub(super) is_match_arm: bool,
     pub(super) has_item_list_or_source_file_parent: bool,
+    pub(super) for_is_prev2: bool,
+    pub(super) fn_is_prev: bool,
     pub(super) locals: Vec<(String, Local)>,
 }
 
@@ -168,12 +169,15 @@ impl<'a> CompletionContext<'a> {
             block_expr_parent: false,
             has_trait_parent: false,
             has_impl_parent: false,
+            inside_impl_trait_block: false,
             has_field_list_parent: false,
             trait_as_prev_sibling: false,
             impl_as_prev_sibling: false,
             if_is_prev: false,
             is_match_arm: false,
             has_item_list_or_source_file_parent: false,
+            for_is_prev2: false,
+            fn_is_prev: false,
             locals,
         };
 
@@ -221,6 +225,15 @@ impl<'a> CompletionContext<'a> {
         Some(ctx)
     }
 
+    /// Checks whether completions in that particular case don't make much sense.
+    /// Examples:
+    /// - `fn <|>` -- we expect function name, it's unlikely that "hint" will be helpful.
+    ///   Exception for this case is `impl Trait for Foo`, where we would like to hint trait method names.
+    /// - `for _ i<|>` -- obviously, it'll be "in" keyword.
+    pub(crate) fn no_completion_required(&self) -> bool {
+        (self.fn_is_prev && !self.inside_impl_trait_block) || self.for_is_prev2
+    }
+
     /// The range of the identifier that is being completed.
     pub(crate) fn source_range(&self) -> TextRange {
         // check kind of macro-expanded token, but use range of original token
@@ -244,6 +257,7 @@ impl<'a> CompletionContext<'a> {
         self.in_loop_body = is_in_loop_body(syntax_element.clone());
         self.has_trait_parent = has_trait_parent(syntax_element.clone());
         self.has_impl_parent = has_impl_parent(syntax_element.clone());
+        self.inside_impl_trait_block = inside_impl_trait_block(syntax_element.clone());
         self.has_field_list_parent = has_field_list_parent(syntax_element.clone());
         self.impl_as_prev_sibling = has_impl_as_prev_sibling(syntax_element.clone());
         self.trait_as_prev_sibling = has_trait_as_prev_sibling(syntax_element.clone());
@@ -253,6 +267,8 @@ impl<'a> CompletionContext<'a> {
         self.mod_declaration_under_caret =
             find_node_at_offset::<ast::Module>(&file_with_fake_ident, offset)
                 .filter(|module| module.item_list().is_none());
+        self.for_is_prev2 = for_is_prev2(syntax_element.clone());
+        self.fn_is_prev = fn_is_prev(syntax_element.clone());
     }
 
     fn fill(
diff --git a/crates/ide/src/completion/completion_item.rs b/crates/completion/src/completion_item.rs
index 9377cdc57..f8be0ad2b 100644
--- a/crates/ide/src/completion/completion_item.rs
+++ b/crates/completion/src/completion_item.rs
@@ -1,4 +1,4 @@
-//! FIXME: write short doc here
+//! See `CompletionItem` structure.
 
 use std::fmt;
 
@@ -6,7 +6,7 @@ use hir::Documentation;
 use syntax::TextRange;
 use text_edit::TextEdit;
 
-use crate::completion::completion_config::SnippetCap;
+use crate::completion_config::SnippetCap;
 
 /// `CompletionItem` describes a single completion variant in the editor pop-up.
 /// It is basically a POD with various properties. To construct a
@@ -360,15 +360,15 @@ impl<'a> Into<CompletionItem> for Builder {
 
 /// Represents an in-progress set of completions being built.
 #[derive(Debug, Default)]
-pub(crate) struct Completions {
+pub struct Completions {
     buf: Vec<CompletionItem>,
 }
 
 impl Completions {
-    pub(crate) fn add(&mut self, item: impl Into<CompletionItem>) {
+    pub fn add(&mut self, item: impl Into<CompletionItem>) {
         self.buf.push(item.into())
     }
-    pub(crate) fn add_all<I>(&mut self, items: I)
+    pub fn add_all<I>(&mut self, items: I)
     where
         I: IntoIterator,
         I::Item: Into<CompletionItem>,
diff --git a/crates/ide/src/completion/generated_features.rs b/crates/completion/src/generated_features.rs
index 24754a8cf..090cad2db 100644
--- a/crates/ide/src/completion/generated_features.rs
+++ b/crates/completion/src/generated_features.rs
@@ -1,4 +1,4 @@
 //! Generated file, do not edit by hand, see `xtask/src/codegen`
 
-use crate::completion::complete_attribute::LintCompletion;
+use crate::complete_attribute::LintCompletion;