111 files changed, 4413 insertions, 1575 deletions
diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index fb077e28d..a19bc9ad3 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -30,6 +30,9 @@ jobs:
    steps:
    - name: Checkout repository
      uses: actions/checkout@v2
+      with:
+        ref: ${{ github.event.pull_request.head.sha }}
+        fetch-depth: 20
    # We need to disable the existing toolchain to avoid updating rust-docs
    # which takes a long time. The fastest way to do this is to rename the
diff --git a/.github/workflows/publish.yml b/.github/workflows/publish.yml
index 0e26bb784..e54a3693b 100644
--- a/.github/workflows/publish.yml
+++ b/.github/workflows/publish.yml
@@ -2,8 +2,8 @@ name: publish
 on:
  workflow_dispatch: # We can add version input when 1.0 is released and scheduled releases are removed
-  schedule:
+#   schedule:
-    - cron: "0 0 * * *" # midnight UTC
+#     - cron: "0 0 * * *" # midnight UTC
  push:
    branches:
diff --git a/Cargo.lock b/Cargo.lock
index cec4462f2..7fecee1b5 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -129,9 +129,9 @@ checksum = "08c48aae112d48ed9f069b33538ea9e3e90aa263cfa3d1c24309612b1f7472de"
 [[package]]
 name = "cargo_metadata"
-version = "0.11.1"
+version = "0.11.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "89fec17b16f1ac67908af82e47d0a90a7afd0e1827b181cd77504323d3263d35"
+checksum = "c990b1694d29f8e477f456db1b2fcd5dd1cd6e29d5be082df45213e8834eb39a"
 dependencies = [
 "semver",
 "serde",
@@ -140,9 +140,9 @@ dependencies = [
 [[package]]
 name = "cc"
-version = "1.0.59"
+version = "1.0.60"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "66120af515773fb005778dc07c261bd201ec8ce50bd6e7144c927753fe013381"
+checksum = "ef611cc68ff783f18535d77ddd080185275713d852c4f5cbb6122c462a7a825c"
 [[package]]
 name = "cfg"
@@ -162,9 +162,9 @@ checksum = "4785bdd1c96b2a846b2bd7cc02e86b6b3dbf14e7e53446c4f54c92a361040822"
 [[package]]
 name = "chalk-derive"
-version = "0.23.0"
+version = "0.27.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c3cb438e961fd7f1183dc5e0bdcfd09253bf9b90592cf665d1ce6787d8a4908f"
+checksum = "d5444ff2a211fe2a863e44d16a368c3d8a314d489de21b8eeb6879f14dd5d4a8"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -174,9 +174,9 @@ dependencies = [
 [[package]]
 name = "chalk-ir"
-version = "0.23.0"
+version = "0.27.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bb332abfcb015b148c6fbab39b1d13282745b0f7f312019dd8e138f5f3f0855d"
+checksum = "e39c3db1dd4abfaa7658faaa62e5fe998a982a592b710bd971fad5b6adfcfdef"
 dependencies = [
 "chalk-derive",
 "lazy_static",
@@ -184,9 +184,9 @@ dependencies = [
 [[package]]
 name = "chalk-recursive"
-version = "0.23.0"
+version = "0.27.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e7c7673f10c5fa1acf7fa07d4f4c5917cbcf161ed3a952d14530c79950de32d2"
+checksum = "3bfae328eff80ca54dcd0d731725bbb56136ac21c59261b68f1e5498e056b306"
 dependencies = [
 "chalk-derive",
 "chalk-ir",
@@ -197,9 +197,9 @@ dependencies = [
 [[package]]
 name = "chalk-solve"
-version = "0.23.0"
+version = "0.27.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "802de4eff72e5a5d2828e6c07224c74d66949dc6308aff025d0ae2871a11b4eb"
+checksum = "a673abe3077adc25f8ee0894198aed494a5bb0ce50ee993900d0ee1a44e1948a"
 dependencies = [
 "chalk-derive",
 "chalk-ir",
@@ -252,12 +252,12 @@ dependencies = [
 [[package]]
 name = "crossbeam-channel"
-version = "0.4.3"
+version = "0.4.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "09ee0cc8804d5393478d743b035099520087a5186f3b93fa58cec08fa62407b6"
+checksum = "b153fe7cbef478c567df0f972e02e6d736db11affe43dfc9c56a9374d1adfb87"
 dependencies = [
- "cfg-if",
 "crossbeam-utils",
+ "maybe-uninit",
 ]
 [[package]]
@@ -311,9 +311,9 @@ checksum = "9bda8e21c04aca2ae33ffc2fd8c23134f3cac46db123ba97bd9d3f3b8a4a85e1"
 [[package]]
 name = "either"
-version = "1.6.0"
+version = "1.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cd56b59865bce947ac5958779cfa508f6c3b9497cc762b7e24a12d11ccde2c4f"
+checksum = "e78d4f1cc4ae33bbfc157ed5d5a5ef3bc29227303d595861deb238fcec4e9457"
 [[package]]
 name = "ena"
@@ -335,9 +335,9 @@ dependencies = [
 [[package]]
 name = "expect-test"
-version = "1.0.0"
+version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3a3cb2ab12988de61df699d210428f3a0e26907b9d0978cf2c12e65ee90adb1d"
+checksum = "ceb96f3eaa0d4e8769c52dacfd4eb60183b817ed2f176171b3c691d5022b0f2e"
 dependencies = [
 "difference",
 "once_cell",
@@ -451,12 +451,9 @@ dependencies = [
 [[package]]
 name = "hashbrown"
-version = "0.8.2"
+version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e91b62f79061a0bc2e046024cb7ba44b08419ed238ecbd9adbd787434b9e8c25"
+checksum = "00d63df3d41950fb462ed38308eea019113ad1508da725bbedcd0fa5a85ef5f7"
-dependencies = [
- "autocfg",
-]
 [[package]]
 name = "heck"
@@ -635,9 +632,9 @@ dependencies = [
 [[package]]
 name = "indexmap"
-version = "1.5.1"
+version = "1.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "86b45e59b16c76b11bf9738fd5d38879d3bd28ad292d7b313608becb17ae2df9"
+checksum = "55e2e4c765aa53a0424761bf9f41aa7a6ac1efa87238f59560640e27fca028f2"
 dependencies = [
 "autocfg",
 "hashbrown",
@@ -723,9 +720,9 @@ checksum = "830d08ce1d1d941e6b30645f1a0eb5643013d835ce3779a5fc208261dbe10f55"
 [[package]]
 name = "libc"
-version = "0.2.76"
+version = "0.2.77"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "755456fae044e6fa1ebbbd1b3e902ae19e73097ed4ed87bb79934a867c007bc3"
+checksum = "f2f96b10ec2560088a8e76961b00d47107b3a625fecb76dedb29ee7ccbf98235"
 [[package]]
 name = "libloading"
@@ -778,9 +775,9 @@ dependencies = [
 [[package]]
 name = "lsp-types"
-version = "0.79.0"
+version = "0.82.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7f1f86677fdbe8df5f88b99131b1424e50aad27bbe3e5900d221bc414bd72e9b"
+checksum = "db895abb8527cf59e3de893ab2acf52cf904faeb65e60ea6f373e11fe86464e8"
 dependencies = [
 "base64",
 "bitflags",
@@ -860,11 +857,12 @@ dependencies = [
 [[package]]
 name = "miniz_oxide"
-version = "0.4.1"
+version = "0.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4d7559a8a40d0f97e1edea3220f698f78b1c5ab67532e49f68fde3910323b722"
+checksum = "c60c0dfe32c10b43a144bad8fc83538c52f58302c92300ea7ec7bf7b38d5a7b9"
 dependencies = [
 "adler",
+ "autocfg",
 ]
 [[package]]
@@ -912,9 +910,9 @@ dependencies = [
 [[package]]
 name = "net2"
-version = "0.2.34"
+version = "0.2.35"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2ba7c918ac76704fb42afcbbb43891e72731f3dcca3bef2a19786297baf14af7"
+checksum = "3ebc3ec692ed7c9a255596c67808dee269f64655d8baf7b4f0638e51ba1d6853"
 dependencies = [
 "cfg-if",
 "libc",
@@ -1074,9 +1072,9 @@ checksum = "b4596b6d070b27117e987119b4dac604f3c58cfb0b191112e24771b2faeac1a6"
 [[package]]
 name = "proc-macro2"
-version = "1.0.19"
+version = "1.0.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "04f5f085b5d71e2188cb8271e5da0161ad52c3f227a661a3c135fdf28e258b12"
+checksum = "36e28516df94f3dd551a587da5357459d9b36d945a7c37c3557928c1c2ff2a2c"
 dependencies = [
 "unicode-xid",
 ]
@@ -1189,9 +1187,9 @@ dependencies = [
 [[package]]
 name = "rayon-core"
-version = "1.8.0"
+version = "1.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "91739a34c4355b5434ce54c9086c5895604a9c278586d1f1aa95e04f66b525a0"
+checksum = "e8c4fec834fb6e6d2dd5eece3c7b432a52f0ba887cf40e595190c4107edc08bf"
 dependencies = [
 "crossbeam-channel",
 "crossbeam-deque",
@@ -1404,18 +1402,18 @@ checksum = "388a1df253eca08550bef6c72392cfe7c30914bf41df5269b68cbd6ff8f570a3"
 [[package]]
 name = "serde"
-version = "1.0.115"
+version = "1.0.116"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e54c9a88f2da7238af84b5101443f0c0d0a3bbdc455e34a5c9497b1903ed55d5"
+checksum = "96fe57af81d28386a513cbc6858332abc6117cfdb5999647c6444b8f43a370a5"
 dependencies = [
 "serde_derive",
 ]
 [[package]]
 name = "serde_derive"
-version = "1.0.115"
+version = "1.0.116"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "609feed1d0a73cc36a0182a840a9b37b4a82f0b1150369f0536a9e3f2a31dc48"
+checksum = "f630a6370fd8e457873b4bd2ffdae75408bc291ba72be773772a4c2a065d9ae8"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -1495,9 +1493,9 @@ version = "0.0.0"
 [[package]]
 name = "syn"
-version = "1.0.39"
+version = "1.0.41"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "891d8d6567fe7c7f8835a3a98af4208f3846fba258c1bc3c31d6e506239f11f9"
+checksum = "6690e3e9f692504b941dc6c3b188fd28df054f7fb8469ab40680df52fdcc842b"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -1642,9 +1640,9 @@ dependencies = [
 [[package]]
 name = "tracing-core"
-version = "0.1.15"
+version = "0.1.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4f0e00789804e99b20f12bc7003ca416309d28a6f495d6af58d1e2c2842461b5"
+checksum = "5bcf46c1f1f06aeea2d6b81f3c863d0930a596c86ad1920d4e5bad6dd1d7119a"
 dependencies = [
 "lazy_static",
 ]
@@ -1662,9 +1660,9 @@ dependencies = [
 [[package]]
 name = "tracing-serde"
-version = "0.1.1"
+version = "0.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b6ccba2f8f16e0ed268fc765d9b7ff22e965e7185d32f8f1ec8294fe17d86e79"
+checksum = "fb65ea441fbb84f9f6748fd496cf7f63ec9af5bca94dd86456978d055e8eb28b"
 dependencies = [
 "serde",
 "tracing-core",
@@ -1672,9 +1670,9 @@ dependencies = [
 [[package]]
 name = "tracing-subscriber"
-version = "0.2.11"
+version = "0.2.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "abd165311cc4d7a555ad11cc77a37756df836182db0d81aac908c8184c584f40"
+checksum = "82bb5079aa76438620837198db8a5c529fb9878c730bc2b28179b0241cf04c10"
 dependencies = [
 "ansi_term",
 "chrono",
diff --git a/crates/assists/src/assist_config.rs b/crates/assists/src/assist_config.rs
index cda2abfb9..adf02edab 100644
--- a/crates/assists/src/assist_config.rs
+++ b/crates/assists/src/assist_config.rs
@@ -4,12 +4,13 @@
 //! module, and we use to statically check that we only produce snippet
 //! assists if we are allowed to.
-use crate::AssistKind;
+use crate::{utils::MergeBehaviour, AssistKind};
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct AssistConfig {
    pub snippet_cap: Option<SnippetCap>,
    pub allowed: Option<Vec<AssistKind>>,
+    pub insert_use: InsertUseConfig,
 }
 impl AssistConfig {
@@ -25,6 +26,21 @@ pub struct SnippetCap {
 impl Default for AssistConfig {
    fn default() -> Self {
-        AssistConfig { snippet_cap: Some(SnippetCap { _private: () }), allowed: None }
+        AssistConfig {
+            snippet_cap: Some(SnippetCap { _private: () }),
+            allowed: None,
+            insert_use: InsertUseConfig::default(),
+        }
+    }
+}
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct InsertUseConfig {
+    pub merge: Option<MergeBehaviour>,
+}
+impl Default for InsertUseConfig {
+    fn default() -> Self {
+        InsertUseConfig { merge: Some(MergeBehaviour::Full) }
    }
 }
diff --git a/crates/assists/src/ast_transform.rs b/crates/assists/src/ast_transform.rs
index 5216862ba..835da3bb2 100644
--- a/crates/assists/src/ast_transform.rs
+++ b/crates/assists/src/ast_transform.rs
@@ -18,6 +18,34 @@ pub fn apply<'a, N: AstNode>(transformer: &dyn AstTransform<'a>, node: N) -> N {
    .rewrite_ast(&node)
 }
+/// `AstTransform` helps with applying bulk transformations to syntax nodes.
+///
+/// This is mostly useful for IDE code generation. If you paste some existing
+/// code into a new context (for example, to add method overrides to an `impl`
+/// block), you generally want to appropriately qualify the names, and sometimes
+/// you might want to substitute generic parameters as well:
+///
+/// ```
+/// mod x {
+///   pub struct A;
+///   pub trait T<U> { fn foo(&self, _: U) -> A; }
+/// }
+///
+/// mod y {
+///   use x::T;
+///
+///   impl T<()> for () {
+///      // If we invoke **Add Missing Members** here, we want to copy-paste `foo`.
+///      // But we want a slightly-modified version of it:
+///      fn foo(&self, _: ()) -> x::A {}
+///   }
+/// }
+/// ```
+///
+/// So, a single `AstTransform` describes such function from `SyntaxNode` to
+/// `SyntaxNode`. Note that the API here is a bit too high-order and high-brow.
+/// We'd want to somehow express this concept simpler, but so far nobody got to
+/// simplifying this!
 pub trait AstTransform<'a> {
    fn get_substitution(&self, node: &syntax::SyntaxNode) -> Option<syntax::SyntaxNode>;
@@ -166,7 +194,7 @@ impl<'a> QualifyPaths<'a> {
                    .map(|arg_list| apply(self, arg_list));
                if let Some(type_args) = type_args {
                    let last_segment = path.segment().unwrap();
-                    path = path.with_segment(last_segment.with_type_args(type_args))
+                    path = path.with_segment(last_segment.with_generic_args(type_args))
                }
                Some(path.syntax().clone())
diff --git a/crates/assists/src/handlers/add_missing_impl_members.rs b/crates/assists/src/handlers/add_missing_impl_members.rs
index 83a2ada9a..8df1d786b 100644
--- a/crates/assists/src/handlers/add_missing_impl_members.rs
+++ b/crates/assists/src/handlers/add_missing_impl_members.rs
@@ -111,8 +111,6 @@ fn add_missing_impl_members_inner(
 ) -> Option<()> {
    let _p = profile::span("add_missing_impl_members_inner");
    let impl_def = ctx.find_node_at_offset::<ast::Impl>()?;
-    let impl_item_list = impl_def.assoc_item_list()?;
    let trait_ = resolve_target_trait(&ctx.sema, &impl_def)?;
    let def_name = |item: &ast::AssocItem| -> Option<SmolStr> {
@@ -148,11 +146,14 @@ fn add_missing_impl_members_inner(
    let target = impl_def.syntax().text_range();
    acc.add(AssistId(assist_id, AssistKind::QuickFix), label, target, |builder| {
+        let impl_item_list = impl_def.assoc_item_list().unwrap_or(make::assoc_item_list());
        let n_existing_items = impl_item_list.assoc_items().count();
        let source_scope = ctx.sema.scope_for_def(trait_);
-        let target_scope = ctx.sema.scope(impl_item_list.syntax());
+        let target_scope = ctx.sema.scope(impl_def.syntax());
        let ast_transform = QualifyPaths::new(&target_scope, &source_scope)
-            .or(SubstituteTypeParams::for_trait_impl(&source_scope, trait_, impl_def));
+            .or(SubstituteTypeParams::for_trait_impl(&source_scope, trait_, impl_def.clone()));
        let items = missing_items
            .into_iter()
            .map(|it| ast_transform::apply(&*ast_transform, it))
@@ -162,12 +163,14 @@ fn add_missing_impl_members_inner(
                _ => it,
            })
            .map(|it| edit::remove_attrs_and_docs(&it));
        let new_impl_item_list = impl_item_list.append_items(items);
-        let first_new_item = new_impl_item_list.assoc_items().nth(n_existing_items).unwrap();
+        let new_impl_def = impl_def.with_assoc_item_list(new_impl_item_list);
+        let first_new_item =
+            new_impl_def.assoc_item_list().unwrap().assoc_items().nth(n_existing_items).unwrap();
-        let original_range = impl_item_list.syntax().text_range();
        match ctx.config.snippet_cap {
-            None => builder.replace(original_range, new_impl_item_list.to_string()),
+            None => builder.replace(target, new_impl_def.to_string()),
            Some(cap) => {
                let mut cursor = Cursor::Before(first_new_item.syntax());
                let placeholder;
@@ -181,8 +184,8 @@ fn add_missing_impl_members_inner(
                }
                builder.replace_snippet(
                    cap,
-                    original_range,
+                    target,
-                    render_snippet(cap, new_impl_item_list.syntax(), cursor),
+                    render_snippet(cap, new_impl_def.syntax(), cursor),
                )
            }
        };
@@ -311,6 +314,25 @@ impl Foo for S {
    }
    #[test]
+    fn test_impl_def_without_braces() {
+        check_assist(
+            add_missing_impl_members,
+            r#"
+trait Foo { fn foo(&self); }
+struct S;
+impl Foo for S<|>"#,
+            r#"
+trait Foo { fn foo(&self); }
+struct S;
+impl Foo for S {
+    fn foo(&self) {
+        ${0:todo!()}
+    }
+}"#,
+        );
+    }
+    #[test]
    fn fill_in_type_params_1() {
        check_assist(
            add_missing_impl_members,
diff --git a/crates/assists/src/handlers/auto_import.rs b/crates/assists/src/handlers/auto_import.rs
index c4770f336..b5eb2c722 100644
--- a/crates/assists/src/handlers/auto_import.rs
+++ b/crates/assists/src/handlers/auto_import.rs
@@ -1,20 +1,20 @@
 use std::collections::BTreeSet;
+use ast::make;
 use either::Either;
 use hir::{
    AsAssocItem, AssocItemContainer, ModPath, Module, ModuleDef, PathResolution, Semantics, Trait,
    Type,
 };
 use ide_db::{imports_locator, RootDatabase};
+use insert_use::ImportScope;
 use rustc_hash::FxHashSet;
 use syntax::{
    ast::{self, AstNode},
    SyntaxNode,
 };
-use crate::{
+use crate::{utils::insert_use, AssistContext, AssistId, AssistKind, Assists, GroupLabel};
-    utils::insert_use_statement, AssistContext, AssistId, AssistKind, Assists, GroupLabel,
-};
 // Assist: auto_import
 //
@@ -44,6 +44,9 @@ pub(crate) fn auto_import(acc: &mut Assists, ctx: &AssistContext) -> Option<()>
    let range = ctx.sema.original_range(&auto_import_assets.syntax_under_caret).range;
    let group = auto_import_assets.get_import_group_message();
+    let scope =
+        ImportScope::find_insert_use_container(&auto_import_assets.syntax_under_caret, ctx)?;
+    let syntax = scope.as_syntax_node();
    for import in proposed_imports {
        acc.add_group(
            &group,
@@ -51,12 +54,12 @@ pub(crate) fn auto_import(acc: &mut Assists, ctx: &AssistContext) -> Option<()>
            format!("Import `{}`", &import),
            range,
            |builder| {
-                insert_use_statement(
+                let new_syntax = insert_use(
-                    &auto_import_assets.syntax_under_caret,
+                    &scope,
-                    &import.to_string(),
+                    make::path_from_text(&import.to_string()),
-                    ctx,
+                    ctx.config.insert_use.merge,
-                    builder.text_edit_builder(),
                );
+                builder.replace(syntax.text_range(), new_syntax.to_string())
            },
        );
    }
@@ -358,7 +361,7 @@ mod tests {
            }
            ",
            r"
-            use PubMod::{PubStruct2, PubStruct1};
+            use PubMod::{PubStruct1, PubStruct2};
            struct Test {
                test: PubStruct2<u8>,
diff --git a/crates/assists/src/handlers/expand_glob_import.rs b/crates/assists/src/handlers/expand_glob_import.rs
index b39d040f6..e14ac7f65 100644
--- a/crates/assists/src/handlers/expand_glob_import.rs
+++ b/crates/assists/src/handlers/expand_glob_import.rs
@@ -4,7 +4,11 @@ use ide_db::{
    defs::{classify_name_ref, Definition, NameRefClass},
    search::SearchScope,
 };
-use syntax::{algo, ast, AstNode, Direction, SyntaxNode, SyntaxToken, T};
+use syntax::{
+    algo,
+    ast::{self, make},
+    AstNode, Direction, SyntaxNode, SyntaxToken, T,
+};
 use crate::{
    assist_context::{AssistBuilder, AssistContext, Assists},
@@ -249,7 +253,10 @@ fn replace_ast(
    let new_use_trees: Vec<ast::UseTree> = names_to_import
        .iter()
-        .map(|n| ast::make::use_tree(ast::make::path_from_text(&n.to_string()), None, None, false))
+        .map(|n| {
+            let path = make::path_unqualified(make::path_segment(make::name_ref(&n.to_string())));
+            make::use_tree(path, None, None, false)
+        })
        .collect();
    let use_trees = [&existing_use_trees[..], &new_use_trees[..]].concat();
@@ -257,8 +264,8 @@ fn replace_ast(
    match use_trees.as_slice() {
        [name] => {
            if let Some(end_path) = name.path() {
-                let replacement = ast::make::use_tree(
+                let replacement = make::use_tree(
-                    ast::make::path_from_text(&format!("{}::{}", path, end_path)),
+                    make::path_from_text(&format!("{}::{}", path, end_path)),
                    None,
                    None,
                    false,
@@ -273,15 +280,12 @@ fn replace_ast(
        }
        names => {
            let replacement = match parent {
-                Either::Left(_) => ast::make::use_tree(
+                Either::Left(_) => {
-                    path,
+                    make::use_tree(path, Some(make::use_tree_list(names.to_owned())), None, false)
-                    Some(ast::make::use_tree_list(names.to_owned())),
+                        .syntax()
-                    None,
+                        .clone()
-                    false,
+                }
-                )
+                Either::Right(_) => make::use_tree_list(names.to_owned()).syntax().clone(),
-                .syntax()
-                .clone(),
-                Either::Right(_) => ast::make::use_tree_list(names.to_owned()).syntax().clone(),
            };
            algo::diff(
diff --git a/crates/assists/src/handlers/extract_struct_from_enum_variant.rs b/crates/assists/src/handlers/extract_struct_from_enum_variant.rs
index 8ac20210a..3ea50f375 100644
--- a/crates/assists/src/handlers/extract_struct_from_enum_variant.rs
+++ b/crates/assists/src/handlers/extract_struct_from_enum_variant.rs
@@ -10,9 +10,10 @@ use syntax::{
 };
 use crate::{
-    assist_context::AssistBuilder, utils::insert_use_statement, AssistContext, AssistId,
+    assist_context::AssistBuilder, utils::insert_use, AssistContext, AssistId, AssistKind, Assists,
-    AssistKind, Assists,
 };
+use ast::make;
+use insert_use::ImportScope;
 // Assist: extract_struct_from_enum_variant
 //
@@ -94,6 +95,7 @@ fn existing_struct_def(db: &RootDatabase, variant_name: &str, variant: &EnumVari
        .any(|(name, _)| name.to_string() == variant_name.to_string())
 }
+#[allow(dead_code)]
 fn insert_import(
    ctx: &AssistContext,
    builder: &mut AssistBuilder,
@@ -107,12 +109,16 @@ fn insert_import(
    if let Some(mut mod_path) = mod_path {
        mod_path.segments.pop();
        mod_path.segments.push(variant_hir_name.clone());
-        insert_use_statement(
+        let scope = ImportScope::find_insert_use_container(path.syntax(), ctx)?;
-            path.syntax(),
+        let syntax = scope.as_syntax_node();
-            &mod_path.to_string(),
-            ctx,
+        let new_syntax = insert_use(
-            builder.text_edit_builder(),
+            &scope,
+            make::path_from_text(&mod_path.to_string()),
+            ctx.config.insert_use.merge,
        );
+        // FIXME: this will currently panic as multiple imports will have overlapping text ranges
+        builder.replace(syntax.text_range(), new_syntax.to_string())
    }
    Some(())
 }
@@ -167,9 +173,9 @@ fn update_reference(
    builder: &mut AssistBuilder,
    reference: Reference,
    source_file: &SourceFile,
-    enum_module_def: &ModuleDef,
+    _enum_module_def: &ModuleDef,
-    variant_hir_name: &Name,
+    _variant_hir_name: &Name,
-    visited_modules_set: &mut FxHashSet<Module>,
+    _visited_modules_set: &mut FxHashSet<Module>,
 ) -> Option<()> {
    let path_expr: ast::PathExpr = find_node_at_offset::<ast::PathExpr>(
        source_file.syntax(),
@@ -178,13 +184,14 @@ fn update_reference(
    let call = path_expr.syntax().parent().and_then(ast::CallExpr::cast)?;
    let list = call.arg_list()?;
    let segment = path_expr.path()?.segment()?;
-    let module = ctx.sema.scope(&path_expr.syntax()).module()?;
+    let _module = ctx.sema.scope(&path_expr.syntax()).module()?;
    let list_range = list.syntax().text_range();
    let inside_list_range = TextRange::new(
        list_range.start().checked_add(TextSize::from(1))?,
        list_range.end().checked_sub(TextSize::from(1))?,
    );
    builder.edit_file(reference.file_range.file_id);
+    /* FIXME: this most likely requires AST-based editing, see `insert_import`
    if !visited_modules_set.contains(&module) {
        if insert_import(ctx, builder, &path_expr, &module, enum_module_def, variant_hir_name)
            .is_some()
@@ -192,6 +199,7 @@ fn update_reference(
            visited_modules_set.insert(module);
        }
    }
+    */
    builder.replace(inside_list_range, format!("{}{}", segment, list));
    Some(())
 }
@@ -250,6 +258,7 @@ pub enum A { One(One) }"#,
    }
    #[test]
+    #[ignore] // FIXME: this currently panics if `insert_import` is used
    fn test_extract_struct_with_complex_imports() {
        check_assist(
            extract_struct_from_enum_variant,
diff --git a/crates/assists/src/handlers/merge_imports.rs b/crates/assists/src/handlers/merge_imports.rs
index 35b884206..fe33cee53 100644
--- a/crates/assists/src/handlers/merge_imports.rs
+++ b/crates/assists/src/handlers/merge_imports.rs
@@ -1,14 +1,14 @@
-use std::iter::successors;
 use syntax::{
-    algo::{neighbor, skip_trivia_token, SyntaxRewriter},
+    algo::{neighbor, SyntaxRewriter},
-    ast::{self, edit::AstNodeEdit, make},
+    ast, AstNode,
-    AstNode, Direction, InsertPosition, SyntaxElement, T,
 };
 use crate::{
    assist_context::{AssistContext, Assists},
-    utils::next_prev,
+    utils::{
+        insert_use::{try_merge_imports, try_merge_trees},
+        next_prev, MergeBehaviour,
+    },
    AssistId, AssistKind,
 };
@@ -30,23 +30,22 @@ pub(crate) fn merge_imports(acc: &mut Assists, ctx: &AssistContext) -> Option<()
    let mut offset = ctx.offset();
    if let Some(use_item) = tree.syntax().parent().and_then(ast::Use::cast) {
-        let (merged, to_delete) = next_prev()
+        let (merged, to_delete) =
-            .filter_map(|dir| neighbor(&use_item, dir))
+            next_prev().filter_map(|dir| neighbor(&use_item, dir)).find_map(|use_item2| {
-            .filter_map(|it| Some((it.clone(), it.use_tree()?)))
+                try_merge_imports(&use_item, &use_item2, MergeBehaviour::Full).zip(Some(use_item2))
-            .find_map(|(use_item, use_tree)| {
-                Some((try_merge_trees(&tree, &use_tree)?, use_item))
            })?;
-        rewriter.replace_ast(&tree, &merged);
+        rewriter.replace_ast(&use_item, &merged);
        rewriter += to_delete.remove();
        if to_delete.syntax().text_range().end() < offset {
            offset -= to_delete.syntax().text_range().len();
        }
    } else {
-        let (merged, to_delete) = next_prev()
+        let (merged, to_delete) =
-            .filter_map(|dir| neighbor(&tree, dir))
+            next_prev().filter_map(|dir| neighbor(&tree, dir)).find_map(|use_tree| {
-            .find_map(|use_tree| Some((try_merge_trees(&tree, &use_tree)?, use_tree.clone())))?;
+                try_merge_trees(&tree, &use_tree, MergeBehaviour::Full).zip(Some(use_tree))
+            })?;
        rewriter.replace_ast(&tree, &merged);
        rewriter += to_delete.remove();
@@ -67,66 +66,6 @@ pub(crate) fn merge_imports(acc: &mut Assists, ctx: &AssistContext) -> Option<()
    )
 }
-fn try_merge_trees(old: &ast::UseTree, new: &ast::UseTree) -> Option<ast::UseTree> {
-    let lhs_path = old.path()?;
-    let rhs_path = new.path()?;
-    let (lhs_prefix, rhs_prefix) = common_prefix(&lhs_path, &rhs_path)?;
-    let lhs = old.split_prefix(&lhs_prefix);
-    let rhs = new.split_prefix(&rhs_prefix);
-    let should_insert_comma = lhs
-        .use_tree_list()?
-        .r_curly_token()
-        .and_then(|it| skip_trivia_token(it.prev_token()?, Direction::Prev))
-        .map(|it| it.kind() != T![,])
-        .unwrap_or(true);
-    let mut to_insert: Vec<SyntaxElement> = Vec::new();
-    if should_insert_comma {
-        to_insert.push(make::token(T![,]).into());
-        to_insert.push(make::tokens::single_space().into());
-    }
-    to_insert.extend(
-        rhs.use_tree_list()?
-            .syntax()
-            .children_with_tokens()
-            .filter(|it| it.kind() != T!['{'] && it.kind() != T!['}']),
-    );
-    let use_tree_list = lhs.use_tree_list()?;
-    let pos = InsertPosition::Before(use_tree_list.r_curly_token()?.into());
-    let use_tree_list = use_tree_list.insert_children(pos, to_insert);
-    Some(lhs.with_use_tree_list(use_tree_list))
-}
-fn common_prefix(lhs: &ast::Path, rhs: &ast::Path) -> Option<(ast::Path, ast::Path)> {
-    let mut res = None;
-    let mut lhs_curr = first_path(&lhs);
-    let mut rhs_curr = first_path(&rhs);
-    loop {
-        match (lhs_curr.segment(), rhs_curr.segment()) {
-            (Some(lhs), Some(rhs)) if lhs.syntax().text() == rhs.syntax().text() => (),
-            _ => break,
-        }
-        res = Some((lhs_curr.clone(), rhs_curr.clone()));
-        match (lhs_curr.parent_path(), rhs_curr.parent_path()) {
-            (Some(lhs), Some(rhs)) => {
-                lhs_curr = lhs;
-                rhs_curr = rhs;
-            }
-            _ => break,
-        }
-    }
-    res
-}
-fn first_path(path: &ast::Path) -> ast::Path {
-    successors(Some(path.clone()), |it| it.qualifier()).last().unwrap()
-}
 #[cfg(test)]
 mod tests {
    use crate::tests::{check_assist, check_assist_not_applicable};
@@ -156,7 +95,7 @@ use std::fmt::Debug;
 use std::fmt<|>::Display;
 ",
            r"
-use std::fmt::{Display, Debug};
+use std::fmt::{Debug, Display};
 ",
        );
    }
@@ -183,12 +122,84 @@ use std::fmt::{self, Display};
 use std::{fmt, <|>fmt::Display};
 ",
            r"
-use std::{fmt::{Display, self}};
+use std::{fmt::{self, Display}};
 ",
        );
    }
    #[test]
+    fn skip_pub1() {
+        check_assist_not_applicable(
+            merge_imports,
+            r"
+pub use std::fmt<|>::Debug;
+use std::fmt::Display;
+",
+        );
+    }
+    #[test]
+    fn skip_pub_last() {
+        check_assist_not_applicable(
+            merge_imports,
+            r"
+use std::fmt<|>::Debug;
+pub use std::fmt::Display;
+",
+        );
+    }
+    #[test]
+    fn skip_pub_crate_pub() {
+        check_assist_not_applicable(
+            merge_imports,
+            r"
+pub(crate) use std::fmt<|>::Debug;
+pub use std::fmt::Display;
+",
+        );
+    }
+    #[test]
+    fn skip_pub_pub_crate() {
+        check_assist_not_applicable(
+            merge_imports,
+            r"
+pub use std::fmt<|>::Debug;
+pub(crate) use std::fmt::Display;
+",
+        );
+    }
+    #[test]
+    fn merge_pub() {
+        check_assist(
+            merge_imports,
+            r"
+pub use std::fmt<|>::Debug;
+pub use std::fmt::Display;
+",
+            r"
+pub use std::fmt::{Debug, Display};
+",
+        )
+    }
+    #[test]
+    fn merge_pub_crate() {
+        check_assist(
+            merge_imports,
+            r"
+pub(crate) use std::fmt<|>::Debug;
+pub(crate) use std::fmt::Display;
+",
+            r"
+pub(crate) use std::fmt::{Debug, Display};
+",
+        )
+    }
+    #[test]
    fn test_merge_nested() {
        check_assist(
            merge_imports,
@@ -199,13 +210,17 @@ use std::{fmt<|>::Debug, fmt::Display};
 use std::{fmt::{Debug, Display}};
 ",
        );
+    }
+    #[test]
+    fn test_merge_nested2() {
        check_assist(
            merge_imports,
            r"
 use std::{fmt::Debug, fmt<|>::Display};
 ",
            r"
-use std::{fmt::{Display, Debug}};
+use std::{fmt::{Debug, Display}};
 ",
        );
    }
@@ -299,9 +314,7 @@ use foo::<|>{
 };
 ",
            r"
-use foo::{
+use foo::{FooBar, bar::baz};
-    FooBar,
-bar::baz};
 ",
        )
    }
diff --git a/crates/assists/src/handlers/remove_dbg.rs b/crates/assists/src/handlers/remove_dbg.rs
index 4e252edf0..a8ab2aecc 100644
--- a/crates/assists/src/handlers/remove_dbg.rs
+++ b/crates/assists/src/handlers/remove_dbg.rs
@@ -1,6 +1,6 @@
 use syntax::{
    ast::{self, AstNode},
-    TextRange, TextSize, T,
+    SyntaxElement, TextRange, TextSize, T,
 };
 use crate::{AssistContext, AssistId, AssistKind, Assists};
@@ -22,62 +22,108 @@ use crate::{AssistContext, AssistId, AssistKind, Assists};
 // ```
 pub(crate) fn remove_dbg(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
    let macro_call = ctx.find_node_at_offset::<ast::MacroCall>()?;
+    let new_contents = adjusted_macro_contents(&macro_call)?;
-    if !is_valid_macrocall(&macro_call, "dbg")? {
+    let macro_text_range = macro_call.syntax().text_range();
-        return None;
-    }
-    let is_leaf = macro_call.syntax().next_sibling().is_none();
    let macro_end = if macro_call.semicolon_token().is_some() {
-        macro_call.syntax().text_range().end() - TextSize::of(';')
+        macro_text_range.end() - TextSize::of(';')
    } else {
-        macro_call.syntax().text_range().end()
+        macro_text_range.end()
    };
-    // macro_range determines what will be deleted and replaced with macro_content
+    acc.add(
-    let macro_range = TextRange::new(macro_call.syntax().text_range().start(), macro_end);
+        AssistId("remove_dbg", AssistKind::Refactor),
-    let paste_instead_of_dbg = {
+        "Remove dbg!()",
-        let text = macro_call.token_tree()?.syntax().text();
+        macro_text_range,
+        |builder| {
-        // leafiness determines if we should include the parenthesis or not
+            builder.replace(TextRange::new(macro_text_range.start(), macro_end), new_contents);
-        let slice_index: TextRange = if is_leaf {
+        },
-            // leaf means - we can extract the contents of the dbg! in text
+    )
-            TextRange::new(TextSize::of('('), text.len() - TextSize::of(')'))
+}
-        } else {
-            // not leaf - means we should keep the parens
-            TextRange::up_to(text.len())
-        };
-        text.slice(slice_index).to_string()
-    };
-    let target = macro_call.syntax().text_range();
+fn adjusted_macro_contents(macro_call: &ast::MacroCall) -> Option<String> {
-    acc.add(AssistId("remove_dbg", AssistKind::Refactor), "Remove dbg!()", target, |builder| {
+    let contents = get_valid_macrocall_contents(&macro_call, "dbg")?;
-        builder.replace(macro_range, paste_instead_of_dbg);
+    let macro_text_with_brackets = macro_call.token_tree()?.syntax().text();
+    let macro_text_in_brackets = macro_text_with_brackets.slice(TextRange::new(
+        TextSize::of('('),
+        macro_text_with_brackets.len() - TextSize::of(')'),
+    ));
+    let is_leaf = macro_call.syntax().next_sibling().is_none();
+    Some(if !is_leaf && needs_parentheses_around_macro_contents(contents) {
+        format!("({})", macro_text_in_brackets)
+    } else {
+        macro_text_in_brackets.to_string()
    })
 }
 /// Verifies that the given macro_call actually matches the given name
-/// and contains proper ending tokens
+/// and contains proper ending tokens, then returns the contents between the ending tokens
-fn is_valid_macrocall(macro_call: &ast::MacroCall, macro_name: &str) -> Option<bool> {
+fn get_valid_macrocall_contents(
+    macro_call: &ast::MacroCall,
+    macro_name: &str,
+) -> Option<Vec<SyntaxElement>> {
    let path = macro_call.path()?;
    let name_ref = path.segment()?.name_ref()?;
    // Make sure it is actually a dbg-macro call, dbg followed by !
    let excl = path.syntax().next_sibling_or_token()?;
    if name_ref.text() != macro_name || excl.kind() != T![!] {
        return None;
    }
-    let node = macro_call.token_tree()?.syntax().clone();
+    let mut children_with_tokens = macro_call.token_tree()?.syntax().children_with_tokens();
-    let first_child = node.first_child_or_token()?;
+    let first_child = children_with_tokens.next()?;
-    let last_child = node.last_child_or_token()?;
+    let mut contents_between_brackets = children_with_tokens.collect::<Vec<_>>();
+    let last_child = contents_between_brackets.pop()?;
+    if contents_between_brackets.is_empty() {
+        None
+    } else {
+        match (first_child.kind(), last_child.kind()) {
+            (T!['('], T![')']) | (T!['['], T![']']) | (T!['{'], T!['}']) => {
+                Some(contents_between_brackets)
+            }
+            _ => None,
+        }
+    }
+}
-    match (first_child.kind(), last_child.kind()) {
+fn needs_parentheses_around_macro_contents(macro_contents: Vec<SyntaxElement>) -> bool {
-        (T!['('], T![')']) | (T!['['], T![']']) | (T!['{'], T!['}']) => Some(true),
+    if macro_contents.len() < 2 {
-        _ => Some(false),
+        return false;
    }
+    let mut unpaired_brackets_in_contents = Vec::new();
+    for element in macro_contents {
+        match element.kind() {
+            T!['('] | T!['['] | T!['{'] => unpaired_brackets_in_contents.push(element),
+            T![')'] => {
+                if !matches!(unpaired_brackets_in_contents.pop(), Some(correct_bracket) if correct_bracket.kind() == T!['('])
+                {
+                    return true;
+                }
+            }
+            T![']'] => {
+                if !matches!(unpaired_brackets_in_contents.pop(), Some(correct_bracket) if correct_bracket.kind() == T!['['])
+                {
+                    return true;
+                }
+            }
+            T!['}'] => {
+                if !matches!(unpaired_brackets_in_contents.pop(), Some(correct_bracket) if correct_bracket.kind() == T!['{'])
+                {
+                    return true;
+                }
+            }
+            symbol_kind => {
+                let symbol_not_in_bracket = unpaired_brackets_in_contents.is_empty();
+                if symbol_not_in_bracket && symbol_kind.is_punct() {
+                    return true;
+                }
+            }
+        }
+    }
+    !unpaired_brackets_in_contents.is_empty()
 }
 #[cfg(test)]
@@ -157,12 +203,38 @@ fn foo(n: usize) {
    }
    #[test]
+    fn remove_dbg_from_non_leaf_simple_expression() {
+        check_assist(
+            remove_dbg,
+            "
+fn main() {
+    let mut a = 1;
+    while dbg!<|>(a) < 10000 {
+        a += 1;
+    }
+}
+",
+            "
+fn main() {
+    let mut a = 1;
+    while a < 10000 {
+        a += 1;
+    }
+}
+",
+        );
+    }
+    #[test]
    fn test_remove_dbg_keep_expression() {
        check_assist(
            remove_dbg,
            r#"let res = <|>dbg!(a + b).foo();"#,
            r#"let res = (a + b).foo();"#,
        );
+        check_assist(remove_dbg, r#"let res = <|>dbg!(2 + 2) * 5"#, r#"let res = (2 + 2) * 5"#);
+        check_assist(remove_dbg, r#"let res = <|>dbg![2 + 2] * 5"#, r#"let res = (2 + 2) * 5"#);
    }
    #[test]
diff --git a/crates/assists/src/handlers/replace_impl_trait_with_generic.rs b/crates/assists/src/handlers/replace_impl_trait_with_generic.rs
new file mode 100644
index 000000000..6738bc134
--- /dev/null
+++ b/crates/assists/src/handlers/replace_impl_trait_with_generic.rs
@@ -0,0 +1,168 @@
+use syntax::ast::{self, edit::AstNodeEdit, make, AstNode, GenericParamsOwner};
+use crate::{AssistContext, AssistId, AssistKind, Assists};
+// Assist: replace_impl_trait_with_generic
+//
+// Replaces `impl Trait` function argument with the named generic.
+//
+// ```
+// fn foo(bar: <|>impl Bar) {}
+// ```
+// ->
+// ```
+// fn foo<B: Bar>(bar: B) {}
+// ```
+pub(crate) fn replace_impl_trait_with_generic(
+    acc: &mut Assists,
+    ctx: &AssistContext,
+) -> Option<()> {
+    let type_impl_trait = ctx.find_node_at_offset::<ast::ImplTraitType>()?;
+    let type_param = type_impl_trait.syntax().parent().and_then(ast::Param::cast)?;
+    let type_fn = type_param.syntax().ancestors().find_map(ast::Fn::cast)?;
+    let impl_trait_ty = type_impl_trait.type_bound_list()?;
+    let target = type_fn.syntax().text_range();
+    acc.add(
+        AssistId("replace_impl_trait_with_generic", AssistKind::RefactorRewrite),
+        "Replace impl trait with generic",
+        target,
+        |edit| {
+            let generic_letter = impl_trait_ty.to_string().chars().next().unwrap().to_string();
+            let generic_param_list = type_fn
+                .generic_param_list()
+                .unwrap_or_else(|| make::generic_param_list(None))
+                .append_param(make::generic_param(generic_letter.clone(), Some(impl_trait_ty)));
+            let new_type_fn = type_fn
+                .replace_descendant::<ast::Type>(type_impl_trait.into(), make::ty(&generic_letter))
+                .with_generic_param_list(generic_param_list);
+            edit.replace_ast(type_fn.clone(), new_type_fn);
+        },
+    )
+}
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::tests::check_assist;
+    #[test]
+    fn replace_impl_trait_with_generic_params() {
+        check_assist(
+            replace_impl_trait_with_generic,
+            r#"
+            fn foo<G>(bar: <|>impl Bar) {}
+            "#,
+            r#"
+            fn foo<G, B: Bar>(bar: B) {}
+            "#,
+        );
+    }
+    #[test]
+    fn replace_impl_trait_without_generic_params() {
+        check_assist(
+            replace_impl_trait_with_generic,
+            r#"
+            fn foo(bar: <|>impl Bar) {}
+            "#,
+            r#"
+            fn foo<B: Bar>(bar: B) {}
+            "#,
+        );
+    }
+    #[test]
+    fn replace_two_impl_trait_with_generic_params() {
+        check_assist(
+            replace_impl_trait_with_generic,
+            r#"
+            fn foo<G>(foo: impl Foo, bar: <|>impl Bar) {}
+            "#,
+            r#"
+            fn foo<G, B: Bar>(foo: impl Foo, bar: B) {}
+            "#,
+        );
+    }
+    #[test]
+    fn replace_impl_trait_with_empty_generic_params() {
+        check_assist(
+            replace_impl_trait_with_generic,
+            r#"
+            fn foo<>(bar: <|>impl Bar) {}
+            "#,
+            r#"
+            fn foo<B: Bar>(bar: B) {}
+            "#,
+        );
+    }
+    #[test]
+    fn replace_impl_trait_with_empty_multiline_generic_params() {
+        check_assist(
+            replace_impl_trait_with_generic,
+            r#"
+            fn foo<
+            >(bar: <|>impl Bar) {}
+            "#,
+            r#"
+            fn foo<B: Bar
+            >(bar: B) {}
+            "#,
+        );
+    }
+    #[test]
+    #[ignore = "This case is very rare but there is no simple solutions to fix it."]
+    fn replace_impl_trait_with_exist_generic_letter() {
+        check_assist(
+            replace_impl_trait_with_generic,
+            r#"
+            fn foo<B>(bar: <|>impl Bar) {}
+            "#,
+            r#"
+            fn foo<B, C: Bar>(bar: C) {}
+            "#,
+        );
+    }
+    #[test]
+    fn replace_impl_trait_with_multiline_generic_params() {
+        check_assist(
+            replace_impl_trait_with_generic,
+            r#"
+            fn foo<
+                G: Foo,
+                F,
+                H,
+            >(bar: <|>impl Bar) {}
+            "#,
+            r#"
+            fn foo<
+                G: Foo,
+                F,
+                H, B: Bar
+            >(bar: B) {}
+            "#,
+        );
+    }
+    #[test]
+    fn replace_impl_trait_multiple() {
+        check_assist(
+            replace_impl_trait_with_generic,
+            r#"
+            fn foo(bar: <|>impl Foo + Bar) {}
+            "#,
+            r#"
+            fn foo<F: Foo + Bar>(bar: F) {}
+            "#,
+        );
+    }
+}
diff --git a/crates/assists/src/handlers/replace_qualified_name_with_use.rs b/crates/assists/src/handlers/replace_qualified_name_with_use.rs
index 470e5f8ff..8ac907707 100644
--- a/crates/assists/src/handlers/replace_qualified_name_with_use.rs
+++ b/crates/assists/src/handlers/replace_qualified_name_with_use.rs
@@ -2,9 +2,10 @@ use syntax::{algo::SyntaxRewriter, ast, match_ast, AstNode, SyntaxNode, TextRang
 use test_utils::mark;
 use crate::{
-    utils::{find_insert_use_container, insert_use_statement},
+    utils::{insert_use, ImportScope},
    AssistContext, AssistId, AssistKind, Assists,
 };
+use ast::make;
 // Assist: replace_qualified_name_with_use
 //
@@ -32,7 +33,7 @@ pub(crate) fn replace_qualified_name_with_use(
        mark::hit!(dont_import_trivial_paths);
        return None;
    }
-    let path_to_import = path.to_string().clone();
+    let path_to_import = path.to_string();
    let path_to_import = match path.segment()?.generic_arg_list() {
        Some(generic_args) => {
            let generic_args_start =
@@ -43,28 +44,26 @@ pub(crate) fn replace_qualified_name_with_use(
    };
    let target = path.syntax().text_range();
+    let scope = ImportScope::find_insert_use_container(path.syntax(), ctx)?;
+    let syntax = scope.as_syntax_node();
    acc.add(
        AssistId("replace_qualified_name_with_use", AssistKind::RefactorRewrite),
        "Replace qualified path with use",
        target,
        |builder| {
-            let container = match find_insert_use_container(path.syntax(), ctx) {
-                Some(c) => c,
-                None => return,
-            };
-            insert_use_statement(
-                path.syntax(),
-                &path_to_import.to_string(),
-                ctx,
-                builder.text_edit_builder(),
-            );
            // Now that we've brought the name into scope, re-qualify all paths that could be
            // affected (that is, all paths inside the node we added the `use` to).
            let mut rewriter = SyntaxRewriter::default();
-            let syntax = container.either(|l| l.syntax().clone(), |r| r.syntax().clone());
+            shorten_paths(&mut rewriter, syntax.clone(), path);
-            shorten_paths(&mut rewriter, syntax, path);
+            let rewritten_syntax = rewriter.rewrite(&syntax);
-            builder.rewrite(rewriter);
+            if let Some(ref import_scope) = ImportScope::from(rewritten_syntax) {
+                let new_syntax = insert_use(
+                    import_scope,
+                    make::path_from_text(path_to_import),
+                    ctx.config.insert_use.merge,
+                );
+                builder.replace(syntax.text_range(), new_syntax.to_string())
+            }
        },
    )
 }
@@ -220,9 +219,10 @@ impl std::fmt::Debug<|> for Foo {
 }
    ",
            r"
-use stdx;
 use std::fmt::Debug;
+use stdx;
 impl Debug for Foo {
 }
    ",
@@ -274,7 +274,7 @@ impl std::io<|> for Foo {
 }
    ",
            r"
-use std::{io, fmt};
+use std::{fmt, io};
 impl io for Foo {
 }
@@ -293,7 +293,7 @@ impl std::fmt::Debug<|> for Foo {
 }
    ",
            r"
-use std::fmt::{self, Debug, };
+use std::fmt::{self, Debug};
 impl Debug for Foo {
 }
@@ -331,7 +331,7 @@ impl std::fmt::nested<|> for Foo {
 }
 ",
            r"
-use std::fmt::{Debug, nested::{Display, self}};
+use std::fmt::{Debug, nested::{self, Display}};
 impl nested for Foo {
 }
@@ -369,7 +369,7 @@ impl std::fmt::nested::Debug<|> for Foo {
 }
 ",
            r"
-use std::fmt::{Debug, nested::{Display, Debug}};
+use std::fmt::{Debug, nested::{Debug, Display}};
 impl Debug for Foo {
 }
@@ -388,7 +388,7 @@ impl std::fmt::nested::Display<|> for Foo {
 }
 ",
            r"
-use std::fmt::{nested::Display, Debug};
+use std::fmt::{Debug, nested::Display};
 impl Display for Foo {
 }
@@ -428,10 +428,7 @@ use crate::{
 fn foo() { crate::ty::lower<|>::trait_env() }
 ",
            r"
-use crate::{
+use crate::{AssocItem, ty::{Substs, Ty, lower}};
-    ty::{Substs, Ty, lower},
-    AssocItem,
-};
 fn foo() { lower::trait_env() }
 ",
@@ -451,6 +448,8 @@ impl foo::Debug<|> for Foo {
            r"
 use std::fmt as foo;
+use foo::Debug;
 impl Debug for Foo {
 }
 ",
@@ -515,6 +514,7 @@ fn main() {
    ",
            r"
 #![allow(dead_code)]
 use std::fmt::Debug;
 fn main() {
@@ -647,9 +647,8 @@ impl std::io<|> for Foo {
 }
    ",
            r"
-use std::io;
 pub use std::fmt;
+use std::io;
 impl io for Foo {
 }
@@ -668,9 +667,8 @@ impl std::io<|> for Foo {
 }
    ",
            r"
-use std::io;
 pub(crate) use std::fmt;
+use std::io;
 impl io for Foo {
 }
diff --git a/crates/assists/src/lib.rs b/crates/assists/src/lib.rs
index 2e0d191a6..cbac53e71 100644
--- a/crates/assists/src/lib.rs
+++ b/crates/assists/src/lib.rs
@@ -155,6 +155,7 @@ mod handlers {
    mod remove_unused_param;
    mod reorder_fields;
    mod replace_if_let_with_match;
+    mod replace_impl_trait_with_generic;
    mod replace_let_with_if_let;
    mod replace_qualified_name_with_use;
    mod replace_unwrap_with_match;
@@ -202,6 +203,7 @@ mod handlers {
            remove_unused_param::remove_unused_param,
            reorder_fields::reorder_fields,
            replace_if_let_with_match::replace_if_let_with_match,
+            replace_impl_trait_with_generic::replace_impl_trait_with_generic,
            replace_let_with_if_let::replace_let_with_if_let,
            replace_qualified_name_with_use::replace_qualified_name_with_use,
            replace_unwrap_with_match::replace_unwrap_with_match,
diff --git a/crates/assists/src/tests/generated.rs b/crates/assists/src/tests/generated.rs
index 04c8fd1f9..27d15adb0 100644
--- a/crates/assists/src/tests/generated.rs
+++ b/crates/assists/src/tests/generated.rs
@@ -815,6 +815,19 @@ fn handle(action: Action) {
 }
 #[test]
+fn doctest_replace_impl_trait_with_generic() {
+    check_doc_test(
+        "replace_impl_trait_with_generic",
+        r#####"
+fn foo(bar: <|>impl Bar) {}
+"#####,
+        r#####"
+fn foo<B: Bar>(bar: B) {}
+"#####,
+    )
+}
+#[test]
 fn doctest_replace_let_with_if_let() {
    check_doc_test(
        "replace_let_with_if_let",
diff --git a/crates/assists/src/utils.rs b/crates/assists/src/utils.rs
index daa7b64f7..b0511ceb6 100644
--- a/crates/assists/src/utils.rs
+++ b/crates/assists/src/utils.rs
@@ -16,7 +16,8 @@ use syntax::{
 use crate::assist_config::SnippetCap;
-pub(crate) use insert_use::{find_insert_use_container, insert_use_statement};
+pub use insert_use::MergeBehaviour;
+pub(crate) use insert_use::{insert_use, ImportScope};
 pub(crate) fn unwrap_trivial_block(block: ast::BlockExpr) -> ast::Expr {
    extract_trivial_expression(&block)
diff --git a/crates/assists/src/utils/insert_use.rs b/crates/assists/src/utils/insert_use.rs
index 49096a67c..09f4a2224 100644
--- a/crates/assists/src/utils/insert_use.rs
+++ b/crates/assists/src/utils/insert_use.rs
@@ -1,546 +1,933 @@
 //! Handle syntactic aspects of inserting a new `use`.
-// FIXME: rewrite according to the plan, outlined in
+use std::{
-// https://github.com/rust-analyzer/rust-analyzer/issues/3301#issuecomment-592931553
+    cmp::Ordering,
+    iter::{self, successors},
-use std::iter::successors;
+};
-use either::Either;
+use ast::{
+    edit::{AstNodeEdit, IndentLevel},
+    PathSegmentKind, VisibilityOwner,
+};
 use syntax::{
-    ast::{self, NameOwner, VisibilityOwner},
+    algo,
-    AstNode, AstToken, Direction, SmolStr,
+    ast::{self, make, AstNode},
-    SyntaxKind::{PATH, PATH_SEGMENT},
+    InsertPosition, SyntaxElement, SyntaxNode,
-    SyntaxNode, SyntaxToken, T,
 };
-use text_edit::TextEditBuilder;
-use crate::assist_context::AssistContext;
-/// Determines the containing syntax node in which to insert a `use` statement affecting `position`.
-pub(crate) fn find_insert_use_container(
-    position: &SyntaxNode,
-    ctx: &AssistContext,
-) -> Option<Either<ast::ItemList, ast::SourceFile>> {
-    ctx.sema.ancestors_with_macros(position.clone()).find_map(|n| {
-        if let Some(module) = ast::Module::cast(n.clone()) {
-            return module.item_list().map(|it| Either::Left(it));
-        }
-        Some(Either::Right(ast::SourceFile::cast(n)?))
-    })
-}
-/// Creates and inserts a use statement for the given path to import.
+#[derive(Debug)]
-/// The use statement is inserted in the scope most appropriate to the
+pub enum ImportScope {
-/// the cursor position given, additionally merged with the existing use imports.
+    File(ast::SourceFile),
-pub(crate) fn insert_use_statement(
+    Module(ast::ItemList),
-    // Ideally the position of the cursor, used to
-    position: &SyntaxNode,
-    path_to_import: &str,
-    ctx: &AssistContext,
-    builder: &mut TextEditBuilder,
-) {
-    let target = path_to_import.split("::").map(SmolStr::new).collect::<Vec<_>>();
-    let container = find_insert_use_container(position, ctx);
-    if let Some(container) = container {
-        let syntax = container.either(|l| l.syntax().clone(), |r| r.syntax().clone());
-        let action = best_action_for_target(syntax, position.clone(), &target);
-        make_assist(&action, &target, builder);
-    }
 }
-fn collect_path_segments_raw(
+impl ImportScope {
-    segments: &mut Vec<ast::PathSegment>,
+    pub fn from(syntax: SyntaxNode) -> Option<Self> {
-    mut path: ast::Path,
+        if let Some(module) = ast::Module::cast(syntax.clone()) {
-) -> Option<usize> {
+            module.item_list().map(ImportScope::Module)
-    let oldlen = segments.len();
+        } else if let this @ Some(_) = ast::SourceFile::cast(syntax.clone()) {
-    loop {
+            this.map(ImportScope::File)
-        let mut children = path.syntax().children_with_tokens();
+        } else {
-        let (first, second, third) = (
+            ast::ItemList::cast(syntax).map(ImportScope::Module)
-            children.next().map(|n| (n.clone(), n.kind())),
-            children.next().map(|n| (n.clone(), n.kind())),
-            children.next().map(|n| (n.clone(), n.kind())),
-        );
-        match (first, second, third) {
-            (Some((subpath, PATH)), Some((_, T![::])), Some((segment, PATH_SEGMENT))) => {
-                path = ast::Path::cast(subpath.as_node()?.clone())?;
-                segments.push(ast::PathSegment::cast(segment.as_node()?.clone())?);
-            }
-            (Some((segment, PATH_SEGMENT)), _, _) => {
-                segments.push(ast::PathSegment::cast(segment.as_node()?.clone())?);
-                break;
-            }
-            (_, _, _) => return None,
        }
    }
-    // We need to reverse only the new added segments
-    let only_new_segments = segments.split_at_mut(oldlen).1;
-    only_new_segments.reverse();
-    Some(segments.len() - oldlen)
-}
-fn fmt_segments_raw(segments: &[SmolStr], buf: &mut String) {
+    /// Determines the containing syntax node in which to insert a `use` statement affecting `position`.
-    let mut iter = segments.iter();
+    pub(crate) fn find_insert_use_container(
-    if let Some(s) = iter.next() {
+        position: &SyntaxNode,
-        buf.push_str(s);
+        ctx: &crate::assist_context::AssistContext,
-    }
+    ) -> Option<Self> {
-    for s in iter {
+        ctx.sema.ancestors_with_macros(position.clone()).find_map(Self::from)
-        buf.push_str("::");
-        buf.push_str(s);
    }
-}
-/// Returns the number of common segments.
-fn compare_path_segments(left: &[SmolStr], right: &[ast::PathSegment]) -> usize {
-    left.iter().zip(right).take_while(|(l, r)| compare_path_segment(l, r)).count()
-}
-fn compare_path_segment(a: &SmolStr, b: &ast::PathSegment) -> bool {
+    pub(crate) fn as_syntax_node(&self) -> &SyntaxNode {
-    if let Some(kb) = b.kind() {
+        match self {
-        match kb {
+            ImportScope::File(file) => file.syntax(),
-            ast::PathSegmentKind::Name(nameref_b) => a == nameref_b.text(),
+            ImportScope::Module(item_list) => item_list.syntax(),
-            ast::PathSegmentKind::SelfKw => a == "self",
-            ast::PathSegmentKind::SuperKw => a == "super",
-            ast::PathSegmentKind::CrateKw => a == "crate",
-            ast::PathSegmentKind::Type { .. } => false, // not allowed in imports
        }
-    } else {
-        false
    }
-}
-fn compare_path_segment_with_name(a: &SmolStr, b: &ast::Name) -> bool {
-    a == b.text()
-}
-#[derive(Clone, Debug)]
+    fn indent_level(&self) -> IndentLevel {
-enum ImportAction {
+        match self {
-    Nothing,
+            ImportScope::File(file) => file.indent_level(),
-    // Add a brand new use statement.
+            ImportScope::Module(item_list) => item_list.indent_level() + 1,
-    AddNewUse {
-        anchor: Option<SyntaxNode>, // anchor node
-        add_after_anchor: bool,
-    },
-    // To split an existing use statement creating a nested import.
-    AddNestedImport {
-        // how may segments matched with the target path
-        common_segments: usize,
-        path_to_split: ast::Path,
-        // the first segment of path_to_split we want to add into the new nested list
-        first_segment_to_split: Option<ast::PathSegment>,
-        // Wether to add 'self' in addition to the target path
-        add_self: bool,
-    },
-    // To add the target path to an existing nested import tree list.
-    AddInTreeList {
-        common_segments: usize,
-        // The UseTreeList where to add the target path
-        tree_list: ast::UseTreeList,
-        add_self: bool,
-    },
-}
-impl ImportAction {
-    fn add_new_use(anchor: Option<SyntaxNode>, add_after_anchor: bool) -> Self {
-        ImportAction::AddNewUse { anchor, add_after_anchor }
-    }
-    fn add_nested_import(
-        common_segments: usize,
-        path_to_split: ast::Path,
-        first_segment_to_split: Option<ast::PathSegment>,
-        add_self: bool,
-    ) -> Self {
-        ImportAction::AddNestedImport {
-            common_segments,
-            path_to_split,
-            first_segment_to_split,
-            add_self,
        }
    }
-    fn add_in_tree_list(
+    fn first_insert_pos(&self) -> (InsertPosition<SyntaxElement>, AddBlankLine) {
-        common_segments: usize,
+        match self {
-        tree_list: ast::UseTreeList,
+            ImportScope::File(_) => (InsertPosition::First, AddBlankLine::AfterTwice),
-        add_self: bool,
+            // don't insert the imports before the item list's opening curly brace
-    ) -> Self {
+            ImportScope::Module(item_list) => item_list
-        ImportAction::AddInTreeList { common_segments, tree_list, add_self }
+                .l_curly_token()
-    }
+                .map(|b| (InsertPosition::After(b.into()), AddBlankLine::Around))
+                .unwrap_or((InsertPosition::First, AddBlankLine::AfterTwice)),
-    fn better(left: ImportAction, right: ImportAction) -> ImportAction {
-        if left.is_better(&right) {
-            left
-        } else {
-            right
        }
    }
-    fn is_better(&self, other: &ImportAction) -> bool {
+    fn insert_pos_after_inner_attribute(&self) -> (InsertPosition<SyntaxElement>, AddBlankLine) {
-        match (self, other) {
+        // check if the scope has inner attributes, we dont want to insert in front of them
-            (ImportAction::Nothing, _) => true,
+        match self
-            (ImportAction::AddInTreeList { .. }, ImportAction::Nothing) => false,
+            .as_syntax_node()
-            (
+            .children()
-                ImportAction::AddNestedImport { common_segments: n, .. },
+            // no flat_map here cause we want to short circuit the iterator
-                ImportAction::AddInTreeList { common_segments: m, .. },
+            .map(ast::Attr::cast)
-            )
+            .take_while(|attr| {
-            | (
+                attr.as_ref().map(|attr| attr.kind() == ast::AttrKind::Inner).unwrap_or(false)
-                ImportAction::AddInTreeList { common_segments: n, .. },
+            })
-                ImportAction::AddNestedImport { common_segments: m, .. },
+            .last()
-            )
+            .flatten()
-            | (
+        {
-                ImportAction::AddInTreeList { common_segments: n, .. },
+            Some(attr) => {
-                ImportAction::AddInTreeList { common_segments: m, .. },
+                (InsertPosition::After(attr.syntax().clone().into()), AddBlankLine::BeforeTwice)
-            )
+            }
-            | (
+            None => self.first_insert_pos(),
-                ImportAction::AddNestedImport { common_segments: n, .. },
-                ImportAction::AddNestedImport { common_segments: m, .. },
-            ) => n > m,
-            (ImportAction::AddInTreeList { .. }, _) => true,
-            (ImportAction::AddNestedImport { .. }, ImportAction::Nothing) => false,
-            (ImportAction::AddNestedImport { .. }, _) => true,
-            (ImportAction::AddNewUse { .. }, _) => false,
        }
    }
 }
-// Find out the best ImportAction to import target path against current_use_tree.
+/// Insert an import path into the given file/node. A `merge` value of none indicates that no import merging is allowed to occur.
-// If current_use_tree has a nested import the function gets called recursively on every UseTree inside a UseTreeList.
+pub(crate) fn insert_use(
-fn walk_use_tree_for_best_action(
+    scope: &ImportScope,
-    current_path_segments: &mut Vec<ast::PathSegment>, // buffer containing path segments
+    path: ast::Path,
-    current_parent_use_tree_list: Option<ast::UseTreeList>, // will be Some value if we are in a nested import
+    merge: Option<MergeBehaviour>,
-    current_use_tree: ast::UseTree, // the use tree we are currently examinating
+) -> SyntaxNode {
-    target: &[SmolStr],             // the path we want to import
+    let use_item = make::use_(make::use_tree(path.clone(), None, None, false));
-) -> ImportAction {
+    // merge into existing imports if possible
-    // We save the number of segments in the buffer so we can restore the correct segments
+    if let Some(mb) = merge {
-    // before returning. Recursive call will add segments so we need to delete them.
+        for existing_use in scope.as_syntax_node().children().filter_map(ast::Use::cast) {
-    let prev_len = current_path_segments.len();
+            if let Some(merged) = try_merge_imports(&existing_use, &use_item, mb) {
+                let to_delete: SyntaxElement = existing_use.syntax().clone().into();
-    let tree_list = current_use_tree.use_tree_list();
+                let to_delete = to_delete.clone()..=to_delete;
-    let alias = current_use_tree.rename();
+                let to_insert = iter::once(merged.syntax().clone().into());
+                return algo::replace_children(scope.as_syntax_node(), to_delete, to_insert);
-    let path = match current_use_tree.path() {
+            }
-        Some(path) => path,
-        None => {
-            // If the use item don't have a path, it means it's broken (syntax error)
-            return ImportAction::add_new_use(
-                current_use_tree
-                    .syntax()
-                    .ancestors()
-                    .find_map(ast::Use::cast)
-                    .map(|it| it.syntax().clone()),
-                true,
-            );
-        }
-    };
-    // This can happen only if current_use_tree is a direct child of a UseItem
-    if let Some(name) = alias.and_then(|it| it.name()) {
-        if compare_path_segment_with_name(&target[0], &name) {
-            return ImportAction::Nothing;
        }
    }
-    collect_path_segments_raw(current_path_segments, path.clone());
+    // either we weren't allowed to merge or there is no import that fits the merge conditions
+    // so look for the place we have to insert to
-    // We compare only the new segments added in the line just above.
+    let (insert_position, add_blank) = find_insert_position(scope, path);
-    // The first prev_len segments were already compared in 'parent' recursive calls.
-    let left = target.split_at(prev_len).1;
+    let to_insert: Vec<SyntaxElement> = {
-    let right = current_path_segments.split_at(prev_len).1;
+        let mut buf = Vec::new();
-    let common = compare_path_segments(left, &right);
-    let mut action = match common {
+        match add_blank {
-        0 => ImportAction::add_new_use(
+            AddBlankLine::Before | AddBlankLine::Around => {
-            // e.g: target is std::fmt and we can have
+                buf.push(make::tokens::single_newline().into())
-            // use foo::bar
-            // We add a brand new use statement
-            current_use_tree
-                .syntax()
-                .ancestors()
-                .find_map(ast::Use::cast)
-                .map(|it| it.syntax().clone()),
-            true,
-        ),
-        common if common == left.len() && left.len() == right.len() => {
-            // e.g: target is std::fmt and we can have
-            // 1- use std::fmt;
-            // 2- use std::fmt::{ ... }
-            if let Some(list) = tree_list {
-                // In case 2 we need to add self to the nested list
-                // unless it's already there
-                let has_self = list.use_trees().map(|it| it.path()).any(|p| {
-                    p.and_then(|it| it.segment())
-                        .and_then(|it| it.kind())
-                        .filter(|k| *k == ast::PathSegmentKind::SelfKw)
-                        .is_some()
-                });
-                if has_self {
-                    ImportAction::Nothing
-                } else {
-                    ImportAction::add_in_tree_list(current_path_segments.len(), list, true)
-                }
-            } else {
-                // Case 1
-                ImportAction::Nothing
            }
+            AddBlankLine::BeforeTwice => buf.push(make::tokens::blank_line().into()),
+            _ => (),
        }
-        common if common != left.len() && left.len() == right.len() => {
-            // e.g: target is std::fmt and we have
+        if let ident_level @ 1..=usize::MAX = scope.indent_level().0 as usize {
-            // use std::io;
+            buf.push(make::tokens::whitespace(&" ".repeat(4 * ident_level)).into());
-            // We need to split.
-            let segments_to_split = current_path_segments.split_at(prev_len + common).1;
-            ImportAction::add_nested_import(
-                prev_len + common,
-                path,
-                Some(segments_to_split[0].clone()),
-                false,
-            )
        }
-        common if common == right.len() && left.len() > right.len() => {
+        buf.push(use_item.syntax().clone().into());
-            // e.g: target is std::fmt and we can have
-            // 1- use std;
+        match add_blank {
-            // 2- use std::{ ... };
+            AddBlankLine::After | AddBlankLine::Around => {
+                buf.push(make::tokens::single_newline().into())
-            // fallback action
-            let mut better_action = ImportAction::add_new_use(
-                current_use_tree
-                    .syntax()
-                    .ancestors()
-                    .find_map(ast::Use::cast)
-                    .map(|it| it.syntax().clone()),
-                true,
-            );
-            if let Some(list) = tree_list {
-                // Case 2, check recursively if the path is already imported in the nested list
-                for u in list.use_trees() {
-                    let child_action = walk_use_tree_for_best_action(
-                        current_path_segments,
-                        Some(list.clone()),
-                        u,
-                        target,
-                    );
-                    if child_action.is_better(&better_action) {
-                        better_action = child_action;
-                        if let ImportAction::Nothing = better_action {
-                            return better_action;
-                        }
-                    }
-                }
-            } else {
-                // Case 1, split adding self
-                better_action = ImportAction::add_nested_import(prev_len + common, path, None, true)
            }
-            better_action
+            AddBlankLine::AfterTwice => buf.push(make::tokens::blank_line().into()),
+            _ => (),
        }
-        common if common == left.len() && left.len() < right.len() => {
-            // e.g: target is std::fmt and we can have
-            // use std::fmt::Debug;
-            let segments_to_split = current_path_segments.split_at(prev_len + common).1;
-            ImportAction::add_nested_import(
-                prev_len + common,
-                path,
-                Some(segments_to_split[0].clone()),
-                true,
-            )
-        }
-        common if common < left.len() && common < right.len() => {
-            // e.g: target is std::fmt::nested::Debug
-            // use std::fmt::Display
-            let segments_to_split = current_path_segments.split_at(prev_len + common).1;
-            ImportAction::add_nested_import(
-                prev_len + common,
-                path,
-                Some(segments_to_split[0].clone()),
-                false,
-            )
-        }
-        _ => unreachable!(),
-    };
-    // If we are inside a UseTreeList adding a use statement become adding to the existing
+        buf
-    // tree list.
-    action = match (current_parent_use_tree_list, action.clone()) {
-        (Some(use_tree_list), ImportAction::AddNewUse { .. }) => {
-            ImportAction::add_in_tree_list(prev_len, use_tree_list, false)
-        }
-        (_, _) => action,
    };
-    // We remove the segments added
+    algo::insert_children(scope.as_syntax_node(), insert_position, to_insert)
-    current_path_segments.truncate(prev_len);
-    action
 }
-fn best_action_for_target(
+fn eq_visibility(vis0: Option<ast::Visibility>, vis1: Option<ast::Visibility>) -> bool {
-    container: SyntaxNode,
+    match (vis0, vis1) {
-    anchor: SyntaxNode,
+        (None, None) => true,
-    target: &[SmolStr],
+        // FIXME: Don't use the string representation to check for equality
-) -> ImportAction {
+        // spaces inside of the node would break this comparison
-    let mut storage = Vec::with_capacity(16); // this should be the only allocation
+        (Some(vis0), Some(vis1)) => vis0.to_string() == vis1.to_string(),
-    let best_action = container
+        _ => false,
-        .children()
+    }
-        .filter_map(ast::Use::cast)
+}
-        .filter(|u| u.visibility().is_none())
-        .filter_map(|it| it.use_tree())
-        .map(|u| walk_use_tree_for_best_action(&mut storage, None, u, target))
-        .fold(None, |best, a| match best {
-            Some(best) => Some(ImportAction::better(best, a)),
-            None => Some(a),
-        });
-    match best_action {
-        Some(action) => action,
-        None => {
-            // We have no action and no UseItem was found in container so we find
-            // another item and we use it as anchor.
-            // If there are no items above, we choose the target path itself as anchor.
-            // todo: we should include even whitespace blocks as anchor candidates
-            let anchor = container.children().next().or_else(|| Some(anchor));
-            let add_after_anchor = anchor
+pub(crate) fn try_merge_imports(
-                .clone()
+    lhs: &ast::Use,
-                .and_then(ast::Attr::cast)
+    rhs: &ast::Use,
-                .map(|attr| attr.kind() == ast::AttrKind::Inner)
+    merge_behaviour: MergeBehaviour,
-                .unwrap_or(false);
+) -> Option<ast::Use> {
-            ImportAction::add_new_use(anchor, add_after_anchor)
+    // don't merge imports with different visibilities
-        }
+    if !eq_visibility(lhs.visibility(), rhs.visibility()) {
+        return None;
    }
+    let lhs_tree = lhs.use_tree()?;
+    let rhs_tree = rhs.use_tree()?;
+    let merged = try_merge_trees(&lhs_tree, &rhs_tree, merge_behaviour)?;
+    Some(lhs.with_use_tree(merged))
 }
-fn make_assist(action: &ImportAction, target: &[SmolStr], edit: &mut TextEditBuilder) {
+pub(crate) fn try_merge_trees(
-    match action {
+    lhs: &ast::UseTree,
-        ImportAction::AddNewUse { anchor, add_after_anchor } => {
+    rhs: &ast::UseTree,
-            make_assist_add_new_use(anchor, *add_after_anchor, target, edit)
+    merge: MergeBehaviour,
-        }
+) -> Option<ast::UseTree> {
-        ImportAction::AddInTreeList { common_segments, tree_list, add_self } => {
+    let lhs_path = lhs.path()?;
-            // We know that the fist n segments already exists in the use statement we want
+    let rhs_path = rhs.path()?;
-            // to modify, so we want to add only the last target.len() - n segments.
-            let segments_to_add = target.split_at(*common_segments).1;
+    let (lhs_prefix, rhs_prefix) = common_prefix(&lhs_path, &rhs_path)?;
-            make_assist_add_in_tree_list(tree_list, segments_to_add, *add_self, edit)
+    let lhs = lhs.split_prefix(&lhs_prefix);
-        }
+    let rhs = rhs.split_prefix(&rhs_prefix);
-        ImportAction::AddNestedImport {
+    recursive_merge(&lhs, &rhs, merge).map(|(merged, _)| merged)
-            common_segments,
+}
-            path_to_split,
-            first_segment_to_split,
+/// Recursively "zips" together lhs and rhs.
-            add_self,
+fn recursive_merge(
-        } => {
+    lhs: &ast::UseTree,
-            let segments_to_add = target.split_at(*common_segments).1;
+    rhs: &ast::UseTree,
-            make_assist_add_nested_import(
+    merge: MergeBehaviour,
-                path_to_split,
+) -> Option<(ast::UseTree, bool)> {
-                first_segment_to_split,
+    let mut use_trees = lhs
-                segments_to_add,
+        .use_tree_list()
-                *add_self,
+        .into_iter()
-                edit,
+        .flat_map(|list| list.use_trees())
-            )
+        // check if any of the use trees are nested, if they are and the behaviour is `last` we are not allowed to merge this
+        // so early exit the iterator by using Option's Intoiterator impl
+        .map(|tree| match merge == MergeBehaviour::Last && tree.use_tree_list().is_some() {
+            true => None,
+            false => Some(tree),
+        })
+        .collect::<Option<Vec<_>>>()?;
+    use_trees.sort_unstable_by(|a, b| path_cmp_opt(a.path(), b.path()));
+    for rhs_t in rhs.use_tree_list().into_iter().flat_map(|list| list.use_trees()) {
+        let rhs_path = rhs_t.path();
+        match use_trees.binary_search_by(|p| path_cmp_opt(p.path(), rhs_path.clone())) {
+            Ok(idx) => {
+                let lhs_t = &mut use_trees[idx];
+                let lhs_path = lhs_t.path()?;
+                let rhs_path = rhs_path?;
+                let (lhs_prefix, rhs_prefix) = common_prefix(&lhs_path, &rhs_path)?;
+                if lhs_prefix == lhs_path && rhs_prefix == rhs_path {
+                    let tree_is_self = |tree: ast::UseTree| {
+                        tree.path().as_ref().map(path_is_self).unwrap_or(false)
+                    };
+                    // check if only one of the two trees has a tree list, and whether that then contains `self` or not.
+                    // If this is the case we can skip this iteration since the path without the list is already included in the other one via `self`
+                    let tree_contains_self = |tree: &ast::UseTree| {
+                        tree.use_tree_list()
+                            .map(|tree_list| tree_list.use_trees().any(tree_is_self))
+                            .unwrap_or(false)
+                    };
+                    match (tree_contains_self(&lhs_t), tree_contains_self(&rhs_t)) {
+                        (true, false) => continue,
+                        (false, true) => {
+                            *lhs_t = rhs_t;
+                            continue;
+                        }
+                        _ => (),
+                    }
+                    // glob imports arent part of the use-tree lists so we need to special handle them here as well
+                    // this special handling is only required for when we merge a module import into a glob import of said module
+                    // see the `merge_self_glob` or `merge_mod_into_glob` tests
+                    if lhs_t.star_token().is_some() || rhs_t.star_token().is_some() {
+                        *lhs_t = make::use_tree(
+                            make::path_unqualified(make::path_segment_self()),
+                            None,
+                            None,
+                            false,
+                        );
+                        use_trees.insert(idx, make::glob_use_tree());
+                        continue;
+                    }
+                }
+                let lhs = lhs_t.split_prefix(&lhs_prefix);
+                let rhs = rhs_t.split_prefix(&rhs_prefix);
+                let this_has_children = use_trees.len() > 0;
+                match recursive_merge(&lhs, &rhs, merge) {
+                    Some((_, has_multiple_children))
+                        if merge == MergeBehaviour::Last
+                            && this_has_children
+                            && has_multiple_children =>
+                    {
+                        return None
+                    }
+                    Some((use_tree, _)) => use_trees[idx] = use_tree,
+                    None => use_trees.insert(idx, rhs_t),
+                }
+            }
+            Err(_)
+                if merge == MergeBehaviour::Last
+                    && use_trees.len() > 0
+                    && rhs_t.use_tree_list().is_some() =>
+            {
+                return None
+            }
+            Err(idx) => {
+                use_trees.insert(idx, rhs_t);
+            }
        }
-        _ => {}
    }
+    let has_multiple_children = use_trees.len() > 1;
+    Some((lhs.with_use_tree_list(make::use_tree_list(use_trees)), has_multiple_children))
 }
-fn make_assist_add_new_use(
+/// Traverses both paths until they differ, returning the common prefix of both.
-    anchor: &Option<SyntaxNode>,
+fn common_prefix(lhs: &ast::Path, rhs: &ast::Path) -> Option<(ast::Path, ast::Path)> {
-    after: bool,
+    let mut res = None;
-    target: &[SmolStr],
+    let mut lhs_curr = first_path(&lhs);
-    edit: &mut TextEditBuilder,
+    let mut rhs_curr = first_path(&rhs);
-) {
+    loop {
-    if let Some(anchor) = anchor {
+        match (lhs_curr.segment(), rhs_curr.segment()) {
-        let indent = leading_indent(anchor);
+            (Some(lhs), Some(rhs)) if lhs.syntax().text() == rhs.syntax().text() => (),
-        let mut buf = String::new();
+            _ => break res,
-        if after {
-            buf.push_str("\n");
-            if let Some(spaces) = &indent {
-                buf.push_str(spaces);
-            }
        }
-        buf.push_str("use ");
+        res = Some((lhs_curr.clone(), rhs_curr.clone()));
-        fmt_segments_raw(target, &mut buf);
-        buf.push_str(";");
+        match lhs_curr.parent_path().zip(rhs_curr.parent_path()) {
-        if !after {
+            Some((lhs, rhs)) => {
-            buf.push_str("\n\n");
+                lhs_curr = lhs;
-            if let Some(spaces) = &indent {
+                rhs_curr = rhs;
-                buf.push_str(&spaces);
            }
+            _ => break res,
        }
-        let position = if after { anchor.text_range().end() } else { anchor.text_range().start() };
-        edit.insert(position, buf);
    }
 }
-fn make_assist_add_in_tree_list(
+fn path_is_self(path: &ast::Path) -> bool {
-    tree_list: &ast::UseTreeList,
+    path.segment().and_then(|seg| seg.self_token()).is_some() && path.qualifier().is_none()
-    target: &[SmolStr],
+}
-    add_self: bool,
-    edit: &mut TextEditBuilder,
+#[inline]
-) {
+fn first_segment(path: &ast::Path) -> Option<ast::PathSegment> {
-    let last = tree_list.use_trees().last();
+    first_path(path).segment()
-    if let Some(last) = last {
+}
-        let mut buf = String::new();
-        let comma = last.syntax().siblings(Direction::Next).find(|n| n.kind() == T![,]);
+fn first_path(path: &ast::Path) -> ast::Path {
-        let offset = if let Some(comma) = comma {
+    successors(Some(path.clone()), ast::Path::qualifier).last().unwrap()
-            comma.text_range().end()
+}
-        } else {
-            buf.push_str(",");
+fn segment_iter(path: &ast::Path) -> impl Iterator<Item = ast::PathSegment> + Clone {
-            last.syntax().text_range().end()
+    // cant make use of SyntaxNode::siblings, because the returned Iterator is not clone
-        };
+    successors(first_segment(path), |p| p.parent_path().parent_path().and_then(|p| p.segment()))
-        if add_self {
+}
-            buf.push_str(" self")
-        } else {
+/// Orders paths in the following way:
-            buf.push_str(" ");
+/// the sole self token comes first, after that come uppercase identifiers, then lowercase identifiers
+// FIXME: rustfmt sort lowercase idents before uppercase, in general we want to have the same ordering rustfmt has
+// which is `self` and `super` first, then identifier imports with lowercase ones first, then glob imports and at last list imports.
+// Example foo::{self, foo, baz, Baz, Qux, *, {Bar}}
+fn path_cmp(a: &ast::Path, b: &ast::Path) -> Ordering {
+    match (path_is_self(a), path_is_self(b)) {
+        (true, true) => Ordering::Equal,
+        (true, false) => Ordering::Less,
+        (false, true) => Ordering::Greater,
+        (false, false) => {
+            let a = segment_iter(a);
+            let b = segment_iter(b);
+            // cmp_by would be useful for us here but that is currently unstable
+            // cmp doesnt work due the lifetimes on text's return type
+            a.zip(b)
+                .flat_map(|(seg, seg2)| seg.name_ref().zip(seg2.name_ref()))
+                .find_map(|(a, b)| match a.text().cmp(b.text()) {
+                    ord @ Ordering::Greater | ord @ Ordering::Less => Some(ord),
+                    Ordering::Equal => None,
+                })
+                .unwrap_or(Ordering::Equal)
        }
-        fmt_segments_raw(target, &mut buf);
-        edit.insert(offset, buf);
-    } else {
    }
 }
-fn make_assist_add_nested_import(
+fn path_cmp_opt(a: Option<ast::Path>, b: Option<ast::Path>) -> Ordering {
-    path: &ast::Path,
+    match (a, b) {
-    first_segment_to_split: &Option<ast::PathSegment>,
+        (None, None) => Ordering::Equal,
-    target: &[SmolStr],
+        (None, Some(_)) => Ordering::Less,
-    add_self: bool,
+        (Some(_), None) => Ordering::Greater,
-    edit: &mut TextEditBuilder,
+        (Some(a), Some(b)) => path_cmp(&a, &b),
-) {
+    }
-    let use_tree = path.syntax().ancestors().find_map(ast::UseTree::cast);
+}
-    if let Some(use_tree) = use_tree {
-        let (start, add_colon_colon) = if let Some(first_segment_to_split) = first_segment_to_split
+/// What type of merges are allowed.
-        {
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
-            (first_segment_to_split.syntax().text_range().start(), false)
+pub enum MergeBehaviour {
-        } else {
+    /// Merge everything together creating deeply nested imports.
-            (use_tree.syntax().text_range().end(), true)
+    Full,
+    /// Only merge the last import level, doesn't allow import nesting.
+    Last,
+}
+#[derive(Eq, PartialEq, PartialOrd, Ord)]
+enum ImportGroup {
+    // the order here defines the order of new group inserts
+    Std,
+    ExternCrate,
+    ThisCrate,
+    ThisModule,
+    SuperModule,
+}
+impl ImportGroup {
+    fn new(path: &ast::Path) -> ImportGroup {
+        let default = ImportGroup::ExternCrate;
+        let first_segment = match first_segment(path) {
+            Some(it) => it,
+            None => return default,
        };
-        let end = use_tree.syntax().text_range().end();
-        let mut buf = String::new();
+        let kind = first_segment.kind().unwrap_or(PathSegmentKind::SelfKw);
-        if add_colon_colon {
+        match kind {
-            buf.push_str("::");
+            PathSegmentKind::SelfKw => ImportGroup::ThisModule,
+            PathSegmentKind::SuperKw => ImportGroup::SuperModule,
+            PathSegmentKind::CrateKw => ImportGroup::ThisCrate,
+            PathSegmentKind::Name(name) => match name.text().as_str() {
+                "std" => ImportGroup::Std,
+                "core" => ImportGroup::Std,
+                // FIXME: can be ThisModule as well
+                _ => ImportGroup::ExternCrate,
+            },
+            PathSegmentKind::Type { .. } => unreachable!(),
        }
-        buf.push_str("{");
-        if add_self {
-            buf.push_str("self, ");
-        }
-        fmt_segments_raw(target, &mut buf);
-        if !target.is_empty() {
-            buf.push_str(", ");
-        }
-        edit.insert(start, buf);
-        edit.insert(end, "}".to_string());
    }
 }
-/// If the node is on the beginning of the line, calculate indent.
+#[derive(PartialEq, Eq)]
-fn leading_indent(node: &SyntaxNode) -> Option<SmolStr> {
+enum AddBlankLine {
-    for token in prev_tokens(node.first_token()?) {
+    Before,
-        if let Some(ws) = ast::Whitespace::cast(token.clone()) {
+    BeforeTwice,
-            let ws_text = ws.text();
+    Around,
-            if let Some(pos) = ws_text.rfind('\n') {
+    After,
-                return Some(ws_text[pos + 1..].into());
+    AfterTwice,
+}
+fn find_insert_position(
+    scope: &ImportScope,
+    insert_path: ast::Path,
+) -> (InsertPosition<SyntaxElement>, AddBlankLine) {
+    let group = ImportGroup::new(&insert_path);
+    let path_node_iter = scope
+        .as_syntax_node()
+        .children()
+        .filter_map(|node| ast::Use::cast(node.clone()).zip(Some(node)))
+        .flat_map(|(use_, node)| use_.use_tree().and_then(|tree| tree.path()).zip(Some(node)));
+    // Iterator that discards anything thats not in the required grouping
+    // This implementation allows the user to rearrange their import groups as this only takes the first group that fits
+    let group_iter = path_node_iter
+        .clone()
+        .skip_while(|(path, _)| ImportGroup::new(path) != group)
+        .take_while(|(path, _)| ImportGroup::new(path) == group);
+    let segments = segment_iter(&insert_path);
+    // track the last element we iterated over, if this is still None after the iteration then that means we never iterated in the first place
+    let mut last = None;
+    // find the element that would come directly after our new import
+    let post_insert =
+        group_iter.inspect(|(_, node)| last = Some(node.clone())).find(|(path, _)| {
+            let check_segments = segment_iter(&path);
+            segments
+                .clone()
+                .zip(check_segments)
+                .flat_map(|(seg, seg2)| seg.name_ref().zip(seg2.name_ref()))
+                .all(|(l, r)| l.text() <= r.text())
+        });
+    match post_insert {
+        // insert our import before that element
+        Some((_, node)) => (InsertPosition::Before(node.into()), AddBlankLine::After),
+        // there is no element after our new import, so append it to the end of the group
+        None => match last {
+            Some(node) => (InsertPosition::After(node.into()), AddBlankLine::Before),
+            // the group we were looking for actually doesnt exist, so insert
+            None => {
+                // similar concept here to the `last` from above
+                let mut last = None;
+                // find the group that comes after where we want to insert
+                let post_group = path_node_iter
+                    .inspect(|(_, node)| last = Some(node.clone()))
+                    .find(|(p, _)| ImportGroup::new(p) > group);
+                match post_group {
+                    Some((_, node)) => {
+                        (InsertPosition::Before(node.into()), AddBlankLine::AfterTwice)
+                    }
+                    // there is no such group, so append after the last one
+                    None => match last {
+                        Some(node) => {
+                            (InsertPosition::After(node.into()), AddBlankLine::BeforeTwice)
+                        }
+                        // there are no imports in this file at all
+                        None => scope.insert_pos_after_inner_attribute(),
+                    },
+                }
            }
-        }
+        },
-        if token.text().contains('\n') {
-            break;
-        }
    }
-    return None;
+}
-    fn prev_tokens(token: SyntaxToken) -> impl Iterator<Item = SyntaxToken> {
-        successors(token.prev_token(), |token| token.prev_token())
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use test_utils::assert_eq_text;
+    #[test]
+    fn insert_start() {
+        check_none(
+            "std::bar::AA",
+            r"
+use std::bar::B;
+use std::bar::D;
+use std::bar::F;
+use std::bar::G;",
+            r"
+use std::bar::AA;
+use std::bar::B;
+use std::bar::D;
+use std::bar::F;
+use std::bar::G;",
+        )
+    }
+    #[test]
+    fn insert_middle() {
+        check_none(
+            "std::bar::EE",
+            r"
+use std::bar::A;
+use std::bar::D;
+use std::bar::F;
+use std::bar::G;",
+            r"
+use std::bar::A;
+use std::bar::D;
+use std::bar::EE;
+use std::bar::F;
+use std::bar::G;",
+        )
+    }
+    #[test]
+    fn insert_end() {
+        check_none(
+            "std::bar::ZZ",
+            r"
+use std::bar::A;
+use std::bar::D;
+use std::bar::F;
+use std::bar::G;",
+            r"
+use std::bar::A;
+use std::bar::D;
+use std::bar::F;
+use std::bar::G;
+use std::bar::ZZ;",
+        )
+    }
+    #[test]
+    fn insert_middle_nested() {
+        check_none(
+            "std::bar::EE",
+            r"
+use std::bar::A;
+use std::bar::{D, Z}; // example of weird imports due to user
+use std::bar::F;
+use std::bar::G;",
+            r"
+use std::bar::A;
+use std::bar::EE;
+use std::bar::{D, Z}; // example of weird imports due to user
+use std::bar::F;
+use std::bar::G;",
+        )
+    }
+    #[test]
+    fn insert_middle_groups() {
+        check_none(
+            "foo::bar::GG",
+            r"
+use std::bar::A;
+use std::bar::D;
+use foo::bar::F;
+use foo::bar::H;",
+            r"
+use std::bar::A;
+use std::bar::D;
+use foo::bar::F;
+use foo::bar::GG;
+use foo::bar::H;",
+        )
+    }
+    #[test]
+    fn insert_first_matching_group() {
+        check_none(
+            "foo::bar::GG",
+            r"
+use foo::bar::A;
+use foo::bar::D;
+use std;
+use foo::bar::F;
+use foo::bar::H;",
+            r"
+use foo::bar::A;
+use foo::bar::D;
+use foo::bar::GG;
+use std;
+use foo::bar::F;
+use foo::bar::H;",
+        )
+    }
+    #[test]
+    fn insert_missing_group_std() {
+        check_none(
+            "std::fmt",
+            r"
+use foo::bar::A;
+use foo::bar::D;",
+            r"
+use std::fmt;
+use foo::bar::A;
+use foo::bar::D;",
+        )
+    }
+    #[test]
+    fn insert_missing_group_self() {
+        check_none(
+            "self::fmt",
+            r"
+use foo::bar::A;
+use foo::bar::D;",
+            r"
+use foo::bar::A;
+use foo::bar::D;
+use self::fmt;",
+        )
+    }
+    #[test]
+    fn insert_no_imports() {
+        check_full(
+            "foo::bar",
+            "fn main() {}",
+            r"use foo::bar;
+fn main() {}",
+        )
+    }
+    #[test]
+    fn insert_empty_file() {
+        // empty files will get two trailing newlines
+        // this is due to the test case insert_no_imports above
+        check_full(
+            "foo::bar",
+            "",
+            r"use foo::bar;
+",
+        )
+    }
+    #[test]
+    fn insert_after_inner_attr() {
+        check_full(
+            "foo::bar",
+            r"#![allow(unused_imports)]",
+            r"#![allow(unused_imports)]
+use foo::bar;",
+        )
+    }
+    #[test]
+    fn insert_after_inner_attr2() {
+        check_full(
+            "foo::bar",
+            r"#![allow(unused_imports)]
+fn main() {}",
+            r"#![allow(unused_imports)]
+use foo::bar;
+fn main() {}",
+        )
+    }
+    #[test]
+    fn merge_groups() {
+        check_last("std::io", r"use std::fmt;", r"use std::{fmt, io};")
+    }
+    #[test]
+    fn merge_groups_last() {
+        check_last(
+            "std::io",
+            r"use std::fmt::{Result, Display};",
+            r"use std::fmt::{Result, Display};
+use std::io;",
+        )
+    }
+    #[test]
+    fn merge_groups_full() {
+        check_full(
+            "std::io",
+            r"use std::fmt::{Result, Display};",
+            r"use std::{fmt::{Result, Display}, io};",
+        )
+    }
+    #[test]
+    fn merge_groups_long_full() {
+        check_full(
+            "std::foo::bar::Baz",
+            r"use std::foo::bar::Qux;",
+            r"use std::foo::bar::{Baz, Qux};",
+        )
+    }
+    #[test]
+    fn merge_groups_long_last() {
+        check_last(
+            "std::foo::bar::Baz",
+            r"use std::foo::bar::Qux;",
+            r"use std::foo::bar::{Baz, Qux};",
+        )
+    }
+    #[test]
+    fn merge_groups_long_full_list() {
+        check_full(
+            "std::foo::bar::Baz",
+            r"use std::foo::bar::{Qux, Quux};",
+            r"use std::foo::bar::{Baz, Quux, Qux};",
+        )
+    }
+    #[test]
+    fn merge_groups_long_last_list() {
+        check_last(
+            "std::foo::bar::Baz",
+            r"use std::foo::bar::{Qux, Quux};",
+            r"use std::foo::bar::{Baz, Quux, Qux};",
+        )
+    }
+    #[test]
+    fn merge_groups_long_full_nested() {
+        check_full(
+            "std::foo::bar::Baz",
+            r"use std::foo::bar::{Qux, quux::{Fez, Fizz}};",
+            r"use std::foo::bar::{Baz, Qux, quux::{Fez, Fizz}};",
+        )
+    }
+    #[test]
+    fn merge_groups_long_last_nested() {
+        check_last(
+            "std::foo::bar::Baz",
+            r"use std::foo::bar::{Qux, quux::{Fez, Fizz}};",
+            r"use std::foo::bar::Baz;
+use std::foo::bar::{Qux, quux::{Fez, Fizz}};",
+        )
+    }
+    #[test]
+    fn merge_groups_full_nested_deep() {
+        check_full(
+            "std::foo::bar::quux::Baz",
+            r"use std::foo::bar::{Qux, quux::{Fez, Fizz}};",
+            r"use std::foo::bar::{Qux, quux::{Baz, Fez, Fizz}};",
+        )
+    }
+    #[test]
+    fn merge_groups_skip_pub() {
+        check_full(
+            "std::io",
+            r"pub use std::fmt::{Result, Display};",
+            r"pub use std::fmt::{Result, Display};
+use std::io;",
+        )
+    }
+    #[test]
+    fn merge_groups_skip_pub_crate() {
+        check_full(
+            "std::io",
+            r"pub(crate) use std::fmt::{Result, Display};",
+            r"pub(crate) use std::fmt::{Result, Display};
+use std::io;",
+        )
+    }
+    #[test]
+    #[ignore] // FIXME: Support this
+    fn split_out_merge() {
+        check_last(
+            "std::fmt::Result",
+            r"use std::{fmt, io};",
+            r"use std::fmt::{self, Result};
+use std::io;",
+        )
+    }
+    #[test]
+    fn merge_into_module_import() {
+        check_full(
+            "std::fmt::Result",
+            r"use std::{fmt, io};",
+            r"use std::{fmt::{self, Result}, io};",
+        )
+    }
+    #[test]
+    fn merge_groups_self() {
+        check_full("std::fmt::Debug", r"use std::fmt;", r"use std::fmt::{self, Debug};")
+    }
+    #[test]
+    fn merge_mod_into_glob() {
+        check_full(
+            "token::TokenKind",
+            r"use token::TokenKind::*;",
+            r"use token::TokenKind::{*, self};",
+        )
+        // FIXME: have it emit `use token::TokenKind::{self, *}`?
+    }
+    #[test]
+    fn merge_self_glob() {
+        check_full("self", r"use self::*;", r"use self::{*, self};")
+        // FIXME: have it emit `use {self, *}`?
+    }
+    #[test]
+    #[ignore] // FIXME: Support this
+    fn merge_partial_path() {
+        check_full(
+            "ast::Foo",
+            r"use syntax::{ast, algo};",
+            r"use syntax::{ast::{self, Foo}, algo};",
+        )
+    }
+    #[test]
+    fn merge_glob_nested() {
+        check_full(
+            "foo::bar::quux::Fez",
+            r"use foo::bar::{Baz, quux::*};",
+            r"use foo::bar::{Baz, quux::{self::*, Fez}};",
+        )
+    }
+    #[test]
+    fn merge_last_too_long() {
+        check_last("foo::bar", r"use foo::bar::baz::Qux;", r"use foo::bar::{self, baz::Qux};");
+    }
+    #[test]
+    fn insert_short_before_long() {
+        check_none(
+            "foo::bar",
+            r"use foo::bar::baz::Qux;",
+            r"use foo::bar;
+use foo::bar::baz::Qux;",
+        );
+    }
+    #[test]
+    fn merge_last_fail() {
+        check_merge_only_fail(
+            r"use foo::bar::{baz::{Qux, Fez}};",
+            r"use foo::bar::{baaz::{Quux, Feez}};",
+            MergeBehaviour::Last,
+        );
+    }
+    #[test]
+    fn merge_last_fail1() {
+        check_merge_only_fail(
+            r"use foo::bar::{baz::{Qux, Fez}};",
+            r"use foo::bar::baaz::{Quux, Feez};",
+            MergeBehaviour::Last,
+        );
+    }
+    #[test]
+    fn merge_last_fail2() {
+        check_merge_only_fail(
+            r"use foo::bar::baz::{Qux, Fez};",
+            r"use foo::bar::{baaz::{Quux, Feez}};",
+            MergeBehaviour::Last,
+        );
+    }
+    #[test]
+    fn merge_last_fail3() {
+        check_merge_only_fail(
+            r"use foo::bar::baz::{Qux, Fez};",
+            r"use foo::bar::baaz::{Quux, Feez};",
+            MergeBehaviour::Last,
+        );
+    }
+    fn check(
+        path: &str,
+        ra_fixture_before: &str,
+        ra_fixture_after: &str,
+        mb: Option<MergeBehaviour>,
+    ) {
+        let file = super::ImportScope::from(
+            ast::SourceFile::parse(ra_fixture_before).tree().syntax().clone(),
+        )
+        .unwrap();
+        let path = ast::SourceFile::parse(&format!("use {};", path))
+            .tree()
+            .syntax()
+            .descendants()
+            .find_map(ast::Path::cast)
+            .unwrap();
+        let result = insert_use(&file, path, mb).to_string();
+        assert_eq_text!(&result, ra_fixture_after);
+    }
+    fn check_full(path: &str, ra_fixture_before: &str, ra_fixture_after: &str) {
+        check(path, ra_fixture_before, ra_fixture_after, Some(MergeBehaviour::Full))
+    }
+    fn check_last(path: &str, ra_fixture_before: &str, ra_fixture_after: &str) {
+        check(path, ra_fixture_before, ra_fixture_after, Some(MergeBehaviour::Last))
+    }
+    fn check_none(path: &str, ra_fixture_before: &str, ra_fixture_after: &str) {
+        check(path, ra_fixture_before, ra_fixture_after, None)
+    }
+    fn check_merge_only_fail(ra_fixture0: &str, ra_fixture1: &str, mb: MergeBehaviour) {
+        let use0 = ast::SourceFile::parse(ra_fixture0)
+            .tree()
+            .syntax()
+            .descendants()
+            .find_map(ast::Use::cast)
+            .unwrap();
+        let use1 = ast::SourceFile::parse(ra_fixture1)
+            .tree()
+            .syntax()
+            .descendants()
+            .find_map(ast::Use::cast)
+            .unwrap();
+        let result = try_merge_imports(&use0, &use1, mb);
+        assert_eq!(result.map(|u| u.to_string()), None);
    }
 }
diff --git a/crates/base_db/src/input.rs b/crates/base_db/src/input.rs
index f3d65cdf0..9a61f1d56 100644
--- a/crates/base_db/src/input.rs
+++ b/crates/base_db/src/input.rs
@@ -12,7 +12,7 @@ use cfg::CfgOptions;
 use rustc_hash::{FxHashMap, FxHashSet};
 use syntax::SmolStr;
 use tt::TokenExpander;
-use vfs::file_set::FileSet;
+use vfs::{file_set::FileSet, VfsPath};
 pub use vfs::FileId;
@@ -43,6 +43,12 @@ impl SourceRoot {
    pub fn new_library(file_set: FileSet) -> SourceRoot {
        SourceRoot { is_library: true, file_set }
    }
+    pub fn path_for_file(&self, file: &FileId) -> Option<&VfsPath> {
+        self.file_set.path_for_file(file)
+    }
+    pub fn file_for_path(&self, path: &VfsPath) -> Option<&FileId> {
+        self.file_set.file_for_path(path)
+    }
    pub fn iter(&self) -> impl Iterator<Item = FileId> + '_ {
        self.file_set.iter()
    }
diff --git a/crates/hir/src/code_model.rs b/crates/hir/src/code_model.rs
index dc3a1699f..a2a166e0a 100644
--- a/crates/hir/src/code_model.rs
+++ b/crates/hir/src/code_model.rs
@@ -926,12 +926,12 @@ impl MacroDef {
    /// Indicate it is a proc-macro
    pub fn is_proc_macro(&self) -> bool {
-        matches!(self.id.kind, MacroDefKind::CustomDerive(_))
+        matches!(self.id.kind, MacroDefKind::ProcMacro(_))
    }
    /// Indicate it is a derive macro
    pub fn is_derive_macro(&self) -> bool {
-        matches!(self.id.kind, MacroDefKind::CustomDerive(_) | MacroDefKind::BuiltInDerive(_))
+        matches!(self.id.kind, MacroDefKind::ProcMacro(_) | MacroDefKind::BuiltInDerive(_))
    }
 }
@@ -1309,6 +1309,8 @@ impl Type {
    /// Checks that particular type `ty` implements `std::future::Future`.
    /// This function is used in `.await` syntax completion.
    pub fn impls_future(&self, db: &dyn HirDatabase) -> bool {
+        // No special case for the type of async block, since Chalk can figure it out.
        let krate = self.krate;
        let std_future_trait =
@@ -1626,6 +1628,11 @@ impl Type {
                                cb(type_.derived(ty.clone()));
                            }
                        }
+                        TypeCtor::OpaqueType(..) => {
+                            if let Some(bounds) = ty.impl_trait_bounds(db) {
+                                walk_bounds(db, &type_.derived(ty.clone()), &bounds, cb);
+                            }
+                        }
                        _ => (),
                    }
diff --git a/crates/hir/src/semantics.rs b/crates/hir/src/semantics.rs
index 1594d4f0f..c61a430e1 100644
--- a/crates/hir/src/semantics.rs
+++ b/crates/hir/src/semantics.rs
@@ -207,8 +207,8 @@ impl<'db, DB: HirDatabase> Semantics<'db, DB> {
        self.imp.resolve_record_field(field)
    }
-    pub fn resolve_record_field_pat(&self, field: &ast::RecordPatField) -> Option<Field> {
+    pub fn resolve_record_pat_field(&self, field: &ast::RecordPatField) -> Option<Field> {
-        self.imp.resolve_record_field_pat(field)
+        self.imp.resolve_record_pat_field(field)
    }
    pub fn resolve_macro_call(&self, macro_call: &ast::MacroCall) -> Option<MacroDef> {
@@ -433,8 +433,8 @@ impl<'db> SemanticsImpl<'db> {
        self.analyze(field.syntax()).resolve_record_field(self.db, field)
    }
-    fn resolve_record_field_pat(&self, field: &ast::RecordPatField) -> Option<Field> {
+    fn resolve_record_pat_field(&self, field: &ast::RecordPatField) -> Option<Field> {
-        self.analyze(field.syntax()).resolve_record_field_pat(self.db, field)
+        self.analyze(field.syntax()).resolve_record_pat_field(self.db, field)
    }
    fn resolve_macro_call(&self, macro_call: &ast::MacroCall) -> Option<MacroDef> {
@@ -697,6 +697,25 @@ fn find_root(node: &SyntaxNode) -> SyntaxNode {
    node.ancestors().last().unwrap()
 }
+/// `SemanticScope` encapsulates the notion of a scope (the set of visible
+/// names) at a particular program point.
+///
+/// It is a bit tricky, as scopes do not really exist inside the compiler.
+/// Rather, the compiler directly computes for each reference the definition it
+/// refers to. It might transiently compute the explicit scope map while doing
+/// so, but, generally, this is not something left after the analysis.
+///
+/// However, we do very much need explicit scopes for IDE purposes --
+/// completion, at its core, lists the contents of the current scope. The notion
+/// of scope is also useful to answer questions like "what would be the meaning
+/// of this piece of code if we inserted it into this position?".
+///
+/// So `SemanticsScope` is constructed from a specific program point (a syntax
+/// node or just a raw offset) and provides access to the set of visible names
+/// on a somewhat best-effort basis.
+///
+/// Note that if you are wondering "what does this specific existing name mean?",
+/// you'd better use the `resolve_` family of methods.
 #[derive(Debug)]
 pub struct SemanticsScope<'a> {
    pub db: &'a dyn HirDatabase,
diff --git a/crates/hir/src/source_analyzer.rs b/crates/hir/src/source_analyzer.rs
index 1d13c4f1d..1aef0f33f 100644
--- a/crates/hir/src/source_analyzer.rs
+++ b/crates/hir/src/source_analyzer.rs
@@ -179,13 +179,13 @@ impl SourceAnalyzer {
        Some((struct_field.into(), local))
    }
-    pub(crate) fn resolve_record_field_pat(
+    pub(crate) fn resolve_record_pat_field(
        &self,
        _db: &dyn HirDatabase,
        field: &ast::RecordPatField,
    ) -> Option<Field> {
        let pat_id = self.pat_id(&field.pat()?)?;
-        let struct_field = self.infer.as_ref()?.record_field_pat_resolution(pat_id)?;
+        let struct_field = self.infer.as_ref()?.record_pat_field_resolution(pat_id)?;
        Some(struct_field.into())
    }
diff --git a/crates/hir_def/src/body/lower.rs b/crates/hir_def/src/body/lower.rs
index 30ac12a12..2d91bb21f 100644
--- a/crates/hir_def/src/body/lower.rs
+++ b/crates/hir_def/src/body/lower.rs
@@ -239,7 +239,10 @@ impl ExprCollector<'_> {
                    None => self.missing_expr(),
                },
                // FIXME: we need to record these effects somewhere...
-                ast::Effect::Async(_) => self.collect_block_opt(e.block_expr()),
+                ast::Effect::Async(_) => {
+                    let body = self.collect_block_opt(e.block_expr());
+                    self.alloc_expr(Expr::Async { body }, syntax_ptr)
+                }
            },
            ast::Expr::BlockExpr(e) => self.collect_block(e),
            ast::Expr::LoopExpr(e) => {
@@ -835,8 +838,12 @@ impl ExprCollector<'_> {
                Pat::Missing
            }
+            ast::Pat::BoxPat(boxpat) => {
+                let inner = self.collect_pat_opt(boxpat.pat());
+                Pat::Box { inner }
+            }
            // FIXME: implement
-            ast::Pat::BoxPat(_) | ast::Pat::RangePat(_) | ast::Pat::MacroPat(_) => Pat::Missing,
+            ast::Pat::RangePat(_) | ast::Pat::MacroPat(_) => Pat::Missing,
        };
        let ptr = AstPtr::new(&pat);
        self.alloc_pat(pattern, Either::Left(ptr))
diff --git a/crates/hir_def/src/data.rs b/crates/hir_def/src/data.rs
index 9a8eb4ede..6190906da 100644
--- a/crates/hir_def/src/data.rs
+++ b/crates/hir_def/src/data.rs
@@ -54,6 +54,7 @@ pub struct TypeAliasData {
    pub name: Name,
    pub type_ref: Option<TypeRef>,
    pub visibility: RawVisibility,
+    pub is_extern: bool,
    /// Bounds restricting the type alias itself (eg. `type Ty: Bound;` in a trait or impl).
    pub bounds: Vec<TypeBound>,
 }
@@ -71,6 +72,7 @@ impl TypeAliasData {
            name: typ.name.clone(),
            type_ref: typ.type_ref.clone(),
            visibility: item_tree[typ.visibility].clone(),
+            is_extern: typ.is_extern,
            bounds: typ.bounds.to_vec(),
        })
    }
diff --git a/crates/hir_def/src/diagnostics.rs b/crates/hir_def/src/diagnostics.rs
index 3e19d9117..2ec0fd3fb 100644
--- a/crates/hir_def/src/diagnostics.rs
+++ b/crates/hir_def/src/diagnostics.rs
@@ -28,3 +28,45 @@ impl Diagnostic for UnresolvedModule {
        self
    }
 }
+#[derive(Debug)]
+pub struct UnresolvedExternCrate {
+    pub file: HirFileId,
+    pub item: AstPtr<ast::ExternCrate>,
+}
+impl Diagnostic for UnresolvedExternCrate {
+    fn code(&self) -> DiagnosticCode {
+        DiagnosticCode("unresolved-extern-crate")
+    }
+    fn message(&self) -> String {
+        "unresolved extern crate".to_string()
+    }
+    fn display_source(&self) -> InFile<SyntaxNodePtr> {
+        InFile::new(self.file, self.item.clone().into())
+    }
+    fn as_any(&self) -> &(dyn Any + Send + 'static) {
+        self
+    }
+}
+#[derive(Debug)]
+pub struct UnresolvedImport {
+    pub file: HirFileId,
+    pub node: AstPtr<ast::UseTree>,
+}
+impl Diagnostic for UnresolvedImport {
+    fn code(&self) -> DiagnosticCode {
+        DiagnosticCode("unresolved-import")
+    }
+    fn message(&self) -> String {
+        "unresolved import".to_string()
+    }
+    fn display_source(&self) -> InFile<SyntaxNodePtr> {
+        InFile::new(self.file, self.node.clone().into())
+    }
+    fn as_any(&self) -> &(dyn Any + Send + 'static) {
+        self
+    }
+}
diff --git a/crates/hir_def/src/expr.rs b/crates/hir_def/src/expr.rs
index c94b3a36f..e5d740a36 100644
--- a/crates/hir_def/src/expr.rs
+++ b/crates/hir_def/src/expr.rs
@@ -111,6 +111,9 @@ pub enum Expr {
    TryBlock {
        body: ExprId,
    },
+    Async {
+        body: ExprId,
+    },
    Cast {
        expr: ExprId,
        type_ref: TypeRef,
@@ -250,7 +253,7 @@ impl Expr {
                    f(*expr);
                }
            }
-            Expr::TryBlock { body } | Expr::Unsafe { body } => f(*body),
+            Expr::TryBlock { body } | Expr::Unsafe { body } | Expr::Async { body } => f(*body),
            Expr::Loop { body, .. } => f(*body),
            Expr::While { condition, body, .. } => {
                f(*condition);
@@ -395,6 +398,7 @@ pub enum Pat {
    Bind { mode: BindingAnnotation, name: Name, subpat: Option<PatId> },
    TupleStruct { path: Option<Path>, args: Vec<PatId>, ellipsis: Option<usize> },
    Ref { pat: PatId, mutability: Mutability },
+    Box { inner: PatId },
 }
 impl Pat {
@@ -415,6 +419,7 @@ impl Pat {
            Pat::Record { args, .. } => {
                args.iter().map(|f| f.pat).for_each(f);
            }
+            Pat::Box { inner } => f(*inner),
        }
    }
 }
diff --git a/crates/hir_def/src/item_tree.rs b/crates/hir_def/src/item_tree.rs
index e14722cae..0fd91b9d0 100644
--- a/crates/hir_def/src/item_tree.rs
+++ b/crates/hir_def/src/item_tree.rs
@@ -291,7 +291,6 @@ pub enum AttrOwner {
    Variant(Idx<Variant>),
    Field(Idx<Field>),
-    // FIXME: Store variant and field attrs, and stop reparsing them in `attrs_query`.
 }
 macro_rules! from_attrs {
@@ -483,11 +482,16 @@ pub struct Import {
    /// AST ID of the `use` or `extern crate` item this import was derived from. Note that many
    /// `Import`s can map to the same `use` item.
    pub ast_id: FileAstId<ast::Use>,
+    /// Index of this `Import` when the containing `Use` is visited via `ModPath::expand_use_item`.
+    ///
+    /// This can be used to get the `UseTree` this `Import` corresponds to and allows emitting
+    /// precise diagnostics.
+    pub index: usize,
 }
 #[derive(Debug, Clone, Eq, PartialEq)]
 pub struct ExternCrate {
-    pub path: ModPath,
+    pub name: Name,
    pub alias: Option<ImportAlias>,
    pub visibility: RawVisibilityId,
    /// Whether this is a `#[macro_use] extern crate ...`.
@@ -592,6 +596,7 @@ pub struct TypeAlias {
    pub bounds: Box<[TypeBound]>,
    pub generic_params: GenericParamsId,
    pub type_ref: Option<TypeRef>,
+    pub is_extern: bool,
    pub ast_id: FileAstId<ast::TypeAlias>,
 }
diff --git a/crates/hir_def/src/item_tree/lower.rs b/crates/hir_def/src/item_tree/lower.rs
index 6a503d785..54814f141 100644
--- a/crates/hir_def/src/item_tree/lower.rs
+++ b/crates/hir_def/src/item_tree/lower.rs
@@ -364,6 +364,7 @@ impl Ctx {
            generic_params,
            type_ref,
            ast_id,
+            is_extern: false,
        };
        Some(id(self.data().type_aliases.alloc(res)))
    }
@@ -482,7 +483,7 @@ impl Ctx {
        ModPath::expand_use_item(
            InFile::new(self.file, use_item.clone()),
            &self.hygiene,
-            |path, _tree, is_glob, alias| {
+            |path, _use_tree, is_glob, alias| {
                imports.push(id(tree.imports.alloc(Import {
                    path,
                    alias,
@@ -490,6 +491,7 @@ impl Ctx {
                    is_glob,
                    is_prelude,
                    ast_id,
+                    index: imports.len(),
                })));
            },
        );
@@ -501,7 +503,7 @@ impl Ctx {
        &mut self,
        extern_crate: &ast::ExternCrate,
    ) -> Option<FileItemTreeId<ExternCrate>> {
-        let path = ModPath::from_name_ref(&extern_crate.name_ref()?);
+        let name = extern_crate.name_ref()?.as_name();
        let alias = extern_crate.rename().map(|a| {
            a.name().map(|it| it.as_name()).map_or(ImportAlias::Underscore, ImportAlias::Alias)
        });
@@ -510,7 +512,7 @@ impl Ctx {
        // FIXME: cfg_attr
        let is_macro_use = extern_crate.has_atom_attr("macro_use");
-        let res = ExternCrate { path, alias, visibility, is_macro_use, ast_id };
+        let res = ExternCrate { name, alias, visibility, is_macro_use, ast_id };
        Some(id(self.data().extern_crates.alloc(res)))
    }
@@ -558,8 +560,9 @@ impl Ctx {
                            statik.into()
                        }
                        ast::ExternItem::TypeAlias(ty) => {
-                            let id = self.lower_type_alias(&ty)?;
+                            let foreign_ty = self.lower_type_alias(&ty)?;
-                            id.into()
+                            self.data().type_aliases[foreign_ty.index].is_extern = true;
+                            foreign_ty.into()
                        }
                        ast::ExternItem::MacroCall(_) => return None,
                    };
diff --git a/crates/hir_def/src/item_tree/tests.rs b/crates/hir_def/src/item_tree/tests.rs
index 620e697d4..1a806cda5 100644
--- a/crates/hir_def/src/item_tree/tests.rs
+++ b/crates/hir_def/src/item_tree/tests.rs
@@ -228,15 +228,15 @@ fn smoke() {
            top-level items:
            #[Attrs { entries: Some([Attr { path: ModPath { kind: Plain, segments: [Name(Text("attr_on_use"))] }, input: None }]) }]
-            Import { path: ModPath { kind: Plain, segments: [Name(Text("a"))] }, alias: None, visibility: RawVisibilityId("pub(self)"), is_glob: false, is_prelude: false, ast_id: FileAstId::<syntax::ast::generated::nodes::Use>(0) }
+            Import { path: ModPath { kind: Plain, segments: [Name(Text("a"))] }, alias: None, visibility: RawVisibilityId("pub(self)"), is_glob: false, is_prelude: false, ast_id: FileAstId::<syntax::ast::generated::nodes::Use>(0), index: 0 }
            #[Attrs { entries: Some([Attr { path: ModPath { kind: Plain, segments: [Name(Text("attr_on_use"))] }, input: None }]) }]
-            Import { path: ModPath { kind: Plain, segments: [Name(Text("b"))] }, alias: None, visibility: RawVisibilityId("pub(self)"), is_glob: true, is_prelude: false, ast_id: FileAstId::<syntax::ast::generated::nodes::Use>(0) }
+            Import { path: ModPath { kind: Plain, segments: [Name(Text("b"))] }, alias: None, visibility: RawVisibilityId("pub(self)"), is_glob: true, is_prelude: false, ast_id: FileAstId::<syntax::ast::generated::nodes::Use>(0), index: 1 }
            #[Attrs { entries: Some([Attr { path: ModPath { kind: Plain, segments: [Name(Text("ext_crate"))] }, input: None }]) }]
-            ExternCrate { path: ModPath { kind: Plain, segments: [Name(Text("krate"))] }, alias: None, visibility: RawVisibilityId("pub(self)"), is_macro_use: false, ast_id: FileAstId::<syntax::ast::generated::nodes::ExternCrate>(1) }
+            ExternCrate { name: Name(Text("krate")), alias: None, visibility: RawVisibilityId("pub(self)"), is_macro_use: false, ast_id: FileAstId::<syntax::ast::generated::nodes::ExternCrate>(1) }
            #[Attrs { entries: Some([Attr { path: ModPath { kind: Plain, segments: [Name(Text("on_trait"))] }, input: None }]) }]
            Trait { name: Name(Text("Tr")), visibility: RawVisibilityId("pub(self)"), generic_params: GenericParamsId(0), auto: false, items: [TypeAlias(Idx::<TypeAlias>(0)), Const(Idx::<Const>(0)), Function(Idx::<Function>(0)), Function(Idx::<Function>(1))], ast_id: FileAstId::<syntax::ast::generated::nodes::Trait>(2) }
            > #[Attrs { entries: Some([Attr { path: ModPath { kind: Plain, segments: [Name(Text("assoc_ty"))] }, input: None }]) }]
-            > TypeAlias { name: Name(Text("AssocTy")), visibility: RawVisibilityId("pub(self)"), bounds: [Path(Path { type_anchor: None, mod_path: ModPath { kind: Plain, segments: [Name(Text("Tr"))] }, generic_args: [Some(GenericArgs { args: [Type(Tuple([]))], has_self_type: false, bindings: [] })] })], generic_params: GenericParamsId(4294967295), type_ref: None, ast_id: FileAstId::<syntax::ast::generated::nodes::TypeAlias>(8) }
+            > TypeAlias { name: Name(Text("AssocTy")), visibility: RawVisibilityId("pub(self)"), bounds: [Path(Path { type_anchor: None, mod_path: ModPath { kind: Plain, segments: [Name(Text("Tr"))] }, generic_args: [Some(GenericArgs { args: [Type(Tuple([]))], has_self_type: false, bindings: [] })] })], generic_params: GenericParamsId(4294967295), type_ref: None, is_extern: false, ast_id: FileAstId::<syntax::ast::generated::nodes::TypeAlias>(8) }
            > #[Attrs { entries: Some([Attr { path: ModPath { kind: Plain, segments: [Name(Text("assoc_const"))] }, input: None }]) }]
            > Const { name: Some(Name(Text("CONST"))), visibility: RawVisibilityId("pub(self)"), type_ref: Path(Path { type_anchor: None, mod_path: ModPath { kind: Plain, segments: [Name(Text("u8"))] }, generic_args: [None] }), ast_id: FileAstId::<syntax::ast::generated::nodes::Const>(9) }
            > #[Attrs { entries: Some([Attr { path: ModPath { kind: Plain, segments: [Name(Text("assoc_method"))] }, input: None }]) }]
diff --git a/crates/hir_def/src/nameres.rs b/crates/hir_def/src/nameres.rs
index bf302172d..5e4d73c1f 100644
--- a/crates/hir_def/src/nameres.rs
+++ b/crates/hir_def/src/nameres.rs
@@ -288,31 +288,70 @@ pub enum ModuleSource {
 mod diagnostics {
    use hir_expand::diagnostics::DiagnosticSink;
+    use hir_expand::hygiene::Hygiene;
+    use hir_expand::InFile;
    use syntax::{ast, AstPtr};
-    use crate::{db::DefDatabase, diagnostics::UnresolvedModule, nameres::LocalModuleId, AstId};
+    use crate::path::ModPath;
+    use crate::{db::DefDatabase, diagnostics::*, nameres::LocalModuleId, AstId};
    #[derive(Debug, PartialEq, Eq)]
-    pub(super) enum DefDiagnostic {
+    enum DiagnosticKind {
-        UnresolvedModule {
+        UnresolvedModule { declaration: AstId<ast::Module>, candidate: String },
-            module: LocalModuleId,
-            declaration: AstId<ast::Module>,
+        UnresolvedExternCrate { ast: AstId<ast::ExternCrate> },
-            candidate: String,
-        },
+        UnresolvedImport { ast: AstId<ast::Use>, index: usize },
+    }
+    #[derive(Debug, PartialEq, Eq)]
+    pub(super) struct DefDiagnostic {
+        in_module: LocalModuleId,
+        kind: DiagnosticKind,
    }
    impl DefDiagnostic {
+        pub(super) fn unresolved_module(
+            container: LocalModuleId,
+            declaration: AstId<ast::Module>,
+            candidate: String,
+        ) -> Self {
+            Self {
+                in_module: container,
+                kind: DiagnosticKind::UnresolvedModule { declaration, candidate },
+            }
+        }
+        pub(super) fn unresolved_extern_crate(
+            container: LocalModuleId,
+            declaration: AstId<ast::ExternCrate>,
+        ) -> Self {
+            Self {
+                in_module: container,
+                kind: DiagnosticKind::UnresolvedExternCrate { ast: declaration },
+            }
+        }
+        pub(super) fn unresolved_import(
+            container: LocalModuleId,
+            ast: AstId<ast::Use>,
+            index: usize,
+        ) -> Self {
+            Self { in_module: container, kind: DiagnosticKind::UnresolvedImport { ast, index } }
+        }
        pub(super) fn add_to(
            &self,
            db: &dyn DefDatabase,
            target_module: LocalModuleId,
            sink: &mut DiagnosticSink,
        ) {
-            match self {
+            if self.in_module != target_module {
-                DefDiagnostic::UnresolvedModule { module, declaration, candidate } => {
+                return;
-                    if *module != target_module {
+            }
-                        return;
-                    }
+            match &self.kind {
+                DiagnosticKind::UnresolvedModule { declaration, candidate } => {
                    let decl = declaration.to_node(db.upcast());
                    sink.push(UnresolvedModule {
                        file: declaration.file_id,
@@ -320,6 +359,36 @@ mod diagnostics {
                        candidate: candidate.clone(),
                    })
                }
+                DiagnosticKind::UnresolvedExternCrate { ast } => {
+                    let item = ast.to_node(db.upcast());
+                    sink.push(UnresolvedExternCrate {
+                        file: ast.file_id,
+                        item: AstPtr::new(&item),
+                    });
+                }
+                DiagnosticKind::UnresolvedImport { ast, index } => {
+                    let use_item = ast.to_node(db.upcast());
+                    let hygiene = Hygiene::new(db.upcast(), ast.file_id);
+                    let mut cur = 0;
+                    let mut tree = None;
+                    ModPath::expand_use_item(
+                        InFile::new(ast.file_id, use_item),
+                        &hygiene,
+                        |_mod_path, use_tree, _is_glob, _alias| {
+                            if cur == *index {
+                                tree = Some(use_tree.clone());
+                            }
+                            cur += 1;
+                        },
+                    );
+                    if let Some(tree) = tree {
+                        sink.push(UnresolvedImport { file: ast.file_id, node: AstPtr::new(&tree) });
+                    }
+                }
            }
        }
    }
diff --git a/crates/hir_def/src/nameres/collector.rs b/crates/hir_def/src/nameres/collector.rs
index 3e99c8773..4c3993ff0 100644
--- a/crates/hir_def/src/nameres/collector.rs
+++ b/crates/hir_def/src/nameres/collector.rs
@@ -3,8 +3,11 @@
 //! `DefCollector::collect` contains the fixed-point iteration loop which
 //! resolves imports and expands macros.
+use std::iter;
 use base_db::{CrateId, FileId, ProcMacroId};
 use cfg::CfgOptions;
+use hir_expand::InFile;
 use hir_expand::{
    ast_id_map::FileAstId,
    builtin_derive::find_builtin_derive,
@@ -14,6 +17,7 @@ use hir_expand::{
    HirFileId, MacroCallId, MacroDefId, MacroDefKind,
 };
 use rustc_hash::FxHashMap;
+use rustc_hash::FxHashSet;
 use syntax::ast;
 use test_utils::mark;
@@ -21,9 +25,7 @@ use crate::{
    attr::Attrs,
    db::DefDatabase,
    item_scope::{ImportType, PerNsGlobImports},
-    item_tree::{
+    item_tree::{self, ItemTree, ItemTreeId, MacroCall, Mod, ModItem, ModKind, StructDefKind},
-        self, FileItemTreeId, ItemTree, ItemTreeId, MacroCall, Mod, ModItem, ModKind, StructDefKind,
-    },
    nameres::{
        diagnostics::DefDiagnostic, mod_resolution::ModDir, path_resolution::ReachedFixedPoint,
        BuiltinShadowMode, CrateDefMap, ModuleData, ModuleOrigin, ResolveMode,
@@ -112,6 +114,12 @@ impl PartialResolvedImport {
 }
 #[derive(Clone, Debug, Eq, PartialEq)]
+enum ImportSource {
+    Import(ItemTreeId<item_tree::Import>),
+    ExternCrate(ItemTreeId<item_tree::ExternCrate>),
+}
+#[derive(Clone, Debug, Eq, PartialEq)]
 struct Import {
    pub path: ModPath,
    pub alias: Option<ImportAlias>,
@@ -120,11 +128,12 @@ struct Import {
    pub is_prelude: bool,
    pub is_extern_crate: bool,
    pub is_macro_use: bool,
+    source: ImportSource,
 }
 impl Import {
-    fn from_use(tree: &ItemTree, id: FileItemTreeId<item_tree::Import>) -> Self {
+    fn from_use(tree: &ItemTree, id: ItemTreeId<item_tree::Import>) -> Self {
-        let it = &tree[id];
+        let it = &tree[id.value];
        let visibility = &tree[it.visibility];
        Self {
            path: it.path.clone(),
@@ -134,20 +143,22 @@ impl Import {
            is_prelude: it.is_prelude,
            is_extern_crate: false,
            is_macro_use: false,
+            source: ImportSource::Import(id),
        }
    }
-    fn from_extern_crate(tree: &ItemTree, id: FileItemTreeId<item_tree::ExternCrate>) -> Self {
+    fn from_extern_crate(tree: &ItemTree, id: ItemTreeId<item_tree::ExternCrate>) -> Self {
-        let it = &tree[id];
+        let it = &tree[id.value];
        let visibility = &tree[it.visibility];
        Self {
-            path: it.path.clone(),
+            path: ModPath::from_segments(PathKind::Plain, iter::once(it.name.clone())),
            alias: it.alias.clone(),
            visibility: visibility.clone(),
            is_glob: false,
            is_prelude: false,
            is_extern_crate: true,
            is_macro_use: it.is_macro_use,
+            source: ImportSource::ExternCrate(id),
        }
    }
 }
@@ -245,9 +256,10 @@ impl DefCollector<'_> {
        let unresolved_imports = std::mem::replace(&mut self.unresolved_imports, Vec::new());
        // show unresolved imports in completion, etc
-        for directive in unresolved_imports {
+        for directive in &unresolved_imports {
-            self.record_resolved_import(&directive)
+            self.record_resolved_import(directive)
        }
+        self.unresolved_imports = unresolved_imports;
        // Record proc-macros
        self.collect_proc_macro();
@@ -261,7 +273,7 @@ impl DefCollector<'_> {
            let macro_id = MacroDefId {
                ast_id: None,
                krate: Some(krate),
-                kind: MacroDefKind::CustomDerive(expander),
+                kind: MacroDefKind::ProcMacro(expander),
                local_inner: false,
            };
@@ -346,20 +358,15 @@ impl DefCollector<'_> {
    fn import_macros_from_extern_crate(
        &mut self,
        current_module_id: LocalModuleId,
-        import: &item_tree::ExternCrate,
+        extern_crate: &item_tree::ExternCrate,
    ) {
        log::debug!(
            "importing macros from extern crate: {:?} ({:?})",
-            import,
+            extern_crate,
            self.def_map.edition,
        );
-        let res = self.def_map.resolve_name_in_extern_prelude(
+        let res = self.def_map.resolve_name_in_extern_prelude(&extern_crate.name);
-            &import
-                .path
-                .as_ident()
-                .expect("extern crate should have been desugared to one-element path"),
-        );
        if let Some(ModuleDefId::ModuleId(m)) = res.take_types() {
            mark::hit!(macro_rules_from_other_crates_are_visible_with_macro_use);
@@ -420,7 +427,11 @@ impl DefCollector<'_> {
                    .as_ident()
                    .expect("extern crate should have been desugared to one-element path"),
            );
-            PartialResolvedImport::Resolved(res)
+            if res.is_none() {
+                PartialResolvedImport::Unresolved
+            } else {
+                PartialResolvedImport::Resolved(res)
+            }
        } else {
            let res = self.def_map.resolve_path_fp_with_macro(
                self.db,
@@ -774,7 +785,51 @@ impl DefCollector<'_> {
        .collect(item_tree.top_level_items());
    }
-    fn finish(self) -> CrateDefMap {
+    fn finish(mut self) -> CrateDefMap {
+        // Emit diagnostics for all remaining unresolved imports.
+        // We'd like to avoid emitting a diagnostics avalanche when some `extern crate` doesn't
+        // resolve. We first emit diagnostics for unresolved extern crates and collect the missing
+        // crate names. Then we emit diagnostics for unresolved imports, but only if the import
+        // doesn't start with an unresolved crate's name. Due to renaming and reexports, this is a
+        // heuristic, but it works in practice.
+        let mut diagnosed_extern_crates = FxHashSet::default();
+        for directive in &self.unresolved_imports {
+            if let ImportSource::ExternCrate(krate) = directive.import.source {
+                let item_tree = self.db.item_tree(krate.file_id);
+                let extern_crate = &item_tree[krate.value];
+                diagnosed_extern_crates.insert(extern_crate.name.clone());
+                self.def_map.diagnostics.push(DefDiagnostic::unresolved_extern_crate(
+                    directive.module_id,
+                    InFile::new(krate.file_id, extern_crate.ast_id),
+                ));
+            }
+        }
+        for directive in &self.unresolved_imports {
+            if let ImportSource::Import(import) = &directive.import.source {
+                let item_tree = self.db.item_tree(import.file_id);
+                let import_data = &item_tree[import.value];
+                match (import_data.path.segments.first(), &import_data.path.kind) {
+                    (Some(krate), PathKind::Plain) | (Some(krate), PathKind::Abs) => {
+                        if diagnosed_extern_crates.contains(krate) {
+                            continue;
+                        }
+                    }
+                    _ => {}
+                }
+                self.def_map.diagnostics.push(DefDiagnostic::unresolved_import(
+                    directive.module_id,
+                    InFile::new(import.file_id, import_data.ast_id),
+                    import_data.index,
+                ));
+            }
+        }
        self.def_map
    }
 }
@@ -819,179 +874,184 @@ impl ModCollector<'_, '_> {
        for &item in items {
            let attrs = self.item_tree.attrs(item.into());
-            if self.is_cfg_enabled(attrs) {
+            if !self.is_cfg_enabled(attrs) {
-                let module =
+                continue;
-                    ModuleId { krate: self.def_collector.def_map.krate, local_id: self.module_id };
+            }
-                let container = ContainerId::ModuleId(module);
+            let module =
+                ModuleId { krate: self.def_collector.def_map.krate, local_id: self.module_id };
-                let mut def = None;
+            let container = ContainerId::ModuleId(module);
-                match item {
-                    ModItem::Mod(m) => self.collect_module(&self.item_tree[m], attrs),
+            let mut def = None;
-                    ModItem::Import(import_id) => {
+            match item {
-                        self.def_collector.unresolved_imports.push(ImportDirective {
+                ModItem::Mod(m) => self.collect_module(&self.item_tree[m], attrs),
-                            module_id: self.module_id,
+                ModItem::Import(import_id) => {
-                            import: Import::from_use(&self.item_tree, import_id),
+                    self.def_collector.unresolved_imports.push(ImportDirective {
-                            status: PartialResolvedImport::Unresolved,
+                        module_id: self.module_id,
-                        })
+                        import: Import::from_use(
-                    }
+                            &self.item_tree,
-                    ModItem::ExternCrate(import_id) => {
+                            InFile::new(self.file_id, import_id),
-                        self.def_collector.unresolved_imports.push(ImportDirective {
+                        ),
-                            module_id: self.module_id,
+                        status: PartialResolvedImport::Unresolved,
-                            import: Import::from_extern_crate(&self.item_tree, import_id),
+                    })
-                            status: PartialResolvedImport::Unresolved,
+                }
-                        })
+                ModItem::ExternCrate(import_id) => {
-                    }
+                    self.def_collector.unresolved_imports.push(ImportDirective {
-                    ModItem::MacroCall(mac) => self.collect_macro(&self.item_tree[mac]),
+                        module_id: self.module_id,
-                    ModItem::Impl(imp) => {
+                        import: Import::from_extern_crate(
-                        let module = ModuleId {
+                            &self.item_tree,
-                            krate: self.def_collector.def_map.krate,
+                            InFile::new(self.file_id, import_id),
-                            local_id: self.module_id,
+                        ),
-                        };
+                        status: PartialResolvedImport::Unresolved,
-                        let container = ContainerId::ModuleId(module);
+                    })
-                        let impl_id = ImplLoc { container, id: ItemTreeId::new(self.file_id, imp) }
+                }
-                            .intern(self.def_collector.db);
+                ModItem::MacroCall(mac) => self.collect_macro(&self.item_tree[mac]),
-                        self.def_collector.def_map.modules[self.module_id]
+                ModItem::Impl(imp) => {
-                            .scope
+                    let module = ModuleId {
-                            .define_impl(impl_id)
+                        krate: self.def_collector.def_map.krate,
-                    }
+                        local_id: self.module_id,
-                    ModItem::Function(id) => {
+                    };
-                        let func = &self.item_tree[id];
+                    let container = ContainerId::ModuleId(module);
-                        def = Some(DefData {
+                    let impl_id = ImplLoc { container, id: ItemTreeId::new(self.file_id, imp) }
-                            id: FunctionLoc {
+                        .intern(self.def_collector.db);
-                                container: container.into(),
+                    self.def_collector.def_map.modules[self.module_id].scope.define_impl(impl_id)
-                                id: ItemTreeId::new(self.file_id, id),
+                }
-                            }
+                ModItem::Function(id) => {
-                            .intern(self.def_collector.db)
+                    let func = &self.item_tree[id];
-                            .into(),
+                    def = Some(DefData {
-                            name: &func.name,
+                        id: FunctionLoc {
-                            visibility: &self.item_tree[func.visibility],
+                            container: container.into(),
-                            has_constructor: false,
+                            id: ItemTreeId::new(self.file_id, id),
-                        });
+                        }
-                    }
+                        .intern(self.def_collector.db)
-                    ModItem::Struct(id) => {
+                        .into(),
-                        let it = &self.item_tree[id];
+                        name: &func.name,
+                        visibility: &self.item_tree[func.visibility],
-                        // FIXME: check attrs to see if this is an attribute macro invocation;
+                        has_constructor: false,
-                        // in which case we don't add the invocation, just a single attribute
+                    });
-                        // macro invocation
+                }
-                        self.collect_derives(attrs, it.ast_id.upcast());
+                ModItem::Struct(id) => {
+                    let it = &self.item_tree[id];
-                        def = Some(DefData {
-                            id: StructLoc { container, id: ItemTreeId::new(self.file_id, id) }
-                                .intern(self.def_collector.db)
-                                .into(),
-                            name: &it.name,
-                            visibility: &self.item_tree[it.visibility],
-                            has_constructor: it.kind != StructDefKind::Record,
-                        });
-                    }
-                    ModItem::Union(id) => {
-                        let it = &self.item_tree[id];
-                        // FIXME: check attrs to see if this is an attribute macro invocation;
+                    // FIXME: check attrs to see if this is an attribute macro invocation;
-                        // in which case we don't add the invocation, just a single attribute
+                    // in which case we don't add the invocation, just a single attribute
-                        // macro invocation
+                    // macro invocation
-                        self.collect_derives(attrs, it.ast_id.upcast());
+                    self.collect_derives(attrs, it.ast_id.upcast());
-                        def = Some(DefData {
+                    def = Some(DefData {
-                            id: UnionLoc { container, id: ItemTreeId::new(self.file_id, id) }
+                        id: StructLoc { container, id: ItemTreeId::new(self.file_id, id) }
-                                .intern(self.def_collector.db)
+                            .intern(self.def_collector.db)
-                                .into(),
+                            .into(),
-                            name: &it.name,
+                        name: &it.name,
-                            visibility: &self.item_tree[it.visibility],
+                        visibility: &self.item_tree[it.visibility],
-                            has_constructor: false,
+                        has_constructor: it.kind != StructDefKind::Record,
-                        });
+                    });
-                    }
+                }
-                    ModItem::Enum(id) => {
+                ModItem::Union(id) => {
-                        let it = &self.item_tree[id];
+                    let it = &self.item_tree[id];
-                        // FIXME: check attrs to see if this is an attribute macro invocation;
+                    // FIXME: check attrs to see if this is an attribute macro invocation;
-                        // in which case we don't add the invocation, just a single attribute
+                    // in which case we don't add the invocation, just a single attribute
-                        // macro invocation
+                    // macro invocation
-                        self.collect_derives(attrs, it.ast_id.upcast());
+                    self.collect_derives(attrs, it.ast_id.upcast());
-                        def = Some(DefData {
+                    def = Some(DefData {
-                            id: EnumLoc { container, id: ItemTreeId::new(self.file_id, id) }
+                        id: UnionLoc { container, id: ItemTreeId::new(self.file_id, id) }
-                                .intern(self.def_collector.db)
+                            .intern(self.def_collector.db)
-                                .into(),
+                            .into(),
-                            name: &it.name,
+                        name: &it.name,
-                            visibility: &self.item_tree[it.visibility],
+                        visibility: &self.item_tree[it.visibility],
-                            has_constructor: false,
+                        has_constructor: false,
-                        });
+                    });
-                    }
+                }
-                    ModItem::Const(id) => {
+                ModItem::Enum(id) => {
-                        let it = &self.item_tree[id];
+                    let it = &self.item_tree[id];
-                        if let Some(name) = &it.name {
-                            def = Some(DefData {
-                                id: ConstLoc {
-                                    container: container.into(),
-                                    id: ItemTreeId::new(self.file_id, id),
-                                }
-                                .intern(self.def_collector.db)
-                                .into(),
-                                name,
-                                visibility: &self.item_tree[it.visibility],
-                                has_constructor: false,
-                            });
-                        }
-                    }
-                    ModItem::Static(id) => {
-                        let it = &self.item_tree[id];
-                        def = Some(DefData {
+                    // FIXME: check attrs to see if this is an attribute macro invocation;
-                            id: StaticLoc { container, id: ItemTreeId::new(self.file_id, id) }
+                    // in which case we don't add the invocation, just a single attribute
-                                .intern(self.def_collector.db)
+                    // macro invocation
-                                .into(),
+                    self.collect_derives(attrs, it.ast_id.upcast());
-                            name: &it.name,
-                            visibility: &self.item_tree[it.visibility],
-                            has_constructor: false,
-                        });
-                    }
-                    ModItem::Trait(id) => {
-                        let it = &self.item_tree[id];
-                        def = Some(DefData {
+                    def = Some(DefData {
-                            id: TraitLoc { container, id: ItemTreeId::new(self.file_id, id) }
+                        id: EnumLoc { container, id: ItemTreeId::new(self.file_id, id) }
-                                .intern(self.def_collector.db)
+                            .intern(self.def_collector.db)
-                                .into(),
+                            .into(),
-                            name: &it.name,
+                        name: &it.name,
-                            visibility: &self.item_tree[it.visibility],
+                        visibility: &self.item_tree[it.visibility],
-                            has_constructor: false,
+                        has_constructor: false,
-                        });
+                    });
-                    }
+                }
-                    ModItem::TypeAlias(id) => {
+                ModItem::Const(id) => {
-                        let it = &self.item_tree[id];
+                    let it = &self.item_tree[id];
+                    if let Some(name) = &it.name {
                        def = Some(DefData {
-                            id: TypeAliasLoc {
+                            id: ConstLoc {
                                container: container.into(),
                                id: ItemTreeId::new(self.file_id, id),
                            }
                            .intern(self.def_collector.db)
                            .into(),
-                            name: &it.name,
+                            name,
                            visibility: &self.item_tree[it.visibility],
                            has_constructor: false,
                        });
                    }
                }
+                ModItem::Static(id) => {
+                    let it = &self.item_tree[id];
-                if let Some(DefData { id, name, visibility, has_constructor }) = def {
+                    def = Some(DefData {
-                    self.def_collector.def_map.modules[self.module_id].scope.define_def(id);
+                        id: StaticLoc { container, id: ItemTreeId::new(self.file_id, id) }
-                    let vis = self
+                            .intern(self.def_collector.db)
-                        .def_collector
+                            .into(),
-                        .def_map
+                        name: &it.name,
-                        .resolve_visibility(self.def_collector.db, self.module_id, visibility)
+                        visibility: &self.item_tree[it.visibility],
-                        .unwrap_or(Visibility::Public);
+                        has_constructor: false,
-                    self.def_collector.update(
+                    });
-                        self.module_id,
+                }
-                        &[(Some(name.clone()), PerNs::from_def(id, vis, has_constructor))],
+                ModItem::Trait(id) => {
-                        vis,
+                    let it = &self.item_tree[id];
-                        ImportType::Named,
-                    )
+                    def = Some(DefData {
+                        id: TraitLoc { container, id: ItemTreeId::new(self.file_id, id) }
+                            .intern(self.def_collector.db)
+                            .into(),
+                        name: &it.name,
+                        visibility: &self.item_tree[it.visibility],
+                        has_constructor: false,
+                    });
+                }
+                ModItem::TypeAlias(id) => {
+                    let it = &self.item_tree[id];
+                    def = Some(DefData {
+                        id: TypeAliasLoc {
+                            container: container.into(),
+                            id: ItemTreeId::new(self.file_id, id),
+                        }
+                        .intern(self.def_collector.db)
+                        .into(),
+                        name: &it.name,
+                        visibility: &self.item_tree[it.visibility],
+                        has_constructor: false,
+                    });
                }
            }
+            if let Some(DefData { id, name, visibility, has_constructor }) = def {
+                self.def_collector.def_map.modules[self.module_id].scope.define_def(id);
+                let vis = self
+                    .def_collector
+                    .def_map
+                    .resolve_visibility(self.def_collector.db, self.module_id, visibility)
+                    .unwrap_or(Visibility::Public);
+                self.def_collector.update(
+                    self.module_id,
+                    &[(Some(name.clone()), PerNs::from_def(id, vis, has_constructor))],
+                    vis,
+                    ImportType::Named,
+                )
+            }
        }
    }
@@ -1051,13 +1111,11 @@ impl ModCollector<'_, '_> {
                            self.import_all_legacy_macros(module_id);
                        }
                    }
-                    Err(candidate) => self.def_collector.def_map.diagnostics.push(
+                    Err(candidate) => {
-                        DefDiagnostic::UnresolvedModule {
+                        self.def_collector.def_map.diagnostics.push(
-                            module: self.module_id,
+                            DefDiagnostic::unresolved_module(self.module_id, ast_id, candidate),
-                            declaration: ast_id,
+                        );
-                            candidate,
+                    }
-                        },
-                    ),
                };
            }
        }
diff --git a/crates/hir_def/src/nameres/tests.rs b/crates/hir_def/src/nameres/tests.rs
index 5ca30dac9..11d84f808 100644
--- a/crates/hir_def/src/nameres/tests.rs
+++ b/crates/hir_def/src/nameres/tests.rs
@@ -2,6 +2,7 @@ mod globs;
 mod incremental;
 mod macros;
 mod mod_resolution;
+mod diagnostics;
 mod primitives;
 use std::sync::Arc;
diff --git a/crates/hir_def/src/nameres/tests/diagnostics.rs b/crates/hir_def/src/nameres/tests/diagnostics.rs
new file mode 100644
index 000000000..576b813d2
--- /dev/null
+++ b/crates/hir_def/src/nameres/tests/diagnostics.rs
@@ -0,0 +1,131 @@
+use base_db::fixture::WithFixture;
+use base_db::FileId;
+use base_db::SourceDatabaseExt;
+use hir_expand::db::AstDatabase;
+use rustc_hash::FxHashMap;
+use syntax::TextRange;
+use syntax::TextSize;
+use crate::test_db::TestDB;
+fn check_diagnostics(ra_fixture: &str) {
+    let db: TestDB = TestDB::with_files(ra_fixture);
+    let annotations = db.extract_annotations();
+    assert!(!annotations.is_empty());
+    let mut actual: FxHashMap<FileId, Vec<(TextRange, String)>> = FxHashMap::default();
+    db.diagnostics(|d| {
+        let src = d.display_source();
+        let root = db.parse_or_expand(src.file_id).unwrap();