96 files changed, 3865 insertions, 1248 deletions
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();
+        // FIXME: macros...
+        let file_id = src.file_id.original_file(&db);
+        let range = src.value.to_node(&root).text_range();
+        let message = d.message().to_owned();
+        actual.entry(file_id).or_default().push((range, message));
+    });
+    for (file_id, diags) in actual.iter_mut() {
+        diags.sort_by_key(|it| it.0.start());
+        let text = db.file_text(*file_id);
+        // For multiline spans, place them on line start
+        for (range, content) in diags {
+            if text[*range].contains('\n') {
+                *range = TextRange::new(range.start(), range.start() + TextSize::from(1));
+                *content = format!("... {}", content);
+            }
+        }
+    }
+    assert_eq!(annotations, actual);
+}
+#[test]
+fn unresolved_import() {
+    check_diagnostics(
+        r"
+        use does_exist;
+        use does_not_exist;
+          //^^^^^^^^^^^^^^ unresolved import
+        mod does_exist {}
+        ",
+    );
+}
+#[test]
+fn unresolved_import_in_use_tree() {
+    // Only the relevant part of a nested `use` item should be highlighted.
+    check_diagnostics(
+        r"
+        use does_exist::{Exists, DoesntExist};
+                               //^^^^^^^^^^^ unresolved import
+        use {does_not_exist::*, does_exist};
+           //^^^^^^^^^^^^^^^^^ unresolved import
+        use does_not_exist::{
+            a,
+          //^ unresolved import
+            b,
+          //^ unresolved import
+            c,
+          //^ unresolved import
+        };
+        mod does_exist {
+            pub struct Exists;
+        }
+        ",
+    );
+}
+#[test]
+fn unresolved_extern_crate() {
+    check_diagnostics(
+        r"
+        //- /main.rs crate:main deps:core
+        extern crate core;
+          extern crate doesnotexist;
+        //^^^^^^^^^^^^^^^^^^^^^^^^^^ unresolved extern crate
+        //- /lib.rs crate:core
+        ",
+    );
+}
+#[test]
+fn dedup_unresolved_import_from_unresolved_crate() {
+    check_diagnostics(
+        r"
+        //- /main.rs crate:main
+        mod a {
+            extern crate doesnotexist;
+          //^^^^^^^^^^^^^^^^^^^^^^^^^^ unresolved extern crate
+            // Should not error, since we already errored for the missing crate.
+            use doesnotexist::{self, bla, *};
+            use crate::doesnotexist;
+              //^^^^^^^^^^^^^^^^^^^ unresolved import
+        }
+        mod m {
+            use super::doesnotexist;
+              //^^^^^^^^^^^^^^^^^^^ unresolved import
+        }
+        ",
+    );
+}
+#[test]
+fn unresolved_module() {
+    check_diagnostics(
+        r"
+        //- /lib.rs
+        mod foo;
+          mod bar;
+        //^^^^^^^^ unresolved module
+        mod baz {}
+        //- /foo.rs
+        ",
+    );
+}
diff --git a/crates/hir_def/src/nameres/tests/mod_resolution.rs b/crates/hir_def/src/nameres/tests/mod_resolution.rs
index 1f619787e..f93337a6e 100644
--- a/crates/hir_def/src/nameres/tests/mod_resolution.rs
+++ b/crates/hir_def/src/nameres/tests/mod_resolution.rs
@@ -672,42 +672,6 @@ pub struct Baz;
 }
 #[test]
-fn unresolved_module_diagnostics() {
-    let db = TestDB::with_files(
-        r"
-        //- /lib.rs
-        mod foo;
-        mod bar;
-        mod baz {}
-        //- /foo.rs
-        ",
-    );
-    let krate = db.test_crate();
-    let crate_def_map = db.crate_def_map(krate);
-    expect![[r#"
-        [
-            UnresolvedModule {
-                module: Idx::<ModuleData>(0),
-                declaration: InFile {
-                    file_id: HirFileId(
-                        FileId(
-                            FileId(
-                                0,
-                            ),
-                        ),
-                    ),
-                    value: FileAstId::<syntax::ast::generated::nodes::Module>(1),
-                },
-                candidate: "bar.rs",
-            },
-        ]
-    "#]]
-    .assert_debug_eq(&crate_def_map.diagnostics);
-}
-#[test]
 fn module_resolution_decl_inside_module_in_non_crate_root_2() {
    check(
        r#"
diff --git a/crates/hir_def/src/path.rs b/crates/hir_def/src/path.rs
index 99395667d..734310458 100644
--- a/crates/hir_def/src/path.rs
+++ b/crates/hir_def/src/path.rs
@@ -56,10 +56,6 @@ impl ModPath {
        ModPath { kind, segments }
    }
-    pub(crate) fn from_name_ref(name_ref: &ast::NameRef) -> ModPath {
-        name_ref.as_name().into()
-    }
    /// Converts an `tt::Ident` into a single-identifier `Path`.
    pub(crate) fn from_tt_ident(ident: &tt::Ident) -> ModPath {
        ident.as_name().into()
diff --git a/crates/hir_def/src/test_db.rs b/crates/hir_def/src/test_db.rs
index 42a762936..fb1d3c974 100644
--- a/crates/hir_def/src/test_db.rs
+++ b/crates/hir_def/src/test_db.rs
@@ -5,9 +5,15 @@ use std::{
    sync::{Arc, Mutex},
 };
+use base_db::SourceDatabase;
 use base_db::{salsa, CrateId, FileId, FileLoader, FileLoaderDelegate, Upcast};
 use hir_expand::db::AstDatabase;
+use hir_expand::diagnostics::Diagnostic;
+use hir_expand::diagnostics::DiagnosticSinkBuilder;
+use rustc_hash::FxHashMap;
 use rustc_hash::FxHashSet;
+use syntax::TextRange;
+use test_utils::extract_annotations;
 use crate::db::DefDatabase;
@@ -98,4 +104,40 @@ impl TestDB {
            })
            .collect()
    }
+    pub fn extract_annotations(&self) -> FxHashMap<FileId, Vec<(TextRange, String)>> {
+        let mut files = Vec::new();
+        let crate_graph = self.crate_graph();
+        for krate in crate_graph.iter() {
+            let crate_def_map = self.crate_def_map(krate);
+            for (module_id, _) in crate_def_map.modules.iter() {
+                let file_id = crate_def_map[module_id].origin.file_id();
+                files.extend(file_id)
+            }
+        }
+        assert!(!files.is_empty());
+        files
+            .into_iter()
+            .filter_map(|file_id| {
+                let text = self.file_text(file_id);
+                let annotations = extract_annotations(&text);
+                if annotations.is_empty() {
+                    return None;
+                }
+                Some((file_id, annotations))
+            })
+            .collect()
+    }
+    pub fn diagnostics<F: FnMut(&dyn Diagnostic)>(&self, mut cb: F) {
+        let crate_graph = self.crate_graph();
+        for krate in crate_graph.iter() {
+            let crate_def_map = self.crate_def_map(krate);
+            let mut sink = DiagnosticSinkBuilder::new().build(&mut cb);
+            for (module_id, _) in crate_def_map.modules.iter() {
+                crate_def_map.add_diagnostics(self, module_id, &mut sink);
+            }
+        }
+    }
 }
diff --git a/crates/hir_expand/src/db.rs b/crates/hir_expand/src/db.rs
index dcc038bcd..b591130ca 100644
--- a/crates/hir_expand/src/db.rs
+++ b/crates/hir_expand/src/db.rs
@@ -143,7 +143,7 @@ pub(crate) fn macro_def(
            Some(Arc::new((TokenExpander::BuiltinDerive(expander), mbe::TokenMap::default())))
        }
        MacroDefKind::BuiltInEager(_) => None,
-        MacroDefKind::CustomDerive(expander) => {
+        MacroDefKind::ProcMacro(expander) => {
            Some(Arc::new((TokenExpander::ProcMacro(expander), mbe::TokenMap::default())))
        }
    }
@@ -223,7 +223,7 @@ fn macro_expand_with_arg(
    let ExpandResult(tt, err) = macro_rules.0.expand(db, lazy_id, &macro_arg.0);
    // Set a hard limit for the expanded tt
    let count = tt.count();
-    if count > 65536 {
+    if count > 262144 {
        return (None, Some(format!("Total tokens count exceed limit : count = {}", count)));
    }
    (Some(Arc::new(tt)), err.map(|e| format!("{:?}", e)))
@@ -249,7 +249,7 @@ pub(crate) fn expand_proc_macro(
    };
    let expander = match loc.def.kind {
-        MacroDefKind::CustomDerive(expander) => expander,
+        MacroDefKind::ProcMacro(expander) => expander,
        _ => unreachable!(),
    };
diff --git a/crates/hir_expand/src/eager.rs b/crates/hir_expand/src/eager.rs
index 10c45646f..2f37d7189 100644
--- a/crates/hir_expand/src/eager.rs
+++ b/crates/hir_expand/src/eager.rs
@@ -129,7 +129,7 @@ fn eager_macro_recur(
            MacroDefKind::Declarative
            | MacroDefKind::BuiltIn(_)
            | MacroDefKind::BuiltInDerive(_)
-            | MacroDefKind::CustomDerive(_) => {
+            | MacroDefKind::ProcMacro(_) => {
                let expanded = lazy_expand(db, &def, curr.with_value(child.clone()), krate)?;
                // replace macro inside
                eager_macro_recur(db, expanded, krate, macro_resolver)?
diff --git a/crates/hir_expand/src/hygiene.rs b/crates/hir_expand/src/hygiene.rs
index 845e9cbc1..d383b968d 100644
--- a/crates/hir_expand/src/hygiene.rs
+++ b/crates/hir_expand/src/hygiene.rs
@@ -33,7 +33,7 @@ impl Hygiene {
                        MacroDefKind::BuiltIn(_) => (None, false),
                        MacroDefKind::BuiltInDerive(_) => (None, false),
                        MacroDefKind::BuiltInEager(_) => (None, false),
-                        MacroDefKind::CustomDerive(_) => (None, false),
+                        MacroDefKind::ProcMacro(_) => (None, false),
                    }
                }
                MacroCallId::EagerMacro(_id) => (None, false),
diff --git a/crates/hir_expand/src/lib.rs b/crates/hir_expand/src/lib.rs
index 2be15e841..17f1178ed 100644
--- a/crates/hir_expand/src/lib.rs
+++ b/crates/hir_expand/src/lib.rs
@@ -246,7 +246,7 @@ pub enum MacroDefKind {
    // FIXME: maybe just Builtin and rename BuiltinFnLikeExpander to BuiltinExpander
    BuiltInDerive(BuiltinDeriveExpander),
    BuiltInEager(EagerExpander),
-    CustomDerive(ProcMacroExpander),
+    ProcMacro(ProcMacroExpander),
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
diff --git a/crates/hir_ty/Cargo.toml b/crates/hir_ty/Cargo.toml
index 47940c36e..bc86df2b1 100644
--- a/crates/hir_ty/Cargo.toml
+++ b/crates/hir_ty/Cargo.toml
@@ -17,9 +17,9 @@ ena = "0.14.0"
 log = "0.4.8"
 rustc-hash = "1.1.0"
 scoped-tls = "1"
-chalk-solve = { version = "0.23.0" }
+chalk-solve = { version = "0.27.0" }
-chalk-ir = { version = "0.23.0" }
+chalk-ir = { version = "0.27.0" }
-chalk-recursive = { version = "0.23.0" }
+chalk-recursive = { version = "0.27.0" }
 stdx = { path = "../stdx", version = "0.0.0" }
 hir_def = { path = "../hir_def", version = "0.0.0" }
diff --git a/crates/hir_ty/src/display.rs b/crates/hir_ty/src/display.rs
index 64b68014d..f389c5a4b 100644
--- a/crates/hir_ty/src/display.rs
+++ b/crates/hir_ty/src/display.rs
@@ -380,20 +380,34 @@ impl HirDisplay for ApplicationTy {
                    write!(f, ">")?;
                }
            }
+            TypeCtor::ForeignType(type_alias) => {
+                let type_alias = f.db.type_alias_data(type_alias);
+                write!(f, "{}", type_alias.name)?;
+                if self.parameters.len() > 0 {
+                    write!(f, "<")?;
+                    f.write_joined(&*self.parameters.0, ", ")?;
+                    write!(f, ">")?;
+                }
+            }
            TypeCtor::OpaqueType(opaque_ty_id) => {
-                let bounds = match opaque_ty_id {
+                match opaque_ty_id {
                    OpaqueTyId::ReturnTypeImplTrait(func, idx) => {
                        let datas =
                            f.db.return_type_impl_traits(func).expect("impl trait id without data");
                        let data = (*datas)
                            .as_ref()
                            .map(|rpit| rpit.impl_traits[idx as usize].bounds.clone());
-                        data.subst(&self.parameters)
+                        let bounds = data.subst(&self.parameters);
+                        write!(f, "impl ")?;
+                        write_bounds_like_dyn_trait(&bounds.value, f)?;
+                        // FIXME: it would maybe be good to distinguish this from the alias type (when debug printing), and to show the substitution
                    }
-                };
+                    OpaqueTyId::AsyncBlockTypeImplTrait(..) => {
-                write!(f, "impl ")?;
+                        write!(f, "impl Future<Output = ")?;
-                write_bounds_like_dyn_trait(&bounds.value, f)?;
+                        self.parameters[0].hir_fmt(f)?;
-                // FIXME: it would maybe be good to distinguish this from the alias type (when debug printing), and to show the substitution
+                        write!(f, ">")?;
+                    }
+                }
            }
            TypeCtor::Closure { .. } => {
                let sig = self.parameters[0].callable_sig(f.db);
@@ -474,18 +488,21 @@ impl HirDisplay for Ty {
                write_bounds_like_dyn_trait(predicates, f)?;
            }
            Ty::Opaque(opaque_ty) => {
-                let bounds = match opaque_ty.opaque_ty_id {
+                match opaque_ty.opaque_ty_id {
                    OpaqueTyId::ReturnTypeImplTrait(func, idx) => {
                        let datas =
                            f.db.return_type_impl_traits(func).expect("impl trait id without data");
                        let data = (*datas)
                            .as_ref()
                            .map(|rpit| rpit.impl_traits[idx as usize].bounds.clone());
-                        data.subst(&opaque_ty.parameters)
+                        let bounds = data.subst(&opaque_ty.parameters);
+                        write!(f, "impl ")?;
+                        write_bounds_like_dyn_trait(&bounds.value, f)?;
+                    }
+                    OpaqueTyId::AsyncBlockTypeImplTrait(..) => {
+                        write!(f, "{{async block}}")?;
                    }
                };
-                write!(f, "impl ")?;
-                write_bounds_like_dyn_trait(&bounds.value, f)?;
            }
            Ty::Unknown => write!(f, "{{unknown}}")?,
            Ty::Infer(..) => write!(f, "_")?,
diff --git a/crates/hir_ty/src/infer.rs b/crates/hir_ty/src/infer.rs
index 03b00b101..2b53b8297 100644
--- a/crates/hir_ty/src/infer.rs
+++ b/crates/hir_ty/src/infer.rs
@@ -125,7 +125,7 @@ pub struct InferenceResult {
    field_resolutions: FxHashMap<ExprId, FieldId>,
    /// For each field in record literal, records the field it resolves to.
    record_field_resolutions: FxHashMap<ExprId, FieldId>,
-    record_field_pat_resolutions: FxHashMap<PatId, FieldId>,
+    record_pat_field_resolutions: FxHashMap<PatId, FieldId>,
    /// For each struct literal, records the variant it resolves to.
    variant_resolutions: FxHashMap<ExprOrPatId, VariantId>,
    /// For each associated item record what it resolves to
@@ -146,8 +146,8 @@ impl InferenceResult {
    pub fn record_field_resolution(&self, expr: ExprId) -> Option<FieldId> {
        self.record_field_resolutions.get(&expr).copied()
    }
-    pub fn record_field_pat_resolution(&self, pat: PatId) -> Option<FieldId> {
+    pub fn record_pat_field_resolution(&self, pat: PatId) -> Option<FieldId> {
-        self.record_field_pat_resolutions.get(&pat).copied()
+        self.record_pat_field_resolutions.get(&pat).copied()
    }
    pub fn variant_resolution_for_expr(&self, id: ExprId) -> Option<VariantId> {
        self.variant_resolutions.get(&id.into()).copied()
diff --git a/crates/hir_ty/src/infer/expr.rs b/crates/hir_ty/src/infer/expr.rs
index a2f849d02..0a141b9cb 100644
--- a/crates/hir_ty/src/infer/expr.rs
+++ b/crates/hir_ty/src/infer/expr.rs
@@ -17,8 +17,8 @@ use crate::{
    autoderef, method_resolution, op,
    traits::{FnTrait, InEnvironment},
    utils::{generics, variant_data, Generics},
-    ApplicationTy, Binders, CallableDefId, InferTy, IntTy, Mutability, Obligation, Rawness, Substs,
+    ApplicationTy, Binders, CallableDefId, InferTy, IntTy, Mutability, Obligation, OpaqueTyId,
-    TraitRef, Ty, TypeCtor,
+    Rawness, Substs, TraitRef, Ty, TypeCtor,
 };
 use super::{
@@ -146,6 +146,13 @@ impl<'a> InferenceContext<'a> {
                // FIXME should be std::result::Result<{inner}, _>
                Ty::Unknown
            }
+            Expr::Async { body } => {
+                // Use the first type parameter as the output type of future.
+                // existenail type AsyncBlockImplTrait<InnerType>: Future<Output = InnerType>
+                let inner_ty = self.infer_expr(*body, &Expectation::none());
+                let opaque_ty_id = OpaqueTyId::AsyncBlockTypeImplTrait(self.owner, *body);
+                Ty::apply_one(TypeCtor::OpaqueType(opaque_ty_id), inner_ty)
+            }
            Expr::Loop { body, label } => {
                self.breakables.push(BreakableContext {
                    may_break: false,
diff --git a/crates/hir_ty/src/infer/pat.rs b/crates/hir_ty/src/infer/pat.rs
index 4dd4f9802..cde2ab82b 100644
--- a/crates/hir_ty/src/infer/pat.rs
+++ b/crates/hir_ty/src/infer/pat.rs
@@ -70,7 +70,7 @@ impl<'a> InferenceContext<'a> {
            let matching_field = var_data.as_ref().and_then(|it| it.field(&subpat.name));
            if let Some(local_id) = matching_field {
                let field_def = FieldId { parent: def.unwrap(), local_id };
-                self.result.record_field_pat_resolutions.insert(subpat.pat, field_def);
+                self.result.record_pat_field_resolutions.insert(subpat.pat, field_def);
            }
            let expected_ty =
@@ -209,6 +209,18 @@ impl<'a> InferenceContext<'a> {
                end_ty
            }
            Pat::Lit(expr) => self.infer_expr(*expr, &Expectation::has_type(expected.clone())),
+            Pat::Box { inner } => match self.resolve_boxed_box() {
+                Some(box_adt) => {
+                    let inner_expected = match expected.as_adt() {
+                        Some((adt, substs)) if adt == box_adt => substs.as_single(),
+                        _ => &Ty::Unknown,
+                    };
+                    let inner_ty = self.infer_pat(*inner, inner_expected, default_bm);
+                    Ty::apply_one(TypeCtor::Adt(box_adt), inner_ty)
+                }
+                None => Ty::Unknown,
+            },
            Pat::Missing => Ty::Unknown,
        };
        // use a new type variable if we got Ty::Unknown here
@@ -236,6 +248,6 @@ fn is_non_ref_pat(body: &hir_def::body::Body, pat: PatId) -> bool {
            Expr::Literal(Literal::String(..)) => false,
            _ => true,
        },
-        Pat::Wild | Pat::Bind { .. } | Pat::Ref { .. } | Pat::Missing => false,
+        Pat::Wild | Pat::Bind { .. } | Pat::Ref { .. } | Pat::Box { .. } | Pat::Missing => false,
    }
 }
diff --git a/crates/hir_ty/src/lib.rs b/crates/hir_ty/src/lib.rs
index 1e748476a..768d95eff 100644
--- a/crates/hir_ty/src/lib.rs
+++ b/crates/hir_ty/src/lib.rs
@@ -129,10 +129,14 @@ pub enum TypeCtor {
    /// This represents a placeholder for an opaque type in situations where we
    /// don't know the hidden type (i.e. currently almost always). This is
-    /// analogous to the `AssociatedType` type constructor. As with that one,
+    /// analogous to the `AssociatedType` type constructor.
-    /// these are only produced by Chalk.
+    /// It is also used as the type of async block, with one type parameter
+    /// representing the Future::Output type.
    OpaqueType(OpaqueTyId),
+    /// Represents a foreign type declared in external blocks.
+    ForeignType(TypeAliasId),
    /// The type of a specific closure.
    ///
    /// The closure signature is stored in a `FnPtr` type in the first type
@@ -167,12 +171,18 @@ impl TypeCtor {
                let generic_params = generics(db.upcast(), type_alias.into());
                generic_params.len()
            }
+            TypeCtor::ForeignType(type_alias) => {
+                let generic_params = generics(db.upcast(), type_alias.into());
+                generic_params.len()
+            }
            TypeCtor::OpaqueType(opaque_ty_id) => {
                match opaque_ty_id {
                    OpaqueTyId::ReturnTypeImplTrait(func, _) => {
                        let generic_params = generics(db.upcast(), func.into());
                        generic_params.len()
                    }
+                    // 1 param representing Future::Output type.
+                    OpaqueTyId::AsyncBlockTypeImplTrait(..) => 1,
                }
            }
            TypeCtor::FnPtr { num_args, is_varargs: _ } => num_args as usize + 1,
@@ -201,10 +211,14 @@ impl TypeCtor {
            TypeCtor::AssociatedType(type_alias) => {
                Some(type_alias.lookup(db.upcast()).module(db.upcast()).krate)
            }
+            TypeCtor::ForeignType(type_alias) => {
+                Some(type_alias.lookup(db.upcast()).module(db.upcast()).krate)
+            }
            TypeCtor::OpaqueType(opaque_ty_id) => match opaque_ty_id {
                OpaqueTyId::ReturnTypeImplTrait(func, _) => {
                    Some(func.lookup(db.upcast()).module(db.upcast()).krate)
                }
+                OpaqueTyId::AsyncBlockTypeImplTrait(def, _) => Some(def.module(db.upcast()).krate),
            },
        }
    }
@@ -227,6 +241,7 @@ impl TypeCtor {
            TypeCtor::Adt(adt) => Some(adt.into()),
            TypeCtor::FnDef(callable) => Some(callable.into()),
            TypeCtor::AssociatedType(type_alias) => Some(type_alias.into()),
+            TypeCtor::ForeignType(type_alias) => Some(type_alias.into()),
            TypeCtor::OpaqueType(_impl_trait_id) => None,
        }
    }
@@ -843,6 +858,29 @@ impl Ty {
    pub fn impl_trait_bounds(&self, db: &dyn HirDatabase) -> Option<Vec<GenericPredicate>> {
        match self {
+            Ty::Apply(ApplicationTy { ctor: TypeCtor::OpaqueType(opaque_ty_id), .. }) => {
+                match opaque_ty_id {
+                    OpaqueTyId::AsyncBlockTypeImplTrait(def, _expr) => {
+                        let krate = def.module(db.upcast()).krate;
+                        if let Some(future_trait) = db
+                            .lang_item(krate, "future_trait".into())
+                            .and_then(|item| item.as_trait())
+                        {
+                            // This is only used by type walking.
+                            // Parameters will be walked outside, and projection predicate is not used.
+                            // So just provide the Future trait.
+                            let impl_bound = GenericPredicate::Implemented(TraitRef {
+                                trait_: future_trait,
+                                substs: Substs::empty(),
+                            });
+                            Some(vec![impl_bound])
+                        } else {
+                            None
+                        }
+                    }
+                    OpaqueTyId::ReturnTypeImplTrait(..) => None,
+                }
+            }
            Ty::Opaque(opaque_ty) => {
                let predicates = match opaque_ty.opaque_ty_id {
                    OpaqueTyId::ReturnTypeImplTrait(func, idx) => {
@@ -853,6 +891,8 @@ impl Ty {
                            data.subst(&opaque_ty.parameters)
                        })
                    }
+                    // It always has an parameter for Future::Output type.
+                    OpaqueTyId::AsyncBlockTypeImplTrait(..) => unreachable!(),
                };
                predicates.map(|it| it.value)
@@ -1065,6 +1105,7 @@ impl<T: TypeWalk> TypeWalk for Vec<T> {
 #[derive(Copy, Clone, PartialEq, Eq, Debug, Hash)]
 pub enum OpaqueTyId {
    ReturnTypeImplTrait(hir_def::FunctionId, u16),
+    AsyncBlockTypeImplTrait(hir_def::DefWithBodyId, ExprId),
 }
 #[derive(Clone, PartialEq, Eq, Debug, Hash)]
diff --git a/crates/hir_ty/src/lower.rs b/crates/hir_ty/src/lower.rs
index cd574e983..708e2af0f 100644
--- a/crates/hir_ty/src/lower.rs
+++ b/crates/hir_ty/src/lower.rs
@@ -1101,10 +1101,14 @@ fn type_for_type_alias(db: &dyn HirDatabase, t: TypeAliasId) -> Binders<Ty> {
    let resolver = t.resolver(db.upcast());
    let ctx =
        TyLoweringContext::new(db, &resolver).with_type_param_mode(TypeParamLoweringMode::Variable);
-    let type_ref = &db.type_alias_data(t).type_ref;
    let substs = Substs::bound_vars(&generics, DebruijnIndex::INNERMOST);
-    let inner = Ty::from_hir(&ctx, type_ref.as_ref().unwrap_or(&TypeRef::Error));
+    if db.type_alias_data(t).is_extern {
-    Binders::new(substs.len(), inner)
+        Binders::new(substs.len(), Ty::apply(TypeCtor::ForeignType(t), substs))
+    } else {
+        let type_ref = &db.type_alias_data(t).type_ref;
+        let inner = Ty::from_hir(&ctx, type_ref.as_ref().unwrap_or(&TypeRef::Error));
+        Binders::new(substs.len(), inner)
+    }
 }
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
diff --git a/crates/hir_ty/src/method_resolution.rs b/crates/hir_ty/src/method_resolution.rs
index ec59145c7..8961df404 100644
--- a/crates/hir_ty/src/method_resolution.rs
+++ b/crates/hir_ty/src/method_resolution.rs
@@ -250,6 +250,14 @@ impl Ty {
                TypeCtor::Adt(def_id) => {
                    return Some(std::iter::once(def_id.module(db.upcast()).krate).collect())
                }
+                TypeCtor::ForeignType(type_alias_id) => {
+                    return Some(
+                        std::iter::once(
+                            type_alias_id.lookup(db.upcast()).module(db.upcast()).krate,
+                        )
+                        .collect(),
+                    )
+                }
                TypeCtor::Bool => lang_item_crate!("bool"),
                TypeCtor::Char => lang_item_crate!("char"),
                TypeCtor::Float(f) => match f.bitness {
diff --git a/crates/hir_ty/src/tests/method_resolution.rs b/crates/hir_ty/src/tests/method_resolution.rs
index 23b2601e6..0f17ff151 100644
--- a/crates/hir_ty/src/tests/method_resolution.rs
+++ b/crates/hir_ty/src/tests/method_resolution.rs
@@ -1051,3 +1051,39 @@ fn dyn_trait_super_trait_not_in_scope() {
        "#]],
    );
 }
+#[test]
+fn method_resolution_foreign_opaque_type() {
+    check_infer(
+        r#"
+        extern "C" {
+            type S;
+            fn f() -> &'static S;
+        }
+        impl S {
+            fn foo(&self) -> bool {
+                true
+            }
+        }
+        fn test() {
+            let s = unsafe { f() };
+            s.foo();
+        }
+        "#,
+        expect![[r#"
+            75..79 'self': &S
+            89..109 '{     ...     }': bool
+            99..103 'true': bool
+            123..167 '{     ...o(); }': ()
+            133..134 's': &S
+            137..151 'unsafe { f() }': &S
+            144..151 '{ f() }': &S
+            146..147 'f': fn f() -> &S
+            146..149 'f()': &S
+            157..158 's': &S
+            157..164 's.foo()': bool
+        "#]],
+    );
+}
diff --git a/crates/hir_ty/src/tests/patterns.rs b/crates/hir_ty/src/tests/patterns.rs
index aeb191c79..6a965ac4f 100644
--- a/crates/hir_ty/src/tests/patterns.rs
+++ b/crates/hir_ty/src/tests/patterns.rs
@@ -654,3 +654,28 @@ fn slice_tail_pattern() {
        "#]],
    );
 }
+#[test]
+fn box_pattern() {
+    check_infer(
+        r#"
+        #[lang = "owned_box"]
+        pub struct Box<T>(T);
+        fn foo(params: Box<i32>) {
+            match params {
+                box integer => {}
+            }
+        }
+        "#,
+        expect![[r#"
+            52..58 'params': Box<i32>
+            70..124 '{     ...   } }': ()
+            76..122 'match ...     }': ()
+            82..88 'params': Box<i32>
+            99..110 'box integer': Box<i32>
+            103..110 'integer': i32
+            114..116 '{}': ()
+        "#]],
+    );
+}
diff --git a/crates/hir_ty/src/tests/simple.rs b/crates/hir_ty/src/tests/simple.rs
index 48db23a34..5b07948f3 100644
--- a/crates/hir_ty/src/tests/simple.rs
+++ b/crates/hir_ty/src/tests/simple.rs
@@ -1889,31 +1889,40 @@ fn fn_pointer_return() {
 fn effects_smoke_test() {
    check_infer(
        r#"
-        fn main() {
+        async fn main() {
            let x = unsafe { 92 };
            let y = async { async { () }.await };
            let z = try { () };
            let t = 'a: { 92 };
        }
+        #[prelude_import] use future::*;
+        mod future {
+            #[lang = "future_trait"]
+            pub trait Future { type Output; }
+        }
        "#,
        expect![[r#"
-            10..130 '{     ...2 }; }': ()
+            16..136 '{     ...2 }; }': ()
-            20..21 'x': i32
+            26..27 'x': i32
-            24..37 'unsafe { 92 }': i32
+            30..43 'unsafe { 92 }': i32
-            31..37 '{ 92 }': i32
+            37..43 '{ 92 }': i32
-            33..35 '92': i32
+            39..41 '92': i32
-            47..48 'y': {unknown}
+            53..54 'y': impl Future<Output = ()>
-            57..79 '{ asyn...wait }': {unknown}
+            57..85 'async ...wait }': impl Future<Output = ()>
-            59..77 'async ....await': {unknown}
+            63..85 '{ asyn...wait }': ()
-            65..71 '{ () }': ()
+            65..77 'async { () }': impl Future<Output = ()>
-            67..69 '()': ()
+            65..83 'async ....await': ()
-            89..90 'z': {unknown}
+            71..77 '{ () }': ()
-            93..103 'try { () }': {unknown}
+            73..75 '()': ()
-            97..103 '{ () }': ()
+            95..96 'z': {unknown}
-            99..101 '()': ()
+            99..109 'try { () }': {unknown}
-            113..114 't': i32
+            103..109 '{ () }': ()
-            121..127 '{ 92 }': i32
+            105..107 '()': ()
-            123..125 '92': i32
+            119..120 't': i32
+            127..133 '{ 92 }': i32
+            129..131 '92': i32
        "#]],
    )
 }
diff --git a/crates/hir_ty/src/tests/traits.rs b/crates/hir_ty/src/tests/traits.rs
index 1f1056962..41d097519 100644
--- a/crates/hir_ty/src/tests/traits.rs
+++ b/crates/hir_ty/src/tests/traits.rs
@@ -86,6 +86,46 @@ mod future {
 }
 #[test]
+fn infer_async_block() {
+    check_types(
+        r#"
+//- /main.rs crate:main deps:core
+async fn test() {
+    let a = async { 42 };
+    a;
+//  ^ impl Future<Output = i32>
+    let x = a.await;
+    x;
+//  ^ i32
+    let b = async {}.await;
+    b;
+//  ^ ()
+    let c = async {
+        let y = Option::None;
+        y
+    //  ^ Option<u64>
+    };
+    let _: Option<u64> = c.await;
+    c;
+//  ^ impl Future<Output = Option<u64>>
+}
+enum Option<T> { None, Some(T) }
+//- /core.rs crate:core
+#[prelude_import] use future::*;
+mod future {
+    #[lang = "future_trait"]
+    trait Future {
+        type Output;
+    }
+}
+"#,
+    );
+}
+#[test]
 fn infer_try() {
    check_types(
        r#"
diff --git a/crates/hir_ty/src/traits/chalk.rs b/crates/hir_ty/src/traits/chalk.rs
index 17c83b6a4..27f0ed628 100644
--- a/crates/hir_ty/src/traits/chalk.rs
+++ b/crates/hir_ty/src/traits/chalk.rs
@@ -11,6 +11,7 @@ use hir_def::{
    lang_item::{lang_attr, LangItemTarget},
    AssocContainerId, AssocItemId, HasModule, Lookup, TypeAliasId,
 };
+use hir_expand::name::name;
 use super::ChalkContext;
 use crate::{
@@ -18,10 +19,12 @@ use crate::{
    display::HirDisplay,
    method_resolution::{TyFingerprint, ALL_FLOAT_FPS, ALL_INT_FPS},
    utils::generics,
-    CallableDefId, DebruijnIndex, FnSig, GenericPredicate, Substs, Ty, TypeCtor,
+    BoundVar, CallableDefId, DebruijnIndex, FnSig, GenericPredicate, ProjectionPredicate,
+    ProjectionTy, Substs, TraitRef, Ty, TypeCtor,
 };
 use mapping::{
-    convert_where_clauses, generic_predicate_to_inline_bound, make_binders, TypeAliasAsValue,
+    convert_where_clauses, generic_predicate_to_inline_bound, make_binders, TypeAliasAsAssocType,
+    TypeAliasAsValue,
 };
 pub use self::interner::*;
@@ -166,27 +169,88 @@ impl<'a> chalk_solve::RustIrDatabase<Interner> for ChalkContext<'a> {
    fn opaque_ty_data(&self, id: chalk_ir::OpaqueTyId<Interner>) -> Arc<OpaqueTyDatum> {
        let interned_id = crate::db::InternedOpaqueTyId::from(id);
        let full_id = self.db.lookup_intern_impl_trait_id(interned_id);
-        let (func, idx) = match full_id {
+        let bound = match full_id {
-            crate::OpaqueTyId::ReturnTypeImplTrait(func, idx) => (func, idx),
+            crate::OpaqueTyId::ReturnTypeImplTrait(func, idx) => {
-        };
+                let datas = self
-        let datas =
+                    .db
-            self.db.return_type_impl_traits(func).expect("impl trait id without impl traits");
+                    .return_type_impl_traits(func)
-        let data = &datas.value.impl_traits[idx as usize];
+                    .expect("impl trait id without impl traits");
-        let bound = OpaqueTyDatumBound {
+                let data = &datas.value.impl_traits[idx as usize];
-            bounds: make_binders(
+                let bound = OpaqueTyDatumBound {
-                data.bounds
+                    bounds: make_binders(
-                    .value
+                        data.bounds
-                    .iter()
+                            .value
-                    .cloned()
+                            .iter()
-                    .filter(|b| !b.is_error())
+                            .cloned()
-                    .map(|b| b.to_chalk(self.db))
+                            .filter(|b| !b.is_error())
-                    .collect(),
+                            .map(|b| b.to_chalk(self.db))
-                1,
+                            .collect(),
-            ),
+                        1,
-            where_clauses: make_binders(vec![], 0),
+                    ),
+                    where_clauses: make_binders(vec![], 0),
+                };
+                let num_vars = datas.num_binders;
+                make_binders(bound, num_vars)
+            }
+            crate::OpaqueTyId::AsyncBlockTypeImplTrait(..) => {
+                if let Some((future_trait, future_output)) = self
+                    .db
+                    .lang_item(self.krate, "future_trait".into())
+                    .and_then(|item| item.as_trait())
+                    .and_then(|trait_| {
+                        let alias =
+                            self.db.trait_data(trait_).associated_type_by_name(&name![Output])?;
+                        Some((trait_, alias))
+                    })
+                {
+                    // Making up `AsyncBlock<T>: Future<Output = T>`
+                    //
+                    // |--------------------OpaqueTyDatum-------------------|
+                    //        |-------------OpaqueTyDatumBound--------------|
+                    // for<T> <Self> [Future<Self>, Future::Output<Self> = T]
+                    //     ^1  ^0            ^0                    ^0      ^1
+                    let impl_bound = GenericPredicate::Implemented(TraitRef {
+                        trait_: future_trait,
+                        // Self type as the first parameter.
+                        substs: Substs::single(Ty::Bound(BoundVar {
+                            debruijn: DebruijnIndex::INNERMOST,
+                            index: 0,
+                        })),
+                    });
+                    let proj_bound = GenericPredicate::Projection(ProjectionPredicate {
+                        // The parameter of the opaque type.
+                        ty: Ty::Bound(BoundVar { debruijn: DebruijnIndex::ONE, index: 0 }),
+                        projection_ty: ProjectionTy {
+                            associated_ty: future_output,
+                            // Self type as the first parameter.
+                            parameters: Substs::single(Ty::Bound(BoundVar::new(
+                                DebruijnIndex::INNERMOST,
+                                0,
+                            ))),
+                        },
+                    });
+                    let bound = OpaqueTyDatumBound {
+                        bounds: make_binders(
+                            vec![impl_bound.to_chalk(self.db), proj_bound.to_chalk(self.db)],
+                            1,
+                        ),
+                        where_clauses: make_binders(vec![], 0),
+                    };
+                    // The opaque type has 1 parameter.
+                    make_binders(bound, 1)
+                } else {
+                    // If failed to find `Future::Output`, return empty bounds as fallback.
+                    let bound = OpaqueTyDatumBound {
+                        bounds: make_binders(vec![], 0),
+                        where_clauses: make_binders(vec![], 0),
+                    };
+                    // The opaque type has 1 parameter.
+                    make_binders(bound, 1)
+                }
+            }
        };
-        let num_vars = datas.num_binders;
-        Arc::new(OpaqueTyDatum { opaque_ty_id: id, bound: make_binders(bound, num_vars) })
+        Arc::new(OpaqueTyDatum { opaque_ty_id: id, bound })
    }
    fn hidden_opaque_type(&self, _id: chalk_ir::OpaqueTyId<Interner>) -> chalk_ir::Ty<Interner> {
@@ -244,13 +308,17 @@ impl<'a> chalk_solve::RustIrDatabase<Interner> for ChalkContext<'a> {
        let id = from_chalk(self.db, trait_id);
        self.db.trait_data(id).name.to_string()
    }
-    // FIXME: lookup names
+    fn adt_name(&self, adt_id: chalk_ir::AdtId<Interner>) -> String {
-    fn adt_name(&self, struct_id: chalk_ir::AdtId<Interner>) -> String {
+        let id = from_chalk(self.db, adt_id);
-        let datum = self.db.struct_datum(self.krate, struct_id);
+        match id {
-        format!("{:?}", datum.name(&Interner))
+            hir_def::AdtId::StructId(id) => self.db.struct_data(id).name.to_string(),
+            hir_def::AdtId::EnumId(id) => self.db.enum_data(id).name.to_string(),
+            hir_def::AdtId::UnionId(id) => self.db.union_data(id).name.to_string(),
+        }
    }
    fn assoc_type_name(&self, assoc_ty_id: chalk_ir::AssocTypeId<Interner>) -> String {
-        format!("Assoc_{}", assoc_ty_id.0)
+        let id = self.db.associated_ty_data(assoc_ty_id).name;
+        self.db.type_alias_data(id).name.to_string()
    }
    fn opaque_type_name(&self, opaque_ty_id: chalk_ir::OpaqueTyId<Interner>) -> String {
        format!("Opaque_{}", opaque_ty_id.0)
@@ -273,7 +341,7 @@ pub(crate) fn associated_ty_data_query(
    id: AssocTypeId,
 ) -> Arc<AssociatedTyDatum> {
    debug!("associated_ty_data {:?}", id);
-    let type_alias: TypeAliasId = from_chalk(db, id);
+    let type_alias: TypeAliasId = from_chalk::<TypeAliasAsAssocType, _>(db, id).0;
    let trait_ = match type_alias.lookup(db.upcast()).container {
        AssocContainerId::TraitId(t) => t,
        _ => panic!("associated type not in trait"),
@@ -327,8 +395,10 @@ pub(crate) fn trait_datum_query(
        fundamental: false,
    };
    let where_clauses = convert_where_clauses(db, trait_.into(), &bound_vars);
-    let associated_ty_ids =
+    let associated_ty_ids = trait_data
-        trait_data.associated_types().map(|type_alias| type_alias.to_chalk(db)).collect();
+        .associated_types()
+        .map(|type_alias| TypeAliasAsAssocType(type_alias).to_chalk(db))
+        .collect();
    let trait_datum_bound = rust_ir::TraitDatumBound { where_clauses };
    let well_known =
        lang_attr(db.upcast(), trait_).and_then(|name| well_known_trait_from_lang_attr(&name));
@@ -366,6 +436,7 @@ fn lang_attr_from_well_known_trait(attr: WellKnownTrait) -> &'static str {
        WellKnownTrait::FnMut => "fn_mut",
        WellKnownTrait::Fn => "fn",
        WellKnownTrait::Unsize => "unsize",
+        WellKnownTrait::Unpin => "unpin",
    }
 }
@@ -509,7 +580,7 @@ fn type_alias_associated_ty_value(
    let value_bound = rust_ir::AssociatedTyValueBound { ty: ty.value.to_chalk(db) };
    let value = rust_ir::AssociatedTyValue {
        impl_id: impl_id.to_chalk(db),
-        associated_ty_id: assoc_ty.to_chalk(db),
+        associated_ty_id: TypeAliasAsAssocType(assoc_ty).to_chalk(db),
        value: make_binders(value_bound, ty.num_binders),
    };
    Arc::new(value)
@@ -544,9 +615,11 @@ pub(crate) fn fn_def_datum_query(
    };
    let datum = FnDefDatum {
        id: fn_def_id,
-        abi: (),
+        sig: chalk_ir::FnSig {
-        safety: chalk_ir::Safety::Safe,
+            abi: (),
-        variadic: sig.value.is_varargs,
+            safety: chalk_ir::Safety::Safe,
+            variadic: sig.value.is_varargs,
+        },
        binders: make_binders(bound, sig.num_binders),
    };
    Arc::new(datum)
diff --git a/crates/hir_ty/src/traits/chalk/interner.rs b/crates/hir_ty/src/traits/chalk/interner.rs
index fc0f9c201..f9304b7d0 100644
--- a/crates/hir_ty/src/traits/chalk/interner.rs
+++ b/crates/hir_ty/src/traits/chalk/interner.rs
@@ -12,6 +12,7 @@ pub struct Interner;
 pub type AssocTypeId = chalk_ir::AssocTypeId<Interner>;
 pub type AssociatedTyDatum = chalk_solve::rust_ir::AssociatedTyDatum<Interner>;
+pub type ForeignDefId = chalk_ir::ForeignDefId<Interner>;
 pub type TraitId = chalk_ir::TraitId<Interner>;
 pub type TraitDatum = chalk_solve::rust_ir::TraitDatum<Interner>;
 pub type AdtId = chalk_ir::AdtId<Interner>;
@@ -26,7 +27,7 @@ pub type OpaqueTyId = chalk_ir::OpaqueTyId<Interner>;
 pub type OpaqueTyDatum = chalk_solve::rust_ir::OpaqueTyDatum<Interner>;
 impl chalk_ir::interner::Interner for Interner {
-    type InternedType = Box<chalk_ir::TyData<Self>>; // FIXME use Arc?
+    type InternedType = Arc<chalk_ir::TyData<Self>>;
    type InternedLifetime = chalk_ir::LifetimeData<Self>;
    type InternedConst = Arc<chalk_ir::ConstData<Self>>;
    type InternedConcreteConst = ();
@@ -34,7 +35,7 @@ impl chalk_ir::interner::Interner for Interner {
    type InternedGoal = Arc<GoalData<Self>>;
    type InternedGoals = Vec<Goal<Self>>;
    type InternedSubstitution = Vec<GenericArg<Self>>;
-    type InternedProgramClause = chalk_ir::ProgramClauseData<Self>;
+    type InternedProgramClause = Arc<chalk_ir::ProgramClauseData<Self>>;
    type InternedProgramClauses = Arc<[chalk_ir::ProgramClause<Self>]>;
    type InternedQuantifiedWhereClauses = Vec<chalk_ir::QuantifiedWhereClause<Self>>;
    type InternedVariableKinds = Vec<chalk_ir::VariableKind<Self>>;
@@ -197,11 +198,11 @@ impl chalk_ir::interner::Interner for Interner {
        tls::with_current_program(|prog| Some(prog?.debug_quantified_where_clauses(clauses, fmt)))
    }
-    fn intern_ty(&self, ty: chalk_ir::TyData<Self>) -> Box<chalk_ir::TyData<Self>> {
+    fn intern_ty(&self, ty: chalk_ir::TyData<Self>) -> Arc<chalk_ir::TyData<Self>> {
-        Box::new(ty)
+        Arc::new(ty)
    }
-    fn ty_data<'a>(&self, ty: &'a Box<chalk_ir::TyData<Self>>) -> &'a chalk_ir::TyData<Self> {
+    fn ty_data<'a>(&self, ty: &'a Arc<chalk_ir::TyData<Self>>) -> &'a chalk_ir::TyData<Self> {
        ty
    }
@@ -230,7 +231,7 @@ impl chalk_ir::interner::Interner for Interner {
        constant
    }
-    fn const_eq(&self, _ty: &Box<chalk_ir::TyData<Self>>, _c1: &(), _c2: &()) -> bool {
+    fn const_eq(&self, _ty: &Arc<chalk_ir::TyData<Self>>, _c1: &(), _c2: &()) -> bool {
        true
    }
@@ -284,13 +285,13 @@ impl chalk_ir::interner::Interner for Interner {
    fn intern_program_clause(
        &self,
        data: chalk_ir::ProgramClauseData<Self>,
-    ) -> chalk_ir::ProgramClauseData<Self> {
+    ) -> Arc<chalk_ir::ProgramClauseData<Self>> {
-        data
+        Arc::new(data)
    }
    fn program_clause_data<'a>(
        &self,
-        clause: &'a chalk_ir::ProgramClauseData<Self>,
+        clause: &'a Arc<chalk_ir::ProgramClauseData<Self>>,
    ) -> &'a chalk_ir::ProgramClauseData<Self> {
        clause
    }
diff --git a/crates/hir_ty/src/traits/chalk/mapping.rs b/crates/hir_ty/src/traits/chalk/mapping.rs
index fe62f3fa7..d42f4bba9 100644
--- a/crates/hir_ty/src/traits/chalk/mapping.rs
+++ b/crates/hir_ty/src/traits/chalk/mapping.rs
@@ -34,9 +34,11 @@ impl ToChalk for Ty {
                    let substitution = apply_ty.parameters.to_chalk(db).shifted_in(&Interner);
                    chalk_ir::TyData::Function(chalk_ir::FnPointer {
                        num_binders: 0,
-                        abi: (),
+                        sig: chalk_ir::FnSig {
-                        safety: chalk_ir::Safety::Safe,
+                            abi: (),
-                        variadic: is_varargs,
+                            safety: chalk_ir::Safety::Safe,
+                            variadic: is_varargs,
+                        },
                        substitution,
                    })
                    .intern(&Interner)
@@ -48,7 +50,7 @@ impl ToChalk for Ty {
                }
            },
            Ty::Projection(proj_ty) => {
-                let associated_ty_id = proj_ty.associated_ty.to_chalk(db);
+                let associated_ty_id = TypeAliasAsAssocType(proj_ty.associated_ty).to_chalk(db);
                let substitution = proj_ty.parameters.to_chalk(db);
                chalk_ir::AliasTy::Projection(chalk_ir::ProjectionTy {
                    associated_ty_id,
@@ -114,7 +116,8 @@ impl ToChalk for Ty {
                Ty::Placeholder(db.lookup_intern_type_param_id(interned_id))
            }
            chalk_ir::TyData::Alias(chalk_ir::AliasTy::Projection(proj)) => {
-                let associated_ty = from_chalk(db, proj.associated_ty_id);
+                let associated_ty =
+                    from_chalk::<TypeAliasAsAssocType, _>(db, proj.associated_ty_id).0;
                let parameters = from_chalk(db, proj.substitution);
                Ty::Projection(ProjectionTy { associated_ty, parameters })
            }
@@ -125,7 +128,7 @@ impl ToChalk for Ty {
            }
            chalk_ir::TyData::Function(chalk_ir::FnPointer {
                num_binders,
-                variadic,
+                sig: chalk_ir::FnSig { variadic, .. },
                substitution,
                ..
            }) => {
@@ -290,8 +293,9 @@ impl ToChalk for TypeCtor {
    fn to_chalk(self, db: &dyn HirDatabase) -> TypeName<Interner> {
        match self {
            TypeCtor::AssociatedType(type_alias) => {
-                let type_id = type_alias.to_chalk(db);
+                let assoc_type = TypeAliasAsAssocType(type_alias);
-                TypeName::AssociatedType(type_id)
+                let assoc_type_id = assoc_type.to_chalk(db);
+                TypeName::AssociatedType(assoc_type_id)
            }
            TypeCtor::OpaqueType(impl_trait_id) => {
@@ -299,6 +303,12 @@ impl ToChalk for TypeCtor {
                TypeName::OpaqueType(id)
            }
+            TypeCtor::ForeignType(type_alias) => {
+                let foreign_type = TypeAliasAsForeignType(type_alias);
+                let foreign_type_id = foreign_type.to_chalk(db);
+                TypeName::Foreign(foreign_type_id)
+            }
            TypeCtor::Bool => TypeName::Scalar(Scalar::Bool),
            TypeCtor::Char => TypeName::Scalar(Scalar::Char),
            TypeCtor::Int(int_ty) => TypeName::Scalar(int_ty_to_chalk(int_ty)),
@@ -339,7 +349,9 @@ impl ToChalk for TypeCtor {
    fn from_chalk(db: &dyn HirDatabase, type_name: TypeName<Interner>) -> TypeCtor {
        match type_name {
            TypeName::Adt(struct_id) => TypeCtor::Adt(struct_id.0),
-            TypeName::AssociatedType(type_id) => TypeCtor::AssociatedType(from_chalk(db, type_id)),
+            TypeName::AssociatedType(type_id) => {
+                TypeCtor::AssociatedType(from_chalk::<TypeAliasAsAssocType, _>(db, type_id).0)
+            }
            TypeName::OpaqueType(opaque_type_id) => {
                TypeCtor::OpaqueType(from_chalk(db, opaque_type_id))
            }
@@ -379,6 +391,10 @@ impl ToChalk for TypeCtor {
                TypeCtor::Closure { def, expr }
            }
+            TypeName::Foreign(foreign_def_id) => {
+                TypeCtor::ForeignType(from_chalk::<TypeAliasAsForeignType, _>(db, foreign_def_id).0)
+            }
            TypeName::Error => {
                // this should not be reached, since we don't represent TypeName::Error with TypeCtor
                unreachable!()
@@ -464,6 +480,18 @@ impl ToChalk for hir_def::ImplId {
    }
 }
+impl ToChalk for hir_def::AdtId {
+    type Chalk = AdtId;
+    fn to_chalk(self, _db: &dyn HirDatabase) -> Self::Chalk {
+        chalk_ir::AdtId(self.into())
+    }
+    fn from_chalk(_db: &dyn HirDatabase, id: AdtId) -> Self {
+        id.0
+    }
+}
 impl ToChalk for CallableDefId {
    type Chalk = FnDefId;
@@ -476,15 +504,31 @@ impl ToChalk for CallableDefId {
    }
 }
-impl ToChalk for TypeAliasId {
+pub struct TypeAliasAsAssocType(pub TypeAliasId);
+impl ToChalk for TypeAliasAsAssocType {
    type Chalk = AssocTypeId;
    fn to_chalk(self, _db: &dyn HirDatabase) -> AssocTypeId {
-        chalk_ir::AssocTypeId(self.as_intern_id())
+        chalk_ir::AssocTypeId(self.0.as_intern_id())
+    }
+    fn from_chalk(_db: &dyn HirDatabase, assoc_type_id: AssocTypeId) -> TypeAliasAsAssocType {
+        TypeAliasAsAssocType(InternKey::from_intern_id(assoc_type_id.0))
+    }
+}
+pub struct TypeAliasAsForeignType(pub TypeAliasId);
+impl ToChalk for TypeAliasAsForeignType {
+    type Chalk = ForeignDefId;
+    fn to_chalk(self, _db: &dyn HirDatabase) -> ForeignDefId {
+        chalk_ir::ForeignDefId(self.0.as_intern_id())
    }
-    fn from_chalk(_db: &dyn HirDatabase, type_alias_id: AssocTypeId) -> TypeAliasId {
+    fn from_chalk(_db: &dyn HirDatabase, foreign_def_id: ForeignDefId) -> TypeAliasAsForeignType {
-        InternKey::from_intern_id(type_alias_id.0)
+        TypeAliasAsForeignType(InternKey::from_intern_id(foreign_def_id.0))
    }
 }
@@ -568,7 +612,7 @@ impl ToChalk for ProjectionTy {
    fn to_chalk(self, db: &dyn HirDatabase) -> chalk_ir::ProjectionTy<Interner> {
        chalk_ir::ProjectionTy {
-            associated_ty_id: self.associated_ty.to_chalk(db),
+            associated_ty_id: TypeAliasAsAssocType(self.associated_ty).to_chalk(db),
            substitution: self.parameters.to_chalk(db),
        }
    }
@@ -578,7 +622,11 @@ impl ToChalk for ProjectionTy {
        projection_ty: chalk_ir::ProjectionTy<Interner>,
    ) -> ProjectionTy {
        ProjectionTy {
-            associated_ty: from_chalk(db, projection_ty.associated_ty_id),
+            associated_ty: from_chalk::<TypeAliasAsAssocType, _>(
+                db,
+                projection_ty.associated_ty_id,
+            )
+            .0,
            parameters: from_chalk(db, projection_ty.substitution),
        }
    }
@@ -777,7 +825,8 @@ pub(super) fn generic_predicate_to_inline_bound(
            let alias_eq_bound = rust_ir::AliasEqBound {
                value: proj.ty.clone().to_chalk(db),
                trait_bound: rust_ir::TraitBound { trait_id: trait_.to_chalk(db), args_no_self },
-                associated_ty_id: proj.projection_ty.associated_ty.to_chalk(db),
+                associated_ty_id: TypeAliasAsAssocType(proj.projection_ty.associated_ty)
+                    .to_chalk(db),
                parameters: Vec::new(), // FIXME we don't support generic associated types yet
            };
            Some(rust_ir::InlineBound::AliasEqBound(alias_eq_bound))
diff --git a/crates/hir_ty/src/traits/chalk/tls.rs b/crates/hir_ty/src/traits/chalk/tls.rs
index db915625c..b4568cff6 100644
--- a/crates/hir_ty/src/traits/chalk/tls.rs
+++ b/crates/hir_ty/src/traits/chalk/tls.rs
@@ -4,7 +4,7 @@ use std::fmt;
 use chalk_ir::{AliasTy, GenericArg, Goal, Goals, Lifetime, ProgramClauseImplication, TypeName};
 use itertools::Itertools;
-use super::{from_chalk, Interner};
+use super::{from_chalk, Interner, TypeAliasAsAssocType};
 use crate::{db::HirDatabase, CallableDefId, TypeCtor};
 use hir_def::{AdtId, AssocContainerId, DefWithBodyId, Lookup, TypeAliasId};
@@ -73,7 +73,14 @@ impl DebugContext<'_> {
                crate::OpaqueTyId::ReturnTypeImplTrait(func, idx) => {
                    write!(f, "{{impl trait {} of {:?}}}", idx, func)?;
                }
+                crate::OpaqueTyId::AsyncBlockTypeImplTrait(def, idx) => {
+                    write!(f, "{{impl trait of async block {} of {:?}}}", idx.into_raw(), def)?;
+                }
            },
+            TypeCtor::ForeignType(type_alias) => {
+                let name = self.0.type_alias_data(type_alias).name.clone();
+                write!(f, "{}", name)?;
+            }
            TypeCtor::Closure { def, expr } => {
                write!(f, "{{closure {:?} in ", expr.into_raw())?;
                match def {
@@ -116,7 +123,7 @@ impl DebugContext<'_> {
        id: super::AssocTypeId,
        fmt: &mut fmt::Formatter<'_>,
    ) -> Result<(), fmt::Error> {
-        let type_alias: TypeAliasId = from_chalk(self.0, id);
+        let type_alias: TypeAliasId = from_chalk::<TypeAliasAsAssocType, _>(self.0, id).0;
        let type_alias_data = self.0.type_alias_data(type_alias);
        let trait_ = match type_alias.lookup(self.0.upcast()).container {
            AssocContainerId::TraitId(t) => t,
@@ -150,7 +157,8 @@ impl DebugContext<'_> {
        projection_ty: &chalk_ir::ProjectionTy<Interner>,
        fmt: &mut fmt::Formatter<'_>,
    ) -> Result<(), fmt::Error> {
-        let type_alias: TypeAliasId = from_chalk(self.0, projection_ty.associated_ty_id);
+        let type_alias: TypeAliasId =
+            from_chalk::<TypeAliasAsAssocType, _>(self.0, projection_ty.associated_ty_id).0;
        let type_alias_data = self.0.type_alias_data(type_alias);
        let trait_ = match type_alias.lookup(self.0.upcast()).container {
            AssocContainerId::TraitId(t) => t,
diff --git a/crates/ide/src/completion.rs b/crates/ide/src/completion.rs
index 33bed6991..daea2aa95 100644
--- a/crates/ide/src/completion.rs
+++ b/crates/ide/src/completion.rs
@@ -19,6 +19,7 @@ mod complete_unqualified_path;
 mod complete_postfix;
 mod complete_macro_in_item_position;
 mod complete_trait_impl;
+mod complete_mod;
 use ide_db::RootDatabase;
@@ -124,6 +125,7 @@ pub(crate) fn completions(
    complete_postfix::complete_postfix(&mut acc, &ctx);
    complete_macro_in_item_position::complete_macro_in_item_position(&mut acc, &ctx);
    complete_trait_impl::complete_trait_impl(&mut acc, &ctx);
+    complete_mod::complete_mod(&mut acc, &ctx);
    Some(acc)
 }
diff --git a/crates/ide/src/completion/complete_attribute.rs b/crates/ide/src/completion/complete_attribute.rs
index 0abfaebcb..f4a9864d1 100644
--- a/crates/ide/src/completion/complete_attribute.rs
+++ b/crates/ide/src/completion/complete_attribute.rs
@@ -13,6 +13,10 @@ use crate::completion::{
 };
 pub(super) fn complete_attribute(acc: &mut Completions, ctx: &CompletionContext) -> Option<()> {
+    if ctx.mod_declaration_under_caret.is_some() {
+        return None;
+    }
    let attribute = ctx.attribute_under_caret.as_ref()?;
    match (attribute.path(), attribute.token_tree()) {
        (Some(path), Some(token_tree)) if path.to_string() == "derive" => {
diff --git a/crates/ide/src/completion/complete_keyword.rs b/crates/ide/src/completion/complete_keyword.rs
index 53ba76e0e..5645b41fa 100644
--- a/crates/ide/src/completion/complete_keyword.rs
+++ b/crates/ide/src/completion/complete_keyword.rs
@@ -510,6 +510,28 @@ pub mod future {
            expect![[r#"
                kw await expr.await
            "#]],
+        );
+        check(
+            r#"
+//- /main.rs
+use std::future::*;
+fn foo() {
+    let a = async {};
+    a.<|>
+}
+//- /std/lib.rs
+pub mod future {
+    #[lang = "future_trait"]
+    pub trait Future {
+        type Output;
+    }
+}
+"#,
+            expect![[r#"
+                kw await expr.await
+            "#]],
        )
    }
diff --git a/crates/ide/src/completion/complete_mod.rs b/crates/ide/src/completion/complete_mod.rs
new file mode 100644
index 000000000..3cfc2e131
--- /dev/null
+++ b/crates/ide/src/completion/complete_mod.rs
@@ -0,0 +1,324 @@
+//! Completes mod declarations.
+use base_db::{SourceDatabaseExt, VfsPath};
+use hir::{Module, ModuleSource};
+use ide_db::RootDatabase;
+use rustc_hash::FxHashSet;
+use crate::{CompletionItem, CompletionItemKind};
+use super::{
+    completion_context::CompletionContext, completion_item::CompletionKind,
+    completion_item::Completions,
+};
+/// Complete mod declaration, i.e. `mod <|> ;`
+pub(super) fn complete_mod(acc: &mut Completions, ctx: &CompletionContext) -> Option<()> {
+    let mod_under_caret = match &ctx.mod_declaration_under_caret {
+        Some(mod_under_caret) if mod_under_caret.item_list().is_some() => return None,
+        Some(mod_under_caret) => mod_under_caret,
+        None => return None,
+    };
+    let _p = profile::span("completion::complete_mod");
+    let current_module = ctx.scope.module()?;
+    let module_definition_file =
+        current_module.definition_source(ctx.db).file_id.original_file(ctx.db);
+    let source_root = ctx.db.source_root(ctx.db.file_source_root(module_definition_file));
+    let directory_to_look_for_submodules = directory_to_look_for_submodules(
+        current_module,
+        ctx.db,
+        source_root.path_for_file(&module_definition_file)?,
+    )?;
+    let existing_mod_declarations = current_module
+        .children(ctx.db)
+        .filter_map(|module| Some(module.name(ctx.db)?.to_string()))
+        .collect::<FxHashSet<_>>();
+    let module_declaration_file =
+        current_module.declaration_source(ctx.db).map(|module_declaration_source_file| {
+            module_declaration_source_file.file_id.original_file(ctx.db)
+        });
+    source_root
+        .iter()
+        .filter(|submodule_candidate_file| submodule_candidate_file != &module_definition_file)
+        .filter(|submodule_candidate_file| {
+            Some(submodule_candidate_file) != module_declaration_file.as_ref()
+        })
+        .filter_map(|submodule_file| {
+            let submodule_path = source_root.path_for_file(&submodule_file)?;
+            let directory_with_submodule = submodule_path.parent()?;
+            match submodule_path.name_and_extension()? {
+                ("lib", Some("rs")) | ("main", Some("rs")) => None,
+                ("mod", Some("rs")) => {
+                    if directory_with_submodule.parent()? == directory_to_look_for_submodules {
+                        match directory_with_submodule.name_and_extension()? {
+                            (directory_name, None) => Some(directory_name.to_owned()),
+                            _ => None,
+                        }
+                    } else {
+                        None
+                    }
+                }
+                (file_name, Some("rs"))
+                    if directory_with_submodule == directory_to_look_for_submodules =>
+                {
+                    Some(file_name.to_owned())
+                }
+                _ => None,
+            }
+        })
+        .filter(|name| !existing_mod_declarations.contains(name))
+        .for_each(|submodule_name| {
+            let mut label = submodule_name;
+            if mod_under_caret.semicolon_token().is_none() {
+                label.push(';')
+            }
+            acc.add(
+                CompletionItem::new(CompletionKind::Magic, ctx.source_range(), &label)
+                    .kind(CompletionItemKind::Module),
+            )
+        });
+    Some(())
+}
+fn directory_to_look_for_submodules(
+    module: Module,
+    db: &RootDatabase,
+    module_file_path: &VfsPath,
+) -> Option<VfsPath> {
+    let directory_with_module_path = module_file_path.parent()?;
+    let base_directory = match module_file_path.name_and_extension()? {
+        ("mod", Some("rs")) | ("lib", Some("rs")) | ("main", Some("rs")) => {
+            Some(directory_with_module_path)
+        }
+        (regular_rust_file_name, Some("rs")) => {
+            if matches!(
+                (
+                    directory_with_module_path
+                        .parent()
+                        .as_ref()
+                        .and_then(|path| path.name_and_extension()),
+                    directory_with_module_path.name_and_extension(),
+                ),
+                (Some(("src", None)), Some(("bin", None)))
+            ) {
+                // files in /src/bin/ can import each other directly
+                Some(directory_with_module_path)
+            } else {
+                directory_with_module_path.join(regular_rust_file_name)
+            }
+        }
+        _ => None,
+    }?;
+    let mut resulting_path = base_directory;
+    for module in module_chain_to_containing_module_file(module, db) {
+        if let Some(name) = module.name(db) {
+            resulting_path = resulting_path.join(&name.to_string())?;
+        }
+    }
+    Some(resulting_path)
+}
+fn module_chain_to_containing_module_file(
+    current_module: Module,
+    db: &RootDatabase,
+) -> Vec<Module> {
+    let mut path = Vec::new();
+    let mut current_module = Some(current_module);
+    while let Some(ModuleSource::Module(_)) =
+        current_module.map(|module| module.definition_source(db).value)
+    {
+        if let Some(module) = current_module {
+            path.insert(0, module);
+            current_module = module.parent(db);
+        } else {
+            current_module = None;
+        }
+    }
+    path
+}
+#[cfg(test)]
+mod tests {
+    use crate::completion::{test_utils::completion_list, CompletionKind};
+    use expect_test::{expect, Expect};
+    fn check(ra_fixture: &str, expect: Expect) {
+        let actual = completion_list(ra_fixture, CompletionKind::Magic);
+        expect.assert_eq(&actual);
+    }
+    #[test]
+    fn lib_module_completion() {
+        check(
+            r#"
+            //- /lib.rs
+            mod <|>
+            //- /foo.rs
+            fn foo() {}
+            //- /foo/ignored_foo.rs
+            fn ignored_foo() {}
+            //- /bar/mod.rs
+            fn bar() {}
+            //- /bar/ignored_bar.rs
+            fn ignored_bar() {}
+        "#,
+            expect![[r#"
+                md bar;
+                md foo;
+            "#]],
+        );
+    }
+    #[test]
+    fn no_module_completion_with_module_body() {
+        check(
+            r#"
+            //- /lib.rs
+            mod <|> {
+            }
+            //- /foo.rs
+            fn foo() {}
+        "#,
+            expect![[r#""#]],
+        );
+    }
+    #[test]
+    fn main_module_completion() {
+        check(
+            r#"
+            //- /main.rs
+            mod <|>
+            //- /foo.rs
+            fn foo() {}
+            //- /foo/ignored_foo.rs
+            fn ignored_foo() {}
+            //- /bar/mod.rs
+            fn bar() {}
+            //- /bar/ignored_bar.rs
+            fn ignored_bar() {}
+        "#,
+            expect![[r#"
+                md bar;
+                md foo;
+            "#]],
+        );
+    }
+    #[test]
+    fn main_test_module_completion() {
+        check(
+            r#"
+            //- /main.rs
+            mod tests {
+                mod <|>;
+            }
+            //- /tests/foo.rs
+            fn foo() {}
+        "#,
+            expect![[r#"
+                md foo
+            "#]],
+        );
+    }
+    #[test]
+    fn directly_nested_module_completion() {
+        check(
+            r#"
+            //- /lib.rs
+            mod foo;
+            //- /foo.rs
+            mod <|>;
+            //- /foo/bar.rs
+            fn bar() {}
+            //- /foo/bar/ignored_bar.rs
+            fn ignored_bar() {}
+            //- /foo/baz/mod.rs
+            fn baz() {}
+            //- /foo/moar/ignored_moar.rs
+            fn ignored_moar() {}
+        "#,
+            expect![[r#"
+                md bar
+                md baz
+            "#]],
+        );
+    }
+    #[test]
+    fn nested_in_source_module_completion() {
+        check(
+            r#"
+            //- /lib.rs
+            mod foo;
+            //- /foo.rs
+            mod bar {
+                mod <|>
+            }
+            //- /foo/bar/baz.rs
+            fn baz() {}
+        "#,
+            expect![[r#"
+                md baz;
+            "#]],
+        );
+    }
+    // FIXME binary modules are not supported in tests properly
+    // Binary modules are a bit special, they allow importing the modules from `/src/bin`
+    // and that's why are good to test two things:
+    // * no cycles are allowed in mod declarations
+    // * no modules from the parent directory are proposed
+    // Unfortunately, binary modules support is in cargo not rustc,
+    // hence the test does not work now
+    //
+    // #[test]
+    // fn regular_bin_module_completion() {
+    //     check(
+    //         r#"
+    //         //- /src/bin.rs
+    //         fn main() {}
+    //         //- /src/bin/foo.rs
+    //         mod <|>
+    //         //- /src/bin/bar.rs
+    //         fn bar() {}
+    //         //- /src/bin/bar/bar_ignored.rs
+    //         fn bar_ignored() {}
+    //     "#,
+    //         expect![[r#"
+    //             md bar;
+    //         "#]],
+    //     );
+    // }
+    #[test]
+    fn already_declared_bin_module_completion_omitted() {
+        check(
+            r#"
+            //- /src/bin.rs
+            fn main() {}
+            //- /src/bin/foo.rs
+            mod <|>
+            //- /src/bin/bar.rs
+            mod foo;
+            fn bar() {}
+            //- /src/bin/bar/bar_ignored.rs
+            fn bar_ignored() {}
+        "#,
+            expect![[r#""#]],
+        );
+    }
+}
diff --git a/crates/ide/src/completion/complete_qualified_path.rs b/crates/ide/src/completion/complete_qualified_path.rs
index accb09f7e..00e89f0fd 100644
--- a/crates/ide/src/completion/complete_qualified_path.rs
+++ b/crates/ide/src/completion/complete_qualified_path.rs
@@ -13,7 +13,7 @@ pub(super) fn complete_qualified_path(acc: &mut Completions, ctx: &CompletionCon
        None => return,
    };
-    if ctx.attribute_under_caret.is_some() {
+    if ctx.attribute_under_caret.is_some() || ctx.mod_declaration_under_caret.is_some() {
        return;
    }
@@ -730,4 +730,26 @@ fn f() {}
            expect![[""]],
        );
    }
+    #[test]
+    fn completes_function() {
+        check(
+            r#"
+fn foo(
+    a: i32,
+    b: i32
+) {
+}
+fn main() {
+    fo<|>
+}
+"#,
+            expect![[r#"
+                fn foo(…) fn foo(a: i32, b: i32)
+                fn main() fn main()
+            "#]],
+        );
+    }
 }
diff --git a/crates/ide/src/completion/complete_trait_impl.rs b/crates/ide/src/completion/complete_trait_impl.rs
index 26f268bd1..ff115df92 100644
--- a/crates/ide/src/completion/complete_trait_impl.rs
+++ b/crates/ide/src/completion/complete_trait_impl.rs
@@ -46,76 +46,86 @@ use crate::{
    display::function_declaration,
 };
+#[derive(Debug, PartialEq, Eq)]
+enum ImplCompletionKind {
+    All,
+    Fn,
+    TypeAlias,
+    Const,
+}
 pub(crate) fn complete_trait_impl(acc: &mut Completions, ctx: &CompletionContext) {
-    if let Some((trigger, impl_def)) = completion_match(ctx) {
+    if let Some((kind, trigger, impl_def)) = completion_match(ctx) {
-        match trigger.kind() {
+        get_missing_assoc_items(&ctx.sema, &impl_def).into_iter().for_each(|item| match item {
-            SyntaxKind::NAME_REF => get_missing_assoc_items(&ctx.sema, &impl_def)
+            hir::AssocItem::Function(fn_item)
-                .into_iter()
+                if kind == ImplCompletionKind::All || kind == ImplCompletionKind::Fn =>
-                .for_each(|item| match item {
+            {
-                    hir::AssocItem::Function(fn_item) => {
+                add_function_impl(&trigger, acc, ctx, fn_item)
-                        add_function_impl(&trigger, acc, ctx, fn_item)
-                    }
-                    hir::AssocItem::TypeAlias(type_item) => {
-                        add_type_alias_impl(&trigger, acc, ctx, type_item)
-                    }
-                    hir::AssocItem::Const(const_item) => {
-                        add_const_impl(&trigger, acc, ctx, const_item)
-                    }
-                }),
-            SyntaxKind::FN => {
-                for missing_fn in get_missing_assoc_items(&ctx.sema, &impl_def)
-                    .into_iter()
-                    .filter_map(|item| match item {
-                        hir::AssocItem::Function(fn_item) => Some(fn_item),
-                        _ => None,
-                    })
-                {
-                    add_function_impl(&trigger, acc, ctx, missing_fn);
-                }
            }
+            hir::AssocItem::TypeAlias(type_item)
-            SyntaxKind::TYPE_ALIAS => {
+                if kind == ImplCompletionKind::All || kind == ImplCompletionKind::TypeAlias =>
-                for missing_fn in get_missing_assoc_items(&ctx.sema, &impl_def)
+            {
-                    .into_iter()
+                add_type_alias_impl(&trigger, acc, ctx, type_item)
-                    .filter_map(|item| match item {
-                        hir::AssocItem::TypeAlias(type_item) => Some(type_item),
-                        _ => None,
-                    })
-                {
-                    add_type_alias_impl(&trigger, acc, ctx, missing_fn);
-                }
            }
+            hir::AssocItem::Const(const_item)
-            SyntaxKind::CONST => {
+                if kind == ImplCompletionKind::All || kind == ImplCompletionKind::Const =>
-                for missing_fn in get_missing_assoc_items(&ctx.sema, &impl_def)
+            {
-                    .into_iter()
+                add_const_impl(&trigger, acc, ctx, const_item)
-                    .filter_map(|item| match item {
-                        hir::AssocItem::Const(const_item) => Some(const_item),
-                        _ => None,
-                    })
-                {
-                    add_const_impl(&trigger, acc, ctx, missing_fn);
-                }
            }
            _ => {}
-        }
+        });
    }
 }
-fn completion_match(ctx: &CompletionContext) -> Option<(SyntaxNode, Impl)> {
+fn completion_match(ctx: &CompletionContext) -> Option<(ImplCompletionKind, SyntaxNode, Impl)> {
-    let (trigger, impl_def_offset) = ctx.token.ancestors().find_map(|p| match p.kind() {
+    let mut token = ctx.token.clone();
-        SyntaxKind::FN | SyntaxKind::TYPE_ALIAS | SyntaxKind::CONST | SyntaxKind::BLOCK_EXPR => {
+    // For keywork without name like `impl .. { fn <|> }`, the current position is inside
-            Some((p, 2))
+    // the whitespace token, which is outside `FN` syntax node.
-        }
+    // We need to follow the previous token in this case.
-        SyntaxKind::NAME_REF => Some((p, 5)),
+    if token.kind() == SyntaxKind::WHITESPACE {
-        _ => None,
+        token = token.prev_token()?;
-    })?;
+    }
-    let impl_def = (0..impl_def_offset - 1)
-        .try_fold(trigger.parent()?, |t, _| t.parent())
+    let impl_item_offset = match token.kind() {
-        .and_then(ast::Impl::cast)?;
+        // `impl .. { const <|> }`
-    Some((trigger, impl_def))
+        // ERROR      0
+        //   CONST_KW <- *
+        SyntaxKind::CONST_KW => 0,
+        // `impl .. { fn/type <|> }`
+        // FN/TYPE_ALIAS  0
+        //   FN_KW        <- *
+        SyntaxKind::FN_KW | SyntaxKind::TYPE_KW => 0,
+        // `impl .. { fn/type/const foo<|> }`
+        // FN/TYPE_ALIAS/CONST  1
+        //  NAME                0
+        //    IDENT             <- *
+        SyntaxKind::IDENT if token.parent().kind() == SyntaxKind::NAME => 1,
+        // `impl .. { foo<|> }`
+        // MACRO_CALL       3
+        //  PATH            2
+        //    PATH_SEGMENT  1
+        //      NAME_REF    0
+        //        IDENT     <- *
+        SyntaxKind::IDENT if token.parent().kind() == SyntaxKind::NAME_REF => 3,
+        _ => return None,
+    };
+    let impl_item = token.ancestors().nth(impl_item_offset)?;
+    // Must directly belong to an impl block.
+    // IMPL
+    //   ASSOC_ITEM_LIST
+    //     <item>
+    let impl_def = ast::Impl::cast(impl_item.parent()?.parent()?)?;
+    let kind = match impl_item.kind() {
+        // `impl ... { const <|> fn/type/const }`
+        _ if token.kind() == SyntaxKind::CONST_KW => ImplCompletionKind::Const,
+        SyntaxKind::CONST | SyntaxKind::ERROR => ImplCompletionKind::Const,
+        SyntaxKind::TYPE_ALIAS => ImplCompletionKind::TypeAlias,
+        SyntaxKind::FN => ImplCompletionKind::Fn,
+        SyntaxKind::MACRO_CALL => ImplCompletionKind::All,
+        _ => return None,
+    };
+    Some((kind, impl_item, impl_def))
 }
 fn add_function_impl(
@@ -261,19 +271,191 @@ ta type TestType = \n\
    }
    #[test]
-    fn no_nested_fn_completions() {
+    fn no_completion_inside_fn() {
        check(
            r"
-trait Test {
+trait Test { fn test(); fn test2(); }
-    fn test();
+struct T;
-    fn test2();
+impl Test for T {
+    fn test() {
+        t<|>
+    }
+}
+",
+            expect![[""]],
+        );
+        check(
+            r"
+trait Test { fn test(); fn test2(); }
+struct T;
+impl Test for T {
+    fn test() {
+        fn t<|>
+    }
+}
+",
+            expect![[""]],
+        );
+        check(
+            r"
+trait Test { fn test(); fn test2(); }
+struct T;
+impl Test for T {
+    fn test() {
+        fn <|>
+    }
 }
+",
+            expect![[""]],
+        );
+        // https://github.com/rust-analyzer/rust-analyzer/pull/5976#issuecomment-692332191
+        check(
+            r"
+trait Test { fn test(); fn test2(); }
 struct T;
 impl Test for T {
    fn test() {
+        foo.<|>
+    }
+}
+",
+            expect![[""]],
+        );
+        check(
+            r"
+trait Test { fn test(_: i32); fn test2(); }
+struct T;
+impl Test for T {
+    fn test(t<|>)
+}
+",
+            expect![[""]],
+        );
+        check(
+            r"
+trait Test { fn test(_: fn()); fn test2(); }
+struct T;
+impl Test for T {
+    fn test(f: fn <|>)
+}
+",
+            expect![[""]],
+        );
+    }
+    #[test]
+    fn no_completion_inside_const() {
+        check(
+            r"
+trait Test { const TEST: fn(); const TEST2: u32; type Test; fn test(); }
+struct T;
+impl Test for T {
+    const TEST: fn <|>
+}
+",
+            expect![[""]],
+        );
+        check(
+            r"
+trait Test { const TEST: u32; const TEST2: u32; type Test; fn test(); }
+struct T;
+impl Test for T {
+    const TEST: T<|>
+}
+",
+            expect![[""]],
+        );
+        check(
+            r"
+trait Test { const TEST: u32; const TEST2: u32; type Test; fn test(); }
+struct T;
+impl Test for T {
+    const TEST: u32 = f<|>
+}
+",
+            expect![[""]],
+        );
+        check(
+            r"
+trait Test { const TEST: u32; const TEST2: u32; type Test; fn test(); }
+struct T;
+impl Test for T {
+    const TEST: u32 = {
        t<|>
+    };
+}
+",
+            expect![[""]],
+        );
+        check(
+            r"
+trait Test { const TEST: u32; const TEST2: u32; type Test; fn test(); }
+struct T;
+impl Test for T {
+    const TEST: u32 = {
+        fn <|>
+    };
+}
+",
+            expect![[""]],
+        );
+        check(
+            r"
+trait Test { const TEST: u32; const TEST2: u32; type Test; fn test(); }
+struct T;
+impl Test for T {
+    const TEST: u32 = {
+        fn t<|>
+    };
+}
+",
+            expect![[""]],
+        );
    }
+    #[test]
+    fn no_completion_inside_type() {
+        check(
+            r"
+trait Test { type Test; type Test2; fn test(); }
+struct T;
+impl Test for T {
+    type Test = T<|>;
+}
+",
+            expect![[""]],
+        );
+        check(
+            r"
+trait Test { type Test; type Test2; fn test(); }
+struct T;
+impl Test for T {
+    type Test = fn <|>;
 }
 ",
            expect![[""]],
@@ -485,4 +667,67 @@ impl Test for () {
 ",
        );
    }
+    #[test]
+    fn complete_without_name() {
+        let test = |completion: &str, hint: &str, completed: &str, next_sibling: &str| {
+            println!(
+                "completion='{}', hint='{}', next_sibling='{}'",
+                completion, hint, next_sibling
+            );
+            check_edit(
+                completion,
+                &format!(
+                    r#"
+trait Test {{
+    type Foo;
+    const CONST: u16;
+    fn bar();
+}}
+struct T;
+impl Test for T {{
+    {}
+    {}
+}}
+"#,
+                    hint, next_sibling
+                ),
+                &format!(
+                    r#"
+trait Test {{
+    type Foo;
+    const CONST: u16;
+    fn bar();
+}}
+struct T;
+impl Test for T {{
+    {}
+    {}
+}}
+"#,
+                    completed, next_sibling
+                ),
+            )
+        };
+        // Enumerate some possible next siblings.
+        for next_sibling in &[
+            "",
+            "fn other_fn() {}", // `const <|> fn` -> `const fn`
+            "type OtherType = i32;",
+            "const OTHER_CONST: i32 = 0;",
+            "async fn other_fn() {}",
+            "unsafe fn other_fn() {}",
+            "default fn other_fn() {}",
+            "default type OtherType = i32;",
+            "default const OTHER_CONST: i32 = 0;",
+        ] {
+            test("bar", "fn <|>", "fn bar() {\n    $0\n}", next_sibling);
+            test("Foo", "type <|>", "type Foo = ", next_sibling);
+            test("CONST", "const <|>", "const CONST: u16 = ", next_sibling);
+        }
+    }
 }
diff --git a/crates/ide/src/completion/complete_unqualified_path.rs b/crates/ide/src/completion/complete_unqualified_path.rs
index 1f1b682a7..8eda4b64d 100644
--- a/crates/ide/src/completion/complete_unqualified_path.rs
+++ b/crates/ide/src/completion/complete_unqualified_path.rs
@@ -13,6 +13,7 @@ pub(super) fn complete_unqualified_path(acc: &mut Completions, ctx: &CompletionC
    if ctx.record_lit_syntax.is_some()
        || ctx.record_pat_syntax.is_some()
        || ctx.attribute_under_caret.is_some()
+        || ctx.mod_declaration_under_caret.is_some()
    {
        return;
    }
diff --git a/crates/ide/src/completion/completion_context.rs b/crates/ide/src/completion/completion_context.rs
index 3ef1b97cf..671b13328 100644
--- a/crates/ide/src/completion/completion_context.rs
+++ b/crates/ide/src/completion/completion_context.rs
@@ -77,6 +77,7 @@ pub(crate) struct CompletionContext<'a> {
    pub(super) is_path_type: bool,
    pub(super) has_type_args: bool,
    pub(super) attribute_under_caret: Option<ast::Attr>,
+    pub(super) mod_declaration_under_caret: Option<ast::Module>,
    pub(super) unsafe_is_prev: bool,
    pub(super) if_is_prev: bool,
    pub(super) block_expr_parent: bool,
@@ -159,6 +160,7 @@ impl<'a> CompletionContext<'a> {
            has_type_args: false,
            dot_receiver_is_ambiguous_float_literal: false,
            attribute_under_caret: None,
+            mod_declaration_under_caret: None,
            unsafe_is_prev: false,
            in_loop_body: false,
            ref_pat_parent: false,
@@ -246,7 +248,10 @@ impl<'a> CompletionContext<'a> {
        self.trait_as_prev_sibling = has_trait_as_prev_sibling(syntax_element.clone());
        self.is_match_arm = is_match_arm(syntax_element.clone());
        self.has_item_list_or_source_file_parent =
-            has_item_list_or_source_file_parent(syntax_element);
+            has_item_list_or_source_file_parent(syntax_element.clone());
+        self.mod_declaration_under_caret =
+            find_node_at_offset::<ast::Module>(&file_with_fake_ident, offset)
+                .filter(|module| module.item_list().is_none());
    }
    fn fill(
diff --git a/crates/ide/src/completion/patterns.rs b/crates/ide/src/completion/patterns.rs
index c6ae589db..b17ddf133 100644
--- a/crates/ide/src/completion/patterns.rs
+++ b/crates/ide/src/completion/patterns.rs
@@ -115,6 +115,7 @@ pub(crate) fn if_is_prev(element: SyntaxElement) -> bool {
        .filter(|it| it.kind() == IF_KW)
        .is_some()
 }
 #[test]
 fn test_if_is_prev() {
    check_pattern_is_applicable(r"if l<|>", if_is_prev);
diff --git a/crates/ide/src/diagnostics.rs b/crates/ide/src/diagnostics.rs
index b2b972b02..dc815a483 100644
--- a/crates/ide/src/diagnostics.rs
+++ b/crates/ide/src/diagnostics.rs
@@ -622,13 +622,65 @@ pub struct Foo { pub a: i32, pub b: i32 }
            r#"
 use a;
 use a::{c, d::e};
+mod a {
+    mod c {}
+    mod d {
+        mod e {}
+    }
+}
 "#,
        );
-        check_fix(r#"use {<|>b};"#, r#"use b;"#);
+        check_fix(
-        check_fix(r#"use {b<|>};"#, r#"use b;"#);
+            r"
-        check_fix(r#"use a::{c<|>};"#, r#"use a::c;"#);
+            mod b {}
-        check_fix(r#"use a::{self<|>};"#, r#"use a;"#);
+            use {<|>b};
-        check_fix(r#"use a::{c, d::{e<|>}};"#, r#"use a::{c, d::e};"#);
+            ",
+            r"
+            mod b {}
+            use b;
+            ",
+        );
+        check_fix(
+            r"
+            mod b {}
+            use {b<|>};
+            ",
+            r"
+            mod b {}
+            use b;
+            ",
+        );
+        check_fix(
+            r"
+            mod a { mod c {} }
+            use a::{c<|>};
+            ",
+            r"
+            mod a { mod c {} }
+            use a::c;
+            ",
+        );
+        check_fix(
+            r"
+            mod a {}
+            use a::{self<|>};
+            ",
+            r"
+            mod a {}
+            use a;
+            ",
+        );
+        check_fix(
+            r"
+            mod a { mod c {} mod d { mod e {} } }
+            use a::{c, d::{e<|>}};
+            ",
+            r"
+            mod a { mod c {} mod d { mod e {} } }
+            use a::{c, d::e};
+            ",
+        );
    }
    #[test]
diff --git a/crates/ide/src/display.rs b/crates/ide/src/display.rs
index 41b5bdc49..2484dbbf1 100644
--- a/crates/ide/src/display.rs
+++ b/crates/ide/src/display.rs
@@ -41,7 +41,14 @@ pub(crate) fn function_declaration(node: &ast::Fn) -> String {
        format_to!(buf, "{}", type_params);
    }
    if let Some(param_list) = node.param_list() {
-        format_to!(buf, "{}", param_list);
+        let params: Vec<String> = param_list
+            .self_param()
+            .into_iter()
+            .map(|self_param| self_param.to_string())
+            .chain(param_list.params().map(|param| param.to_string()))
+            .collect();
+        // Useful to inline parameters
+        format_to!(buf, "({})", params.join(", "));
    }
    if let Some(ret_type) = node.ret_type() {
        if ret_type.ty().is_some() {
diff --git a/crates/ide/src/hover.rs b/crates/ide/src/hover.rs
index efec0184e..37171cbef 100644
--- a/crates/ide/src/hover.rs
+++ b/crates/ide/src/hover.rs
@@ -2647,6 +2647,70 @@ fn foo(ar<|>g: &impl Foo + Bar<S>) {}
    }
    #[test]
+    fn test_hover_async_block_impl_trait_has_goto_type_action() {
+        check_actions(
+            r#"
+struct S;
+fn foo() {
+    let fo<|>o = async { S };
+}
+#[prelude_import] use future::*;
+mod future {
+    #[lang = "future_trait"]
+    pub trait Future { type Output; }
+}
+"#,
+            expect![[r#"
+                [
+                    GoToType(
+                        [
+                            HoverGotoTypeData {
+                                mod_path: "test::future::Future",
+                                nav: NavigationTarget {
+                                    file_id: FileId(
+                                        1,
+                                    ),
+                                    full_range: 101..163,
+                                    focus_range: Some(
+                                        140..146,
+                                    ),
+                                    name: "Future",
+                                    kind: TRAIT,
+                                    container_name: None,
+                                    description: Some(
+                                        "pub trait Future",
+                                    ),
+                                    docs: None,
+                                },
+                            },
+                            HoverGotoTypeData {
+                                mod_path: "test::S",
+                                nav: NavigationTarget {
+                                    file_id: FileId(
+                                        1,
+                                    ),
+                                    full_range: 0..9,
+                                    focus_range: Some(
+                                        7..8,
+                                    ),
+                                    name: "S",
+                                    kind: STRUCT,
+                                    container_name: None,
+                                    description: Some(
+                                        "struct S",
+                                    ),
+                                    docs: None,
+                                },
+                            },
+                        ],
+                    ),
+                ]
+            "#]],
+        );
+    }
+    #[test]
    fn test_hover_arg_generic_impl_trait_has_goto_type_action() {
        check_actions(
            r#"
diff --git a/crates/ide/src/lib.rs b/crates/ide/src/lib.rs
index 570790384..3b97e087f 100644
--- a/crates/ide/src/lib.rs
+++ b/crates/ide/src/lib.rs
@@ -81,7 +81,9 @@ pub use crate::{
    },
 };
-pub use assists::{Assist, AssistConfig, AssistId, AssistKind, ResolvedAssist};
+pub use assists::{
+    utils::MergeBehaviour, Assist, AssistConfig, AssistId, AssistKind, ResolvedAssist,
+};
 pub use base_db::{
    Canceled, CrateGraph, CrateId, Edition, FileId, FilePosition, FileRange, SourceRoot,
    SourceRootId,
diff --git a/crates/ide/src/syntax_highlighting.rs b/crates/ide/src/syntax_highlighting.rs
index 25d6f7abd..d9fc25d88 100644
--- a/crates/ide/src/syntax_highlighting.rs
+++ b/crates/ide/src/syntax_highlighting.rs
@@ -4,7 +4,7 @@ mod injection;
 #[cfg(test)]
 mod tests;
-use hir::{Name, Semantics, VariantDef};
+use hir::{Local, Name, Semantics, VariantDef};
 use ide_db::{
    defs::{classify_name, classify_name_ref, Definition, NameClass, NameRefClass},
    RootDatabase,
@@ -13,8 +13,8 @@ use rustc_hash::FxHashMap;
 use syntax::{
    ast::{self, HasFormatSpecifier},
    AstNode, AstToken, Direction, NodeOrToken, SyntaxElement,
-    SyntaxKind::*,
+    SyntaxKind::{self, *},
-    TextRange, WalkEvent, T,
+    SyntaxNode, SyntaxToken, TextRange, WalkEvent, T,
 };
 use crate::FileId;
@@ -454,6 +454,32 @@ fn macro_call_range(macro_call: &ast::MacroCall) -> Option<TextRange> {
    Some(TextRange::new(range_start, range_end))
 }
+/// Returns true if the parent nodes of `node` all match the `SyntaxKind`s in `kinds` exactly.
+fn parents_match(mut node: NodeOrToken<SyntaxNode, SyntaxToken>, mut kinds: &[SyntaxKind]) -> bool {
+    while let (Some(parent), [kind, rest @ ..]) = (&node.parent(), kinds) {
+        if parent.kind() != *kind {
+            return false;
+        }
+        // FIXME: Would be nice to get parent out of the match, but binding by-move and by-value
+        // in the same pattern is unstable: rust-lang/rust#68354.
+        node = node.parent().unwrap().into();
+        kinds = rest;
+    }
+    // Only true if we matched all expected kinds
+    kinds.len() == 0
+}
+fn is_consumed_lvalue(
+    node: NodeOrToken<SyntaxNode, SyntaxToken>,
+    local: &Local,
+    db: &RootDatabase,
+) -> bool {
+    // When lvalues are passed as arguments and they're not Copy, then mark them as Consuming.
+    parents_match(node, &[PATH_SEGMENT, PATH, PATH_EXPR, ARG_LIST]) && !local.ty(db).is_copy(db)
+}
 fn highlight_element(
    sema: &Semantics<RootDatabase>,
    bindings_shadow_count: &mut FxHashMap<Name, u32>,
@@ -522,6 +548,12 @@ fn highlight_element(
                            let mut h = highlight_def(db, def);
+                            if let Definition::Local(local) = &def {
+                                if is_consumed_lvalue(name_ref.syntax().clone().into(), local, db) {
+                                    h |= HighlightModifier::Consuming;
+                                }
+                            }
                            if let Some(parent) = name_ref.syntax().parent() {
                                if matches!(parent.kind(), FIELD_EXPR | RECORD_PAT_FIELD) {
                                    if let Definition::Field(field) = def {
@@ -645,21 +677,30 @@ fn highlight_element(
                        .and_then(ast::SelfParam::cast)
                        .and_then(|p| p.mut_token())
                        .is_some();
-                    // closure to enforce lazyness
+                    let self_path = &element
-                    let self_path = || {
+                        .parent()
-                        sema.resolve_path(&element.parent()?.parent().and_then(ast::Path::cast)?)
+                        .as_ref()
-                    };
+                        .and_then(SyntaxNode::parent)
+                        .and_then(ast::Path::cast)
+                        .and_then(|p| sema.resolve_path(&p));
+                    let mut h = HighlightTag::SelfKeyword.into();
                    if self_param_is_mut
-                        || matches!(self_path(),
+                        || matches!(self_path,
                            Some(hir::PathResolution::Local(local))
                                if local.is_self(db)
                                    && (local.is_mut(db) || local.ty(db).is_mutable_reference())
                        )
                    {
-                        HighlightTag::SelfKeyword | HighlightModifier::Mutable
+                        h |= HighlightModifier::Mutable
-                    } else {
-                        HighlightTag::SelfKeyword.into()
                    }
+                    if let Some(hir::PathResolution::Local(local)) = self_path {
+                        if is_consumed_lvalue(element, &local, db) {
+                            h |= HighlightModifier::Consuming;
+                        }
+                    }
+                    h
                }
                T![ref] => element
                    .parent()
diff --git a/crates/ide/src/syntax_highlighting/test_data/highlighting.html b/crates/ide/src/syntax_highlighting/test_data/highlighting.html
index d0df2e0ec..cde42024c 100644
--- a/crates/ide/src/syntax_highlighting/test_data/highlighting.html
+++ b/crates/ide/src/syntax_highlighting/test_data/highlighting.html
@@ -61,8 +61,8 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 <span class="punctuation">}</span>
 <span class="keyword">impl</span> <span class="struct">Foo</span> <span class="punctuation">{</span>
-    <span class="keyword">fn</span> <span class="function declaration">baz</span><span class="punctuation">(</span><span class="keyword">mut</span> <span class="self_keyword mutable">self</span><span class="punctuation">)</span> <span class="operator">-&gt;</span> <span class="builtin_type">i32</span> <span class="punctuation">{</span>
+    <span class="keyword">fn</span> <span class="function declaration">baz</span><span class="punctuation">(</span><span class="keyword">mut</span> <span class="self_keyword mutable">self</span><span class="punctuation">,</span> <span class="value_param declaration">f</span><span class="punctuation">:</span> <span class="struct">Foo</span><span class="punctuation">)</span> <span class="operator">-&gt;</span> <span class="builtin_type">i32</span> <span class="punctuation">{</span>
-        <span class="self_keyword">self</span><span class="punctuation">.</span><span class="field">x</span>
+        <span class="value_param">f</span><span class="punctuation">.</span><span class="function consuming">baz</span><span class="punctuation">(</span><span class="self_keyword consuming">self</span><span class="punctuation">)</span>
    <span class="punctuation">}</span>
    <span class="keyword">fn</span> <span class="function declaration">qux</span><span class="punctuation">(</span><span class="operator">&</span><span class="keyword">mut</span> <span class="self_keyword mutable">self</span><span class="punctuation">)</span> <span class="punctuation">{</span>
@@ -80,8 +80,8 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 <span class="punctuation">}</span>
 <span class="keyword">impl</span> <span class="struct">FooCopy</span> <span class="punctuation">{</span>
-    <span class="keyword">fn</span> <span class="function declaration">baz</span><span class="punctuation">(</span><span class="self_keyword">self</span><span class="punctuation">)</span> <span class="operator">-&gt;</span> <span class="builtin_type">u32</span> <span class="punctuation">{</span>
+    <span class="keyword">fn</span> <span class="function declaration">baz</span><span class="punctuation">(</span><span class="self_keyword">self</span><span class="punctuation">,</span> <span class="value_param declaration">f</span><span class="punctuation">:</span> <span class="struct">FooCopy</span><span class="punctuation">)</span> <span class="operator">-&gt;</span> <span class="builtin_type">u32</span> <span class="punctuation">{</span>
-        <span class="self_keyword">self</span><span class="punctuation">.</span><span class="field">x</span>
+        <span class="value_param">f</span><span class="punctuation">.</span><span class="function">baz</span><span class="punctuation">(</span><span class="self_keyword">self</span><span class="punctuation">)</span>
    <span class="punctuation">}</span>
    <span class="keyword">fn</span> <span class="function declaration">qux</span><span class="punctuation">(</span><span class="operator">&</span><span class="keyword">mut</span> <span class="self_keyword mutable">self</span><span class="punctuation">)</span> <span class="punctuation">{</span>
@@ -144,14 +144,15 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
    <span class="variable">y</span><span class="punctuation">;</span>
    <span class="keyword">let</span> <span class="keyword">mut</span> <span class="variable declaration mutable">foo</span> <span class="operator">=</span> <span class="struct">Foo</span> <span class="punctuation">{</span> <span class="field">x</span><span class="punctuation">,</span> <span class="field">y</span><span class="punctuation">:</span> <span class="variable mutable">x</span> <span class="punctuation">}</span><span class="punctuation">;</span>
+    <span class="keyword">let</span> <span class="variable declaration">foo2</span> <span class="operator">=</span> <span class="variable mutable">foo</span><span class="punctuation">.</span><span class="unresolved_reference">clone</span><span class="punctuation">(</span><span class="punctuation">)</span><span class="punctuation">;</span>
    <span class="variable mutable">foo</span><span class="punctuation">.</span><span class="function">quop</span><span class="punctuation">(</span><span class="punctuation">)</span><span class="punctuation">;</span>
    <span class="variable mutable">foo</span><span class="punctuation">.</span><span class="function mutable">qux</span><span class="punctuation">(</span><span class="punctuation">)</span><span class="punctuation">;</span>
-    <span class="variable mutable">foo</span><span class="punctuation">.</span><span class="function consuming">baz</span><span class="punctuation">(</span><span class="punctuation">)</span><span class="punctuation">;</span>
+    <span class="variable mutable">foo</span><span class="punctuation">.</span><span class="function consuming">baz</span><span class="punctuation">(</span><span class="variable consuming">foo2</span><span class="punctuation">)</span><span class="punctuation">;</span>
    <span class="keyword">let</span> <span class="keyword">mut</span> <span class="variable declaration mutable">copy</span> <span class="operator">=</span> <span class="struct">FooCopy</span> <span class="punctuation">{</span> <span class="field">x</span> <span class="punctuation">}</span><span class="punctuation">;</span>
    <span class="variable mutable">copy</span><span class="punctuation">.</span><span class="function">quop</span><span class="punctuation">(</span><span class="punctuation">)</span><span class="punctuation">;</span>
    <span class="variable mutable">copy</span><span class="punctuation">.</span><span class="function mutable">qux</span><span class="punctuation">(</span><span class="punctuation">)</span><span class="punctuation">;</span>
-    <span class="variable mutable">copy</span><span class="punctuation">.</span><span class="function">baz</span><span class="punctuation">(</span><span class="punctuation">)</span><span class="punctuation">;</span>
+    <span class="variable mutable">copy</span><span class="punctuation">.</span><span class="function">baz</span><span class="punctuation">(</span><span class="variable mutable">copy</span><span class="punctuation">)</span><span class="punctuation">;</span>
 <span class="punctuation">}</span>
 <span class="keyword">enum</span> <span class="enum declaration">Option</span><span class="punctuation">&lt;</span><span class="type_param declaration">T</span><span class="punctuation">&gt;</span> <span class="punctuation">{</span>
diff --git a/crates/ide/src/syntax_highlighting/tests.rs b/crates/ide/src/syntax_highlighting/tests.rs
index 6f72a29bd..57d4e1252 100644
--- a/crates/ide/src/syntax_highlighting/tests.rs
+++ b/crates/ide/src/syntax_highlighting/tests.rs
@@ -35,8 +35,8 @@ impl Bar for Foo {
 }
 impl Foo {
-    fn baz(mut self) -> i32 {
+    fn baz(mut self, f: Foo) -> i32 {
-        self.x
+        f.baz(self)
    }
    fn qux(&mut self) {
@@ -54,8 +54,8 @@ struct FooCopy {
 }
 impl FooCopy {
-    fn baz(self) -> u32 {
+    fn baz(self, f: FooCopy) -> u32 {
-        self.x
+        f.baz(self)
    }
    fn qux(&mut self) {
@@ -118,14 +118,15 @@ fn main() {
    y;
    let mut foo = Foo { x, y: x };
+    let foo2 = foo.clone();
    foo.quop();
    foo.qux();
-    foo.baz();
+    foo.baz(foo2);
    let mut copy = FooCopy { x };
    copy.quop();
    copy.qux();
-    copy.baz();
+    copy.baz(copy);
 }
 enum Option<T> {
diff --git a/crates/ide/src/typing.rs b/crates/ide/src/typing.rs
index 899ce5f26..94b91f049 100644
--- a/crates/ide/src/typing.rs
+++ b/crates/ide/src/typing.rs
@@ -39,6 +39,14 @@ pub(crate) const TRIGGER_CHARS: &str = ".=>";
 //
 // - typing `let =` tries to smartly add `;` if `=` is followed by an existing expression
 // - typing `.` in a chain method call auto-indents
+//
+// VS Code::
+//
+// Add the following to `settings.json`:
+// [source,json]
+// ----
+// "editor.formatOnType": true,
+// ----
 pub(crate) fn on_char_typed(
    db: &RootDatabase,
    position: FilePosition,
diff --git a/crates/ide_db/src/defs.rs b/crates/ide_db/src/defs.rs
index 0d0affc27..f8c7aa491 100644
--- a/crates/ide_db/src/defs.rs
+++ b/crates/ide_db/src/defs.rs
@@ -157,9 +157,9 @@ pub fn classify_name(sema: &Semantics<RootDatabase>, name: &ast::Name) -> Option
            ast::IdentPat(it) => {
                let local = sema.to_def(&it)?;
-                if let Some(record_field_pat) = it.syntax().parent().and_then(ast::RecordPatField::cast) {
+                if let Some(record_pat_field) = it.syntax().parent().and_then(ast::RecordPatField::cast) {
-                    if record_field_pat.name_ref().is_none() {
+                    if record_pat_field.name_ref().is_none() {
-                        if let Some(field) = sema.resolve_record_field_pat(&record_field_pat) {
+                        if let Some(field) = sema.resolve_record_pat_field(&record_pat_field) {
                            let field = Definition::Field(field);
                            return Some(NameClass::FieldShorthand { local, field });
                        }
@@ -275,8 +275,8 @@ pub fn classify_name_ref(
        }
    }
-    if let Some(record_field_pat) = ast::RecordPatField::cast(parent.clone()) {
+    if let Some(record_pat_field) = ast::RecordPatField::cast(parent.clone()) {
-        if let Some(field) = sema.resolve_record_field_pat(&record_field_pat) {
+        if let Some(field) = sema.resolve_record_pat_field(&record_pat_field) {
            let field = Definition::Field(field);
            return Some(NameRefClass::Definition(field));
        }
diff --git a/crates/parser/src/grammar/patterns.rs b/crates/parser/src/grammar/patterns.rs
index 796f206e1..7e7f73dee 100644
--- a/crates/parser/src/grammar/patterns.rs
+++ b/crates/parser/src/grammar/patterns.rs
@@ -188,7 +188,7 @@ fn tuple_pat_fields(p: &mut Parser) {
    p.expect(T![')']);
 }
-// test record_field_pat_list
+// test record_pat_field_list
 // fn foo() {
 //     let S {} = ();
 //     let S { f, ref mut g } = ();
@@ -208,7 +208,7 @@ fn record_pat_field_list(p: &mut Parser) {
            c => {
                let m = p.start();
                match c {
-                    // test record_field_pat
+                    // test record_pat_field
                    // fn foo() {
                    //     let S { 0: 1 } = ();
                    //     let S { x: 1 } = ();
diff --git a/crates/parser/src/syntax_kind/generated.rs b/crates/parser/src/syntax_kind/generated.rs
index 192ecd864..935bd2c5e 100644
--- a/crates/parser/src/syntax_kind/generated.rs
+++ b/crates/parser/src/syntax_kind/generated.rs
@@ -364,4 +364,4 @@ impl SyntaxKind {
    }
 }
 #[macro_export]
-macro_rules ! T { [ ; ] => { $ crate :: SyntaxKind :: SEMICOLON } ; [ , ] => { $ crate :: SyntaxKind :: COMMA } ; [ '(' ] => { $ crate :: SyntaxKind :: L_PAREN } ; [ ')' ] => { $ crate :: SyntaxKind :: R_PAREN } ; [ '{' ] => { $ crate :: SyntaxKind :: L_CURLY } ; [ '}' ] => { $ crate :: SyntaxKind :: R_CURLY } ; [ '[' ] => { $ crate :: SyntaxKind :: L_BRACK } ; [ ']' ] => { $ crate :: SyntaxKind :: R_BRACK } ; [ < ] => { $ crate :: SyntaxKind :: L_ANGLE } ; [ > ] => { $ crate :: SyntaxKind :: R_ANGLE } ; [ @ ] => { $ crate :: SyntaxKind :: AT } ; [ # ] => { $ crate :: SyntaxKind :: POUND } ; [ ~ ] => { $ crate :: SyntaxKind :: TILDE } ; [ ? ] => { $ crate :: SyntaxKind :: QUESTION } ; [ $ ] => { $ crate :: SyntaxKind :: DOLLAR } ; [ & ] => { $ crate :: SyntaxKind :: AMP } ; [ | ] => { $ crate :: SyntaxKind :: PIPE } ; [ + ] => { $ crate :: SyntaxKind :: PLUS } ; [ * ] => { $ crate :: SyntaxKind :: STAR } ; [ / ] => { $ crate :: SyntaxKind :: SLASH } ; [ ^ ] => { $ crate :: SyntaxKind :: CARET } ; [ % ] => { $ crate :: SyntaxKind :: PERCENT } ; [ _ ] => { $ crate :: SyntaxKind :: UNDERSCORE } ; [ . ] => { $ crate :: SyntaxKind :: DOT } ; [ .. ] => { $ crate :: SyntaxKind :: DOT2 } ; [ ... ] => { $ crate :: SyntaxKind :: DOT3 } ; [ ..= ] => { $ crate :: SyntaxKind :: DOT2EQ } ; [ : ] => { $ crate :: SyntaxKind :: COLON } ; [ :: ] => { $ crate :: SyntaxKind :: COLON2 } ; [ = ] => { $ crate :: SyntaxKind :: EQ } ; [ == ] => { $ crate :: SyntaxKind :: EQ2 } ; [ => ] => { $ crate :: SyntaxKind :: FAT_ARROW } ; [ ! ] => { $ crate :: SyntaxKind :: BANG } ; [ != ] => { $ crate :: SyntaxKind :: NEQ } ; [ - ] => { $ crate :: SyntaxKind :: MINUS } ; [ -> ] => { $ crate :: SyntaxKind :: THIN_ARROW } ; [ <= ] => { $ crate :: SyntaxKind :: LTEQ } ; [ >= ] => { $ crate :: SyntaxKind :: GTEQ } ; [ += ] => { $ crate :: SyntaxKind :: PLUSEQ } ; [ -= ] => { $ crate :: SyntaxKind :: MINUSEQ } ; [ |= ] => { $ crate :: SyntaxKind :: PIPEEQ } ; [ &= ] => { $ crate :: SyntaxKind :: AMPEQ } ; [ ^= ] => { $ crate :: SyntaxKind :: CARETEQ } ; [ /= ] => { $ crate :: SyntaxKind :: SLASHEQ } ; [ *= ] => { $ crate :: SyntaxKind :: STAREQ } ; [ %= ] => { $ crate :: SyntaxKind :: PERCENTEQ } ; [ && ] => { $ crate :: SyntaxKind :: AMP2 } ; [ || ] => { $ crate :: SyntaxKind :: PIPE2 } ; [ << ] => { $ crate :: SyntaxKind :: SHL } ; [ >> ] => { $ crate :: SyntaxKind :: SHR } ; [ <<= ] => { $ crate :: SyntaxKind :: SHLEQ } ; [ >>= ] => { $ crate :: SyntaxKind :: SHREQ } ; [ as ] => { $ crate :: SyntaxKind :: AS_KW } ; [ async ] => { $ crate :: SyntaxKind :: ASYNC_KW } ; [ await ] => { $ crate :: SyntaxKind :: AWAIT_KW } ; [ box ] => { $ crate :: SyntaxKind :: BOX_KW } ; [ break ] => { $ crate :: SyntaxKind :: BREAK_KW } ; [ const ] => { $ crate :: SyntaxKind :: CONST_KW } ; [ continue ] => { $ crate :: SyntaxKind :: CONTINUE_KW } ; [ crate ] => { $ crate :: SyntaxKind :: CRATE_KW } ; [ dyn ] => { $ crate :: SyntaxKind :: DYN_KW } ; [ else ] => { $ crate :: SyntaxKind :: ELSE_KW } ; [ enum ] => { $ crate :: SyntaxKind :: ENUM_KW } ; [ extern ] => { $ crate :: SyntaxKind :: EXTERN_KW } ; [ false ] => { $ crate :: SyntaxKind :: FALSE_KW } ; [ fn ] => { $ crate :: SyntaxKind :: FN_KW } ; [ for ] => { $ crate :: SyntaxKind :: FOR_KW } ; [ if ] => { $ crate :: SyntaxKind :: IF_KW } ; [ impl ] => { $ crate :: SyntaxKind :: IMPL_KW } ; [ in ] => { $ crate :: SyntaxKind :: IN_KW } ; [ let ] => { $ crate :: SyntaxKind :: LET_KW } ; [ loop ] => { $ crate :: SyntaxKind :: LOOP_KW } ; [ macro ] => { $ crate :: SyntaxKind :: MACRO_KW } ; [ match ] => { $ crate :: SyntaxKind :: MATCH_KW } ; [ mod ] => { $ crate :: SyntaxKind :: MOD_KW } ; [ move ] => { $ crate :: SyntaxKind :: MOVE_KW } ; [ mut ] => { $ crate :: SyntaxKind :: MUT_KW } ; [ pub ] => { $ crate :: SyntaxKind :: PUB_KW } ; [ ref ] => { $ crate :: SyntaxKind :: REF_KW } ; [ return ] => { $ crate :: SyntaxKind :: RETURN_KW } ; [ self ] => { $ crate :: SyntaxKind :: SELF_KW } ; [ static ] => { $ crate :: SyntaxKind :: STATIC_KW } ; [ struct ] => { $ crate :: SyntaxKind :: STRUCT_KW } ; [ super ] => { $ crate :: SyntaxKind :: SUPER_KW } ; [ trait ] => { $ crate :: SyntaxKind :: TRAIT_KW } ; [ true ] => { $ crate :: SyntaxKind :: TRUE_KW } ; [ try ] => { $ crate :: SyntaxKind :: TRY_KW } ; [ type ] => { $ crate :: SyntaxKind :: TYPE_KW } ; [ unsafe ] => { $ crate :: SyntaxKind :: UNSAFE_KW } ; [ use ] => { $ crate :: SyntaxKind :: USE_KW } ; [ where ] => { $ crate :: SyntaxKind :: WHERE_KW } ; [ while ] => { $ crate :: SyntaxKind :: WHILE_KW } ; [ auto ] => { $ crate :: SyntaxKind :: AUTO_KW } ; [ default ] => { $ crate :: SyntaxKind :: DEFAULT_KW } ; [ existential ] => { $ crate :: SyntaxKind :: EXISTENTIAL_KW } ; [ union ] => { $ crate :: SyntaxKind :: UNION_KW } ; [ raw ] => { $ crate :: SyntaxKind :: RAW_KW } ; [ lifetime ] => { $ crate :: SyntaxKind :: LIFETIME } ; [ ident ] => { $ crate :: SyntaxKind :: IDENT } ; [ shebang ] => { $ crate :: SyntaxKind :: SHEBANG } ; }
+macro_rules ! T { [;] => { $ crate :: SyntaxKind :: SEMICOLON } ; [,] => { $ crate :: SyntaxKind :: COMMA } ; ['('] => { $ crate :: SyntaxKind :: L_PAREN } ; [')'] => { $ crate :: SyntaxKind :: R_PAREN } ; ['{'] => { $ crate :: SyntaxKind :: L_CURLY } ; ['}'] => { $ crate :: SyntaxKind :: R_CURLY } ; ['['] => { $ crate :: SyntaxKind :: L_BRACK } ; [']'] => { $ crate :: SyntaxKind :: R_BRACK } ; [<] => { $ crate :: SyntaxKind :: L_ANGLE } ; [>] => { $ crate :: SyntaxKind :: R_ANGLE } ; [@] => { $ crate :: SyntaxKind :: AT } ; [#] => { $ crate :: SyntaxKind :: POUND } ; [~] => { $ crate :: SyntaxKind :: TILDE } ; [?] => { $ crate :: SyntaxKind :: QUESTION } ; [$] => { $ crate :: SyntaxKind :: DOLLAR } ; [&] => { $ crate :: SyntaxKind :: AMP } ; [|] => { $ crate :: SyntaxKind :: PIPE } ; [+] => { $ crate :: SyntaxKind :: PLUS } ; [*] => { $ crate :: SyntaxKind :: STAR } ; [/] => { $ crate :: SyntaxKind :: SLASH } ; [^] => { $ crate :: SyntaxKind :: CARET } ; [%] => { $ crate :: SyntaxKind :: PERCENT } ; [_] => { $ crate :: SyntaxKind :: UNDERSCORE } ; [.] => { $ crate :: SyntaxKind :: DOT } ; [..] => { $ crate :: SyntaxKind :: DOT2 } ; [...] => { $ crate :: SyntaxKind :: DOT3 } ; [..=] => { $ crate :: SyntaxKind :: DOT2EQ } ; [:] => { $ crate :: SyntaxKind :: COLON } ; [::] => { $ crate :: SyntaxKind :: COLON2 } ; [=] => { $ crate :: SyntaxKind :: EQ } ; [==] => { $ crate :: SyntaxKind :: EQ2 } ; [=>] => { $ crate :: SyntaxKind :: FAT_ARROW } ; [!] => { $ crate :: SyntaxKind :: BANG } ; [!=] => { $ crate :: SyntaxKind :: NEQ } ; [-] => { $ crate :: SyntaxKind :: MINUS } ; [->] => { $ crate :: SyntaxKind :: THIN_ARROW } ; [<=] => { $ crate :: SyntaxKind :: LTEQ } ; [>=] => { $ crate :: SyntaxKind :: GTEQ } ; [+=] => { $ crate :: SyntaxKind :: PLUSEQ } ; [-=] => { $ crate :: SyntaxKind :: MINUSEQ } ; [|=] => { $ crate :: SyntaxKind :: PIPEEQ } ; [&=] => { $ crate :: SyntaxKind :: AMPEQ } ; [^=] => { $ crate :: SyntaxKind :: CARETEQ } ; [/=] => { $ crate :: SyntaxKind :: SLASHEQ } ; [*=] => { $ crate :: SyntaxKind :: STAREQ } ; [%=] => { $ crate :: SyntaxKind :: PERCENTEQ } ; [&&] => { $ crate :: SyntaxKind :: AMP2 } ; [||] => { $ crate :: SyntaxKind :: PIPE2 } ; [<<] => { $ crate :: SyntaxKind :: SHL } ; [>>] => { $ crate :: SyntaxKind :: SHR } ; [<<=] => { $ crate :: SyntaxKind :: SHLEQ } ; [>>=] => { $ crate :: SyntaxKind :: SHREQ } ; [as] => { $ crate :: SyntaxKind :: AS_KW } ; [async] => { $ crate :: SyntaxKind :: ASYNC_KW } ; [await] => { $ crate :: SyntaxKind :: AWAIT_KW } ; [box] => { $ crate :: SyntaxKind :: BOX_KW } ; [break] => { $ crate :: SyntaxKind :: BREAK_KW } ; [const] => { $ crate :: SyntaxKind :: CONST_KW } ; [continue] => { $ crate :: SyntaxKind :: CONTINUE_KW } ; [crate] => { $ crate :: SyntaxKind :: CRATE_KW } ; [dyn] => { $ crate :: SyntaxKind :: DYN_KW } ; [else] => { $ crate :: SyntaxKind :: ELSE_KW } ; [enum] => { $ crate :: SyntaxKind :: ENUM_KW } ; [extern] => { $ crate :: SyntaxKind :: EXTERN_KW } ; [false] => { $ crate :: SyntaxKind :: FALSE_KW } ; [fn] => { $ crate :: SyntaxKind :: FN_KW } ; [for] => { $ crate :: SyntaxKind :: FOR_KW } ; [if] => { $ crate :: SyntaxKind :: IF_KW } ; [impl] => { $ crate :: SyntaxKind :: IMPL_KW } ; [in] => { $ crate :: SyntaxKind :: IN_KW } ; [let] => { $ crate :: SyntaxKind :: LET_KW } ; [loop] => { $ crate :: SyntaxKind :: LOOP_KW } ; [macro] => { $ crate :: SyntaxKind :: MACRO_KW } ; [match] => { $ crate :: SyntaxKind :: MATCH_KW } ; [mod] => { $ crate :: SyntaxKind :: MOD_KW } ; [move] => { $ crate :: SyntaxKind :: MOVE_KW } ; [mut] => { $ crate :: SyntaxKind :: MUT_KW } ; [pub] => { $ crate :: SyntaxKind :: PUB_KW } ; [ref] => { $ crate :: SyntaxKind :: REF_KW } ; [return] => { $ crate :: SyntaxKind :: RETURN_KW } ; [self] => { $ crate :: SyntaxKind :: SELF_KW } ; [static] => { $ crate :: SyntaxKind :: STATIC_KW } ; [struct] => { $ crate :: SyntaxKind :: STRUCT_KW } ; [super] => { $ crate :: SyntaxKind :: SUPER_KW } ; [trait] => { $ crate :: SyntaxKind :: TRAIT_KW } ; [true] => { $ crate :: SyntaxKind :: TRUE_KW } ; [try] => { $ crate :: SyntaxKind :: TRY_KW } ; [type] => { $ crate :: SyntaxKind :: TYPE_KW } ; [unsafe] => { $ crate :: SyntaxKind :: UNSAFE_KW } ; [use] => { $ crate :: SyntaxKind :: USE_KW } ; [where] => { $ crate :: SyntaxKind :: WHERE_KW } ; [while] => { $ crate :: SyntaxKind :: WHILE_KW } ; [auto] => { $ crate :: SyntaxKind :: AUTO_KW } ; [default] => { $ crate :: SyntaxKind :: DEFAULT_KW } ; [existential] => { $ crate :: SyntaxKind :: EXISTENTIAL_KW } ; [union] => { $ crate :: SyntaxKind :: UNION_KW } ; [raw] => { $ crate :: SyntaxKind :: RAW_KW } ; [lifetime] => { $ crate :: SyntaxKind :: LIFETIME } ; [ident] => { $ crate :: SyntaxKind :: IDENT } ; [shebang] => { $ crate :: SyntaxKind :: SHEBANG } ; }
diff --git a/crates/project_model/src/lib.rs b/crates/project_model/src/lib.rs
index 2d91939ce..258f60e28 100644
--- a/crates/project_model/src/lib.rs
+++ b/crates/project_model/src/lib.rs
@@ -33,7 +33,7 @@ pub enum ProjectWorkspace {
    /// Project workspace was discovered by running `cargo metadata` and `rustc --print sysroot`.
    Cargo { cargo: CargoWorkspace, sysroot: Sysroot },
    /// Project workspace was manually specified using a `rust-project.json` file.
-    Json { project: ProjectJson },
+    Json { project: ProjectJson, sysroot: Option<Sysroot> },
 }
 impl fmt::Debug for ProjectWorkspace {
@@ -44,10 +44,10 @@ impl fmt::Debug for ProjectWorkspace {
                .field("n_packages", &cargo.packages().len())
                .field("n_sysroot_crates", &sysroot.crates().len())
                .finish(),
-            ProjectWorkspace::Json { project } => {
+            ProjectWorkspace::Json { project, sysroot } => {
                let mut debug_struct = f.debug_struct("Json");
                debug_struct.field("n_crates", &project.n_crates());
-                if let Some(sysroot) = &project.sysroot {
+                if let Some(sysroot) = sysroot {
                    debug_struct.field("n_sysroot_crates", &sysroot.crates().len());
                }
                debug_struct.finish()
@@ -169,7 +169,11 @@ impl ProjectWorkspace {
                })?;
                let project_location = project_json.parent().unwrap().to_path_buf();
                let project = ProjectJson::new(&project_location, data);
-                ProjectWorkspace::Json { project }
+                let sysroot = match &project.sysroot_src {
+                    Some(path) => Some(Sysroot::load(path)?),
+                    None => None,
+                };
+                ProjectWorkspace::Json { project, sysroot }
            }
            ProjectManifest::CargoToml(cargo_toml) => {
                let cargo_version = utf8_stdout({
@@ -203,12 +207,21 @@ impl ProjectWorkspace {
        Ok(res)
    }
+    pub fn load_inline(project_json: ProjectJson) -> Result<ProjectWorkspace> {
+        let sysroot = match &project_json.sysroot_src {
+            Some(path) => Some(Sysroot::load(path)?),
+            None => None,
+        };
+        Ok(ProjectWorkspace::Json { project: project_json, sysroot })
+    }
    /// Returns the roots for the current `ProjectWorkspace`
    /// The return type contains the path and whether or not
    /// the root is a member of the current workspace
    pub fn to_roots(&self) -> Vec<PackageRoot> {
        match self {
-            ProjectWorkspace::Json { project } => project
+            ProjectWorkspace::Json { project, sysroot } => project
                .crates()
                .map(|(_, krate)| PackageRoot {
                    is_member: krate.is_workspace_member,
@@ -217,7 +230,7 @@ impl ProjectWorkspace {
                })
                .collect::<FxHashSet<_>>()
                .into_iter()
-                .chain(project.sysroot.as_ref().into_iter().flat_map(|sysroot| {
+                .chain(sysroot.as_ref().into_iter().flat_map(|sysroot| {
                    sysroot.crates().map(move |krate| PackageRoot {
                        is_member: false,
                        include: vec![sysroot[krate].root_dir().to_path_buf()],
@@ -255,7 +268,7 @@ impl ProjectWorkspace {
    pub fn proc_macro_dylib_paths(&self) -> Vec<AbsPathBuf> {
        match self {
-            ProjectWorkspace::Json { project } => project
+            ProjectWorkspace::Json { project, sysroot: _ } => project
                .crates()
                .filter_map(|(_, krate)| krate.proc_macro_dylib_path.as_ref())
                .cloned()
@@ -285,9 +298,8 @@ impl ProjectWorkspace {
    ) -> CrateGraph {
        let mut crate_graph = CrateGraph::default();
        match self {
-            ProjectWorkspace::Json { project } => {
+            ProjectWorkspace::Json { project, sysroot } => {
-                let sysroot_dps = project
+                let sysroot_dps = sysroot
-                    .sysroot
                    .as_ref()
                    .map(|sysroot| sysroot_to_crate_graph(&mut crate_graph, sysroot, target, load));
@@ -296,7 +308,13 @@ impl ProjectWorkspace {
                    .crates()
                    .filter_map(|(crate_id, krate)| {
                        let file_path = &krate.root_module;
-                        let file_id = load(&file_path)?;
+                        let file_id = match load(&file_path) {
+                            Some(id) => id,
+                            None => {
+                                log::error!("failed to load crate root {}", file_path.display());
+                                return None;
+                            }
+                        };
                        let env = krate.env.clone().into_iter().collect();
                        let proc_macro = krate
diff --git a/crates/project_model/src/project_json.rs b/crates/project_model/src/project_json.rs
index 5a0fe749a..a6895ecdd 100644
--- a/crates/project_model/src/project_json.rs
+++ b/crates/project_model/src/project_json.rs
@@ -7,12 +7,13 @@ use paths::{AbsPath, AbsPathBuf};
 use rustc_hash::FxHashMap;
 use serde::{de, Deserialize};
-use crate::{cfg_flag::CfgFlag, Sysroot};
+use crate::cfg_flag::CfgFlag;
 /// Roots and crates that compose this Rust project.
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct ProjectJson {
-    pub(crate) sysroot: Option<Sysroot>,
+    pub(crate) sysroot_src: Option<AbsPathBuf>,
+    project_root: AbsPathBuf,
    crates: Vec<Crate>,
 }
@@ -33,9 +34,17 @@ pub struct Crate {
 }
 impl ProjectJson {
+    /// Create a new ProjectJson instance.
+    ///
+    /// # Arguments
+    ///
+    /// * `base` - The path to the workspace root (i.e. the folder containing `rust-project.json`)
+    /// * `data` - The parsed contents of `rust-project.json`, or project json that's passed via
+    ///            configuration.
    pub fn new(base: &AbsPath, data: ProjectJsonData) -> ProjectJson {
        ProjectJson {
-            sysroot: data.sysroot_src.map(|it| base.join(it)).map(|it| Sysroot::load(&it)),
+            sysroot_src: data.sysroot_src.map(|it| base.join(it)),
+            project_root: base.to_path_buf(),
            crates: data
                .crates
                .into_iter()
@@ -83,12 +92,18 @@ impl ProjectJson {
                .collect::<Vec<_>>(),
        }
    }
+    /// Returns the number of crates in the project.
    pub fn n_crates(&self) -> usize {
        self.crates.len()
    }
+    /// Returns an iterator over the crates in the project.
    pub fn crates(&self) -> impl Iterator<Item = (CrateId, &Crate)> + '_ {
        self.crates.iter().enumerate().map(|(idx, krate)| (CrateId(idx as u32), krate))
    }
+    /// Returns the path to the project's root folder.
+    pub fn path(&self) -> &AbsPath {
+        &self.project_root
+    }
 }
 #[derive(Deserialize)]
diff --git a/crates/project_model/src/sysroot.rs b/crates/project_model/src/sysroot.rs
index 74c0eda9a..871808d89 100644
--- a/crates/project_model/src/sysroot.rs
+++ b/crates/project_model/src/sysroot.rs
@@ -51,11 +51,11 @@ impl Sysroot {
    pub fn discover(cargo_toml: &AbsPath) -> Result<Sysroot> {
        let current_dir = cargo_toml.parent().unwrap();
        let sysroot_src_dir = discover_sysroot_src_dir(current_dir)?;
-        let res = Sysroot::load(&sysroot_src_dir);
+        let res = Sysroot::load(&sysroot_src_dir)?;
        Ok(res)
    }
-    pub fn load(sysroot_src_dir: &AbsPath) -> Sysroot {
+    pub fn load(sysroot_src_dir: &AbsPath) -> Result<Sysroot> {
        let mut sysroot = Sysroot { crates: Arena::default() };
        for name in SYSROOT_CRATES.trim().lines() {
@@ -89,7 +89,14 @@ impl Sysroot {
            }
        }
-        sysroot
+        if sysroot.by_name("core").is_none() {
+            anyhow::bail!(
+                "could not find libcore in sysroot path `{}`",
+                sysroot_src_dir.as_ref().display()
+            );
+        }
+        Ok(sysroot)
    }
    fn by_name(&self, name: &str) -> Option<SysrootCrate> {
diff --git a/crates/rust-analyzer/Cargo.toml b/crates/rust-analyzer/Cargo.toml
index e06956d6c..631ffc4a7 100644
--- a/crates/rust-analyzer/Cargo.toml
+++ b/crates/rust-analyzer/Cargo.toml
@@ -21,7 +21,7 @@ env_logger = { version = "0.7.1", default-features = false }
 itertools = "0.9.0"
 jod-thread = "0.1.0"
 log = "0.4.8"
-lsp-types = { version = "0.79.0", features = ["proposed"] }
+lsp-types = { version = "0.82.0", features = ["proposed"] }
 parking_lot = "0.11.0"
 pico-args = "0.3.1"
 oorandom = "11.1.2"
diff --git a/crates/rust-analyzer/src/bin/main.rs b/crates/rust-analyzer/src/bin/main.rs
index ba4402ade..97b246a32 100644
--- a/crates/rust-analyzer/src/bin/main.rs
+++ b/crates/rust-analyzer/src/bin/main.rs
@@ -134,6 +134,10 @@ fn run_server() -> Result<()> {
            let discovered = ProjectManifest::discover_all(&workspace_roots);
            log::info!("discovered projects: {:?}", discovered);
+            if discovered.is_empty() {
+                log::error!("failed to find any projects in {:?}", workspace_roots);
+            }
            config.linked_projects = discovered.into_iter().map(LinkedProject::from).collect();
        }
diff --git a/crates/rust-analyzer/src/caps.rs b/crates/rust-analyzer/src/caps.rs
index 92a743fd8..c589afeaf 100644
--- a/crates/rust-analyzer/src/caps.rs
+++ b/crates/rust-analyzer/src/caps.rs
@@ -5,8 +5,8 @@ use lsp_types::{
    CallHierarchyServerCapability, ClientCapabilities, CodeActionKind, CodeActionOptions,
    CodeActionProviderCapability, CodeLensOptions, CompletionOptions,
    DocumentOnTypeFormattingOptions, FoldingRangeProviderCapability, HoverProviderCapability,
-    ImplementationProviderCapability, RenameOptions, RenameProviderCapability, SaveOptions,
+    ImplementationProviderCapability, OneOf, RenameOptions, SaveOptions,
-    SelectionRangeProviderCapability, SemanticTokensDocumentProvider, SemanticTokensLegend,
+    SelectionRangeProviderCapability, SemanticTokensFullOptions, SemanticTokensLegend,
    SemanticTokensOptions, ServerCapabilities, SignatureHelpOptions, TextDocumentSyncCapability,
    TextDocumentSyncKind, TextDocumentSyncOptions, TypeDefinitionProviderCapability,
    WorkDoneProgressOptions,
@@ -42,16 +42,16 @@ pub fn server_capabilities(client_caps: &ClientCapabilities) -> ServerCapabiliti
            work_done_progress_options: WorkDoneProgressOptions { work_done_progress: None },
        }),
        declaration_provider: None,
-        definition_provider: Some(true),
+        definition_provider: Some(OneOf::Left(true)),
        type_definition_provider: Some(TypeDefinitionProviderCapability::Simple(true)),
        implementation_provider: Some(ImplementationProviderCapability::Simple(true)),
-        references_provider: Some(true),
+        references_provider: Some(OneOf::Left(true)),
-        document_highlight_provider: Some(true),
+        document_highlight_provider: Some(OneOf::Left(true)),
-        document_symbol_provider: Some(true),
+        document_symbol_provider: Some(OneOf::Left(true)),
        workspace_symbol_provider: Some(true),
        code_action_provider: Some(code_action_provider),
        code_lens_provider: Some(CodeLensOptions { resolve_provider: Some(true) }),
-        document_formatting_provider: Some(true),
+        document_formatting_provider: Some(OneOf::Left(true)),
        document_range_formatting_provider: None,
        document_on_type_formatting_provider: Some(DocumentOnTypeFormattingOptions {
            first_trigger_character: "=".to_string(),
@@ -60,7 +60,7 @@ pub fn server_capabilities(client_caps: &ClientCapabilities) -> ServerCapabiliti
        selection_range_provider: Some(SelectionRangeProviderCapability::Simple(true)),
        semantic_highlighting: None,
        folding_range_provider: Some(FoldingRangeProviderCapability::Simple(true)),
-        rename_provider: Some(RenameProviderCapability::Options(RenameOptions {
+        rename_provider: Some(OneOf::Right(RenameOptions {
            prepare_provider: Some(true),
            work_done_progress_options: WorkDoneProgressOptions { work_done_progress: None },
        })),
@@ -76,10 +76,8 @@ pub fn server_capabilities(client_caps: &ClientCapabilities) -> ServerCapabiliti
                    token_modifiers: semantic_tokens::SUPPORTED_MODIFIERS.to_vec(),
                },
-                document_provider: Some(SemanticTokensDocumentProvider::Edits {
+                full: Some(SemanticTokensFullOptions::Delta { delta: Some(true) }),
-                    edits: Some(true),
+                range: Some(true),
-                }),
-                range_provider: Some(true),
                work_done_progress_options: Default::default(),
            }
            .into(),
diff --git a/crates/rust-analyzer/src/config.rs b/crates/rust-analyzer/src/config.rs
index 99f7751ac..69d05aed5 100644
--- a/crates/rust-analyzer/src/config.rs
+++ b/crates/rust-analyzer/src/config.rs
@@ -10,7 +10,10 @@
 use std::{ffi::OsString, path::PathBuf};
 use flycheck::FlycheckConfig;
-use ide::{AssistConfig, CompletionConfig, DiagnosticsConfig, HoverConfig, InlayHintsConfig};
+use ide::{
+    AssistConfig, CompletionConfig, DiagnosticsConfig, HoverConfig, InlayHintsConfig,
+    MergeBehaviour,
+};
 use lsp_types::ClientCapabilities;
 use project_model::{CargoConfig, ProjectJson, ProjectJsonData, ProjectManifest};
 use rustc_hash::FxHashSet;
@@ -263,6 +266,12 @@ impl Config {
        self.completion.add_call_parenthesis = data.completion_addCallParenthesis;
        self.completion.add_call_argument_snippets = data.completion_addCallArgumentSnippets;
+        self.assist.insert_use.merge = match data.assist_importMergeBehaviour {
+            MergeBehaviourDef::None => None,
+            MergeBehaviourDef::Full => Some(MergeBehaviour::Full),
+            MergeBehaviourDef::Last => Some(MergeBehaviour::Last),
+        };
        self.call_info_full = data.callInfo_full;
        self.lens = LensConfig {
@@ -279,7 +288,10 @@ impl Config {
                        let path = self.root_path.join(it);
                        match ProjectManifest::from_manifest_file(path) {
                            Ok(it) => it.into(),
-                            Err(_) => continue,
+                            Err(e) => {
+                                log::error!("failed to load linked project: {}", e);
+                                continue;
+                            }
                        }
                    }
                    ManifestOrProjectJson::ProjectJson(it) => {
@@ -370,6 +382,14 @@ enum ManifestOrProjectJson {
    ProjectJson(ProjectJsonData),
 }
+#[derive(Deserialize)]
+#[serde(rename_all = "lowercase")]
+enum MergeBehaviourDef {
+    None,
+    Full,
+    Last,
+}
 macro_rules! config_data {
    (struct $name:ident { $($field:ident: $ty:ty = $default:expr,)*}) => {
        #[allow(non_snake_case)]
@@ -393,6 +413,8 @@ macro_rules! config_data {
 config_data! {
    struct ConfigData {
+        assist_importMergeBehaviour: MergeBehaviourDef = MergeBehaviourDef::None,
        callInfo_full: bool = true,
        cargo_autoreload: bool           = true,
@@ -402,7 +424,7 @@ config_data! {
        cargo_noDefaultFeatures: bool    = false,
        cargo_target: Option<String>     = None,
-        checkOnSave_enable: bool                         = false,
+        checkOnSave_enable: bool                         = true,
        checkOnSave_allFeatures: Option<bool>            = None,
        checkOnSave_allTargets: bool                     = true,
        checkOnSave_command: String                      = "check".into(),
diff --git a/crates/rust-analyzer/src/diagnostics/test_data/macro_compiler_error.txt b/crates/rust-analyzer/src/diagnostics/test_data/macro_compiler_error.txt
index 89dae7d5a..00e8da8a7 100644
--- a/crates/rust-analyzer/src/diagnostics/test_data/macro_compiler_error.txt
+++ b/crates/rust-analyzer/src/diagnostics/test_data/macro_compiler_error.txt
@@ -44,4 +44,49 @@
        },
        fixes: [],
    },
+    MappedRustDiagnostic {
+        url: "file:///test/crates/hir_def/src/path.rs",
+        diagnostic: Diagnostic {
+            range: Range {
+                start: Position {
+                    line: 264,
+                    character: 8,
+                },
+                end: Position {
+                    line: 264,
+                    character: 76,
+                },
+            },
+            severity: Some(
+                Error,
+            ),
+            code: None,
+            source: Some(
+                "rustc",
+            ),
+            message: "Please register your known path in the path module",
+            related_information: Some(
+                [
+                    DiagnosticRelatedInformation {
+                        location: Location {
+                            uri: "file:///test/crates/hir_def/src/data.rs",
+                            range: Range {
+                                start: Position {
+                                    line: 79,
+                                    character: 15,
+                                },
+                                end: Position {
+                                    line: 79,
+                                    character: 41,
+                                },
+                            },
+                        },
+                        message: "Exact error occured here",
+                    },
+                ],
+            ),
+            tags: None,
+        },
+        fixes: [],
+    },
 ]
diff --git a/crates/rust-analyzer/src/diagnostics/to_proto.rs b/crates/rust-analyzer/src/diagnostics/to_proto.rs
index f69a949f2..33606edda 100644
--- a/crates/rust-analyzer/src/diagnostics/to_proto.rs
+++ b/crates/rust-analyzer/src/diagnostics/to_proto.rs
@@ -225,12 +225,43 @@ pub(crate) fn map_rust_diagnostic_to_lsp(
            // If error occurs from macro expansion, add related info pointing to
            // where the error originated
-            if !is_from_macro(&primary_span.file_name) && primary_span.expansion.is_some() {
+            // Also, we would generate an additional diagnostic, so that exact place of macro
-                related_information.push(lsp_types::DiagnosticRelatedInformation {
+            // will be highlighted in the error origin place.
-                    location: location_naive(workspace_root, &primary_span),
+            let additional_diagnostic =
-                    message: "Error originated from macro here".to_string(),
+                if !is_from_macro(&primary_span.file_name) && primary_span.expansion.is_some() {
-                });
+                    let in_macro_location = location_naive(workspace_root, &primary_span);
-            }
+                    // Add related information for the main disagnostic.
+                    related_information.push(lsp_types::DiagnosticRelatedInformation {
+                        location: in_macro_location.clone(),
+                        message: "Error originated from macro here".to_string(),
+                    });
+                    // For the additional in-macro diagnostic we add the inverse message pointing to the error location in code.
+                    let information_for_additional_diagnostic =
+                        vec![lsp_types::DiagnosticRelatedInformation {
+                            location: location.clone(),
+                            message: "Exact error occured here".to_string(),
+                        }];
+                    let diagnostic = lsp_types::Diagnostic {
+                        range: in_macro_location.range,
+                        severity,
+                        code: code.clone().map(lsp_types::NumberOrString::String),
+                        source: Some(source.clone()),
+                        message: message.clone(),
+                        related_information: Some(information_for_additional_diagnostic),
+                        tags: if tags.is_empty() { None } else { Some(tags.clone()) },
+                    };
+                    Some(MappedRustDiagnostic {
+                        url: in_macro_location.uri,
+                        diagnostic,
+                        fixes: fixes.clone(),
+                    })
+                } else {
+                    None
+                };
            let diagnostic = lsp_types::Diagnostic {
                range: location.range,
@@ -246,8 +277,14 @@ pub(crate) fn map_rust_diagnostic_to_lsp(
                tags: if tags.is_empty() { None } else { Some(tags.clone()) },
            };
-            MappedRustDiagnostic { url: location.uri, diagnostic, fixes: fixes.clone() }
+            let main_diagnostic =
+                MappedRustDiagnostic { url: location.uri, diagnostic, fixes: fixes.clone() };
+            match additional_diagnostic {
+                None => vec![main_diagnostic],
+                Some(additional_diagnostic) => vec![main_diagnostic, additional_diagnostic],
+            }
        })
+        .flatten()
        .collect()
 }
diff --git a/crates/rust-analyzer/src/handlers.rs b/crates/rust-analyzer/src/handlers.rs
index d62dd0589..c0943a54d 100644
--- a/crates/rust-analyzer/src/handlers.rs
+++ b/crates/rust-analyzer/src/handlers.rs
@@ -17,8 +17,8 @@ use lsp_types::{
    CallHierarchyOutgoingCall, CallHierarchyOutgoingCallsParams, CallHierarchyPrepareParams,
    CodeActionKind, CodeLens, Command, CompletionItem, Diagnostic, DocumentFormattingParams,
    DocumentHighlight, DocumentSymbol, FoldingRange, FoldingRangeParams, HoverContents, Location,
-    Position, PrepareRenameResponse, Range, RenameParams, SemanticTokensEditResult,
+    Position, PrepareRenameResponse, Range, RenameParams, SemanticTokensDeltaParams,
-    SemanticTokensEditsParams, SemanticTokensParams, SemanticTokensRangeParams,
+    SemanticTokensFullDeltaResult, SemanticTokensParams, SemanticTokensRangeParams,
    SemanticTokensRangeResult, SemanticTokensResult, SymbolInformation, SymbolTag,
    TextDocumentIdentifier, Url, WorkspaceEdit,
 };
@@ -748,10 +748,15 @@ pub(crate) fn handle_formatting(
        }
    }
-    Ok(Some(vec![lsp_types::TextEdit {
+    if *file == captured_stdout {
-        range: Range::new(Position::new(0, 0), end_position),
+        // The document is already formatted correctly -- no edits needed.
-        new_text: captured_stdout,
+        Ok(None)
-    }]))
+    } else {
+        Ok(Some(vec![lsp_types::TextEdit {
+            range: Range::new(Position::new(0, 0), end_position),
+            new_text: captured_stdout,
+        }]))
+    }
 }
 fn handle_fixes(
@@ -1171,11 +1176,11 @@ pub(crate) fn handle_call_hierarchy_outgoing(
    Ok(Some(res))
 }
-pub(crate) fn handle_semantic_tokens(
+pub(crate) fn handle_semantic_tokens_full(
    snap: GlobalStateSnapshot,
    params: SemanticTokensParams,
 ) -> Result<Option<SemanticTokensResult>> {
-    let _p = profile::span("handle_semantic_tokens");
+    let _p = profile::span("handle_semantic_tokens_full");
    let file_id = from_proto::file_id(&snap, &params.text_document.uri)?;
    let text = snap.analysis.file_text(file_id)?;
@@ -1190,11 +1195,11 @@ pub(crate) fn handle_semantic_tokens(
    Ok(Some(semantic_tokens.into()))
 }
-pub(crate) fn handle_semantic_tokens_edits(
+pub(crate) fn handle_semantic_tokens_full_delta(
    snap: GlobalStateSnapshot,
-    params: SemanticTokensEditsParams,
+    params: SemanticTokensDeltaParams,
-) -> Result<Option<SemanticTokensEditResult>> {
+) -> Result<Option<SemanticTokensFullDeltaResult>> {
-    let _p = profile::span("handle_semantic_tokens_edits");
+    let _p = profile::span("handle_semantic_tokens_full_delta");
    let file_id = from_proto::file_id(&snap, &params.text_document.uri)?;
    let text = snap.analysis.file_text(file_id)?;
@@ -1209,9 +1214,9 @@ pub(crate) fn handle_semantic_tokens_edits(
    if let Some(prev_id) = &cached_tokens.result_id {
        if *prev_id == params.previous_result_id {
-            let edits = to_proto::semantic_token_edits(&cached_tokens, &semantic_tokens);
+            let delta = to_proto::semantic_token_delta(&cached_tokens, &semantic_tokens);
            *cached_tokens = semantic_tokens;
-            return Ok(Some(edits.into()));
+            return Ok(Some(delta.into()));
        }
    }
diff --git a/crates/rust-analyzer/src/main_loop.rs b/crates/rust-analyzer/src/main_loop.rs
index 355caaee2..8d3132581 100644
--- a/crates/rust-analyzer/src/main_loop.rs
+++ b/crates/rust-analyzer/src/main_loop.rs
@@ -407,9 +407,11 @@ impl GlobalState {
            .on::<lsp_types::request::CallHierarchyOutgoingCalls>(
                handlers::handle_call_hierarchy_outgoing,
            )?
-            .on::<lsp_types::request::SemanticTokensRequest>(handlers::handle_semantic_tokens)?
+            .on::<lsp_types::request::SemanticTokensFullRequest>(
-            .on::<lsp_types::request::SemanticTokensEditsRequest>(
+                handlers::handle_semantic_tokens_full,
-                handlers::handle_semantic_tokens_edits,
+            )?
+            .on::<lsp_types::request::SemanticTokensFullDeltaRequest>(
+                handlers::handle_semantic_tokens_full_delta,
            )?
            .on::<lsp_types::request::SemanticTokensRangeRequest>(
                handlers::handle_semantic_tokens_range,
diff --git a/crates/rust-analyzer/src/reload.rs b/crates/rust-analyzer/src/reload.rs
index 20019b944..b070087a4 100644
--- a/crates/rust-analyzer/src/reload.rs
+++ b/crates/rust-analyzer/src/reload.rs
@@ -2,7 +2,7 @@
 use std::{mem, sync::Arc};
 use base_db::{CrateGraph, SourceRoot, VfsPath};
-use flycheck::FlycheckHandle;
+use flycheck::{FlycheckConfig, FlycheckHandle};
 use ide::AnalysisChange;
 use project_model::{ProcMacroClient, ProjectWorkspace};
 use vfs::{file_set::FileSetConfig, AbsPath, AbsPathBuf, ChangeKind};
@@ -109,7 +109,7 @@ impl GlobalState {
                            )
                        }
                        LinkedProject::InlineJsonProject(it) => {
-                            Ok(project_model::ProjectWorkspace::Json { project: it.clone() })
+                            project_model::ProjectWorkspace::load_inline(it.clone())
                        }
                    })
                    .collect::<Vec<_>>();
@@ -201,11 +201,14 @@ impl GlobalState {
            let mut crate_graph = CrateGraph::default();
            let vfs = &mut self.vfs.write().0;
            let loader = &mut self.loader;
+            let mem_docs = &self.mem_docs;
            let mut load = |path: &AbsPath| {
-                let contents = loader.handle.load_sync(path);
+                let vfs_path = vfs::VfsPath::from(path.to_path_buf());
-                let path = vfs::VfsPath::from(path.to_path_buf());
+                if !mem_docs.contains_key(&vfs_path) {
-                vfs.set_file_contents(path.clone(), contents);
+                    let contents = loader.handle.load_sync(path);
-                vfs.file_id(&path)
+                    vfs.set_file_contents(vfs_path.clone(), contents);
+                }
+                vfs.file_id(&vfs_path)
            };
            for ws in workspaces.iter() {
                crate_graph.extend(ws.to_crate_graph(
@@ -244,13 +247,17 @@ impl GlobalState {
            .iter()
            // FIXME: Figure out the multi-workspace situation
            .find_map(|w| match w {
-                ProjectWorkspace::Cargo { cargo, sysroot: _ } => Some(cargo),
+                ProjectWorkspace::Cargo { cargo, sysroot: _ } => Some(cargo.workspace_root()),
-                ProjectWorkspace::Json { .. } => None,
+                ProjectWorkspace::Json { project, .. } => {
-            })
+                    // Enable flychecks for json projects if a custom flycheck command was supplied
-            .map(move |cargo| {
+                    // in the workspace configuration.
-                let cargo_project_root = cargo.workspace_root().to_path_buf();
+                    match config {
-                FlycheckHandle::spawn(sender, config, cargo_project_root.into())
+                        FlycheckConfig::CustomCommand { .. } => Some(project.path()),
+                        _ => None,
+                    }
+                }
            })
+            .map(move |root| FlycheckHandle::spawn(sender, config, root.to_path_buf().into()))
    }
 }
diff --git a/crates/rust-analyzer/src/semantic_tokens.rs b/crates/rust-analyzer/src/semantic_tokens.rs
index 9db7b8af5..a6c4d6099 100644
--- a/crates/rust-analyzer/src/semantic_tokens.rs
+++ b/crates/rust-analyzer/src/semantic_tokens.rs
@@ -24,6 +24,7 @@ macro_rules! define_semantic_token_types {
            SemanticTokenType::CLASS,
            SemanticTokenType::INTERFACE,
            SemanticTokenType::ENUM,
+            SemanticTokenType::ENUM_MEMBER,
            SemanticTokenType::TYPE_PARAMETER,
            SemanticTokenType::FUNCTION,
            SemanticTokenType::MEMBER,
@@ -31,7 +32,6 @@ macro_rules! define_semantic_token_types {
            SemanticTokenType::MACRO,
            SemanticTokenType::VARIABLE,
            SemanticTokenType::PARAMETER,
-            SemanticTokenType::LABEL,
            $($ident),*
        ];
    };
@@ -41,7 +41,6 @@ define_semantic_token_types![
    (ATTRIBUTE, "attribute"),
    (BOOLEAN, "boolean"),
    (BUILTIN_TYPE, "builtinType"),
-    (ENUM_MEMBER, "enumMember"),
    (ESCAPE_SEQUENCE, "escapeSequence"),
    (FORMAT_SPECIFIER, "formatSpecifier"),
    (GENERIC, "generic"),
diff --git a/crates/rust-analyzer/src/to_proto.rs b/crates/rust-analyzer/src/to_proto.rs
index a8173a338..59e780b7d 100644
--- a/crates/rust-analyzer/src/to_proto.rs
+++ b/crates/rust-analyzer/src/to_proto.rs
@@ -285,12 +285,18 @@ pub(crate) fn signature_help(
        })
    };
-    let signature =
+    let active_parameter = call_info.active_parameter.map(|it| it as i64);
-        lsp_types::SignatureInformation { label, documentation, parameters: Some(parameters) };
+    let signature = lsp_types::SignatureInformation {
+        label,
+        documentation,
+        parameters: Some(parameters),
+        active_parameter,
+    };
    lsp_types::SignatureHelp {
        signatures: vec![signature],
        active_signature: None,
-        active_parameter: call_info.active_parameter.map(|it| it as i64),
+        active_parameter,
    }
 }
@@ -334,13 +340,13 @@ pub(crate) fn semantic_tokens(
    builder.build()
 }
-pub(crate) fn semantic_token_edits(
+pub(crate) fn semantic_token_delta(
    previous: &lsp_types::SemanticTokens,
    current: &lsp_types::SemanticTokens,
-) -> lsp_types::SemanticTokensEdits {
+) -> lsp_types::SemanticTokensDelta {
    let result_id = current.result_id.clone();
    let edits = semantic_tokens::diff_tokens(&previous.data, &current.data);
-    lsp_types::SemanticTokensEdits { result_id, edits }
+    lsp_types::SemanticTokensDelta { result_id, edits }
 }
 fn semantic_token_type_and_modifiers(
@@ -369,7 +375,7 @@ fn semantic_token_type_and_modifiers(
            mods |= lsp_types::SemanticTokenModifier::STATIC;
            lsp_types::SemanticTokenType::VARIABLE
        }
-        HighlightTag::EnumVariant => semantic_tokens::ENUM_MEMBER,
+        HighlightTag::EnumVariant => lsp_types::SemanticTokenType::ENUM_MEMBER,
        HighlightTag::Macro => lsp_types::SemanticTokenType::MACRO,
        HighlightTag::ValueParam => lsp_types::SemanticTokenType::PARAMETER,
        HighlightTag::Local => lsp_types::SemanticTokenType::VARIABLE,
diff --git a/crates/rust-analyzer/tests/rust-analyzer/main.rs b/crates/rust-analyzer/tests/rust-analyzer/main.rs
index 0880d0425..06726f957 100644
--- a/crates/rust-analyzer/tests/rust-analyzer/main.rs
+++ b/crates/rust-analyzer/tests/rust-analyzer/main.rs
@@ -260,6 +260,42 @@ pub use std::collections::HashMap;
 }
 #[test]
+fn test_format_document_unchanged() {
+    if skip_slow_tests() {
+        return;
+    }
+    let server = project(
+        r#"
+//- /Cargo.toml
+[package]
+name = "foo"
+version = "0.0.0"
+//- /src/lib.rs
+fn main() {}
+"#,
+    )
+    .wait_until_workspace_is_loaded();
+    server.request::<Formatting>(
+        DocumentFormattingParams {
+            text_document: server.doc_id("src/lib.rs"),
+            options: FormattingOptions {
+                tab_size: 4,
+                insert_spaces: false,
+                insert_final_newline: None,
+                trim_final_newlines: None,
+                trim_trailing_whitespace: None,
+                properties: HashMap::new(),
+            },
+            work_done_progress_params: WorkDoneProgressParams::default(),
+        },
+        json!(null),
+    );
+}
+#[test]
 fn test_missing_module_code_action() {
    if skip_slow_tests() {
        return;
diff --git a/crates/syntax/src/ast/edit.rs b/crates/syntax/src/ast/edit.rs
index 060b20966..dda0a0319 100644
--- a/crates/syntax/src/ast/edit.rs
+++ b/crates/syntax/src/ast/edit.rs
@@ -13,7 +13,7 @@ use crate::{
    ast::{
        self,
        make::{self, tokens},
-        AstNode, TypeBoundsOwner,
+        AstNode, GenericParamsOwner, NameOwner, TypeBoundsOwner,
    },
    AstToken, Direction, InsertPosition, SmolStr, SyntaxElement, SyntaxKind,
    SyntaxKind::{ATTR, COMMENT, WHITESPACE},
@@ -46,6 +46,19 @@ impl ast::Fn {
        to_insert.push(body.syntax().clone().into());
        self.replace_children(single_node(old_body_or_semi), to_insert)
    }
+    #[must_use]
+    pub fn with_generic_param_list(&self, generic_args: ast::GenericParamList) -> ast::Fn {
+        if let Some(old) = self.generic_param_list() {
+            return self.replace_descendant(old, generic_args);
+        }
+        let anchor = self.name().expect("The function must have a name").syntax().clone();
+        let mut to_insert: ArrayVec<[SyntaxElement; 1]> = ArrayVec::new();
+        to_insert.push(generic_args.syntax().clone().into());
+        self.insert_children(InsertPosition::After(anchor.into()), to_insert)
+    }
 }
 fn make_multiline<N>(node: N) -> N
@@ -80,6 +93,22 @@ where
    }
 }
+impl ast::Impl {
+    #[must_use]
+    pub fn with_assoc_item_list(&self, items: ast::AssocItemList) -> ast::Impl {
+        let mut to_insert: ArrayVec<[SyntaxElement; 2]> = ArrayVec::new();
+        if let Some(old_items) = self.assoc_item_list() {
+            let to_replace: SyntaxElement = old_items.syntax().clone().into();
+            to_insert.push(items.syntax().clone().into());
+            self.replace_children(single_node(to_replace), to_insert)
+        } else {
+            to_insert.push(make::tokens::single_space().into());
+            to_insert.push(items.syntax().clone().into());
+            self.insert_children(InsertPosition::Last, to_insert)
+        }
+    }
+}
 impl ast::AssocItemList {
    #[must_use]
    pub fn append_items(
@@ -260,16 +289,16 @@ impl ast::Path {
 impl ast::PathSegment {
    #[must_use]
-    pub fn with_type_args(&self, type_args: ast::GenericArgList) -> ast::PathSegment {
+    pub fn with_generic_args(&self, type_args: ast::GenericArgList) -> ast::PathSegment {
-        self._with_type_args(type_args, false)
+        self._with_generic_args(type_args, false)
    }
    #[must_use]
    pub fn with_turbo_fish(&self, type_args: ast::GenericArgList) -> ast::PathSegment {
-        self._with_type_args(type_args, true)
+        self._with_generic_args(type_args, true)
    }
-    fn _with_type_args(&self, type_args: ast::GenericArgList, turbo: bool) -> ast::PathSegment {
+    fn _with_generic_args(&self, type_args: ast::GenericArgList, turbo: bool) -> ast::PathSegment {
        if let Some(old) = self.generic_arg_list() {
            return self.replace_children(
                single_node(old.syntax().clone()),
@@ -334,6 +363,7 @@ impl ast::UseTree {
        self.clone()
    }
+    /// Splits off the given prefix, making it the path component of the use tree, appending the rest of the path to all UseTreeList items.
    #[must_use]
    pub fn split_prefix(&self, prefix: &ast::Path) -> ast::UseTree {
        let suffix = if self.path().as_ref() == Some(prefix) && self.use_tree_list().is_none() {
@@ -459,6 +489,61 @@ impl ast::MatchArmList {
    }
 }
+impl ast::GenericParamList {
+    #[must_use]
+    pub fn append_params(
+        &self,
+        params: impl IntoIterator<Item = ast::GenericParam>,
+    ) -> ast::GenericParamList {
+        let mut res = self.clone();
+        params.into_iter().for_each(|it| res = res.append_param(it));
+        res
+    }
+    #[must_use]
+    pub fn append_param(&self, item: ast::GenericParam) -> ast::GenericParamList {
+        let space = tokens::single_space();
+        let mut to_insert: ArrayVec<[SyntaxElement; 4]> = ArrayVec::new();
+        if self.generic_params().next().is_some() {
+            to_insert.push(space.into());
+        }
+        to_insert.push(item.syntax().clone().into());
+        macro_rules! after_l_angle {
+            () => {{
+                let anchor = match self.l_angle_token() {
+                    Some(it) => it.into(),
+                    None => return self.clone(),
+                };
+                InsertPosition::After(anchor)
+            }};
+        }
+        macro_rules! after_field {
+            ($anchor:expr) => {
+                if let Some(comma) = $anchor
+                    .syntax()
+                    .siblings_with_tokens(Direction::Next)
+                    .find(|it| it.kind() == T![,])
+                {
+                    InsertPosition::After(comma)
+                } else {
+                    to_insert.insert(0, make::token(T![,]).into());
+                    InsertPosition::After($anchor.syntax().clone().into())
+                }
+            };
+        };
+        let position = match self.generic_params().last() {
+            Some(it) => after_field!(it),
+            None => after_l_angle!(),
+        };
+        self.insert_children(position, to_insert)
+    }
+}
 #[must_use]
 pub fn remove_attrs_and_docs<N: ast::AttrsOwner>(node: &N) -> N {
    N::cast(remove_attrs_and_docs_inner(node.syntax().clone())).unwrap()
diff --git a/crates/syntax/src/ast/make.rs b/crates/syntax/src/ast/make.rs
index 7ba625990..4a0ffcbb0 100644
--- a/crates/syntax/src/ast/make.rs
+++ b/crates/syntax/src/ast/make.rs
@@ -21,6 +21,10 @@ pub fn ty(text: &str) -> ast::Type {
    ast_from_text(&format!("impl {} for D {{}};", text))
 }
+pub fn assoc_item_list() -> ast::AssocItemList {
+    ast_from_text("impl C for D {};")
+}
 pub fn path_segment(name_ref: ast::NameRef) -> ast::PathSegment {
    ast_from_text(&format!("use {};", name_ref))
 }
@@ -33,10 +37,15 @@ pub fn path_unqualified(segment: ast::PathSegment) -> ast::Path {
 pub fn path_qualified(qual: ast::Path, segment: ast::PathSegment) -> ast::Path {
    path_from_text(&format!("{}::{}", qual, segment))
 }
+// FIXME: make this private
 pub fn path_from_text(text: &str) -> ast::Path {
    ast_from_text(text)
 }
+pub fn glob_use_tree() -> ast::UseTree {
+    ast_from_text("use *;")
+}
 pub fn use_tree(
    path: ast::Path,
    use_tree_list: Option<ast::UseTreeList>,
@@ -144,10 +153,6 @@ fn expr_from_text(text: &str) -> ast::Expr {
    ast_from_text(&format!("const C: () = {};", text))
 }
-pub fn try_expr_from_text(text: &str) -> Option<ast::Expr> {
-    try_ast_from_text(&format!("const C: () = {};", text))
-}
 pub fn condition(expr: ast::Expr, pattern: Option<ast::Pat>) -> ast::Condition {
    match pattern {
        None => ast_from_text(&format!("const _: () = while {} {{}};", expr)),
@@ -297,6 +302,21 @@ pub fn param_list(pats: impl IntoIterator<Item = ast::Param>) -> ast::ParamList
    ast_from_text(&format!("fn f({}) {{ }}", args))
 }
+pub fn generic_param(name: String, ty: Option<ast::TypeBoundList>) -> ast::GenericParam {
+    let bound = match ty {
+        Some(it) => format!(": {}", it),
+        None => String::new(),
+    };
+    ast_from_text(&format!("fn f<{}{}>() {{ }}", name, bound))
+}
+pub fn generic_param_list(
+    pats: impl IntoIterator<Item = ast::GenericParam>,
+) -> ast::GenericParamList {
+    let args = pats.into_iter().join(", ");
+    ast_from_text(&format!("fn f<{}>() {{ }}", args))
+}
 pub fn visibility_pub_crate() -> ast::Visibility {
    ast_from_text("pub(crate) struct S")
 }
@@ -332,16 +352,6 @@ fn ast_from_text<N: AstNode>(text: &str) -> N {
    node
 }
-fn try_ast_from_text<N: AstNode>(text: &str) -> Option<N> {
-    let parse = SourceFile::parse(text);
-    let node = parse.tree().syntax().descendants().find_map(N::cast)?;
-    let node = node.syntax().clone();
-    let node = unroot(node);
-    let node = N::cast(node).unwrap();
-    assert_eq!(node.syntax().text_range().start(), 0.into());
-    Some(node)
-}
 fn unroot(n: SyntaxNode) -> SyntaxNode {
    SyntaxNode::new_root(n.green().clone())
 }
@@ -352,7 +362,7 @@ pub mod tokens {
    use crate::{ast, AstNode, Parse, SourceFile, SyntaxKind::*, SyntaxToken};
    pub(super) static SOURCE_FILE: Lazy<Parse<SourceFile>> =
-        Lazy::new(|| SourceFile::parse("const C: <()>::Item = (1 != 1, 2 == 2, !true)\n;"));
+        Lazy::new(|| SourceFile::parse("const C: <()>::Item = (1 != 1, 2 == 2, !true)\n;\n\n"));
    pub fn single_space() -> SyntaxToken {
        SOURCE_FILE
@@ -392,6 +402,16 @@ pub mod tokens {
            .unwrap()
    }
+    pub fn blank_line() -> SyntaxToken {
+        SOURCE_FILE
+            .tree()
+            .syntax()
+            .descendants_with_tokens()
+            .filter_map(|it| it.into_token())
+            .find(|it| it.kind() == WHITESPACE && it.text().as_str() == "\n\n")
+            .unwrap()
+    }
    pub struct WsBuilder(SourceFile);
    impl WsBuilder {
diff --git a/crates/syntax/test_data/parser/inline/ok/0102_record_field_pat_list.rast b/crates/syntax/test_data/parser/inline/ok/0102_record_pat_field_list.rast
index 866e60ed8..866e60ed8 100644
--- a/crates/syntax/test_data/parser/inline/ok/0102_record_field_pat_list.rast
+++ b/crates/syntax/test_data/parser/inline/ok/0102_record_pat_field_list.rast
diff --git a/crates/syntax/test_data/parser/inline/ok/0102_record_field_pat_list.rs b/crates/syntax/test_data/parser/inline/ok/0102_record_pat_field_list.rs
index da3412fa8..da3412fa8 100644
--- a/crates/syntax/test_data/parser/inline/ok/0102_record_field_pat_list.rs
+++ b/crates/syntax/test_data/parser/inline/ok/0102_record_pat_field_list.rs
diff --git a/crates/syntax/test_data/parser/inline/ok/0145_record_field_pat.rast b/crates/syntax/test_data/parser/inline/ok/0145_record_pat_field.rast
index 925409bdf..925409bdf 100644
--- a/crates/syntax/test_data/parser/inline/ok/0145_record_field_pat.rast
+++ b/crates/syntax/test_data/parser/inline/ok/0145_record_pat_field.rast
diff --git a/crates/syntax/test_data/parser/inline/ok/0145_record_field_pat.rs b/crates/syntax/test_data/parser/inline/ok/0145_record_pat_field.rs
index 26b1d5f89..26b1d5f89 100644
--- a/crates/syntax/test_data/parser/inline/ok/0145_record_field_pat.rs
+++ b/crates/syntax/test_data/parser/inline/ok/0145_record_pat_field.rs
diff --git a/crates/text_edit/src/lib.rs b/crates/text_edit/src/lib.rs
index e417e8ea6..eb3c8caa2 100644
--- a/crates/text_edit/src/lib.rs
+++ b/crates/text_edit/src/lib.rs
@@ -119,7 +119,7 @@ impl TextEdit {
            return Err(other);
        }
        self.indels.extend(other.indels);
-        assert!(check_disjoint(&mut self.indels));
+        assert_disjoint(&mut self.indels);
        Ok(())
    }
@@ -169,7 +169,7 @@ impl TextEditBuilder {
    }
    pub fn finish(self) -> TextEdit {
        let mut indels = self.indels;
-        assert!(check_disjoint(&mut indels));
+        assert_disjoint(&mut indels);
        TextEdit { indels }
    }
    pub fn invalidates_offset(&self, offset: TextSize) -> bool {
@@ -178,11 +178,14 @@ impl TextEditBuilder {
    fn indel(&mut self, indel: Indel) {
        self.indels.push(indel);
        if self.indels.len() <= 16 {
-            check_disjoint(&mut self.indels);
+            assert_disjoint(&mut self.indels);
        }
    }
 }
+fn assert_disjoint(indels: &mut [impl std::borrow::Borrow<Indel>]) {
+    assert!(check_disjoint(indels));
+}
 fn check_disjoint(indels: &mut [impl std::borrow::Borrow<Indel>]) -> bool {
    indels.sort_by_key(|indel| (indel.borrow().delete.start(), indel.borrow().delete.end()));
    indels
diff --git a/crates/vfs/src/file_set.rs b/crates/vfs/src/file_set.rs
index e9196fcd2..4aa2d6526 100644
--- a/crates/vfs/src/file_set.rs
+++ b/crates/vfs/src/file_set.rs
@@ -23,13 +23,22 @@ impl FileSet {
        let mut base = self.paths[&anchor].clone();
        base.pop();
        let path = base.join(path)?;
-        let res = self.files.get(&path).copied();
+        self.files.get(&path).copied()
-        res
+    }
+    pub fn file_for_path(&self, path: &VfsPath) -> Option<&FileId> {
+        self.files.get(path)
    }
+    pub fn path_for_file(&self, file: &FileId) -> Option<&VfsPath> {
+        self.paths.get(file)
+    }
    pub fn insert(&mut self, file_id: FileId, path: VfsPath) {
        self.files.insert(path.clone(), file_id);
        self.paths.insert(file_id, path);
    }
    pub fn iter(&self) -> impl Iterator<Item = FileId> + '_ {
        self.paths.keys().copied()
    }
diff --git a/crates/vfs/src/vfs_path.rs b/crates/vfs/src/vfs_path.rs
index 944a702df..022a0be1e 100644
--- a/crates/vfs/src/vfs_path.rs
+++ b/crates/vfs/src/vfs_path.rs
@@ -48,6 +48,24 @@ impl VfsPath {
            (VfsPathRepr::VirtualPath(_), _) => false,
        }
    }
+    pub fn parent(&self) -> Option<VfsPath> {
+        let mut parent = self.clone();
+        if parent.pop() {
+            Some(parent)
+        } else {
+            None
+        }
+    }
+    pub fn name_and_extension(&self) -> Option<(&str, Option<&str>)> {
+        match &self.0 {
+            VfsPathRepr::PathBuf(p) => Some((
+                p.file_stem()?.to_str()?,
+                p.extension().and_then(|extension| extension.to_str()),
+            )),
+            VfsPathRepr::VirtualPath(p) => p.name_and_extension(),
+        }
+    }
    // Don't make this `pub`
    pub(crate) fn encode(&self, buf: &mut Vec<u8>) {
@@ -268,4 +286,60 @@ impl VirtualPath {
        res.0 = format!("{}/{}", res.0, path);
        Some(res)
    }
+    pub fn name_and_extension(&self) -> Option<(&str, Option<&str>)> {
+        let file_path = if self.0.ends_with('/') { &self.0[..&self.0.len() - 1] } else { &self.0 };
+        let file_name = match file_path.rfind('/') {
+            Some(position) => &file_path[position + 1..],
+            None => file_path,
+        };
+        if file_name.is_empty() {
+            None
+        } else {
+            let mut file_stem_and_extension = file_name.rsplitn(2, '.');
+            let extension = file_stem_and_extension.next();
+            let file_stem = file_stem_and_extension.next();
+            match (file_stem, extension) {
+                (None, None) => None,
+                (None, Some(_)) | (Some(""), Some(_)) => Some((file_name, None)),
+                (Some(file_stem), extension) => Some((file_stem, extension)),
+            }
+        }
+    }
+}
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn virtual_path_extensions() {
+        assert_eq!(VirtualPath("/".to_string()).name_and_extension(), None);
+        assert_eq!(
+            VirtualPath("/directory".to_string()).name_and_extension(),
+            Some(("directory", None))
+        );
+        assert_eq!(
+            VirtualPath("/directory/".to_string()).name_and_extension(),
+            Some(("directory", None))
+        );
+        assert_eq!(
+            VirtualPath("/directory/file".to_string()).name_and_extension(),
+            Some(("file", None))
+        );
+        assert_eq!(
+            VirtualPath("/directory/.file".to_string()).name_and_extension(),
+            Some((".file", None))
+        );
+        assert_eq!(
+            VirtualPath("/directory/.file.rs".to_string()).name_and_extension(),
+            Some((".file", Some("rs")))
+        );
+        assert_eq!(
+            VirtualPath("/directory/file.rs".to_string()).name_and_extension(),
+            Some(("file", Some("rs")))
+        );
+    }
 }