74 files changed, 1674 insertions, 679 deletions
diff --git a/crates/assists/Cargo.toml b/crates/assists/Cargo.toml
index 108f656e9..3fd8327d6 100644
--- a/crates/assists/Cargo.toml
+++ b/crates/assists/Cargo.toml
@@ -12,7 +12,7 @@ doctest = false
 [dependencies]
 rustc-hash = "1.1.0"
 itertools = "0.9.0"
-either = "1.5.3"
+either = "1.6.1"
 stdx = { path = "../stdx", version = "0.0.0" }
 syntax = { path = "../syntax", version = "0.0.0" }
diff --git a/crates/assists/src/assist_config.rs b/crates/assists/src/assist_config.rs
index b24527ec4..786224cfa 100644
--- a/crates/assists/src/assist_config.rs
+++ b/crates/assists/src/assist_config.rs
@@ -5,8 +5,9 @@
 //! assists if we are allowed to.
 use hir::PrefixKind;
+use ide_db::helpers::insert_use::MergeBehaviour;
-use crate::{utils::MergeBehaviour, AssistKind};
+use crate::AssistKind;
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct AssistConfig {
diff --git a/crates/assists/src/ast_transform.rs b/crates/assists/src/ast_transform.rs
index ac72f3f02..66e4634b1 100644
--- a/crates/assists/src/ast_transform.rs
+++ b/crates/assists/src/ast_transform.rs
@@ -1,5 +1,6 @@
 //! `AstTransformer`s are functions that replace nodes in an AST and can be easily combined.
 use hir::{HirDisplay, PathResolution, SemanticsScope};
+use ide_db::helpers::mod_path_to_ast;
 use rustc_hash::FxHashMap;
 use syntax::{
    algo::SyntaxRewriter,
@@ -7,8 +8,6 @@ use syntax::{
    SyntaxNode,
 };
-use crate::utils::mod_path_to_ast;
 pub fn apply<'a, N: AstNode>(transformer: &dyn AstTransform<'a>, node: N) -> N {
    SyntaxRewriter::from_fn(|element| match element {
        syntax::SyntaxElement::Node(n) => {
diff --git a/crates/assists/src/handlers/auto_import.rs b/crates/assists/src/handlers/auto_import.rs
index d665837a2..bd5bba646 100644
--- a/crates/assists/src/handlers/auto_import.rs
+++ b/crates/assists/src/handlers/auto_import.rs
@@ -1,8 +1,11 @@
+use ide_db::helpers::{
+    insert_use::{insert_use, ImportScope},
+    mod_path_to_ast,
+};
 use syntax::ast;
 use crate::{
    utils::import_assets::{ImportAssets, ImportCandidate},
-    utils::{insert_use, mod_path_to_ast, ImportScope},
    AssistContext, AssistId, AssistKind, Assists, GroupLabel,
 };
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 cac77c49b..d85767b4e 100644
--- a/crates/assists/src/handlers/extract_struct_from_enum_variant.rs
+++ b/crates/assists/src/handlers/extract_struct_from_enum_variant.rs
@@ -2,6 +2,10 @@ use std::iter;
 use either::Either;
 use hir::{AsName, EnumVariant, Module, ModuleDef, Name};
+use ide_db::helpers::{
+    insert_use::{insert_use, ImportScope},
+    mod_path_to_ast,
+};
 use ide_db::{defs::Definition, search::Reference, RootDatabase};
 use rustc_hash::{FxHashMap, FxHashSet};
 use syntax::{
@@ -10,10 +14,7 @@ use syntax::{
    SourceFile, SyntaxElement, SyntaxNode, T,
 };
-use crate::{
+use crate::{AssistContext, AssistId, AssistKind, Assists};
-    utils::{insert_use, mod_path_to_ast, ImportScope},
-    AssistContext, AssistId, AssistKind, Assists,
-};
 // Assist: extract_struct_from_enum_variant
 //
@@ -236,10 +237,9 @@ fn update_reference(
 #[cfg(test)]
 mod tests {
-    use crate::{
+    use ide_db::helpers::FamousDefs;
-        tests::{check_assist, check_assist_not_applicable},
-        utils::FamousDefs,
+    use crate::tests::{check_assist, check_assist_not_applicable};
-    };
    use super::*;
diff --git a/crates/assists/src/handlers/fill_match_arms.rs b/crates/assists/src/handlers/fill_match_arms.rs
index eda45f5b3..ef12ef0cf 100644
--- a/crates/assists/src/handlers/fill_match_arms.rs
+++ b/crates/assists/src/handlers/fill_match_arms.rs
@@ -1,13 +1,14 @@
 use std::iter;
 use hir::{Adt, HasSource, ModuleDef, Semantics};
+use ide_db::helpers::{mod_path_to_ast, FamousDefs};
 use ide_db::RootDatabase;
 use itertools::Itertools;
 use syntax::ast::{self, make, AstNode, MatchArm, NameOwner, Pat};
 use test_utils::mark;
 use crate::{
-    utils::{mod_path_to_ast, render_snippet, Cursor, FamousDefs},
+    utils::{render_snippet, Cursor},
    AssistContext, AssistId, AssistKind, Assists,
 };
@@ -212,12 +213,10 @@ fn build_pat(db: &RootDatabase, module: hir::Module, var: hir::EnumVariant) -> O
 #[cfg(test)]
 mod tests {
+    use ide_db::helpers::FamousDefs;
    use test_utils::mark;
-    use crate::{
+    use crate::tests::{check_assist, check_assist_not_applicable, check_assist_target};
-        tests::{check_assist, check_assist_not_applicable, check_assist_target},
-        utils::FamousDefs,
-    };
    use super::fill_match_arms;
diff --git a/crates/assists/src/handlers/generate_from_impl_for_enum.rs b/crates/assists/src/handlers/generate_from_impl_for_enum.rs
index 674e5a175..3c374e5d9 100644
--- a/crates/assists/src/handlers/generate_from_impl_for_enum.rs
+++ b/crates/assists/src/handlers/generate_from_impl_for_enum.rs
@@ -1,8 +1,9 @@
+use ide_db::helpers::FamousDefs;
 use ide_db::RootDatabase;
 use syntax::ast::{self, AstNode, NameOwner};
 use test_utils::mark;
-use crate::{utils::FamousDefs, AssistContext, AssistId, AssistKind, Assists};
+use crate::{AssistContext, AssistId, AssistKind, Assists};
 // Assist: generate_from_impl_for_enum
 //
diff --git a/crates/assists/src/handlers/ignore_test.rs b/crates/assists/src/handlers/ignore_test.rs
index d2339184f..5096a0005 100644
--- a/crates/assists/src/handlers/ignore_test.rs
+++ b/crates/assists/src/handlers/ignore_test.rs
@@ -1,4 +1,7 @@
-use syntax::{ast, AstNode};
+use syntax::{
+    ast::{self, AttrsOwner},
+    AstNode, AstToken,
+};
 use crate::{utils::test_related_attribute, AssistContext, AssistId, AssistKind, Assists};
@@ -25,10 +28,76 @@ pub(crate) fn ignore_test(acc: &mut Assists, ctx: &AssistContext) -> Option<()>
    let func = attr.syntax().parent().and_then(ast::Fn::cast)?;
    let attr = test_related_attribute(&func)?;
-    acc.add(
+    match has_ignore_attribute(&func) {
-        AssistId("ignore_test", AssistKind::None),
+        None => acc.add(
-        "Ignore this test",
+            AssistId("ignore_test", AssistKind::None),
-        attr.syntax().text_range(),
+            "Ignore this test",
-        |builder| builder.insert(attr.syntax().text_range().end(), &format!("\n#[ignore]")),
+            attr.syntax().text_range(),
-    )
+            |builder| builder.insert(attr.syntax().text_range().end(), &format!("\n#[ignore]")),
+        ),
+        Some(ignore_attr) => acc.add(
+            AssistId("unignore_test", AssistKind::None),
+            "Re-enable this test",
+            ignore_attr.syntax().text_range(),
+            |builder| {
+                builder.delete(ignore_attr.syntax().text_range());
+                let whitespace = ignore_attr
+                    .syntax()
+                    .next_sibling_or_token()
+                    .and_then(|x| x.into_token())
+                    .and_then(ast::Whitespace::cast);
+                if let Some(whitespace) = whitespace {
+                    builder.delete(whitespace.syntax().text_range());
+                }
+            },
+        ),
+    }
+}
+fn has_ignore_attribute(fn_def: &ast::Fn) -> Option<ast::Attr> {
+    fn_def.attrs().find_map(|attr| {
+        if attr.path()?.syntax().text() == "ignore" {
+            Some(attr)
+        } else {
+            None
+        }
+    })
+}
+#[cfg(test)]
+mod tests {
+    use super::ignore_test;
+    use crate::tests::check_assist;
+    #[test]
+    fn test_base_case() {
+        check_assist(
+            ignore_test,
+            r#"
+            #[test<|>]
+            fn test() {}
+            "#,
+            r#"
+            #[test]
+            #[ignore]
+            fn test() {}
+            "#,
+        )
+    }
+    #[test]
+    fn test_unignore() {
+        check_assist(
+            ignore_test,
+            r#"
+            #[test<|>]
+            #[ignore]
+            fn test() {}
+            "#,
+            r#"
+            #[test]
+            fn test() {}
+            "#,
+        )
+    }
 }
diff --git a/crates/assists/src/handlers/infer_function_return_type.rs b/crates/assists/src/handlers/infer_function_return_type.rs
index 520d07ae0..aa584eb03 100644
--- a/crates/assists/src/handlers/infer_function_return_type.rs
+++ b/crates/assists/src/handlers/infer_function_return_type.rs
@@ -17,7 +17,7 @@ use crate::{AssistContext, AssistId, AssistKind, Assists};
 // fn foo() -> i32 { 42i32 }
 // ```
 pub(crate) fn infer_function_return_type(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
-    let (tail_expr, builder_edit_pos, wrap_expr) = extract_tail(ctx)?;
+    let (fn_type, tail_expr, builder_edit_pos) = extract_tail(ctx)?;
    let module = ctx.sema.scope(tail_expr.syntax()).module()?;
    let ty = ctx.sema.type_of_expr(&tail_expr)?;
    if ty.is_unit() {
@@ -27,7 +27,10 @@ pub(crate) fn infer_function_return_type(acc: &mut Assists, ctx: &AssistContext)
    acc.add(
        AssistId("infer_function_return_type", AssistKind::RefactorRewrite),
-        "Add this function's return type",
+        match fn_type {
+            FnType::Function => "Add this function's return type",
+            FnType::Closure { .. } => "Add this closure's return type",
+        },
        tail_expr.syntax().text_range(),
        |builder| {
            match builder_edit_pos {
@@ -38,7 +41,7 @@ pub(crate) fn infer_function_return_type(acc: &mut Assists, ctx: &AssistContext)
                    builder.replace(text_range, &format!("-> {}", ty))
                }
            }
-            if wrap_expr {
+            if let FnType::Closure { wrap_expr: true } = fn_type {
                mark::hit!(wrap_closure_non_block_expr);
                // `|x| x` becomes `|x| -> T x` which is invalid, so wrap it in a block
                builder.replace(tail_expr.syntax().text_range(), &format!("{{{}}}", tail_expr));
@@ -72,8 +75,13 @@ fn ret_ty_to_action(ret_ty: Option<ast::RetType>, insert_pos: TextSize) -> Optio
    }
 }
-fn extract_tail(ctx: &AssistContext) -> Option<(ast::Expr, InsertOrReplace, bool)> {
+enum FnType {
-    let (tail_expr, return_type_range, action, wrap_expr) =
+    Function,
+    Closure { wrap_expr: bool },
+}
+fn extract_tail(ctx: &AssistContext) -> Option<(FnType, ast::Expr, InsertOrReplace)> {
+    let (fn_type, tail_expr, return_type_range, action) =
        if let Some(closure) = ctx.find_node_at_offset::<ast::ClosureExpr>() {
            let rpipe_pos = closure.param_list()?.syntax().last_token()?.text_range().end();
            let action = ret_ty_to_action(closure.ret_type(), rpipe_pos)?;
@@ -86,7 +94,7 @@ fn extract_tail(ctx: &AssistContext) -> Option<(ast::Expr, InsertOrReplace, bool
            };
            let ret_range = TextRange::new(rpipe_pos, body_start);
-            (tail_expr, ret_range, action, wrap_expr)
+            (FnType::Closure { wrap_expr }, tail_expr, ret_range, action)
        } else {
            let func = ctx.find_node_at_offset::<ast::Fn>()?;
            let rparen_pos = func.param_list()?.r_paren_token()?.text_range().end();
@@ -97,7 +105,7 @@ fn extract_tail(ctx: &AssistContext) -> Option<(ast::Expr, InsertOrReplace, bool
            let ret_range_end = body.l_curly_token()?.text_range().start();
            let ret_range = TextRange::new(rparen_pos, ret_range_end);
-            (tail_expr, ret_range, action, false)
+            (FnType::Function, tail_expr, ret_range, action)
        };
    let frange = ctx.frange.range;
    if return_type_range.contains_range(frange) {
@@ -109,7 +117,7 @@ fn extract_tail(ctx: &AssistContext) -> Option<(ast::Expr, InsertOrReplace, bool
    } else {
        return None;
    }
-    Some((tail_expr, action, wrap_expr))
+    Some((fn_type, tail_expr, action))
 }
 #[cfg(test)]
diff --git a/crates/assists/src/handlers/merge_imports.rs b/crates/assists/src/handlers/merge_imports.rs
index fd9c9e03c..b7e853994 100644
--- a/crates/assists/src/handlers/merge_imports.rs
+++ b/crates/assists/src/handlers/merge_imports.rs
@@ -1,3 +1,4 @@
+use ide_db::helpers::insert_use::{try_merge_imports, try_merge_trees, MergeBehaviour};
 use syntax::{
    algo::{neighbor, SyntaxRewriter},
    ast, AstNode,
@@ -5,10 +6,7 @@ use syntax::{
 use crate::{
    assist_context::{AssistContext, Assists},
-    utils::{
+    utils::next_prev,
-        insert_use::{try_merge_imports, try_merge_trees},
-        next_prev, MergeBehaviour,
-    },
    AssistId, AssistKind,
 };
diff --git a/crates/assists/src/handlers/qualify_path.rs b/crates/assists/src/handlers/qualify_path.rs
index d5bc4e574..6f9810fe8 100644
--- a/crates/assists/src/handlers/qualify_path.rs
+++ b/crates/assists/src/handlers/qualify_path.rs
@@ -1,6 +1,7 @@
 use std::iter;
 use hir::AsName;
+use ide_db::helpers::mod_path_to_ast;
 use ide_db::RootDatabase;
 use syntax::{
    ast,
@@ -12,7 +13,6 @@ use test_utils::mark;
 use crate::{
    assist_context::{AssistContext, Assists},
    utils::import_assets::{ImportAssets, ImportCandidate},
-    utils::mod_path_to_ast,
    AssistId, AssistKind, GroupLabel,
 };
diff --git a/crates/assists/src/handlers/replace_derive_with_manual_impl.rs b/crates/assists/src/handlers/replace_derive_with_manual_impl.rs
index 453a6cebf..4d6a1956b 100644
--- a/crates/assists/src/handlers/replace_derive_with_manual_impl.rs
+++ b/crates/assists/src/handlers/replace_derive_with_manual_impl.rs
@@ -1,3 +1,4 @@
+use ide_db::helpers::mod_path_to_ast;
 use ide_db::imports_locator;
 use itertools::Itertools;
 use syntax::{
@@ -10,8 +11,7 @@ use syntax::{
 use crate::{
    assist_context::{AssistBuilder, AssistContext, Assists},
    utils::{
-        add_trait_assoc_items_to_impl, filter_assoc_items, mod_path_to_ast, render_snippet, Cursor,
+        add_trait_assoc_items_to_impl, filter_assoc_items, render_snippet, Cursor, DefaultMethods,
-        DefaultMethods,
    },
    AssistId, AssistKind,
 };
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 a66db9ae3..8bdf9eea5 100644
--- a/crates/assists/src/handlers/replace_qualified_name_with_use.rs
+++ b/crates/assists/src/handlers/replace_qualified_name_with_use.rs
@@ -1,10 +1,8 @@
+use ide_db::helpers::insert_use::{insert_use, ImportScope};
 use syntax::{algo::SyntaxRewriter, ast, match_ast, AstNode, SyntaxNode};
 use test_utils::mark;
-use crate::{
+use crate::{AssistContext, AssistId, AssistKind, Assists};
-    utils::{insert_use, ImportScope},
-    AssistContext, AssistId, AssistKind, Assists,
-};
 // Assist: replace_qualified_name_with_use
 //
diff --git a/crates/assists/src/utils.rs b/crates/assists/src/utils.rs
index 66c0cdd5f..01f5c291f 100644
--- a/crates/assists/src/utils.rs
+++ b/crates/assists/src/utils.rs
@@ -1,10 +1,9 @@
 //! Assorted functions shared by several assists.
-pub(crate) mod insert_use;
 pub(crate) mod import_assets;
 use std::ops;
-use hir::{Crate, Enum, HasSource, Module, ScopeDef, Semantics, Trait};
+use hir::HasSource;
 use ide_db::RootDatabase;
 use itertools::Itertools;
 use syntax::{
@@ -22,29 +21,6 @@ use crate::{
    ast_transform::{self, AstTransform, QualifyPaths, SubstituteTypeParams},
 };
-pub use insert_use::{insert_use, ImportScope, MergeBehaviour};
-pub fn mod_path_to_ast(path: &hir::ModPath) -> ast::Path {
-    let mut segments = Vec::new();
-    let mut is_abs = false;
-    match path.kind {
-        hir::PathKind::Plain => {}
-        hir::PathKind::Super(0) => segments.push(make::path_segment_self()),
-        hir::PathKind::Super(n) => segments.extend((0..n).map(|_| make::path_segment_super())),
-        hir::PathKind::DollarCrate(_) | hir::PathKind::Crate => {
-            segments.push(make::path_segment_crate())
-        }
-        hir::PathKind::Abs => is_abs = true,
-    }
-    segments.extend(
-        path.segments
-            .iter()
-            .map(|segment| make::path_segment(make::name_ref(&segment.to_string()))),
-    );
-    make::path_from_segments(segments, is_abs)
-}
 pub(crate) fn unwrap_trivial_block(block: ast::BlockExpr) -> ast::Expr {
    extract_trivial_expression(&block)
        .filter(|expr| !expr.syntax().text().contains_char('\n'))
@@ -259,179 +235,6 @@ fn invert_special_case(expr: &ast::Expr) -> Option<ast::Expr> {
    }
 }
-/// Helps with finding well-know things inside the standard library. This is
-/// somewhat similar to the known paths infra inside hir, but it different; We
-/// want to make sure that IDE specific paths don't become interesting inside
-/// the compiler itself as well.
-pub struct FamousDefs<'a, 'b>(pub &'a Semantics<'b, RootDatabase>, pub Option<Crate>);
-#[allow(non_snake_case)]
-impl FamousDefs<'_, '_> {
-    pub const FIXTURE: &'static str = r#"//- /libcore.rs crate:core
-pub mod convert {
-    pub trait From<T> {
-        fn from(t: T) -> Self;
-    }
-}
-pub mod default {
-    pub trait Default {
-       fn default() -> Self;
-    }
-}
-pub mod iter {
-    pub use self::traits::{collect::IntoIterator, iterator::Iterator};
-    mod traits {
-        pub(crate) mod iterator {
-            use crate::option::Option;
-            pub trait Iterator {
-                type Item;
-                fn next(&mut self) -> Option<Self::Item>;
-                fn by_ref(&mut self) -> &mut Self {
-                    self
-                }
-                fn take(self, n: usize) -> crate::iter::Take<Self> {
-                    crate::iter::Take { inner: self }
-                }
-            }
-            impl<I: Iterator> Iterator for &mut I {
-                type Item = I::Item;
-                fn next(&mut self) -> Option<I::Item> {
-                    (**self).next()
-                }
-            }
-        }
-        pub(crate) mod collect {
-            pub trait IntoIterator {
-                type Item;
-            }
-        }
-    }
-    pub use self::sources::*;
-    pub(crate) mod sources {
-        use super::Iterator;
-        use crate::option::Option::{self, *};
-        pub struct Repeat<A> {
-            element: A,
-        }
-        pub fn repeat<T>(elt: T) -> Repeat<T> {
-            Repeat { element: elt }
-        }
-        impl<A> Iterator for Repeat<A> {
-            type Item = A;
-            fn next(&mut self) -> Option<A> {
-                None
-            }
-        }
-    }
-    pub use self::adapters::*;
-    pub(crate) mod adapters {
-        use super::Iterator;
-        use crate::option::Option::{self, *};
-        pub struct Take<I> { pub(crate) inner: I }
-        impl<I> Iterator for Take<I> where I: Iterator {
-            type Item = <I as Iterator>::Item;
-            fn next(&mut self) -> Option<<I as Iterator>::Item> {
-                None
-            }
-        }
-    }
-}
-pub mod option {
-    pub enum Option<T> { None, Some(T)}
-}
-pub mod prelude {
-    pub use crate::{convert::From, iter::{IntoIterator, Iterator}, option::Option::{self, *}, default::Default};
-}
-#[prelude_import]
-pub use prelude::*;
-"#;
-    pub fn core(&self) -> Option<Crate> {
-        self.find_crate("core")
-    }
-    pub(crate) fn core_convert_From(&self) -> Option<Trait> {
-        self.find_trait("core:convert:From")
-    }
-    pub(crate) fn core_option_Option(&self) -> Option<Enum> {
-        self.find_enum("core:option:Option")
-    }
-    pub fn core_default_Default(&self) -> Option<Trait> {
-        self.find_trait("core:default:Default")
-    }
-    pub fn core_iter_Iterator(&self) -> Option<Trait> {
-        self.find_trait("core:iter:traits:iterator:Iterator")
-    }
-    pub fn core_iter(&self) -> Option<Module> {
-        self.find_module("core:iter")
-    }
-    fn find_trait(&self, path: &str) -> Option<Trait> {
-        match self.find_def(path)? {
-            hir::ScopeDef::ModuleDef(hir::ModuleDef::Trait(it)) => Some(it),
-            _ => None,
-        }
-    }
-    fn find_enum(&self, path: &str) -> Option<Enum> {
-        match self.find_def(path)? {
-            hir::ScopeDef::ModuleDef(hir::ModuleDef::Adt(hir::Adt::Enum(it))) => Some(it),
-            _ => None,
-        }
-    }
-    fn find_module(&self, path: &str) -> Option<Module> {
-        match self.find_def(path)? {
-            hir::ScopeDef::ModuleDef(hir::ModuleDef::Module(it)) => Some(it),
-            _ => None,
-        }
-    }
-    fn find_crate(&self, name: &str) -> Option<Crate> {
-        let krate = self.1?;
-        let db = self.0.db;
-        let res =
-            krate.dependencies(db).into_iter().find(|dep| dep.name.to_string() == name)?.krate;
-        Some(res)
-    }
-    fn find_def(&self, path: &str) -> Option<ScopeDef> {
-        let db = self.0.db;
-        let mut path = path.split(':');
-        let trait_ = path.next_back()?;
-        let std_crate = path.next()?;
-        let std_crate = self.find_crate(std_crate)?;
-        let mut module = std_crate.root_module(db);
-        for segment in path {
-            module = module.children(db).find_map(|child| {
-                let name = child.name(db)?;
-                if name.to_string() == segment {
-                    Some(child)
-                } else {
-                    None
-                }
-            })?;
-        }
-        let def =
-            module.scope(db, None).into_iter().find(|(name, _def)| name.to_string() == trait_)?.1;
-        Some(def)
-    }
-}
 pub(crate) fn next_prev() -> impl Iterator<Item = Direction> {
    [Direction::Next, Direction::Prev].iter().copied()
 }
diff --git a/crates/completion/Cargo.toml b/crates/completion/Cargo.toml
index e7df9d955..35e169a28 100644
--- a/crates/completion/Cargo.toml
+++ b/crates/completion/Cargo.toml
@@ -15,7 +15,6 @@ log = "0.4.8"
 rustc-hash = "1.1.0"
 either = "1.6.1"
-assists = { path = "../assists", version = "0.0.0" }
 stdx = { path = "../stdx", version = "0.0.0" }
 syntax = { path = "../syntax", version = "0.0.0" }
 text_edit = { path = "../text_edit", version = "0.0.0" }
diff --git a/crates/completion/src/completions/pattern.rs b/crates/completion/src/completions/pattern.rs
index 7ab7f09fe..4f63ff0ef 100644
--- a/crates/completion/src/completions/pattern.rs
+++ b/crates/completion/src/completions/pattern.rs
@@ -4,7 +4,7 @@ use crate::{CompletionContext, Completions};
 /// Completes constats and paths in patterns.
 pub(crate) fn complete_pattern(acc: &mut Completions, ctx: &CompletionContext) {
-    if !ctx.is_pat_binding_or_const {
+    if !(ctx.is_pat_binding_or_const || ctx.is_irrefutable_let_pat_binding) {
        return;
    }
    if ctx.record_pat_syntax.is_some() {
@@ -14,20 +14,27 @@ pub(crate) fn complete_pattern(acc: &mut Completions, ctx: &CompletionContext) {
    // FIXME: ideally, we should look at the type we are matching against and
    // suggest variants + auto-imports
    ctx.scope.process_all_names(&mut |name, res| {
-        match &res {
+        let add_resolution = match &res {
-            hir::ScopeDef::ModuleDef(def) => match def {
+            hir::ScopeDef::ModuleDef(def) => {
-                hir::ModuleDef::Adt(hir::Adt::Enum(..))
+                if ctx.is_irrefutable_let_pat_binding {
-                | hir::ModuleDef::Adt(hir::Adt::Struct(..))
+                    matches!(def, hir::ModuleDef::Adt(hir::Adt::Struct(_)))
-                | hir::ModuleDef::EnumVariant(..)
+                } else {
-                | hir::ModuleDef::Const(..)
+                    matches!(
-                | hir::ModuleDef::Module(..) => (),
+                        def,
-                _ => return,
+                        hir::ModuleDef::Adt(hir::Adt::Enum(..))
-            },
+                            | hir::ModuleDef::Adt(hir::Adt::Struct(..))
-            hir::ScopeDef::MacroDef(_) => (),
+                            | hir::ModuleDef::EnumVariant(..)
-            _ => return,
+                            | hir::ModuleDef::Const(..)
+                            | hir::ModuleDef::Module(..)
+                    )
+                }
+            }
+            hir::ScopeDef::MacroDef(_) => true,
+            _ => false,
        };
+        if add_resolution {
-        acc.add_resolution(ctx, name.to_string(), &res)
+            acc.add_resolution(ctx, name.to_string(), &res);
+        }
    });
 }
@@ -85,4 +92,26 @@ fn foo() {
            "#]],
        );
    }
+    #[test]
+    fn completes_in_irrefutable_let() {
+        check(
+            r#"
+enum E { X }
+use self::E::X;
+const Z: E = E::X;
+mod m {}
+static FOO: E = E::X;
+struct Bar { f: u32 }
+fn foo() {
+   let <|>
+}
+"#,
+            expect![[r#"
+                st Bar
+            "#]],
+        );
+    }
 }
diff --git a/crates/completion/src/completions/record.rs b/crates/completion/src/completions/record.rs
index 2049b9d09..eaa44c97d 100644
--- a/crates/completion/src/completions/record.rs
+++ b/crates/completion/src/completions/record.rs
@@ -1,5 +1,5 @@
 //! Complete fields in record literals and patterns.
-use assists::utils::FamousDefs;
+use ide_db::helpers::FamousDefs;
 use syntax::ast::Expr;
 use crate::{
@@ -45,8 +45,8 @@ pub(crate) fn complete_record(acc: &mut Completions, ctx: &CompletionContext) ->
 #[cfg(test)]
 mod tests {
-    use assists::utils::FamousDefs;
    use expect_test::{expect, Expect};
+    use ide_db::helpers::FamousDefs;
    use crate::{test_utils::completion_list, CompletionKind};
diff --git a/crates/completion/src/completions/unqualified_path.rs b/crates/completion/src/completions/unqualified_path.rs
index 86c143b63..81691cd7f 100644
--- a/crates/completion/src/completions/unqualified_path.rs
+++ b/crates/completion/src/completions/unqualified_path.rs
@@ -1,8 +1,8 @@
 //! Completion of names from the current scope, e.g. locals and imported items.
-use assists::utils::ImportScope;
 use either::Either;
 use hir::{Adt, ModuleDef, ScopeDef, Type};
+use ide_db::helpers::insert_use::ImportScope;
 use ide_db::imports_locator;
 use syntax::AstNode;
 use test_utils::mark;
@@ -44,7 +44,9 @@ pub(crate) fn complete_unqualified_path(acc: &mut Completions, ctx: &CompletionC
        acc.add_resolution(ctx, name.to_string(), &res)
    });
-    fuzzy_completion(acc, ctx).unwrap_or_default()
+    if ctx.config.enable_experimental_completions {
+        fuzzy_completion(acc, ctx).unwrap_or_default()
+    }
 }
 fn complete_enum_variants(acc: &mut Completions, ctx: &CompletionContext, ty: &Type) {
@@ -79,32 +81,34 @@ fn fuzzy_completion(acc: &mut Completions, ctx: &CompletionContext) -> Option<()
    let potential_import_name = ctx.token.to_string();
-    let possible_imports =
+    let possible_imports = imports_locator::find_similar_imports(
-        imports_locator::find_similar_imports(&ctx.sema, ctx.krate?, &potential_import_name, 400)
+        &ctx.sema,
-            .filter_map(|import_candidate| match import_candidate {
+        ctx.krate?,
-                // when completing outside the use declaration, modules are pretty useless
+        &potential_import_name,
-                // and tend to bloat the completion suggestions a lot
+        50,
-                Either::Left(ModuleDef::Module(_)) => None,
+        true,
-                Either::Left(module_def) => Some((
+    )
-                    current_module.find_use_path(ctx.db, module_def)?,
+    .filter_map(|import_candidate| {
-                    ScopeDef::ModuleDef(module_def),
+        Some(match import_candidate {
-                )),
+            Either::Left(module_def) => {
-                Either::Right(macro_def) => Some((
+                (current_module.find_use_path(ctx.db, module_def)?, ScopeDef::ModuleDef(module_def))
-                    current_module.find_use_path(ctx.db, macro_def)?,
+            }
-                    ScopeDef::MacroDef(macro_def),
+            Either::Right(macro_def) => {
-                )),
+                (current_module.find_use_path(ctx.db, macro_def)?, ScopeDef::MacroDef(macro_def))
-            })
+            }
-            .filter(|(mod_path, _)| mod_path.len() > 1)
+        })
-            .filter_map(|(import_path, definition)| {
+    })
-                render_resolution_with_import(
+    .filter(|(mod_path, _)| mod_path.len() > 1)
-                    RenderContext::new(ctx),
+    .take(20)
-                    import_path.clone(),
+    .filter_map(|(import_path, definition)| {
-                    import_scope.clone(),
+        render_resolution_with_import(
-                    ctx.config.merge,
+            RenderContext::new(ctx),
-                    &definition,
+            import_path.clone(),
-                )
+            import_scope.clone(),
-            })
+            ctx.config.merge,
-            .take(20);
+            &definition,
+        )
+    });
    acc.add_all(possible_imports);
    Some(())
diff --git a/crates/completion/src/config.rs b/crates/completion/src/config.rs
index 82874ff25..654a76f7b 100644
--- a/crates/completion/src/config.rs
+++ b/crates/completion/src/config.rs
@@ -4,11 +4,12 @@
 //! module, and we use to statically check that we only produce snippet
 //! completions if we are allowed to.
-use assists::utils::MergeBehaviour;
+use ide_db::helpers::insert_use::MergeBehaviour;
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct CompletionConfig {
    pub enable_postfix_completions: bool,
+    pub enable_experimental_completions: bool,
    pub add_call_parenthesis: bool,
    pub add_call_argument_snippets: bool,
    pub snippet_cap: Option<SnippetCap>,
@@ -30,6 +31,7 @@ impl Default for CompletionConfig {
    fn default() -> Self {
        CompletionConfig {
            enable_postfix_completions: true,
+            enable_experimental_completions: true,
            add_call_parenthesis: true,
            add_call_argument_snippets: true,
            snippet_cap: Some(SnippetCap { _private: () }),
diff --git a/crates/completion/src/context.rs b/crates/completion/src/context.rs
index bf70ee478..5cd11cf77 100644
--- a/crates/completion/src/context.rs
+++ b/crates/completion/src/context.rs
@@ -51,6 +51,7 @@ pub(crate) struct CompletionContext<'a> {
    /// If a name-binding or reference to a const in a pattern.
    /// Irrefutable patterns (like let) are excluded.
    pub(super) is_pat_binding_or_const: bool,
+    pub(super) is_irrefutable_let_pat_binding: bool,
    /// A single-indent path, like `foo`. `::foo` should not be considered a trivial path.
    pub(super) is_trivial_path: bool,
    /// If not a trivial path, the prefix (qualifier).
@@ -146,6 +147,7 @@ impl<'a> CompletionContext<'a> {
            active_parameter: ActiveParameter::at(db, position),
            is_param: false,
            is_pat_binding_or_const: false,
+            is_irrefutable_let_pat_binding: false,
            is_trivial_path: false,
            path_qual: None,
            after_if: false,
@@ -330,6 +332,7 @@ impl<'a> CompletionContext<'a> {
                        if pat.syntax().text_range().contains_range(bind_pat.syntax().text_range())
                        {
                            self.is_pat_binding_or_const = false;
+                            self.is_irrefutable_let_pat_binding = true;
                        }
                    }
                }
diff --git a/crates/completion/src/item.rs b/crates/completion/src/item.rs
index b13c3f376..e85549fef 100644
--- a/crates/completion/src/item.rs
+++ b/crates/completion/src/item.rs
@@ -2,8 +2,11 @@
 use std::fmt;
-use assists::utils::{insert_use, mod_path_to_ast, ImportScope, MergeBehaviour};
 use hir::{Documentation, ModPath, Mutability};
+use ide_db::helpers::{
+    insert_use::{self, ImportScope, MergeBehaviour},
+    mod_path_to_ast,
+};
 use syntax::{algo, TextRange};
 use text_edit::TextEdit;
@@ -201,7 +204,7 @@ impl CompletionItem {
            trigger_call_info: None,
            score: None,
            ref_match: None,
-            import_data: None,
+            import_to_add: None,
        }
    }
@@ -255,13 +258,21 @@ impl CompletionItem {
    }
 }
+/// An extra import to add after the completion is applied.
+#[derive(Clone)]
+pub(crate) struct ImportToAdd {
+    pub(crate) import_path: ModPath,
+    pub(crate) import_scope: ImportScope,
+    pub(crate) merge_behaviour: Option<MergeBehaviour>,
+}
 /// A helper to make `CompletionItem`s.
 #[must_use]
 #[derive(Clone)]
 pub(crate) struct Builder {
    source_range: TextRange,
    completion_kind: CompletionKind,
-    import_data: Option<(ModPath, ImportScope, Option<MergeBehaviour>)>,
+    import_to_add: Option<ImportToAdd>,
    label: String,
    insert_text: Option<String>,
    insert_text_format: InsertTextFormat,
@@ -278,14 +289,16 @@ pub(crate) struct Builder {
 impl Builder {
    pub(crate) fn build(self) -> CompletionItem {
+        let _p = profile::span("item::Builder::build");
        let mut label = self.label;
        let mut lookup = self.lookup;
        let mut insert_text = self.insert_text;
        let mut text_edits = TextEdit::builder();
-        if let Some((import_path, import_scope, merge_behaviour)) = self.import_data {
+        if let Some(import_data) = self.import_to_add {
-            let import = mod_path_to_ast(&import_path);
+            let import = mod_path_to_ast(&import_data.import_path);
-            let mut import_path_without_last_segment = import_path;
+            let mut import_path_without_last_segment = import_data.import_path;
            let _ = import_path_without_last_segment.segments.pop();
            if !import_path_without_last_segment.segments.is_empty() {
@@ -298,7 +311,11 @@ impl Builder {
                label = format!("{}::{}", import_path_without_last_segment, label);
            }
-            let rewriter = insert_use(&import_scope, import, merge_behaviour);
+            let rewriter = insert_use::insert_use(
+                &import_data.import_scope,
+                import,
+                import_data.merge_behaviour,
+            );
            if let Some(old_ast) = rewriter.rewrite_root() {
                algo::diff(&old_ast, &rewriter.rewrite(&old_ast)).into_text_edit(&mut text_edits);
            }
@@ -390,11 +407,8 @@ impl Builder {
        self.trigger_call_info = Some(true);
        self
    }
-    pub(crate) fn import_data(
+    pub(crate) fn add_import(mut self, import_to_add: Option<ImportToAdd>) -> Builder {
-        mut self,
+        self.import_to_add = import_to_add;
-        import_data: Option<(ModPath, ImportScope, Option<MergeBehaviour>)>,
-    ) -> Builder {
-        self.import_data = import_data;
        self
    }
    pub(crate) fn set_ref_match(
diff --git a/crates/completion/src/lib.rs b/crates/completion/src/lib.rs
index ac57683fb..1ec2e9be7 100644
--- a/crates/completion/src/lib.rs
+++ b/crates/completion/src/lib.rs
@@ -69,6 +69,13 @@ pub use crate::{
 //     fn test_name() {}
 // }
 // ```
+//
+// And experimental completions, enabled with the `rust-analyzer.completion.enableExperimental` setting.
+// This flag enables or disables:
+//
+// - Auto import: additional completion options with automatic `use` import and options from all project importable items, matched for the input
+//
+// Experimental completions might cause issues with performance and completion list look.
 /// Main entry point for completion. We run completion as a two-phase process.
 ///
diff --git a/crates/completion/src/render.rs b/crates/completion/src/render.rs
index e892d4de8..504757a6a 100644
--- a/crates/completion/src/render.rs
+++ b/crates/completion/src/render.rs
@@ -9,15 +9,15 @@ pub(crate) mod type_alias;
 mod builder_ext;
-use assists::utils::{ImportScope, MergeBehaviour};
 use hir::{Documentation, HasAttrs, HirDisplay, ModPath, Mutability, ScopeDef, Type};
+use ide_db::helpers::insert_use::{ImportScope, MergeBehaviour};
 use ide_db::RootDatabase;
 use syntax::TextRange;
 use test_utils::mark;
 use crate::{
-    config::SnippetCap, CompletionContext, CompletionItem, CompletionItemKind, CompletionKind,
+    config::SnippetCap, item::ImportToAdd, CompletionContext, CompletionItem, CompletionItemKind,
-    CompletionScore,
+    CompletionKind, CompletionScore,
 };
 use crate::render::{enum_variant::render_enum_variant, function::render_fn, macro_::render_macro};
@@ -48,15 +48,15 @@ pub(crate) fn render_resolution<'a>(
 pub(crate) fn render_resolution_with_import<'a>(
    ctx: RenderContext<'a>,
-    import: ModPath,
+    import_path: ModPath,
    import_scope: ImportScope,
    merge_behaviour: Option<MergeBehaviour>,
    resolution: &ScopeDef,
 ) -> Option<CompletionItem> {
-    let local_name = import.segments.last()?.to_string();
+    let local_name = import_path.segments.last()?.to_string();
    Render::new(ctx).render_resolution(
        local_name,
-        Some((import, import_scope, merge_behaviour)),
+        Some(ImportToAdd { import_path, import_scope, merge_behaviour }),
        resolution,
    )
 }
@@ -147,9 +147,10 @@ impl<'a> Render<'a> {
    fn render_resolution(
        self,
        local_name: String,
-        import_data: Option<(ModPath, ImportScope, Option<MergeBehaviour>)>,
+        import_to_add: Option<ImportToAdd>,
        resolution: &ScopeDef,
    ) -> Option<CompletionItem> {
+        let _p = profile::span("render_resolution");
        use hir::ModuleDef::*;
        let completion_kind = match resolution {
@@ -159,15 +160,16 @@ impl<'a> Render<'a> {
        let kind = match resolution {
            ScopeDef::ModuleDef(Function(func)) => {
-                let item = render_fn(self.ctx, import_data, Some(local_name), *func);
+                let item = render_fn(self.ctx, import_to_add, Some(local_name), *func);
                return Some(item);
            }
            ScopeDef::ModuleDef(EnumVariant(var)) => {
-                let item = render_enum_variant(self.ctx, import_data, Some(local_name), *var, None);
+                let item =
+                    render_enum_variant(self.ctx, import_to_add, Some(local_name), *var, None);
                return Some(item);
            }
            ScopeDef::MacroDef(mac) => {
-                let item = render_macro(self.ctx, import_data, local_name, *mac);
+                let item = render_macro(self.ctx, import_to_add, local_name, *mac);
                return item;
            }
@@ -192,7 +194,7 @@ impl<'a> Render<'a> {
                    local_name,
                )
                .kind(CompletionItemKind::UnresolvedReference)
-                .import_data(import_data)
+                .add_import(import_to_add)
                .build();
                return Some(item);
            }
@@ -247,7 +249,7 @@ impl<'a> Render<'a> {
        let item = item
            .kind(kind)
-            .import_data(import_data)
+            .add_import(import_to_add)
            .set_documentation(docs)
            .set_ref_match(ref_match)
            .build();
diff --git a/crates/completion/src/render/enum_variant.rs b/crates/completion/src/render/enum_variant.rs
index 6070e9b1d..f4bd02f25 100644
--- a/crates/completion/src/render/enum_variant.rs
+++ b/crates/completion/src/render/enum_variant.rs
@@ -1,23 +1,23 @@
 //! Renderer for `enum` variants.
-use assists::utils::{ImportScope, MergeBehaviour};
 use hir::{HasAttrs, HirDisplay, ModPath, StructKind};
 use itertools::Itertools;
 use test_utils::mark;
 use crate::{
-    item::{CompletionItem, CompletionItemKind, CompletionKind},
+    item::{CompletionItem, CompletionItemKind, CompletionKind, ImportToAdd},
    render::{builder_ext::Params, RenderContext},
 };
 pub(crate) fn render_enum_variant<'a>(
    ctx: RenderContext<'a>,
-    import_data: Option<(ModPath, ImportScope, Option<MergeBehaviour>)>,
+    import_to_add: Option<ImportToAdd>,
    local_name: Option<String>,
    variant: hir::EnumVariant,
    path: Option<ModPath>,
 ) -> CompletionItem {
-    EnumVariantRender::new(ctx, local_name, variant, path).render(import_data)
+    let _p = profile::span("render_enum_variant");
+    EnumVariantRender::new(ctx, local_name, variant, path).render(import_to_add)
 }
 #[derive(Debug)]
@@ -62,10 +62,7 @@ impl<'a> EnumVariantRender<'a> {
        }
    }
-    fn render(
+    fn render(self, import_to_add: Option<ImportToAdd>) -> CompletionItem {
-        self,
-        import_data: Option<(ModPath, ImportScope, Option<MergeBehaviour>)>,
-    ) -> CompletionItem {
        let mut builder = CompletionItem::new(
            CompletionKind::Reference,
            self.ctx.source_range(),
@@ -74,7 +71,7 @@ impl<'a> EnumVariantRender<'a> {
        .kind(CompletionItemKind::EnumVariant)
        .set_documentation(self.variant.docs(self.ctx.db()))
        .set_deprecated(self.ctx.is_deprecated(self.variant))
-        .import_data(import_data)
+        .add_import(import_to_add)
        .detail(self.detail());
        if self.variant_kind == StructKind::Tuple {
diff --git a/crates/completion/src/render/function.rs b/crates/completion/src/render/function.rs
index 9dd5cd18c..542383d7e 100644
--- a/crates/completion/src/render/function.rs
+++ b/crates/completion/src/render/function.rs
@@ -1,21 +1,21 @@
 //! Renderer for function calls.
-use assists::utils::{ImportScope, MergeBehaviour};
+use hir::{HasSource, Type};
-use hir::{HasSource, ModPath, Type};
 use syntax::{ast::Fn, display::function_declaration};
 use crate::{
-    item::{CompletionItem, CompletionItemKind, CompletionKind},
+    item::{CompletionItem, CompletionItemKind, CompletionKind, ImportToAdd},
    render::{builder_ext::Params, RenderContext},
 };
 pub(crate) fn render_fn<'a>(
    ctx: RenderContext<'a>,
-    import_data: Option<(ModPath, ImportScope, Option<MergeBehaviour>)>,
+    import_to_add: Option<ImportToAdd>,
    local_name: Option<String>,
    fn_: hir::Function,
 ) -> CompletionItem {
-    FunctionRender::new(ctx, local_name, fn_).render(import_data)
+    let _p = profile::span("render_fn");
+    FunctionRender::new(ctx, local_name, fn_).render(import_to_add)
 }
 #[derive(Debug)]
@@ -38,10 +38,7 @@ impl<'a> FunctionRender<'a> {
        FunctionRender { ctx, name, fn_, ast_node }
    }
-    fn render(
+    fn render(self, import_to_add: Option<ImportToAdd>) -> CompletionItem {
-        self,
-        import_data: Option<(ModPath, ImportScope, Option<MergeBehaviour>)>,
-    ) -> CompletionItem {
        let params = self.params();
        CompletionItem::new(CompletionKind::Reference, self.ctx.source_range(), self.name.clone())
            .kind(self.kind())
@@ -49,7 +46,7 @@ impl<'a> FunctionRender<'a> {
            .set_deprecated(self.ctx.is_deprecated(self.fn_))
            .detail(self.detail())
            .add_call_parens(self.ctx.completion, self.name, params)
-            .import_data(import_data)
+            .add_import(import_to_add)
            .build()
    }
diff --git a/crates/completion/src/render/macro_.rs b/crates/completion/src/render/macro_.rs
index fead59e41..b4ab32c6e 100644
--- a/crates/completion/src/render/macro_.rs
+++ b/crates/completion/src/render/macro_.rs
@@ -1,22 +1,22 @@
 //! Renderer for macro invocations.
-use assists::utils::{ImportScope, MergeBehaviour};
+use hir::{Documentation, HasSource};
-use hir::{Documentation, HasSource, ModPath};
 use syntax::display::macro_label;
 use test_utils::mark;
 use crate::{
-    item::{CompletionItem, CompletionItemKind, CompletionKind},
+    item::{CompletionItem, CompletionItemKind, CompletionKind, ImportToAdd},
    render::RenderContext,
 };
 pub(crate) fn render_macro<'a>(
    ctx: RenderContext<'a>,
-    import_data: Option<(ModPath, ImportScope, Option<MergeBehaviour>)>,
+    import_to_add: Option<ImportToAdd>,
    name: String,
    macro_: hir::MacroDef,
 ) -> Option<CompletionItem> {
-    MacroRender::new(ctx, name, macro_).render(import_data)
+    let _p = profile::span("render_macro");
+    MacroRender::new(ctx, name, macro_).render(import_to_add)
 }
 #[derive(Debug)]
@@ -38,10 +38,7 @@ impl<'a> MacroRender<'a> {
        MacroRender { ctx, name, macro_, docs, bra, ket }
    }
-    fn render(
+    fn render(&self, import_to_add: Option<ImportToAdd>) -> Option<CompletionItem> {
-        &self,
-        import_data: Option<(ModPath, ImportScope, Option<MergeBehaviour>)>,
-    ) -> Option<CompletionItem> {
        // FIXME: Currently proc-macro do not have ast-node,
        // such that it does not have source
        if self.macro_.is_proc_macro() {
@@ -53,7 +50,7 @@ impl<'a> MacroRender<'a> {
                .kind(CompletionItemKind::Macro)
                .set_documentation(self.docs.clone())
                .set_deprecated(self.ctx.is_deprecated(self.macro_))
-                .import_data(import_data)
+                .add_import(import_to_add)
                .detail(self.detail());
        let needs_bang = self.needs_bang();
diff --git a/crates/flycheck/Cargo.toml b/crates/flycheck/Cargo.toml
index 44499bc79..3d9436d69 100644
--- a/crates/flycheck/Cargo.toml
+++ b/crates/flycheck/Cargo.toml
@@ -12,7 +12,7 @@ doctest = false
 [dependencies]
 crossbeam-channel = "0.5.0"
 log = "0.4.8"
-cargo_metadata = "0.12.0"
+cargo_metadata = "=0.12.0"
 serde_json = "1.0.48"
 jod-thread = "0.1.1"
diff --git a/crates/hir/src/code_model.rs b/crates/hir/src/code_model.rs
index 37ed092ad..f06b5cd9f 100644
--- a/crates/hir/src/code_model.rs
+++ b/crates/hir/src/code_model.rs
@@ -1420,11 +1420,11 @@ impl Type {
    pub fn normalize_trait_assoc_type(
        &self,
        db: &dyn HirDatabase,
-        r#trait: Trait,
+        trait_: Trait,
        args: &[Type],
        alias: TypeAlias,
    ) -> Option<Type> {
-        let subst = Substs::build_for_def(db, r#trait.id)
+        let subst = Substs::build_for_def(db, trait_.id)
            .push(self.ty.value.clone())
            .fill(args.iter().map(|t| t.ty.value.clone()))
            .build();
diff --git a/crates/hir/src/db.rs b/crates/hir/src/db.rs
index 07333c453..8c767b249 100644
--- a/crates/hir/src/db.rs
+++ b/crates/hir/src/db.rs
@@ -11,7 +11,7 @@ pub use hir_def::db::{
 };
 pub use hir_expand::db::{
    AstDatabase, AstDatabaseStorage, AstIdMapQuery, InternEagerExpansionQuery, InternMacroQuery,
-    MacroArgTextQuery, MacroDefQuery, MacroExpandQuery, ParseMacroQuery,
+    MacroArgTextQuery, MacroDefQuery, MacroExpandQuery, ParseMacroExpansionQuery,
 };
 pub use hir_ty::db::*;
diff --git a/crates/hir/src/diagnostics.rs b/crates/hir/src/diagnostics.rs
index d9ad8db6f..eaf1a14ec 100644
--- a/crates/hir/src/diagnostics.rs
+++ b/crates/hir/src/diagnostics.rs
@@ -1,5 +1,5 @@
 //! FIXME: write short doc here
-pub use hir_def::diagnostics::{InactiveCode, UnresolvedModule};
+pub use hir_def::diagnostics::{InactiveCode, UnresolvedModule, UnresolvedProcMacro};
 pub use hir_expand::diagnostics::{
    Diagnostic, DiagnosticCode, DiagnosticSink, DiagnosticSinkBuilder,
 };
diff --git a/crates/hir/src/lib.rs b/crates/hir/src/lib.rs
index 5fea25ef1..93bdb4472 100644
--- a/crates/hir/src/lib.rs
+++ b/crates/hir/src/lib.rs
@@ -57,8 +57,8 @@ pub use hir_def::{
    visibility::Visibility,
 };
 pub use hir_expand::{
-    name::known, name::AsName, name::Name, HirFileId, InFile, MacroCallId, MacroCallLoc,
+    name::known, name::AsName, name::Name, ExpandResult, HirFileId, InFile, MacroCallId,
-    /* FIXME */ MacroDefId, MacroFile, Origin,
+    MacroCallLoc, /* FIXME */ MacroDefId, MacroFile, Origin,
 };
 pub use hir_ty::display::HirDisplay;
diff --git a/crates/hir_def/src/diagnostics.rs b/crates/hir_def/src/diagnostics.rs
index b221b290c..c71266dc0 100644
--- a/crates/hir_def/src/diagnostics.rs
+++ b/crates/hir_def/src/diagnostics.rs
@@ -6,7 +6,7 @@ use stdx::format_to;
 use cfg::{CfgExpr, CfgOptions, DnfExpr};
 use hir_expand::diagnostics::{Diagnostic, DiagnosticCode, DiagnosticSink};
 use hir_expand::{HirFileId, InFile};
-use syntax::{ast, AstPtr, SyntaxNodePtr};
+use syntax::{ast, AstPtr, SyntaxNodePtr, TextRange};
 use crate::{db::DefDatabase, DefWithBodyId};
@@ -127,3 +127,68 @@ impl Diagnostic for InactiveCode {
        self
    }
 }
+// Diagnostic: unresolved-proc-macro
+//
+// This diagnostic is shown when a procedural macro can not be found. This usually means that
+// procedural macro support is simply disabled (and hence is only a weak hint instead of an error),
+// but can also indicate project setup problems.
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct UnresolvedProcMacro {
+    pub file: HirFileId,
+    pub node: SyntaxNodePtr,
+    /// If the diagnostic can be pinpointed more accurately than via `node`, this is the `TextRange`
+    /// to use instead.
+    pub precise_location: Option<TextRange>,
+    pub macro_name: Option<String>,
+}
+impl Diagnostic for UnresolvedProcMacro {
+    fn code(&self) -> DiagnosticCode {
+        DiagnosticCode("unresolved-proc-macro")
+    }
+    fn message(&self) -> String {
+        match &self.macro_name {
+            Some(name) => format!("proc macro `{}` not expanded", name),
+            None => "proc macro not expanded".to_string(),
+        }
+    }
+    fn display_source(&self) -> InFile<SyntaxNodePtr> {
+        InFile::new(self.file, self.node.clone())
+    }
+    fn as_any(&self) -> &(dyn Any + Send + 'static) {
+        self
+    }
+}
+// Diagnostic: macro-error
+//
+// This diagnostic is shown for macro expansion errors.
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct MacroError {
+    pub file: HirFileId,
+    pub node: SyntaxNodePtr,
+    pub message: String,
+}
+impl Diagnostic for MacroError {
+    fn code(&self) -> DiagnosticCode {
+        DiagnosticCode("macro-error")
+    }
+    fn message(&self) -> String {
+        self.message.clone()
+    }
+    fn display_source(&self) -> InFile<SyntaxNodePtr> {
+        InFile::new(self.file, self.node.clone())
+    }
+    fn as_any(&self) -> &(dyn Any + Send + 'static) {
+        self
+    }
+    fn is_experimental(&self) -> bool {
+        // Newly added and not very well-tested, might contain false positives.
+        true
+    }
+}
diff --git a/crates/hir_def/src/import_map.rs b/crates/hir_def/src/import_map.rs
index 1e24f29a8..c0f108848 100644
--- a/crates/hir_def/src/import_map.rs
+++ b/crates/hir_def/src/import_map.rs
@@ -7,7 +7,7 @@ use fst::{self, Streamer};
 use hir_expand::name::Name;
 use indexmap::{map::Entry, IndexMap};
 use itertools::Itertools;
-use rustc_hash::{FxHashMap, FxHasher};
+use rustc_hash::{FxHashMap, FxHashSet, FxHasher};
 use smallvec::SmallVec;
 use syntax::SmolStr;
@@ -225,6 +225,19 @@ fn cmp((_, lhs): &(&ItemInNs, &ImportInfo), (_, rhs): &(&ItemInNs, &ImportInfo))
    lhs_str.cmp(&rhs_str)
 }
+#[derive(Debug, Eq, PartialEq, Hash)]
+pub enum ImportKind {
+    Module,
+    Function,
+    Adt,
+    EnumVariant,
+    Const,
+    Static,
+    Trait,
+    TypeAlias,
+    BuiltinType,
+}
 #[derive(Debug)]
 pub struct Query {
    query: String,
@@ -232,6 +245,7 @@ pub struct Query {
    anchor_end: bool,
    case_sensitive: bool,
    limit: usize,
+    exclude_import_kinds: FxHashSet<ImportKind>,
 }
 impl Query {
@@ -242,6 +256,7 @@ impl Query {
            anchor_end: false,
            case_sensitive: false,
            limit: usize::max_value(),
+            exclude_import_kinds: FxHashSet::default(),
        }
    }
@@ -260,6 +275,12 @@ impl Query {
    pub fn case_sensitive(self) -> Self {
        Self { case_sensitive: true, ..self }
    }
+    /// Do not include imports of the specified kind in the search results.
+    pub fn exclude_import_kind(mut self, import_kind: ImportKind) -> Self {
+        self.exclude_import_kinds.insert(import_kind);
+        self
+    }
 }
 /// Searches dependencies of `krate` for an importable path matching `query`.
@@ -303,10 +324,17 @@ pub fn search_dependencies<'a>(
            // Add the items from this `ModPath` group. Those are all subsequent items in
            // `importables` whose paths match `path`.
-            let iter = importables.iter().copied().take_while(|item| {
+            let iter = importables
-                let item_path = &import_map.map[item].path;
+                .iter()
-                fst_path(item_path) == fst_path(path)
+                .copied()
-            });
+                .take_while(|item| {
+                    let item_path = &import_map.map[item].path;
+                    fst_path(item_path) == fst_path(path)
+                })
+                .filter(|&item| match item_import_kind(item) {
+                    Some(import_kind) => !query.exclude_import_kinds.contains(&import_kind),
+                    None => true,
+                });
            if query.case_sensitive {
                // FIXME: This does not do a subsequence match.
@@ -341,6 +369,20 @@ pub fn search_dependencies<'a>(
    res
 }
+fn item_import_kind(item: ItemInNs) -> Option<ImportKind> {
+    Some(match item.as_module_def_id()? {
+        ModuleDefId::ModuleId(_) => ImportKind::Module,
+        ModuleDefId::FunctionId(_) => ImportKind::Function,
+        ModuleDefId::AdtId(_) => ImportKind::Adt,
+        ModuleDefId::EnumVariantId(_) => ImportKind::EnumVariant,
+        ModuleDefId::ConstId(_) => ImportKind::Const,
+        ModuleDefId::StaticId(_) => ImportKind::Static,
+        ModuleDefId::TraitId(_) => ImportKind::Trait,
+        ModuleDefId::TypeAliasId(_) => ImportKind::TypeAlias,
+        ModuleDefId::BuiltinType(_) => ImportKind::BuiltinType,
+    })
+}
 #[cfg(test)]
 mod tests {
    use base_db::{fixture::WithFixture, SourceDatabase, Upcast};
@@ -758,4 +800,34 @@ mod tests {
            "#]],
        );
    }
+    #[test]
+    fn search_exclusions() {
+        let ra_fixture = r#"
+            //- /main.rs crate:main deps:dep
+            //- /dep.rs crate:dep
+            pub struct fmt;
+            pub struct FMT;
+        "#;
+        check_search(
+            ra_fixture,
+            "main",
+            Query::new("FMT"),
+            expect![[r#"
+                dep::fmt (t)
+                dep::fmt (v)
+                dep::FMT (t)
+                dep::FMT (v)
+            "#]],
+        );
+        check_search(
+            ra_fixture,
+            "main",
+            Query::new("FMT").exclude_import_kind(ImportKind::Adt),
+            expect![[r#""#]],
+        );
+    }
 }
diff --git a/crates/hir_def/src/nameres.rs b/crates/hir_def/src/nameres.rs
index eb41d324e..ffd0381d4 100644
--- a/crates/hir_def/src/nameres.rs
+++ b/crates/hir_def/src/nameres.rs
@@ -286,8 +286,9 @@ mod diagnostics {
    use cfg::{CfgExpr, CfgOptions};
    use hir_expand::diagnostics::DiagnosticSink;
    use hir_expand::hygiene::Hygiene;
-    use hir_expand::InFile;
+    use hir_expand::{InFile, MacroCallKind};
-    use syntax::{ast, AstPtr, SyntaxNodePtr};
+    use syntax::ast::AttrsOwner;
+    use syntax::{ast, AstNode, AstPtr, SyntaxKind, SyntaxNodePtr};
    use crate::path::ModPath;
    use crate::{db::DefDatabase, diagnostics::*, nameres::LocalModuleId, AstId};
@@ -300,7 +301,11 @@ mod diagnostics {
        UnresolvedImport { ast: AstId<ast::Use>, index: usize },
-        UnconfiguredCode { ast: InFile<SyntaxNodePtr>, cfg: CfgExpr, opts: CfgOptions },
+        UnconfiguredCode { ast: AstId<ast::Item>, cfg: CfgExpr, opts: CfgOptions },
+        UnresolvedProcMacro { ast: MacroCallKind },
+        MacroError { ast: MacroCallKind, message: String },
    }
    #[derive(Debug, PartialEq, Eq)]
@@ -341,13 +346,25 @@ mod diagnostics {
        pub(super) fn unconfigured_code(
            container: LocalModuleId,
-            ast: InFile<SyntaxNodePtr>,
+            ast: AstId<ast::Item>,
            cfg: CfgExpr,
            opts: CfgOptions,
        ) -> Self {
            Self { in_module: container, kind: DiagnosticKind::UnconfiguredCode { ast, cfg, opts } }
        }
+        pub(super) fn unresolved_proc_macro(container: LocalModuleId, ast: MacroCallKind) -> Self {
+            Self { in_module: container, kind: DiagnosticKind::UnresolvedProcMacro { ast } }
+        }
+        pub(super) fn macro_error(
+            container: LocalModuleId,
+            ast: MacroCallKind,
+            message: String,
+        ) -> Self {
+            Self { in_module: container, kind: DiagnosticKind::MacroError { ast, message } }
+        }
        pub(super) fn add_to(
            &self,
            db: &dyn DefDatabase,
@@ -399,13 +416,80 @@ mod diagnostics {
                }
                DiagnosticKind::UnconfiguredCode { ast, cfg, opts } => {
+                    let item = ast.to_node(db.upcast());
                    sink.push(InactiveCode {
                        file: ast.file_id,
-                        node: ast.value.clone(),
+                        node: AstPtr::new(&item).into(),
                        cfg: cfg.clone(),
                        opts: opts.clone(),
                    });
                }
+                DiagnosticKind::UnresolvedProcMacro { ast } => {
+                    let mut precise_location = None;
+                    let (file, ast, name) = match ast {
+                        MacroCallKind::FnLike(ast) => {
+                            let node = ast.to_node(db.upcast());
+                            (ast.file_id, SyntaxNodePtr::from(AstPtr::new(&node)), None)
+                        }
+                        MacroCallKind::Attr(ast, name) => {
+                            let node = ast.to_node(db.upcast());
+                            // Compute the precise location of the macro name's token in the derive
+                            // list.
+                            // FIXME: This does not handle paths to the macro, but neither does the
+                            // rest of r-a.
+                            let derive_attrs =
+                                node.attrs().filter_map(|attr| match attr.as_simple_call() {
+                                    Some((name, args)) if name == "derive" => Some(args),
+                                    _ => None,
+                                });
+                            'outer: for attr in derive_attrs {
+                                let tokens =
+                                    attr.syntax().children_with_tokens().filter_map(|elem| {
+                                        match elem {
+                                            syntax::NodeOrToken::Node(_) => None,
+                                            syntax::NodeOrToken::Token(tok) => Some(tok),
+                                        }
+                                    });
+                                for token in tokens {
+                                    if token.kind() == SyntaxKind::IDENT
+                                        && token.to_string() == *name
+                                    {
+                                        precise_location = Some(token.text_range());
+                                        break 'outer;
+                                    }
+                                }
+                            }
+                            (
+                                ast.file_id,
+                                SyntaxNodePtr::from(AstPtr::new(&node)),
+                                Some(name.clone()),
+                            )
+                        }
+                    };
+                    sink.push(UnresolvedProcMacro {
+                        file,
+                        node: ast,
+                        precise_location,
+                        macro_name: name,
+                    });
+                }
+                DiagnosticKind::MacroError { ast, message } => {
+                    let (file, ast) = match ast {
+                        MacroCallKind::FnLike(ast) => {
+                            let node = ast.to_node(db.upcast());
+                            (ast.file_id, SyntaxNodePtr::from(AstPtr::new(&node)))
+                        }
+                        MacroCallKind::Attr(ast, _) => {
+                            let node = ast.to_node(db.upcast());
+                            (ast.file_id, SyntaxNodePtr::from(AstPtr::new(&node)))
+                        }
+                    };
+                    sink.push(MacroError { file, node: ast, message: message.clone() });
+                }
            }
        }
    }
diff --git a/crates/hir_def/src/nameres/collector.rs b/crates/hir_def/src/nameres/collector.rs
index 386287518..19cd713ba 100644
--- a/crates/hir_def/src/nameres/collector.rs
+++ b/crates/hir_def/src/nameres/collector.rs
@@ -7,7 +7,6 @@ use std::iter;
 use base_db::{CrateId, FileId, ProcMacroId};
 use cfg::{CfgExpr, CfgOptions};
-use hir_expand::InFile;
 use hir_expand::{
    ast_id_map::FileAstId,
    builtin_derive::find_builtin_derive,
@@ -16,6 +15,7 @@ use hir_expand::{
    proc_macro::ProcMacroExpander,
    HirFileId, MacroCallId, MacroDefId, MacroDefKind,
 };
+use hir_expand::{InFile, MacroCallLoc};
 use rustc_hash::{FxHashMap, FxHashSet};
 use syntax::ast;
 use test_utils::mark;
@@ -812,7 +812,30 @@ impl DefCollector<'_> {
            log::warn!("macro expansion is too deep");
            return;
        }
-        let file_id: HirFileId = macro_call_id.as_file();
+        let file_id = macro_call_id.as_file();
+        // First, fetch the raw expansion result for purposes of error reporting. This goes through
+        // `macro_expand_error` to avoid depending on the full expansion result (to improve
+        // incrementality).
+        let err = self.db.macro_expand_error(macro_call_id);
+        if let Some(err) = err {
+            if let MacroCallId::LazyMacro(id) = macro_call_id {
+                let loc: MacroCallLoc = self.db.lookup_intern_macro(id);
+                let diag = match err {
+                    hir_expand::ExpandError::UnresolvedProcMacro => {
+                        // Missing proc macros are non-fatal, so they are handled specially.
+                        DefDiagnostic::unresolved_proc_macro(module_id, loc.kind)
+                    }
+                    _ => DefDiagnostic::macro_error(module_id, loc.kind, err.to_string()),
+                };
+                self.def_map.diagnostics.push(diag);
+            }
+            // FIXME: Handle eager macros.
+        }
+        // Then, fetch and process the item tree. This will reuse the expansion result from above.
        let item_tree = self.db.item_tree(file_id);
        let mod_dir = self.mod_dirs[&module_id].clone();
        ModCollector {
@@ -1336,13 +1359,11 @@ impl ModCollector<'_, '_> {
    fn emit_unconfigured_diagnostic(&mut self, item: ModItem, cfg: &CfgExpr) {
        let ast_id = item.ast_id(self.item_tree);
-        let id_map = self.def_collector.db.ast_id_map(self.file_id);
-        let syntax_ptr = id_map.get(ast_id).syntax_node_ptr();
-        let ast_node = InFile::new(self.file_id, syntax_ptr);
+        let ast_id = InFile::new(self.file_id, ast_id);
        self.def_collector.def_map.diagnostics.push(DefDiagnostic::unconfigured_code(
            self.module_id,
-            ast_node,
+            ast_id,
            cfg.clone(),
            self.def_collector.cfg_options.clone(),
        ));
diff --git a/crates/hir_def/src/nameres/tests/incremental.rs b/crates/hir_def/src/nameres/tests/incremental.rs
index cfbc62cc4..8981fa7c9 100644
--- a/crates/hir_def/src/nameres/tests/incremental.rs
+++ b/crates/hir_def/src/nameres/tests/incremental.rs
@@ -38,6 +38,9 @@ fn typing_inside_a_function_should_not_invalidate_def_map() {
        fn foo() -> i32 {
            1 + 1
        }
+        #[cfg(never)]
+        fn no() {}
        //- /foo/mod.rs
        pub mod bar;
@@ -53,6 +56,9 @@ fn typing_inside_a_function_should_not_invalidate_def_map() {
        use E::*;
        fn foo() -> i32 { 92 }
+        #[cfg(never)]
+        fn no() {}
        ",
    );
 }
diff --git a/crates/hir_expand/src/db.rs b/crates/hir_expand/src/db.rs
index ade57ac1b..ff50bfd82 100644
--- a/crates/hir_expand/src/db.rs
+++ b/crates/hir_expand/src/db.rs
@@ -3,7 +3,7 @@
 use std::sync::Arc;
 use base_db::{salsa, SourceDatabase};
-use mbe::{ExpandResult, MacroRules};
+use mbe::{ExpandError, ExpandResult, MacroRules};
 use parser::FragmentKind;
 use syntax::{algo::diff, AstNode, GreenNode, Parse, SyntaxKind::*, SyntaxNode};
@@ -75,9 +75,14 @@ pub trait AstDatabase: SourceDatabase {
    #[salsa::transparent]
    fn macro_arg(&self, id: MacroCallId) -> Option<Arc<(tt::Subtree, mbe::TokenMap)>>;
    fn macro_def(&self, id: MacroDefId) -> Option<Arc<(TokenExpander, mbe::TokenMap)>>;
-    fn parse_macro(&self, macro_file: MacroFile)
+    fn parse_macro_expansion(
-        -> Option<(Parse<SyntaxNode>, Arc<mbe::TokenMap>)>;
+        &self,
-    fn macro_expand(&self, macro_call: MacroCallId) -> (Option<Arc<tt::Subtree>>, Option<String>);
+        macro_file: MacroFile,
+    ) -> ExpandResult<Option<(Parse<SyntaxNode>, Arc<mbe::TokenMap>)>>;
+    fn macro_expand(&self, macro_call: MacroCallId) -> ExpandResult<Option<Arc<tt::Subtree>>>;
+    /// Firewall query that returns the error from the `macro_expand` query.
+    fn macro_expand_error(&self, macro_call: MacroCallId) -> Option<ExpandError>;
    #[salsa::interned]
    fn intern_eager_expansion(&self, eager: EagerCallLoc) -> EagerMacroId;
@@ -102,23 +107,20 @@ pub fn expand_hypothetical(
    let token_id = tmap_1.token_by_range(range)?;
    let macro_def = expander(db, actual_macro_call)?;
    let (node, tmap_2) =
-        parse_macro_with_arg(db, macro_file, Some(std::sync::Arc::new((tt, tmap_1))))?;
+        parse_macro_with_arg(db, macro_file, Some(std::sync::Arc::new((tt, tmap_1)))).value?;
    let token_id = macro_def.0.map_id_down(token_id);
    let range = tmap_2.range_by_token(token_id)?.by_kind(token_to_map.kind())?;
    let token = syntax::algo::find_covering_element(&node.syntax_node(), range).into_token()?;
    Some((node.syntax_node(), token))
 }
-pub(crate) fn ast_id_map(db: &dyn AstDatabase, file_id: HirFileId) -> Arc<AstIdMap> {
+fn ast_id_map(db: &dyn AstDatabase, file_id: HirFileId) -> Arc<AstIdMap> {
    let map =
        db.parse_or_expand(file_id).map_or_else(AstIdMap::default, |it| AstIdMap::from_source(&it));
    Arc::new(map)
 }
-pub(crate) fn macro_def(
+fn macro_def(db: &dyn AstDatabase, id: MacroDefId) -> Option<Arc<(TokenExpander, mbe::TokenMap)>> {
-    db: &dyn AstDatabase,
-    id: MacroDefId,
-) -> Option<Arc<(TokenExpander, mbe::TokenMap)>> {
    match id.kind {
        MacroDefKind::Declarative => {
            let macro_call = id.ast_id?.to_node(db);
@@ -149,7 +151,7 @@ pub(crate) fn macro_def(
    }
 }
-pub(crate) fn macro_arg_text(db: &dyn AstDatabase, id: MacroCallId) -> Option<GreenNode> {
+fn macro_arg_text(db: &dyn AstDatabase, id: MacroCallId) -> Option<GreenNode> {
    let id = match id {
        MacroCallId::LazyMacro(id) => id,
        MacroCallId::EagerMacro(_id) => {
@@ -162,22 +164,20 @@ pub(crate) fn macro_arg_text(db: &dyn AstDatabase, id: MacroCallId) -> Option<Gr
    Some(arg.green().clone())
 }
-pub(crate) fn macro_arg(
+fn macro_arg(db: &dyn AstDatabase, id: MacroCallId) -> Option<Arc<(tt::Subtree, mbe::TokenMap)>> {
-    db: &dyn AstDatabase,
-    id: MacroCallId,
-) -> Option<Arc<(tt::Subtree, mbe::TokenMap)>> {
    let arg = db.macro_arg_text(id)?;
    let (tt, tmap) = mbe::syntax_node_to_token_tree(&SyntaxNode::new_root(arg))?;
    Some(Arc::new((tt, tmap)))
 }
-pub(crate) fn macro_expand(
+fn macro_expand(db: &dyn AstDatabase, id: MacroCallId) -> ExpandResult<Option<Arc<tt::Subtree>>> {
-    db: &dyn AstDatabase,
-    id: MacroCallId,
-) -> (Option<Arc<tt::Subtree>>, Option<String>) {
    macro_expand_with_arg(db, id, None)
 }
+fn macro_expand_error(db: &dyn AstDatabase, macro_call: MacroCallId) -> Option<ExpandError> {
+    db.macro_expand(macro_call).err
+}
 fn expander(db: &dyn AstDatabase, id: MacroCallId) -> Option<Arc<(TokenExpander, mbe::TokenMap)>> {
    let lazy_id = match id {
        MacroCallId::LazyMacro(id) => id,
@@ -195,17 +195,20 @@ fn macro_expand_with_arg(
    db: &dyn AstDatabase,
    id: MacroCallId,
    arg: Option<Arc<(tt::Subtree, mbe::TokenMap)>>,
-) -> (Option<Arc<tt::Subtree>>, Option<String>) {
+) -> ExpandResult<Option<Arc<tt::Subtree>>> {
+    let _p = profile::span("macro_expand");
    let lazy_id = match id {
        MacroCallId::LazyMacro(id) => id,
        MacroCallId::EagerMacro(id) => {
            if arg.is_some() {
-                return (
+                return ExpandResult::str_err(
-                    None,
+                    "hypothetical macro expansion not implemented for eager macro".to_owned(),
-                    Some("hypothetical macro expansion not implemented for eager macro".to_owned()),
                );
            } else {
-                return (Some(db.lookup_intern_eager_expansion(id).subtree), None);
+                return ExpandResult {
+                    value: Some(db.lookup_intern_eager_expansion(id).subtree),
+                    err: None,
+                };
            }
        }
    };
@@ -213,23 +216,27 @@ fn macro_expand_with_arg(
    let loc = db.lookup_intern_macro(lazy_id);
    let macro_arg = match arg.or_else(|| db.macro_arg(id)) {
        Some(it) => it,
-        None => return (None, Some("Fail to args in to tt::TokenTree".into())),
+        None => return ExpandResult::str_err("Fail to args in to tt::TokenTree".into()),
    };
    let macro_rules = match db.macro_def(loc.def) {
        Some(it) => it,
-        None => return (None, Some("Fail to find macro definition".into())),
+        None => return ExpandResult::str_err("Fail to find macro definition".into()),
    };
-    let ExpandResult(tt, err) = macro_rules.0.expand(db, lazy_id, &macro_arg.0);
+    let ExpandResult { value: 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 > 262144 {
-        return (None, Some(format!("Total tokens count exceed limit : count = {}", count)));
+        return ExpandResult::str_err(format!(
+            "Total tokens count exceed limit : count = {}",
+            count
+        ));
    }
-    (Some(Arc::new(tt)), err.map(|e| format!("{:?}", e)))
+    ExpandResult { value: Some(Arc::new(tt)), err }
 }
-pub(crate) fn expand_proc_macro(
+fn expand_proc_macro(
    db: &dyn AstDatabase,
    id: MacroCallId,
 ) -> Result<tt::Subtree, mbe::ExpandError> {
@@ -256,36 +263,37 @@ pub(crate) fn expand_proc_macro(
    expander.expand(db, lazy_id, &macro_arg.0)
 }
-pub(crate) fn parse_or_expand(db: &dyn AstDatabase, file_id: HirFileId) -> Option<SyntaxNode> {
+fn parse_or_expand(db: &dyn AstDatabase, file_id: HirFileId) -> Option<SyntaxNode> {
    match file_id.0 {
        HirFileIdRepr::FileId(file_id) => Some(db.parse(file_id).tree().syntax().clone()),
        HirFileIdRepr::MacroFile(macro_file) => {
-            db.parse_macro(macro_file).map(|(it, _)| it.syntax_node())
+            db.parse_macro_expansion(macro_file).value.map(|(it, _)| it.syntax_node())
        }
    }
 }
-pub(crate) fn parse_macro(
+fn parse_macro_expansion(
    db: &dyn AstDatabase,
    macro_file: MacroFile,
-) -> Option<(Parse<SyntaxNode>, Arc<mbe::TokenMap>)> {
+) -> ExpandResult<Option<(Parse<SyntaxNode>, Arc<mbe::TokenMap>)>> {
    parse_macro_with_arg(db, macro_file, None)
 }
-pub fn parse_macro_with_arg(
+fn parse_macro_with_arg(
    db: &dyn AstDatabase,
    macro_file: MacroFile,
    arg: Option<Arc<(tt::Subtree, mbe::TokenMap)>>,
-) -> Option<(Parse<SyntaxNode>, Arc<mbe::TokenMap>)> {
+) -> ExpandResult<Option<(Parse<SyntaxNode>, Arc<mbe::TokenMap>)>> {
-    let _p = profile::span("parse_macro_query");
    let macro_call_id = macro_file.macro_call_id;
-    let (tt, err) = if let Some(arg) = arg {
+    let result = if let Some(arg) = arg {
        macro_expand_with_arg(db, macro_call_id, Some(arg))
    } else {
        db.macro_expand(macro_call_id)
    };
-    if let Some(err) = &err {
+    let _p = profile::span("parse_macro_expansion");
+    if let Some(err) = &result.err {
        // Note:
        // The final goal we would like to make all parse_macro success,
        // such that the following log will not call anyway.
@@ -303,40 +311,50 @@ pub fn parse_macro_with_arg(
                .join("\n");
                log::warn!(
-                    "fail on macro_parse: (reason: {} macro_call: {:#}) parents: {}",
+                    "fail on macro_parse: (reason: {:?} macro_call: {:#}) parents: {}",
                    err,
                    node.value,
                    parents
                );
            }
            _ => {
-                log::warn!("fail on macro_parse: (reason: {})", err);
+                log::warn!("fail on macro_parse: (reason: {:?})", err);
            }
        }
+    }
+    let tt = match result.value {
+        Some(tt) => tt,
+        None => return ExpandResult { value: None, err: result.err },
    };
-    let tt = tt?;
    let fragment_kind = to_fragment_kind(db, macro_call_id);
-    let (parse, rev_token_map) = mbe::token_tree_to_syntax_node(&tt, fragment_kind).ok()?;
+    let (parse, rev_token_map) = match mbe::token_tree_to_syntax_node(&tt, fragment_kind) {
+        Ok(it) => it,
+        Err(err) => {
+            return ExpandResult::only_err(err);
+        }
+    };
-    if err.is_none() {
+    match result.err {
-        Some((parse, Arc::new(rev_token_map)))
+        Some(err) => {
-    } else {
+            // Safety check for recursive identity macro.
-        // FIXME:
+            let node = parse.syntax_node();
-        // In future, we should propagate the actual error with recovery information
+            let file: HirFileId = macro_file.into();
-        // instead of ignore the error here.
+            let call_node = match file.call_node(db) {
+                Some(it) => it,
-        // Safe check for recurisve identity macro
+                None => {
-        let node = parse.syntax_node();
+                    return ExpandResult::only_err(err);
-        let file: HirFileId = macro_file.into();
+                }
-        let call_node = file.call_node(db)?;
+            };
-        if !diff(&node, &call_node.value).is_empty() {
+            if !diff(&node, &call_node.value).is_empty() {
-            Some((parse, Arc::new(rev_token_map)))
+                ExpandResult { value: Some((parse, Arc::new(rev_token_map))), err: Some(err) }
-        } else {
+            } else {
-            None
+                return ExpandResult::only_err(err);
+            }
        }
+        None => ExpandResult { value: Some((parse, Arc::new(rev_token_map))), err: None },
    }
 }
diff --git a/crates/hir_expand/src/diagnostics.rs b/crates/hir_expand/src/diagnostics.rs
index 1043c6aeb..bf0b85ce9 100644
--- a/crates/hir_expand/src/diagnostics.rs
+++ b/crates/hir_expand/src/diagnostics.rs
@@ -5,7 +5,7 @@
 //!
 //! `DiagnosticSink` struct is used as an emitter for diagnostic. When creating
 //! a `DiagnosticSink`, you supply a callback which can react to a `dyn
-//! Diagnostic` or to any concrete diagnostic (downcasting is sued internally).
+//! Diagnostic` or to any concrete diagnostic (downcasting is used internally).
 //!
 //! Because diagnostics store file offsets, it's a bad idea to store them
 //! directly in salsa. For this reason, every hir subsytem defines it's own
@@ -32,7 +32,12 @@ impl DiagnosticCode {
 pub trait Diagnostic: Any + Send + Sync + fmt::Debug + 'static {
    fn code(&self) -> DiagnosticCode;
    fn message(&self) -> String;
-    /// Used in highlighting and related purposes
+    /// Source element that triggered the diagnostics.
+    ///
+    /// Note that this should reflect "semantics", rather than specific span we
+    /// want to highlight. When rendering the diagnostics into an error message,
+    /// the IDE will fetch the `SyntaxNode` and will narrow the span
+    /// appropriately.
    fn display_source(&self) -> InFile<SyntaxNodePtr>;
    fn as_any(&self) -> &(dyn Any + Send + 'static);
    fn is_experimental(&self) -> bool {
diff --git a/crates/hir_expand/src/lib.rs b/crates/hir_expand/src/lib.rs
index 17f1178ed..6dad2507b 100644
--- a/crates/hir_expand/src/lib.rs
+++ b/crates/hir_expand/src/lib.rs
@@ -15,6 +15,8 @@ pub mod proc_macro;
 pub mod quote;
 pub mod eager;
+pub use mbe::{ExpandError, ExpandResult};
 use std::hash::Hash;
 use std::sync::Arc;
@@ -144,7 +146,7 @@ impl HirFileId {
                let def_tt = loc.def.ast_id?.to_node(db).token_tree()?;
                let macro_def = db.macro_def(loc.def)?;
-                let (parse, exp_map) = db.parse_macro(macro_file)?;
+                let (parse, exp_map) = db.parse_macro_expansion(macro_file).value?;
                let macro_arg = db.macro_arg(macro_file.macro_call_id)?;
                Some(ExpansionInfo {
@@ -253,7 +255,7 @@ pub enum MacroDefKind {
 pub struct MacroCallLoc {
    pub(crate) def: MacroDefId,
    pub(crate) krate: CrateId,
-    pub(crate) kind: MacroCallKind,
+    pub kind: MacroCallKind,
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
diff --git a/crates/hir_expand/src/proc_macro.rs b/crates/hir_expand/src/proc_macro.rs
index 7505cb061..97edf0fb6 100644
--- a/crates/hir_expand/src/proc_macro.rs
+++ b/crates/hir_expand/src/proc_macro.rs
@@ -50,7 +50,7 @@ impl ProcMacroExpander {
                proc_macro.expander.expand(&tt, None).map_err(mbe::ExpandError::from)
            }
-            None => Err(err!("Unresolved proc macro")),
+            None => Err(mbe::ExpandError::UnresolvedProcMacro),
        }
    }
 }
diff --git a/crates/hir_ty/src/diagnostics/match_check.rs b/crates/hir_ty/src/diagnostics/match_check.rs
index 5bd03f2ac..62c329731 100644
--- a/crates/hir_ty/src/diagnostics/match_check.rs
+++ b/crates/hir_ty/src/diagnostics/match_check.rs
@@ -216,14 +216,14 @@
 //!   U(P, p) := U(P, (r_1, p_2, .., p_n))
 //!            || U(P, (r_2, p_2, .., p_n))
 //!   ```
-use std::sync::Arc;
+use std::{iter, sync::Arc};
 use arena::Idx;
 use hir_def::{
    adt::VariantData,
    body::Body,
    expr::{Expr, Literal, Pat, PatId},
-    AdtId, EnumVariantId, VariantId,
+    AdtId, EnumVariantId, StructId, VariantId,
 };
 use smallvec::{smallvec, SmallVec};
@@ -366,16 +366,17 @@ impl PatStack {
        let head_pat = head.as_pat(cx);
        let result = match (head_pat, constructor) {
-            (Pat::Tuple { args: ref pat_ids, ellipsis }, Constructor::Tuple { arity: _ }) => {
+            (Pat::Tuple { args: pat_ids, ellipsis }, &Constructor::Tuple { arity }) => {
-                if ellipsis.is_some() {
+                if let Some(ellipsis) = ellipsis {
-                    // If there are ellipsis here, we should add the correct number of
+                    let (pre, post) = pat_ids.split_at(ellipsis);
-                    // Pat::Wild patterns to `pat_ids`. We should be able to use the
+                    let n_wild_pats = arity.saturating_sub(pat_ids.len());
-                    // constructors arity for this, but at the time of writing we aren't
+                    let pre_iter = pre.iter().map(Into::into);
-                    // correctly calculating this arity when ellipsis are present.
+                    let wildcards = iter::repeat(PatIdOrWild::Wild).take(n_wild_pats);
-                    return Err(MatchCheckErr::NotImplemented);
+                    let post_iter = post.iter().map(Into::into);
+                    Some(self.replace_head_with(pre_iter.chain(wildcards).chain(post_iter)))
+                } else {
+                    Some(self.replace_head_with(pat_ids.iter()))
                }
-                Some(self.replace_head_with(pat_ids.iter()))
            }
            (Pat::Lit(lit_expr), Constructor::Bool(constructor_val)) => {
                match cx.body.exprs[lit_expr] {
@@ -390,21 +391,28 @@ impl PatStack {
                }
            }
            (Pat::Wild, constructor) => Some(self.expand_wildcard(cx, constructor)?),
-            (Pat::Path(_), Constructor::Enum(constructor)) => {
+            (Pat::Path(_), constructor) => {
                // unit enum variants become `Pat::Path`
                let pat_id = head.as_id().expect("we know this isn't a wild");
-                if !enum_variant_matches(cx, pat_id, *constructor) {
+                let variant_id: VariantId = match constructor {
+                    &Constructor::Enum(e) => e.into(),
+                    &Constructor::Struct(s) => s.into(),
+                    _ => return Err(MatchCheckErr::NotImplemented),
+                };
+                if Some(variant_id) != cx.infer.variant_resolution_for_pat(pat_id) {
                    None
                } else {
                    Some(self.to_tail())
                }
            }
-            (
+            (Pat::TupleStruct { args: ref pat_ids, ellipsis, .. }, constructor) => {
-                Pat::TupleStruct { args: ref pat_ids, ellipsis, .. },
-                Constructor::Enum(enum_constructor),
-            ) => {
                let pat_id = head.as_id().expect("we know this isn't a wild");
-                if !enum_variant_matches(cx, pat_id, *enum_constructor) {
+                let variant_id: VariantId = match constructor {
+                    &Constructor::Enum(e) => e.into(),
+                    &Constructor::Struct(s) => s.into(),
+                    _ => return Err(MatchCheckErr::MalformedMatchArm),
+                };
+                if Some(variant_id) != cx.infer.variant_resolution_for_pat(pat_id) {
                    None
                } else {
                    let constructor_arity = constructor.arity(cx)?;
@@ -442,12 +450,22 @@ impl PatStack {
                    }
                }
            }
-            (Pat::Record { args: ref arg_patterns, .. }, Constructor::Enum(e)) => {
+            (Pat::Record { args: ref arg_patterns, .. }, constructor) => {
                let pat_id = head.as_id().expect("we know this isn't a wild");
-                if !enum_variant_matches(cx, pat_id, *e) {
+                let (variant_id, variant_data) = match constructor {
+                    &Constructor::Enum(e) => (
+                        e.into(),
+                        cx.db.enum_data(e.parent).variants[e.local_id].variant_data.clone(),
+                    ),
+                    &Constructor::Struct(s) => {
+                        (s.into(), cx.db.struct_data(s).variant_data.clone())
+                    }
+                    _ => return Err(MatchCheckErr::MalformedMatchArm),
+                };
+                if Some(variant_id) != cx.infer.variant_resolution_for_pat(pat_id) {
                    None
                } else {
-                    match cx.db.enum_data(e.parent).variants[e.local_id].variant_data.as_ref() {
+                    match variant_data.as_ref() {
                        VariantData::Record(struct_field_arena) => {
                            // Here we treat any missing fields in the record as the wild pattern, as
                            // if the record has ellipsis. We want to do this here even if the
@@ -726,6 +744,7 @@ enum Constructor {
    Bool(bool),
    Tuple { arity: usize },
    Enum(EnumVariantId),
+    Struct(StructId),
 }
 impl Constructor {
@@ -740,6 +759,11 @@ impl Constructor {
                    VariantData::Unit => 0,
                }
            }
+            &Constructor::Struct(s) => match cx.db.struct_data(s).variant_data.as_ref() {
+                VariantData::Tuple(struct_field_data) => struct_field_data.len(),
+                VariantData::Record(struct_field_data) => struct_field_data.len(),
+                VariantData::Unit => 0,
+            },
        };
        Ok(arity)
@@ -748,7 +772,7 @@ impl Constructor {
    fn all_constructors(&self, cx: &MatchCheckCtx) -> Vec<Constructor> {
        match self {
            Constructor::Bool(_) => vec![Constructor::Bool(true), Constructor::Bool(false)],
-            Constructor::Tuple { .. } => vec![*self],
+            Constructor::Tuple { .. } | Constructor::Struct(_) => vec![*self],
            Constructor::Enum(e) => cx
                .db
                .enum_data(e.parent)
@@ -767,10 +791,11 @@ impl Constructor {
 fn pat_constructor(cx: &MatchCheckCtx, pat: PatIdOrWild) -> MatchCheckResult<Option<Constructor>> {
    let res = match pat.as_pat(cx) {
        Pat::Wild => None,
-        // FIXME somehow create the Tuple constructor with the proper arity. If there are
+        Pat::Tuple { .. } => {
-        // ellipsis, the arity is not equal to the number of patterns.
+            let pat_id = pat.as_id().expect("we already know this pattern is not a wild");
-        Pat::Tuple { args: pats, ellipsis } if ellipsis.is_none() => {
+            Some(Constructor::Tuple {
-            Some(Constructor::Tuple { arity: pats.len() })
+                arity: cx.infer.type_of_pat[pat_id].as_tuple().ok_or(MatchCheckErr::Unknown)?.len(),
+            })
        }
        Pat::Lit(lit_expr) => match cx.body.exprs[lit_expr] {
            Expr::Literal(Literal::Bool(val)) => Some(Constructor::Bool(val)),
@@ -784,6 +809,7 @@ fn pat_constructor(cx: &MatchCheckCtx, pat: PatIdOrWild) -> MatchCheckResult<Opt
                VariantId::EnumVariantId(enum_variant_id) => {
                    Some(Constructor::Enum(enum_variant_id))
                }
+                VariantId::StructId(struct_id) => Some(Constructor::Struct(struct_id)),
                _ => return Err(MatchCheckErr::NotImplemented),
            }
        }
@@ -828,13 +854,13 @@ fn all_constructors_covered(
            false
        }),
+        &Constructor::Struct(s) => used_constructors.iter().any(|constructor| match constructor {
+            &Constructor::Struct(sid) => sid == s,
+            _ => false,
+        }),
    }
 }
-fn enum_variant_matches(cx: &MatchCheckCtx, pat_id: PatId, enum_variant_id: EnumVariantId) -> bool {
-    Some(enum_variant_id.into()) == cx.infer.variant_resolution_for_pat(pat_id)
-}
 #[cfg(test)]
 mod tests {
    use crate::diagnostics::tests::check_diagnostics;
@@ -846,8 +872,8 @@ mod tests {
 fn main() {
    match () { }
        //^^ Missing match arm
-   match (()) { }
+    match (()) { }
-       //^^^^ Missing match arm
+        //^^^^ Missing match arm
    match () { _ => (), }
    match () { () => (), }
@@ -1352,6 +1378,123 @@ fn main() {
        );
    }
+    #[test]
+    fn tuple_of_bools_with_ellipsis_at_end_missing_arm() {
+        check_diagnostics(
+            r#"
+fn main() {
+    match (false, true, false) {
+        //^^^^^^^^^^^^^^^^^^^^ Missing match arm
+        (false, ..) => (),
+    }
+}"#,
+        );
+    }
+    #[test]
+    fn tuple_of_bools_with_ellipsis_at_beginning_missing_arm() {
+        check_diagnostics(
+            r#"
+fn main() {
+    match (false, true, false) {
+        //^^^^^^^^^^^^^^^^^^^^ Missing match arm
+        (.., false) => (),
+    }
+}"#,
+        );
+    }
+    #[test]
+    fn tuple_of_bools_with_ellipsis_in_middle_missing_arm() {
+        check_diagnostics(
+            r#"
+fn main() {
+    match (false, true, false) {
+        //^^^^^^^^^^^^^^^^^^^^ Missing match arm
+        (true, .., false) => (),
+    }
+}"#,
+        );
+    }
+    #[test]
+    fn record_struct() {
+        check_diagnostics(
+            r#"struct Foo { a: bool }
+fn main(f: Foo) {
+    match f {}
+        //^ Missing match arm
+    match f { Foo { a: true } => () }
+        //^ Missing match arm
+    match &f { Foo { a: true } => () }
+        //^^ Missing match arm
+    match f { Foo { a: _ } => () }
+    match f {
+        Foo { a: true } => (),
+        Foo { a: false } => (),
+    }
+    match &f {
+        Foo { a: true } => (),
+        Foo { a: false } => (),
+    }
+}
+"#,
+        );
+    }
+    #[test]
+    fn tuple_struct() {
+        check_diagnostics(
+            r#"struct Foo(bool);
+fn main(f: Foo) {
+    match f {}
+        //^ Missing match arm
+    match f { Foo(true) => () }
+        //^ Missing match arm
+    match f {
+        Foo(true) => (),
+        Foo(false) => (),
+    }
+}
+"#,
+        );
+    }
+    #[test]
+    fn unit_struct() {
+        check_diagnostics(
+            r#"struct Foo;
+fn main(f: Foo) {
+    match f {}
+        //^ Missing match arm
+    match f { Foo => () }
+}
+"#,
+        );
+    }
+    #[test]
+    fn record_struct_ellipsis() {
+        check_diagnostics(
+            r#"struct Foo { foo: bool, bar: bool }
+fn main(f: Foo) {
+    match f { Foo { foo: true, .. } => () }
+        //^ Missing match arm
+    match f {
+        //^ Missing match arm
+        Foo { foo: true, .. } => (),
+        Foo { bar: false, .. } => ()
+    }
+    match f { Foo { .. } => () }
+    match f {
+        Foo { foo: true, .. } => (),
+        Foo { foo: false, .. } => ()
+    }
+}
+"#,
+        );
+    }
    mod false_negatives {
        //! The implementation of match checking here is a work in progress. As we roll this out, we
        //! prefer false negatives to false positives (ideally there would be no false positives). This
@@ -1393,46 +1536,5 @@ fn main() {
 "#,
            );
        }
-        #[test]
-        fn tuple_of_bools_with_ellipsis_at_end_missing_arm() {
-            // We don't currently handle tuple patterns with ellipsis.
-            check_diagnostics(
-                r#"
-fn main() {
-    match (false, true, false) {
-        (false, ..) => (),
-    }
-}
-"#,
-            );
-        }
-        #[test]
-        fn tuple_of_bools_with_ellipsis_at_beginning_missing_arm() {
-            // We don't currently handle tuple patterns with ellipsis.
-            check_diagnostics(
-                r#"
-fn main() {
-    match (false, true, false) {
-        (.., false) => (),
-    }
-}
-"#,
-            );
-        }
-        #[test]
-        fn struct_missing_arm() {
-            // We don't currently handle structs.
-            check_diagnostics(
-                r#"
-struct Foo { a: bool }
-fn main(f: Foo) {
-    match f { Foo { a: true } => () }
-}
-"#,
-            );
-        }
    }
 }
diff --git a/crates/hir_ty/src/infer/pat.rs b/crates/hir_ty/src/infer/pat.rs
index cde2ab82b..b70ec55eb 100644
--- a/crates/hir_ty/src/infer/pat.rs
+++ b/crates/hir_ty/src/infer/pat.rs
@@ -23,6 +23,7 @@ impl<'a> InferenceContext<'a> {
        expected: &Ty,
        default_bm: BindingMode,
        id: PatId,
+        ellipsis: Option<usize>,
    ) -> Ty {
        let (ty, def) = self.resolve_variant(path);
        let var_data = def.map(|it| variant_data(self.db.upcast(), it));
@@ -34,8 +35,15 @@ impl<'a> InferenceContext<'a> {
        let substs = ty.substs().unwrap_or_else(Substs::empty);
        let field_tys = def.map(|it| self.db.field_types(it)).unwrap_or_default();
+        let (pre, post) = match ellipsis {
+            Some(idx) => subpats.split_at(idx),
+            None => (&subpats[..], &[][..]),
+        };
+        let post_idx_offset = field_tys.iter().count() - post.len();
-        for (i, &subpat) in subpats.iter().enumerate() {
+        let pre_iter = pre.iter().enumerate();
+        let post_iter = (post_idx_offset..).zip(post.iter());
+        for (i, &subpat) in pre_iter.chain(post_iter) {
            let expected_ty = var_data
                .as_ref()
                .and_then(|d| d.field(&Name::new_tuple_field(i)))
@@ -111,20 +119,29 @@ impl<'a> InferenceContext<'a> {
        let expected = expected;
        let ty = match &body[pat] {
-            Pat::Tuple { ref args, .. } => {
+            &Pat::Tuple { ref args, ellipsis } => {
                let expectations = match expected.as_tuple() {
                    Some(parameters) => &*parameters.0,
                    _ => &[],
                };
-                let expectations_iter = expectations.iter().chain(repeat(&Ty::Unknown));
-                let inner_tys = args
+                let (pre, post) = match ellipsis {
-                    .iter()
+                    Some(idx) => args.split_at(idx),
-                    .zip(expectations_iter)
+                    None => (&args[..], &[][..]),
-                    .map(|(&pat, ty)| self.infer_pat(pat, ty, default_bm))
+                };
-                    .collect();
+                let n_uncovered_patterns = expectations.len().saturating_sub(args.len());
+                let mut expectations_iter = expectations.iter().chain(repeat(&Ty::Unknown));
+                let mut infer_pat = |(&pat, ty)| self.infer_pat(pat, ty, default_bm);
+                let mut inner_tys = Vec::with_capacity(n_uncovered_patterns + args.len());
+                inner_tys.extend(pre.iter().zip(expectations_iter.by_ref()).map(&mut infer_pat));
+                inner_tys.extend(expectations_iter.by_ref().take(n_uncovered_patterns).cloned());
+                inner_tys.extend(post.iter().zip(expectations_iter).map(infer_pat));
-                Ty::apply(TypeCtor::Tuple { cardinality: args.len() as u16 }, Substs(inner_tys))
+                Ty::apply(
+                    TypeCtor::Tuple { cardinality: inner_tys.len() as u16 },
+                    Substs(inner_tys.into()),
+                )
            }
            Pat::Or(ref pats) => {
                if let Some((first_pat, rest)) = pats.split_first() {
@@ -150,9 +167,14 @@ impl<'a> InferenceContext<'a> {
                let subty = self.infer_pat(*pat, expectation, default_bm);
                Ty::apply_one(TypeCtor::Ref(*mutability), subty)
            }
-            Pat::TupleStruct { path: p, args: subpats, .. } => {
+            Pat::TupleStruct { path: p, args: subpats, ellipsis } => self.infer_tuple_struct_pat(
-                self.infer_tuple_struct_pat(p.as_ref(), subpats, expected, default_bm, pat)
+                p.as_ref(),
-            }
+                subpats,
+                expected,
+                default_bm,
+                pat,
+                *ellipsis,
+            ),
            Pat::Record { path: p, args: fields, ellipsis: _ } => {
                self.infer_record_pat(p.as_ref(), fields, expected, default_bm, pat)
            }
diff --git a/crates/hir_ty/src/tests/patterns.rs b/crates/hir_ty/src/tests/patterns.rs
index 6a965ac4f..5a5f48fd0 100644
--- a/crates/hir_ty/src/tests/patterns.rs
+++ b/crates/hir_ty/src/tests/patterns.rs
@@ -679,3 +679,98 @@ fn box_pattern() {
        "#]],
    );
 }
+#[test]
+fn tuple_ellipsis_pattern() {
+    check_infer(
+        r#"
+fn foo(tuple: (u8, i16, f32)) {
+    match tuple {
+        (.., b, c) => {},
+        (a, .., c) => {},
+        (a, b, ..) => {},
+        (a, b) => {/*too short*/}
+        (a, b, c, d) => {/*too long*/}
+        _ => {}
+    }
+}"#,
+        expect![[r#"
+            7..12 'tuple': (u8, i16, f32)
+            30..224 '{     ...   } }': ()
+            36..222 'match ...     }': ()
+            42..47 'tuple': (u8, i16, f32)
+            58..68 '(.., b, c)': (u8, i16, f32)
+            63..64 'b': i16
+            66..67 'c': f32
+            72..74 '{}': ()
+            84..94 '(a, .., c)': (u8, i16, f32)
+            85..86 'a': u8
+            92..93 'c': f32
+            98..100 '{}': ()
+            110..120 '(a, b, ..)': (u8, i16, f32)
+            111..112 'a': u8
+            114..115 'b': i16
+            124..126 '{}': ()
+            136..142 '(a, b)': (u8, i16, f32)
+            137..138 'a': u8
+            140..141 'b': i16
+            146..161 '{/*too short*/}': ()
+            170..182 '(a, b, c, d)': (u8, i16, f32, {unknown})
+            171..172 'a': u8
+            174..175 'b': i16
+            177..178 'c': f32
+            180..181 'd': {unknown}
+            186..200 '{/*too long*/}': ()
+            209..210 '_': (u8, i16, f32)
+            214..216 '{}': ()
+        "#]],
+    );
+}
+#[test]
+fn tuple_struct_ellipsis_pattern() {
+    check_infer(
+        r#"
+struct Tuple(u8, i16, f32);
+fn foo(tuple: Tuple) {
+    match tuple {
+        Tuple(.., b, c) => {},
+        Tuple(a, .., c) => {},
+        Tuple(a, b, ..) => {},
+        Tuple(a, b) => {/*too short*/}
+        Tuple(a, b, c, d) => {/*too long*/}
+        _ => {}
+    }
+}"#,
+        expect![[r#"
+            35..40 'tuple': Tuple
+            49..268 '{     ...   } }': ()
+            55..266 'match ...     }': ()
+            61..66 'tuple': Tuple
+            77..92 'Tuple(.., b, c)': Tuple
+            87..88 'b': i16
+            90..91 'c': f32
+            96..98 '{}': ()
+            108..123 'Tuple(a, .., c)': Tuple
+            114..115 'a': u8
+            121..122 'c': f32
+            127..129 '{}': ()
+            139..154 'Tuple(a, b, ..)': Tuple
+            145..146 'a': u8
+            148..149 'b': i16
+            158..160 '{}': ()
+            170..181 'Tuple(a, b)': Tuple
+            176..177 'a': u8
+            179..180 'b': i16
+            185..200 '{/*too short*/}': ()
+            209..226 'Tuple(... c, d)': Tuple
+            215..216 'a': u8
+            218..219 'b': i16
+            221..222 'c': f32
+            224..225 'd': {unknown}
+            230..244 '{/*too long*/}': ()
+            253..254 '_': Tuple
+            258..260 '{}': ()
+        "#]],
+    );
+}
diff --git a/crates/ide/src/diagnostics.rs b/crates/ide/src/diagnostics.rs
index 3df73ed4f..9d3d88289 100644
--- a/crates/ide/src/diagnostics.rs
+++ b/crates/ide/src/diagnostics.rs
@@ -142,6 +142,15 @@ pub(crate) fn diagnostics(
                    .with_code(Some(d.code())),
            );
        })
+        .on::<hir::diagnostics::UnresolvedProcMacro, _>(|d| {
+            // Use more accurate position if available.
+            let display_range =
+                d.precise_location.unwrap_or_else(|| sema.diagnostics_display_range(d).range);
+            // FIXME: it would be nice to tell the user whether proc macros are currently disabled
+            res.borrow_mut()
+                .push(Diagnostic::hint(display_range, d.message()).with_code(Some(d.code())));
+        })
        // Only collect experimental diagnostics when they're enabled.
        .filter(|diag| !(diag.is_experimental() && config.disable_experimental))
        .filter(|diag| !config.disabled.contains(diag.code().as_str()));
diff --git a/crates/ide/src/goto_definition.rs b/crates/ide/src/goto_definition.rs
index 15792f947..b9810457f 100644
--- a/crates/ide/src/goto_definition.rs
+++ b/crates/ide/src/goto_definition.rs
@@ -1,14 +1,10 @@
 use hir::Semantics;
 use ide_db::{
+    base_db::FileId,
    defs::{NameClass, NameRefClass},
    symbol_index, RootDatabase,
 };
-use syntax::{
+use syntax::{ast, match_ast, AstNode, SyntaxKind::*, SyntaxToken, TokenAtOffset, T};
-    ast::{self},
-    match_ast, AstNode,
-    SyntaxKind::*,
-    SyntaxToken, TokenAtOffset, T,
-};
 use crate::{
    display::{ToNav, TryToNav},
@@ -44,6 +40,19 @@ pub(crate) fn goto_definition(
                let nav = def.try_to_nav(sema.db)?;
                vec![nav]
            },
+            ast::SelfParam(self_param) => {
+                vec![self_to_nav_target(self_param, position.file_id)?]
+            },
+            ast::PathSegment(segment) => {
+                segment.self_token()?;
+                let path = segment.parent_path();
+                if path.qualifier().is_some() && !ast::PathExpr::can_cast(path.syntax().parent()?.kind()) {
+                    return None;
+                }
+                let func = segment.syntax().ancestors().find_map(ast::Fn::cast)?;
+                let self_param = func.param_list()?.self_param()?;
+                vec![self_to_nav_target(self_param, position.file_id)?]
+            },
            _ => return None,
        }
    };
@@ -62,6 +71,20 @@ fn pick_best(tokens: TokenAtOffset<SyntaxToken>) -> Option<SyntaxToken> {
    }
 }
+fn self_to_nav_target(self_param: ast::SelfParam, file_id: FileId) -> Option<NavigationTarget> {
+    let self_token = self_param.self_token()?;
+    Some(NavigationTarget {
+        file_id,
+        full_range: self_param.syntax().text_range(),
+        focus_range: Some(self_token.text_range()),
+        name: self_token.text().clone(),
+        kind: self_token.kind(),
+        container_name: None,
+        description: None,
+        docs: None,
+    })
+}
 #[derive(Debug)]
 pub(crate) enum ReferenceResult {
    Exact(NavigationTarget),
@@ -984,4 +1007,33 @@ fn g() -> <() as Iterator<A = (), B<|> = u8>>::A {}
 "#,
        );
    }
+    #[test]
+    fn goto_self_param_ty_specified() {
+        check(
+            r#"
+struct Foo {}
+impl Foo {
+    fn bar(self: &Foo) {
+         //^^^^
+        let foo = sel<|>f;
+    }
+}"#,
+        )
+    }
+    #[test]
+    fn goto_self_param_on_decl() {
+        check(
+            r#"
+struct Foo {}
+impl Foo {
+    fn bar(&self<|>) {
+          //^^^^
+    }
+}"#,
+        )
+    }
 }
diff --git a/crates/ide/src/hover.rs b/crates/ide/src/hover.rs
index 832192881..94ad800a0 100644
--- a/crates/ide/src/hover.rs
+++ b/crates/ide/src/hover.rs
@@ -139,14 +139,17 @@ pub(crate) fn hover(
        }
    }
-    let node = token
+    let node = token.ancestors().find(|n| {
-        .ancestors()
+        ast::Expr::can_cast(n.kind())
-        .find(|n| ast::Expr::cast(n.clone()).is_some() || ast::Pat::cast(n.clone()).is_some())?;
+            || ast::Pat::can_cast(n.kind())
+            || ast::SelfParam::can_cast(n.kind())
+    })?;
    let ty = match_ast! {
        match node {
            ast::Expr(it) => sema.type_of_expr(&it)?,
            ast::Pat(it) => sema.type_of_pat(&it)?,
+            ast::SelfParam(self_param) => sema.type_of_self(&self_param)?,
            // If this node is a MACRO_CALL, it means that `descend_into_macros` failed to resolve.
            // (e.g expanding a builtin macro). So we give up here.
            ast::MacroCall(_it) => return None,
@@ -3282,4 +3285,41 @@ fn main() {
            "#]],
        );
    }
+    #[test]
+    fn hover_self_param_shows_type() {
+        check(
+            r#"
+struct Foo {}
+impl Foo {
+    fn bar(&sel<|>f) {}
+}
+"#,
+            expect![[r#"
+                *&self*
+                ```rust
+                &Foo
+                ```
+            "#]],
+        );
+    }
+    #[test]
+    fn hover_self_param_shows_type_for_arbitrary_self_type() {
+        check(
+            r#"
+struct Arc<T>(T);
+struct Foo {}
+impl Foo {
+    fn bar(sel<|>f: Arc<Foo>) {}
+}
+"#,
+            expect![[r#"
+                *self: Arc<Foo>*
+                ```rust
+                Arc<Foo>
+                ```
+            "#]],
+        );
+    }
 }
diff --git a/crates/ide/src/inlay_hints.rs b/crates/ide/src/inlay_hints.rs
index 6cfb22e13..65df7979c 100644
--- a/crates/ide/src/inlay_hints.rs
+++ b/crates/ide/src/inlay_hints.rs
@@ -1,6 +1,6 @@
-use assists::utils::FamousDefs;
 use either::Either;
 use hir::{known, Callable, HirDisplay, Semantics};
+use ide_db::helpers::FamousDefs;
 use ide_db::RootDatabase;
 use stdx::to_lower_snake_case;
 use syntax::{
@@ -427,8 +427,8 @@ fn get_callable(sema: &Semantics<RootDatabase>, expr: &ast::Expr) -> Option<hir:
 #[cfg(test)]
 mod tests {
-    use assists::utils::FamousDefs;
    use expect_test::{expect, Expect};
+    use ide_db::helpers::FamousDefs;
    use test_utils::extract_annotations;
    use crate::{fixture, inlay_hints::InlayHintsConfig};
diff --git a/crates/ide/src/lib.rs b/crates/ide/src/lib.rs
index 6288f7ea7..5244bdd61 100644
--- a/crates/ide/src/lib.rs
+++ b/crates/ide/src/lib.rs
@@ -87,9 +87,7 @@ pub use ide_db::{
    search::{Reference, ReferenceAccess, ReferenceKind},
 };
-pub use assists::{
+pub use assists::{Assist, AssistConfig, AssistId, AssistKind, ResolvedAssist};
-    utils::MergeBehaviour, Assist, AssistConfig, AssistId, AssistKind, ResolvedAssist,
-};
 pub use hir::{Documentation, Semantics};
 pub use ide_db::base_db::{
    Canceled, Change, CrateGraph, CrateId, Edition, FileId, FilePosition, FileRange, SourceRoot,
diff --git a/crates/ide/src/references/rename.rs b/crates/ide/src/references/rename.rs
index b8725693a..731457696 100644
--- a/crates/ide/src/references/rename.rs
+++ b/crates/ide/src/references/rename.rs
@@ -1,4 +1,9 @@
 //! FIXME: write short doc here
+use std::{
+    convert::TryInto,
+    error::Error,
+    fmt::{self, Display},
+};
 use hir::{Module, ModuleDef, ModuleSource, Semantics};
 use ide_db::base_db::{FileRange, SourceDatabaseExt};
@@ -6,12 +11,6 @@ use ide_db::{
    defs::{Definition, NameClass, NameRefClass},
    RootDatabase,
 };
-use std::{
-    convert::TryInto,
-    error::Error,
-    fmt::{self, Display},
-};
 use syntax::{
    algo::find_node_at_offset,
    ast::{self, NameOwner},
@@ -222,24 +221,47 @@ fn rename_to_self(
    let source_file = sema.parse(position.file_id);
    let syn = source_file.syntax();
-    let fn_def = find_node_at_offset::<ast::Fn>(syn, position.offset)
+    let (fn_def, fn_ast) = find_node_at_offset::<ast::Fn>(syn, position.offset)
+        .and_then(|fn_ast| sema.to_def(&fn_ast).zip(Some(fn_ast)))
        .ok_or_else(|| RenameError("No surrounding method declaration found".to_string()))?;
-    let params =
+    let param_range = fn_ast
-        fn_def.param_list().ok_or_else(|| RenameError("Method has no parameters".to_string()))?;
+        .param_list()
-    if params.self_param().is_some() {
+        .and_then(|p| p.params().next())
+        .ok_or_else(|| RenameError("Method has no parameters".to_string()))?
+        .syntax()
+        .text_range();
+    if !param_range.contains(position.offset) {
+        return Err(RenameError("Only the first parameter can be self".to_string()));
+    }
+    let impl_block = find_node_at_offset::<ast::Impl>(syn, position.offset)
+        .and_then(|def| sema.to_def(&def))
+        .ok_or_else(|| RenameError("No impl block found for function".to_string()))?;
+    if fn_def.self_param(sema.db).is_some() {
        return Err(RenameError("Method already has a self parameter".to_string()));
    }
+    let params = fn_def.params(sema.db);
    let first_param =
-        params.params().next().ok_or_else(|| RenameError("Method has no parameters".into()))?;
+        params.first().ok_or_else(|| RenameError("Method has no parameters".into()))?;
-    let mutable = match first_param.ty() {
+    let first_param_ty = first_param.ty();
-        Some(ast::Type::RefType(rt)) => rt.mut_token().is_some(),
+    let impl_ty = impl_block.target_ty(sema.db);
-        _ => return Err(RenameError("Not renaming other types".to_string())),
+    let (ty, self_param) = if impl_ty.remove_ref().is_some() {
+        // if the impl is a ref to the type we can just match the `&T` with self directly
+        (first_param_ty.clone(), "self")
+    } else {
+        first_param_ty.remove_ref().map_or((first_param_ty.clone(), "self"), |ty| {
+            (ty, if first_param_ty.is_mutable_reference() { "&mut self" } else { "&self" })
+        })
    };
+    if ty != impl_ty {
+        return Err(RenameError("Parameter type differs from impl block type".to_string()));
+    }
    let RangeInfo { range, info: refs } = find_all_refs(sema, position, None)
        .ok_or_else(|| RenameError("No reference found at position".to_string()))?;
-    let param_range = first_param.syntax().text_range();
    let (param_ref, usages): (Vec<Reference>, Vec<Reference>) = refs
        .into_iter()
        .partition(|reference| param_range.intersect(reference.file_range.range).is_some());
@@ -255,10 +277,7 @@ fn rename_to_self(
    edits.push(SourceFileEdit {
        file_id: position.file_id,
-        edit: TextEdit::replace(
+        edit: TextEdit::replace(param_range, String::from(self_param)),
-            param_range,
-            String::from(if mutable { "&mut self" } else { "&self" }),
-        ),
    });
    Ok(RangeInfo::new(range, SourceChange::from(edits)))
@@ -281,7 +300,11 @@ fn text_edit_from_self_param(
    let mut replacement_text = String::from(new_name);
    replacement_text.push_str(": ");
-    replacement_text.push_str(self_param.mut_token().map_or("&", |_| "&mut "));
+    match (self_param.amp_token(), self_param.mut_token()) {
+        (None, None) => (),
+        (Some(_), None) => replacement_text.push('&'),
+        (_, Some(_)) => replacement_text.push_str("&mut "),
+    };
    replacement_text.push_str(type_name.as_str());
    Some(TextEdit::replace(self_param.syntax().text_range(), replacement_text))
@@ -1083,6 +1106,95 @@ impl Foo {
 }
 "#,
        );
+        check(
+            "self",
+            r#"
+struct Foo { i: i32 }
+impl Foo {
+    fn f(foo<|>: Foo) -> i32 {
+        foo.i
+    }
+}
+"#,
+            r#"
+struct Foo { i: i32 }
+impl Foo {
+    fn f(self) -> i32 {
+        self.i
+    }
+}
+"#,
+        );
+    }
+    #[test]
+    fn test_parameter_to_self_error_no_impl() {
+        check(
+            "self",
+            r#"
+struct Foo { i: i32 }
+fn f(foo<|>: &mut Foo) -> i32 {
+    foo.i
+}
+"#,
+            "error: No impl block found for function",
+        );
+        check(
+            "self",
+            r#"
+struct Foo { i: i32 }
+struct Bar;
+impl Bar {
+    fn f(foo<|>: &mut Foo) -> i32 {
+        foo.i
+    }
+}
+"#,
+            "error: Parameter type differs from impl block type",
+        );
+    }
+    #[test]
+    fn test_parameter_to_self_error_not_first() {
+        check(
+            "self",
+            r#"
+struct Foo { i: i32 }
+impl Foo {
+    fn f(x: (), foo<|>: &mut Foo) -> i32 {
+        foo.i
+    }
+}
+"#,
+            "error: Only the first parameter can be self",
+        );
+    }
+    #[test]
+    fn test_parameter_to_self_impl_ref() {
+        check(
+            "self",
+            r#"
+struct Foo { i: i32 }
+impl &Foo {
+    fn f(foo<|>: &Foo) -> i32 {
+        foo.i
+    }
+}
+"#,
+            r#"
+struct Foo { i: i32 }
+impl &Foo {
+    fn f(self) -> i32 {
+        self.i
+    }
+}
+"#,
+        );
    }
    #[test]
@@ -1111,6 +1223,31 @@ impl Foo {
    }
    #[test]
+    fn test_owned_self_to_parameter() {
+        check(
+            "foo",
+            r#"
+struct Foo { i: i32 }
+impl Foo {
+    fn f(<|>self) -> i32 {
+        self.i
+    }
+}
+"#,
+            r#"
+struct Foo { i: i32 }
+impl Foo {
+    fn f(foo: Foo) -> i32 {
+        foo.i
+    }
+}
+"#,
+        );
+    }
+    #[test]
    fn test_self_in_path_to_parameter() {
        check(
            "foo",
diff --git a/crates/ide/src/status.rs b/crates/ide/src/status.rs
index 8e91c99d7..e10d7c3a4 100644
--- a/crates/ide/src/status.rs
+++ b/crates/ide/src/status.rs
@@ -1,6 +1,6 @@
 use std::{fmt, iter::FromIterator, sync::Arc};
-use hir::MacroFile;
+use hir::{ExpandResult, MacroFile};
 use ide_db::base_db::{
    salsa::debug::{DebugQueryTable, TableEntry},
    CrateId, FileId, FileTextQuery, SourceDatabase, SourceRootId,
@@ -19,7 +19,7 @@ fn syntax_tree_stats(db: &RootDatabase) -> SyntaxTreeStats {
    ide_db::base_db::ParseQuery.in_db(db).entries::<SyntaxTreeStats>()
 }
 fn macro_syntax_tree_stats(db: &RootDatabase) -> SyntaxTreeStats {
-    hir::db::ParseMacroQuery.in_db(db).entries::<SyntaxTreeStats>()
+    hir::db::ParseMacroExpansionQuery.in_db(db).entries::<SyntaxTreeStats>()
 }
 // Feature: Status
@@ -115,10 +115,12 @@ impl FromIterator<TableEntry<FileId, Parse<ast::SourceFile>>> for SyntaxTreeStat
    }
 }
-impl<M> FromIterator<TableEntry<MacroFile, Option<(Parse<SyntaxNode>, M)>>> for SyntaxTreeStats {
+impl<M> FromIterator<TableEntry<MacroFile, ExpandResult<Option<(Parse<SyntaxNode>, M)>>>>
+    for SyntaxTreeStats
+{
    fn from_iter<T>(iter: T) -> SyntaxTreeStats
    where
-        T: IntoIterator<Item = TableEntry<MacroFile, Option<(Parse<SyntaxNode>, M)>>>,
+        T: IntoIterator<Item = TableEntry<MacroFile, ExpandResult<Option<(Parse<SyntaxNode>, M)>>>>,
    {
        let mut res = SyntaxTreeStats::default();
        for entry in iter {
diff --git a/crates/ide_db/Cargo.toml b/crates/ide_db/Cargo.toml
index 72a9212f1..0ad6e1000 100644
--- a/crates/ide_db/Cargo.toml
+++ b/crates/ide_db/Cargo.toml
@@ -18,7 +18,8 @@ rayon = "1.5.0"
 fst = { version = "0.4", default-features = false }
 rustc-hash = "1.1.0"
 once_cell = "1.3.1"
-either = "1.5.3"
+either = "1.6.1"
+itertools = "0.9.0"
 stdx = { path = "../stdx", version = "0.0.0" }
 syntax = { path = "../syntax", version = "0.0.0" }
diff --git a/crates/ide_db/src/apply_change.rs b/crates/ide_db/src/apply_change.rs
index da16fa21d..987191fe3 100644
--- a/crates/ide_db/src/apply_change.rs
+++ b/crates/ide_db/src/apply_change.rs
@@ -76,7 +76,7 @@ impl RootDatabase {
        let sweep = SweepStrategy::default().discard_values().sweep_all_revisions();
        base_db::ParseQuery.in_db(self).sweep(sweep);
-        hir::db::ParseMacroQuery.in_db(self).sweep(sweep);
+        hir::db::ParseMacroExpansionQuery.in_db(self).sweep(sweep);
        // Macros do take significant space, but less then the syntax trees
        // self.query(hir::db::MacroDefQuery).sweep(sweep);
@@ -143,7 +143,7 @@ impl RootDatabase {
            hir::db::AstIdMapQuery
            hir::db::MacroArgTextQuery
            hir::db::MacroDefQuery
-            hir::db::ParseMacroQuery
+            hir::db::ParseMacroExpansionQuery
            hir::db::MacroExpandQuery
            // DefDatabase
diff --git a/crates/ide_db/src/helpers.rs b/crates/ide_db/src/helpers.rs
new file mode 100644
index 000000000..d988588ff
--- /dev/null
+++ b/crates/ide_db/src/helpers.rs
@@ -0,0 +1,203 @@
+//! A module with ide helpers for high-level ide features.
+use crate::RootDatabase;
+use hir::{Crate, Enum, Module, ScopeDef, Semantics, Trait};
+use syntax::ast::{self, make};
+pub mod insert_use;
+/// Converts the mod path struct into its ast representation.
+pub fn mod_path_to_ast(path: &hir::ModPath) -> ast::Path {
+    let _p = profile::span("mod_path_to_ast");
+    let mut segments = Vec::new();
+    let mut is_abs = false;
+    match path.kind {
+        hir::PathKind::Plain => {}
+        hir::PathKind::Super(0) => segments.push(make::path_segment_self()),
+        hir::PathKind::Super(n) => segments.extend((0..n).map(|_| make::path_segment_super())),
+        hir::PathKind::DollarCrate(_) | hir::PathKind::Crate => {
+            segments.push(make::path_segment_crate())
+        }
+        hir::PathKind::Abs => is_abs = true,
+    }
+    segments.extend(
+        path.segments
+            .iter()
+            .map(|segment| make::path_segment(make::name_ref(&segment.to_string()))),
+    );
+    make::path_from_segments(segments, is_abs)
+}
+/// Helps with finding well-know things inside the standard library. This is
+/// somewhat similar to the known paths infra inside hir, but it different; We
+/// want to make sure that IDE specific paths don't become interesting inside
+/// the compiler itself as well.
+pub struct FamousDefs<'a, 'b>(pub &'a Semantics<'b, RootDatabase>, pub Option<Crate>);
+#[allow(non_snake_case)]
+impl FamousDefs<'_, '_> {
+    pub const FIXTURE: &'static str = r#"//- /libcore.rs crate:core
+pub mod convert {
+    pub trait From<T> {
+        fn from(t: T) -> Self;
+    }
+}
+pub mod default {
+    pub trait Default {
+       fn default() -> Self;
+    }
+}
+pub mod iter {
+    pub use self::traits::{collect::IntoIterator, iterator::Iterator};
+    mod traits {
+        pub(crate) mod iterator {
+            use crate::option::Option;
+            pub trait Iterator {
+                type Item;
+                fn next(&mut self) -> Option<Self::Item>;
+                fn by_ref(&mut self) -> &mut Self {
+                    self
+                }
+                fn take(self, n: usize) -> crate::iter::Take<Self> {
+                    crate::iter::Take { inner: self }
+                }
+            }
+            impl<I: Iterator> Iterator for &mut I {
+                type Item = I::Item;
+                fn next(&mut self) -> Option<I::Item> {
+                    (**self).next()
+                }
+            }
+        }
+        pub(crate) mod collect {
+            pub trait IntoIterator {
+                type Item;
+            }
+        }
+    }
+    pub use self::sources::*;
+    pub(crate) mod sources {
+        use super::Iterator;
+        use crate::option::Option::{self, *};
+        pub struct Repeat<A> {
+            element: A,
+        }
+        pub fn repeat<T>(elt: T) -> Repeat<T> {
+            Repeat { element: elt }
+        }
+        impl<A> Iterator for Repeat<A> {
+            type Item = A;
+            fn next(&mut self) -> Option<A> {
+                None
+            }
+        }
+    }
+    pub use self::adapters::*;
+    pub(crate) mod adapters {
+        use super::Iterator;
+        use crate::option::Option::{self, *};
+        pub struct Take<I> { pub(crate) inner: I }
+        impl<I> Iterator for Take<I> where I: Iterator {
+            type Item = <I as Iterator>::Item;
+            fn next(&mut self) -> Option<<I as Iterator>::Item> {
+                None
+            }
+        }
+    }
+}
+pub mod option {
+    pub enum Option<T> { None, Some(T)}
+}
+pub mod prelude {
+    pub use crate::{convert::From, iter::{IntoIterator, Iterator}, option::Option::{self, *}, default::Default};
+}
+#[prelude_import]
+pub use prelude::*;
+"#;
+    pub fn core(&self) -> Option<Crate> {
+        self.find_crate("core")
+    }
+    pub fn core_convert_From(&self) -> Option<Trait> {
+        self.find_trait("core:convert:From")
+    }
+    pub fn core_option_Option(&self) -> Option<Enum> {
+        self.find_enum("core:option:Option")
+    }
+    pub fn core_default_Default(&self) -> Option<Trait> {
+        self.find_trait("core:default:Default")
+    }
+    pub fn core_iter_Iterator(&self) -> Option<Trait> {
+        self.find_trait("core:iter:traits:iterator:Iterator")
+    }
+    pub fn core_iter(&self) -> Option<Module> {
+        self.find_module("core:iter")
+    }
+    fn find_trait(&self, path: &str) -> Option<Trait> {
+        match self.find_def(path)? {
+            hir::ScopeDef::ModuleDef(hir::ModuleDef::Trait(it)) => Some(it),
+            _ => None,
+        }
+    }
+    fn find_enum(&self, path: &str) -> Option<Enum> {
+        match self.find_def(path)? {
+            hir::ScopeDef::ModuleDef(hir::ModuleDef::Adt(hir::Adt::Enum(it))) => Some(it),
+            _ => None,
+        }
+    }
+    fn find_module(&self, path: &str) -> Option<Module> {
+        match self.find_def(path)? {
+            hir::ScopeDef::ModuleDef(hir::ModuleDef::Module(it)) => Some(it),
+            _ => None,
+        }
+    }
+    fn find_crate(&self, name: &str) -> Option<Crate> {
+        let krate = self.1?;
+        let db = self.0.db;
+        let res =
+            krate.dependencies(db).into_iter().find(|dep| dep.name.to_string() == name)?.krate;
+        Some(res)
+    }
+    fn find_def(&self, path: &str) -> Option<ScopeDef> {
+        let db = self.0.db;
+        let mut path = path.split(':');
+        let trait_ = path.next_back()?;
+        let std_crate = path.next()?;
+        let std_crate = self.find_crate(std_crate)?;
+        let mut module = std_crate.root_module(db);
+        for segment in path {
+            module = module.children(db).find_map(|child| {
+                let name = child.name(db)?;
+                if name.to_string() == segment {
+                    Some(child)
+                } else {
+                    None
+                }
+            })?;
+        }
+        let def =
+            module.scope(db, None).into_iter().find(|(name, _def)| name.to_string() == trait_)?.1;
+        Some(def)
+    }
+}
diff --git a/crates/assists/src/utils/insert_use.rs b/crates/ide_db/src/helpers/insert_use.rs
index 423782a0e..67e800fad 100644
--- a/crates/assists/src/utils/insert_use.rs
+++ b/crates/ide_db/src/helpers/insert_use.rs
@@ -1,8 +1,8 @@
 //! Handle syntactic aspects of inserting a new `use`.
 use std::{cmp::Ordering, iter::successors};
+use crate::RootDatabase;
 use hir::Semantics;
-use ide_db::RootDatabase;
 use itertools::{EitherOrBoth, Itertools};
 use syntax::{
    algo::SyntaxRewriter,
@@ -22,7 +22,7 @@ pub enum ImportScope {
 }
 impl ImportScope {
-    pub(crate) fn from(syntax: SyntaxNode) -> Option<Self> {
+    pub fn from(syntax: SyntaxNode) -> Option<Self> {
        if let Some(module) = ast::Module::cast(syntax.clone()) {
            module.item_list().map(ImportScope::Module)
        } else if let this @ Some(_) = ast::SourceFile::cast(syntax.clone()) {
@@ -95,6 +95,7 @@ pub fn insert_use<'a>(
    path: ast::Path,
    merge: Option<MergeBehaviour>,
 ) -> SyntaxRewriter<'a> {
+    let _p = profile::span("insert_use");
    let mut rewriter = SyntaxRewriter::default();
    let use_item = make::use_(make::use_tree(path.clone(), None, None, false));
    // merge into existing imports if possible
@@ -179,7 +180,7 @@ fn eq_visibility(vis0: Option<ast::Visibility>, vis1: Option<ast::Visibility>) -
    }
 }
-pub(crate) fn try_merge_imports(
+pub fn try_merge_imports(
    lhs: &ast::Use,
    rhs: &ast::Use,
    merge_behaviour: MergeBehaviour,
@@ -194,7 +195,7 @@ pub(crate) fn try_merge_imports(
    Some(lhs.with_use_tree(merged))
 }
-pub(crate) fn try_merge_trees(
+pub fn try_merge_trees(
    lhs: &ast::UseTree,
    rhs: &ast::UseTree,
    merge: MergeBehaviour,
diff --git a/crates/ide_db/src/imports_locator.rs b/crates/ide_db/src/imports_locator.rs
index 9d8ea7368..09046d3c3 100644
--- a/crates/ide_db/src/imports_locator.rs
+++ b/crates/ide_db/src/imports_locator.rs
@@ -36,8 +36,15 @@ pub fn find_similar_imports<'a>(
    krate: Crate,
    name_to_import: &str,
    limit: usize,
+    ignore_modules: bool,
 ) -> impl Iterator<Item = Either<ModuleDef, MacroDef>> {
    let _p = profile::span("find_similar_imports");
+    let mut external_query = import_map::Query::new(name_to_import).limit(limit);
+    if ignore_modules {
+        external_query = external_query.exclude_import_kind(import_map::ImportKind::Module);
+    }
    find_imports(
        sema,
        krate,
@@ -46,7 +53,7 @@ pub fn find_similar_imports<'a>(
            local_query.limit(limit);
            local_query
        },
-        import_map::Query::new(name_to_import).limit(limit),
+        external_query,
    )
 }
diff --git a/crates/ide_db/src/lib.rs b/crates/ide_db/src/lib.rs
index 38ebdbf79..fceaa089a 100644
--- a/crates/ide_db/src/lib.rs
+++ b/crates/ide_db/src/lib.rs
@@ -13,6 +13,7 @@ pub mod source_change;
 pub mod ty_filter;
 pub mod traits;
 pub mod call_info;
+pub mod helpers;
 use std::{fmt, sync::Arc};
@@ -113,7 +114,7 @@ impl RootDatabase {
    pub fn update_lru_capacity(&mut self, lru_capacity: Option<usize>) {
        let lru_capacity = lru_capacity.unwrap_or(base_db::DEFAULT_LRU_CAP);
        base_db::ParseQuery.in_db_mut(self).set_lru_capacity(lru_capacity);
-        hir::db::ParseMacroQuery.in_db_mut(self).set_lru_capacity(lru_capacity);
+        hir::db::ParseMacroExpansionQuery.in_db_mut(self).set_lru_capacity(lru_capacity);
        hir::db::MacroExpandQuery.in_db_mut(self).set_lru_capacity(lru_capacity);
    }
 }
diff --git a/crates/mbe/src/lib.rs b/crates/mbe/src/lib.rs
index f854ca09a..3ad609a00 100644
--- a/crates/mbe/src/lib.rs
+++ b/crates/mbe/src/lib.rs
@@ -12,6 +12,8 @@ mod subtree_source;
 #[cfg(test)]
 mod tests;
+use std::fmt;
 pub use tt::{Delimiter, Punct};
 use crate::{
@@ -33,6 +35,8 @@ pub enum ExpandError {
    ConversionError,
    InvalidRepeat,
    ProcMacroError(tt::ExpansionError),
+    UnresolvedProcMacro,
+    Other(String),
 }
 impl From<tt::ExpansionError> for ExpandError {
@@ -41,6 +45,21 @@ impl From<tt::ExpansionError> for ExpandError {
    }
 }
+impl fmt::Display for ExpandError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            ExpandError::NoMatchingRule => f.write_str("no rule matches input tokens"),
+            ExpandError::UnexpectedToken => f.write_str("unexpected token in input"),
+            ExpandError::BindingError(e) => f.write_str(e),
+            ExpandError::ConversionError => f.write_str("could not convert tokens"),
+            ExpandError::InvalidRepeat => f.write_str("invalid repeat expression"),
+            ExpandError::ProcMacroError(e) => e.fmt(f),
+            ExpandError::UnresolvedProcMacro => f.write_str("unresolved proc macro"),
+            ExpandError::Other(e) => f.write_str(e),
+        }
+    }
+}
 pub use crate::syntax_bridge::{
    ast_to_token_tree, parse_to_token_tree, syntax_node_to_token_tree, token_tree_to_syntax_node,
    TokenMap,
@@ -246,33 +265,42 @@ fn validate(pattern: &tt::Subtree) -> Result<(), ParseError> {
    Ok(())
 }
-#[derive(Debug)]
+#[derive(Debug, Clone, Eq, PartialEq)]
-pub struct ExpandResult<T>(pub T, pub Option<ExpandError>);
+pub struct ExpandResult<T> {
+    pub value: T,
+    pub err: Option<ExpandError>,
+}
 impl<T> ExpandResult<T> {
-    pub fn ok(t: T) -> ExpandResult<T> {
+    pub fn ok(value: T) -> Self {
-        ExpandResult(t, None)
+        Self { value, err: None }
+    }
+    pub fn only_err(err: ExpandError) -> Self
+    where
+        T: Default,
+    {
+        Self { value: Default::default(), err: Some(err) }
    }
-    pub fn only_err(err: ExpandError) -> ExpandResult<T>
+    pub fn str_err(err: String) -> Self
    where
        T: Default,
    {
-        ExpandResult(Default::default(), Some(err))
+        Self::only_err(ExpandError::Other(err))
    }
    pub fn map<U>(self, f: impl FnOnce(T) -> U) -> ExpandResult<U> {
-        ExpandResult(f(self.0), self.1)
+        ExpandResult { value: f(self.value), err: self.err }
    }
    pub fn result(self) -> Result<T, ExpandError> {
-        self.1.map(Err).unwrap_or(Ok(self.0))
+        self.err.map(Err).unwrap_or(Ok(self.value))
    }
 }
 impl<T: Default> From<Result<T, ExpandError>> for ExpandResult<T> {
-    fn from(result: Result<T, ExpandError>) -> ExpandResult<T> {
+    fn from(result: Result<T, ExpandError>) -> Self {
-        result
+        result.map_or_else(|e| Self::only_err(e), |it| Self::ok(it))
-            .map_or_else(|e| ExpandResult(Default::default(), Some(e)), |it| ExpandResult(it, None))
    }
 }
diff --git a/crates/mbe/src/mbe_expander.rs b/crates/mbe/src/mbe_expander.rs
index 1ad8b9f8a..97bce0536 100644
--- a/crates/mbe/src/mbe_expander.rs
+++ b/crates/mbe/src/mbe_expander.rs
@@ -28,10 +28,10 @@ fn expand_rules(rules: &[crate::Rule], input: &tt::Subtree) -> ExpandResult<tt::
            // If we find a rule that applies without errors, we're done.
            // Unconditionally returning the transcription here makes the
            // `test_repeat_bad_var` test fail.
-            let ExpandResult(res, transcribe_err) =
+            let ExpandResult { value, err: transcribe_err } =
                transcriber::transcribe(&rule.rhs, &new_match.bindings);
            if transcribe_err.is_none() {
-                return ExpandResult::ok(res);
+                return ExpandResult::ok(value);
            }
        }
        // Use the rule if we matched more tokens, or had fewer errors
@@ -47,11 +47,11 @@ fn expand_rules(rules: &[crate::Rule], input: &tt::Subtree) -> ExpandResult<tt::
    }
    if let Some((match_, rule)) = match_ {
        // if we got here, there was no match without errors
-        let ExpandResult(result, transcribe_err) =
+        let ExpandResult { value, err: transcribe_err } =
            transcriber::transcribe(&rule.rhs, &match_.bindings);
-        ExpandResult(result, match_.err.or(transcribe_err))
+        ExpandResult { value, err: match_.err.or(transcribe_err) }
    } else {
-        ExpandResult(tt::Subtree::default(), Some(ExpandError::NoMatchingRule))
+        ExpandResult::only_err(ExpandError::NoMatchingRule)
    }
 }
@@ -143,7 +143,10 @@ mod tests {
    }
    fn assert_err(macro_body: &str, invocation: &str, err: ExpandError) {
-        assert_eq!(expand_first(&create_rules(&format_macro(macro_body)), invocation).1, Some(err));
+        assert_eq!(
+            expand_first(&create_rules(&format_macro(macro_body)), invocation).err,
+            Some(err)
+        );
    }
    fn format_macro(macro_body: &str) -> String {
diff --git a/crates/mbe/src/mbe_expander/matcher.rs b/crates/mbe/src/mbe_expander/matcher.rs
index 39a8eefbd..3f8445897 100644
--- a/crates/mbe/src/mbe_expander/matcher.rs
+++ b/crates/mbe/src/mbe_expander/matcher.rs
@@ -158,7 +158,8 @@ fn match_subtree(
                        continue;
                    }
                };
-                let ExpandResult(matched, match_err) = match_meta_var(kind.as_str(), src);
+                let ExpandResult { value: matched, err: match_err } =
+                    match_meta_var(kind.as_str(), src);
                match matched {
                    Some(fragment) => {
                        res.bindings.inner.insert(name.clone(), Binding::Fragment(fragment));
@@ -342,17 +343,17 @@ impl<'a> TtIter<'a> {
                token_trees: res.into_iter().cloned().collect(),
            })),
        };
-        ExpandResult(res, err)
+        ExpandResult { value: res, err }
    }
    pub(crate) fn eat_vis(&mut self) -> Option<tt::TokenTree> {
        let mut fork = self.clone();
        match fork.expect_fragment(Visibility) {
-            ExpandResult(tt, None) => {
+            ExpandResult { value: tt, err: None } => {
                *self = fork;
                tt
            }
-            ExpandResult(_, Some(_)) => None,
+            ExpandResult { value: _, err: Some(_) } => None,
        }
    }
 }
diff --git a/crates/mbe/src/mbe_expander/transcriber.rs b/crates/mbe/src/mbe_expander/transcriber.rs
index c9525c5bf..616119ba9 100644
--- a/crates/mbe/src/mbe_expander/transcriber.rs
+++ b/crates/mbe/src/mbe_expander/transcriber.rs
@@ -93,17 +93,18 @@ fn expand_subtree(
        match op {
            Op::TokenTree(tt @ tt::TokenTree::Leaf(..)) => arena.push(tt.clone()),
            Op::TokenTree(tt::TokenTree::Subtree(tt)) => {
-                let ExpandResult(tt, e) = expand_subtree(ctx, tt, arena);
+                let ExpandResult { value: tt, err: e } = expand_subtree(ctx, tt, arena);
                err = err.or(e);
                arena.push(tt.into());
            }
            Op::Var { name, kind: _ } => {
-                let ExpandResult(fragment, e) = expand_var(ctx, name);
+                let ExpandResult { value: fragment, err: e } = expand_var(ctx, name);
                err = err.or(e);
                push_fragment(arena, fragment);
            }
            Op::Repeat { subtree, kind, separator } => {
-                let ExpandResult(fragment, e) = expand_repeat(ctx, subtree, kind, separator, arena);
+                let ExpandResult { value: fragment, err: e } =
+                    expand_repeat(ctx, subtree, kind, separator, arena);
                err = err.or(e);
                push_fragment(arena, fragment)
            }
@@ -111,7 +112,7 @@ fn expand_subtree(
    }
    // drain the elements added in this instance of expand_subtree
    let tts = arena.drain(start_elements..arena.len()).collect();
-    ExpandResult(tt::Subtree { delimiter: template.delimiter, token_trees: tts }, err)
+    ExpandResult { value: tt::Subtree { delimiter: template.delimiter, token_trees: tts }, err }
 }
 fn expand_var(ctx: &mut ExpandCtx, v: &SmolStr) -> ExpandResult<Fragment> {
@@ -152,7 +153,7 @@ fn expand_var(ctx: &mut ExpandCtx, v: &SmolStr) -> ExpandResult<Fragment> {
        ExpandResult::ok(Fragment::Tokens(tt))
    } else {
        ctx.bindings.get(&v, &mut ctx.nesting).map_or_else(
-            |e| ExpandResult(Fragment::Tokens(tt::TokenTree::empty()), Some(e)),
+            |e| ExpandResult { value: Fragment::Tokens(tt::TokenTree::empty()), err: Some(e) },
            |b| ExpandResult::ok(b.clone()),
        )
    }
@@ -174,7 +175,7 @@ fn expand_repeat(
    let mut counter = 0;
    loop {
-        let ExpandResult(mut t, e) = expand_subtree(ctx, template, arena);
+        let ExpandResult { value: mut t, err: e } = expand_subtree(ctx, template, arena);
        let nesting_state = ctx.nesting.last_mut().unwrap();
        if nesting_state.at_end || !nesting_state.hit {
            break;
@@ -234,7 +235,10 @@ fn expand_repeat(
    let tt = tt::Subtree { delimiter: None, token_trees: buf }.into();
    if RepeatKind::OneOrMore == kind && counter == 0 {
-        return ExpandResult(Fragment::Tokens(tt), Some(ExpandError::UnexpectedToken));
+        return ExpandResult {
+            value: Fragment::Tokens(tt),
+            err: Some(ExpandError::UnexpectedToken),
+        };
    }
    ExpandResult::ok(Fragment::Tokens(tt))
 }
diff --git a/crates/parser/src/grammar/items.rs b/crates/parser/src/grammar/items.rs
index 780bc470a..ad29b82f7 100644
--- a/crates/parser/src/grammar/items.rs
+++ b/crates/parser/src/grammar/items.rs
@@ -112,7 +112,7 @@ pub(super) fn maybe_item(p: &mut Parser, m: Marker) -> Result<(), Marker> {
        has_mods = true;
    }
-    if p.at(T![extern]) {
+    if p.at(T![extern]) && p.nth(1) != T!['{'] && (p.nth(1) != STRING || p.nth(2) != T!['{']) {
        has_mods = true;
        abi(p);
    }
@@ -181,6 +181,14 @@ pub(super) fn maybe_item(p: &mut Parser, m: Marker) -> Result<(), Marker> {
        T![type] => {
            type_alias(p, m);
        }
+        // unsafe extern "C" {}
+        T![extern] => {
+            abi(p);
+            extern_item_list(p);
+            m.complete(p, EXTERN_BLOCK);
+        }
        _ => {
            if !has_visibility && !has_mods {
                return Err(m);
diff --git a/crates/proc_macro_srv/Cargo.toml b/crates/proc_macro_srv/Cargo.toml
index 048b32186..729372968 100644
--- a/crates/proc_macro_srv/Cargo.toml
+++ b/crates/proc_macro_srv/Cargo.toml
@@ -20,7 +20,7 @@ proc_macro_api = { path = "../proc_macro_api", version = "0.0.0" }
 test_utils = { path = "../test_utils", version = "0.0.0" }
 [dev-dependencies]
-cargo_metadata = "0.12.0"
+cargo_metadata = "=0.12.0"
 difference = "2.0.0"
 # used as proc macro test targets
diff --git a/crates/project_model/Cargo.toml b/crates/project_model/Cargo.toml
index 2d53bcbcc..e0c591603 100644
--- a/crates/project_model/Cargo.toml
+++ b/crates/project_model/Cargo.toml
@@ -12,7 +12,7 @@ doctest = false
 [dependencies]
 log = "0.4.8"
 rustc-hash = "1.1.0"
-cargo_metadata = "0.12.0"
+cargo_metadata = "=0.12.0"
 serde = { version = "1.0.106", features = ["derive"] }
 serde_json = "1.0.48"
 anyhow = "1.0.26"
diff --git a/crates/rust-analyzer/Cargo.toml b/crates/rust-analyzer/Cargo.toml
index 56c51486f..08559b53a 100644
--- a/crates/rust-analyzer/Cargo.toml
+++ b/crates/rust-analyzer/Cargo.toml
@@ -21,7 +21,7 @@ env_logger = { version = "0.8.1", default-features = false }
 itertools = "0.9.0"
 jod-thread = "0.1.0"
 log = "0.4.8"
-lsp-types = { version = "0.83.1", features = ["proposed"] }
+lsp-types = { version = "0.84.0", features = ["proposed"] }
 parking_lot = "0.11.0"
 pico-args = "0.3.1"
 oorandom = "11.1.2"
@@ -39,6 +39,7 @@ tracing-tree = { version = "0.1.4" }
 stdx = { path = "../stdx", version = "0.0.0" }
 flycheck = { path = "../flycheck", version = "0.0.0" }
 ide = { path = "../ide", version = "0.0.0" }
+ide_db = { path = "../ide_db", version = "0.0.0" }
 profile = { path = "../profile", version = "0.0.0" }
 project_model = { path = "../project_model", version = "0.0.0" }
 syntax = { path = "../syntax", version = "0.0.0" }
@@ -49,7 +50,6 @@ cfg = { path = "../cfg", version = "0.0.0" }
 toolchain = { path = "../toolchain", version = "0.0.0" }
 # This should only be used in CLI
-ide_db = { path = "../ide_db", version = "0.0.0" }
 ssr = { path = "../ssr", version = "0.0.0" }
 hir = { path = "../hir", version = "0.0.0" }
 hir_def = { path = "../hir_def", version = "0.0.0" }
diff --git a/crates/rust-analyzer/src/config.rs b/crates/rust-analyzer/src/config.rs
index 5fc6800cf..59269a74b 100644
--- a/crates/rust-analyzer/src/config.rs
+++ b/crates/rust-analyzer/src/config.rs
@@ -11,10 +11,8 @@ use std::{convert::TryFrom, ffi::OsString, path::PathBuf};
 use flycheck::FlycheckConfig;
 use hir::PrefixKind;
-use ide::{
+use ide::{AssistConfig, CompletionConfig, DiagnosticsConfig, HoverConfig, InlayHintsConfig};
-    AssistConfig, CompletionConfig, DiagnosticsConfig, HoverConfig, InlayHintsConfig,
+use ide_db::helpers::insert_use::MergeBehaviour;
-    MergeBehaviour,
-};
 use lsp_types::{ClientCapabilities, MarkupKind};
 use project_model::{CargoConfig, ProjectJson, ProjectJsonData, ProjectManifest};
 use rustc_hash::FxHashSet;
@@ -184,6 +182,7 @@ impl Config {
            },
            completion: CompletionConfig {
                enable_postfix_completions: true,
+                enable_experimental_completions: true,
                add_call_parenthesis: true,
                add_call_argument_snippets: true,
                ..CompletionConfig::default()
@@ -306,6 +305,7 @@ impl Config {
        };
        self.completion.enable_postfix_completions = data.completion_postfix_enable;
+        self.completion.enable_experimental_completions = data.completion_enableExperimental;
        self.completion.add_call_parenthesis = data.completion_addCallParenthesis;
        self.completion.add_call_argument_snippets = data.completion_addCallArgumentSnippets;
        self.completion.merge = self.assist.insert_use.merge;
@@ -480,7 +480,7 @@ macro_rules! config_data {
 config_data! {
    struct ConfigData {
-        assist_importMergeBehaviour: MergeBehaviourDef = MergeBehaviourDef::None,
+        assist_importMergeBehaviour: MergeBehaviourDef = MergeBehaviourDef::Full,
        assist_importPrefix: ImportPrefixDef           = ImportPrefixDef::Plain,
        callInfo_full: bool = true,
@@ -506,6 +506,7 @@ config_data! {
        completion_addCallArgumentSnippets: bool = true,
        completion_addCallParenthesis: bool      = true,
        completion_postfix_enable: bool          = true,
+        completion_enableExperimental: bool      = true,
        diagnostics_enable: bool                = true,
        diagnostics_enableExperimental: bool    = true,
diff --git a/crates/rust-analyzer/src/main_loop.rs b/crates/rust-analyzer/src/main_loop.rs
index 6ea08adce..f349b0810 100644
--- a/crates/rust-analyzer/src/main_loop.rs
+++ b/crates/rust-analyzer/src/main_loop.rs
@@ -1,7 +1,7 @@
 //! The main loop of `rust-analyzer` responsible for dispatching LSP
 //! requests/replies and notifications back to the client.
 use std::{
-    env, fmt, panic,
+    env, fmt,
    time::{Duration, Instant},
 };
@@ -289,55 +289,69 @@ impl GlobalState {
                    }
                }
            }
-            Event::Flycheck(task) => match task {
+            Event::Flycheck(mut task) => {
-                flycheck::Message::AddDiagnostic { workspace_root, diagnostic } => {
+                let _p = profile::span("GlobalState::handle_event/flycheck");
-                    let diagnostics = crate::diagnostics::to_proto::map_rust_diagnostic_to_lsp(
+                loop {
-                        &self.config.diagnostics_map,
+                    match task {
-                        &diagnostic,
+                        flycheck::Message::AddDiagnostic { workspace_root, diagnostic } => {
-                        &workspace_root,
+                            let diagnostics =
-                    );
+                                crate::diagnostics::to_proto::map_rust_diagnostic_to_lsp(
-                    for diag in diagnostics {
+                                    &self.config.diagnostics_map,
-                        match url_to_file_id(&self.vfs.read().0, &diag.url) {
+                                    &diagnostic,
-                            Ok(file_id) => self.diagnostics.add_check_diagnostic(
+                                    &workspace_root,
-                                file_id,
+                                );
-                                diag.diagnostic,
+                            for diag in diagnostics {
-                                diag.fixes,
+                                match url_to_file_id(&self.vfs.read().0, &diag.url) {
-                            ),
+                                    Ok(file_id) => self.diagnostics.add_check_diagnostic(
-                            Err(err) => {
+                                        file_id,
-                                log::error!("File with cargo diagnostic not found in VFS: {}", err);
+                                        diag.diagnostic,
-                            }
+                                        diag.fixes,
-                        };
+                                    ),
-                    }
+                                    Err(err) => {
-                }
+                                        log::error!(
+                                            "File with cargo diagnostic not found in VFS: {}",
-                flycheck::Message::Progress { id, progress } => {
+                                            err
-                    let (state, message) = match progress {
+                                        );
-                        flycheck::Progress::DidStart => {
+                                    }
-                            self.diagnostics.clear_check();
+                                };
-                            (Progress::Begin, None)
-                        }
-                        flycheck::Progress::DidCheckCrate(target) => {
-                            (Progress::Report, Some(target))
-                        }
-                        flycheck::Progress::DidCancel => (Progress::End, None),
-                        flycheck::Progress::DidFinish(result) => {
-                            if let Err(err) = result {
-                                log::error!("cargo check failed: {}", err)
                            }
-                            (Progress::End, None)
                        }
-                    };
-                    // When we're running multiple flychecks, we have to include a disambiguator in
+                        flycheck::Message::Progress { id, progress } => {
-                    // the title, or the editor complains. Note that this is a user-facing string.
+                            let (state, message) = match progress {
-                    let title = if self.flycheck.len() == 1 {
+                                flycheck::Progress::DidStart => {
-                        "cargo check".to_string()
+                                    self.diagnostics.clear_check();
-                    } else {
+                                    (Progress::Begin, None)
-                        format!("cargo check (#{})", id + 1)
+                                }
-                    };
+                                flycheck::Progress::DidCheckCrate(target) => {
-                    self.report_progress(&title, state, message, None);
+                                    (Progress::Report, Some(target))
+                                }
+                                flycheck::Progress::DidCancel => (Progress::End, None),
+                                flycheck::Progress::DidFinish(result) => {
+                                    if let Err(err) = result {
+                                        log::error!("cargo check failed: {}", err)
+                                    }
+                                    (Progress::End, None)
+                                }
+                            };
+                            // When we're running multiple flychecks, we have to include a disambiguator in
+                            // the title, or the editor complains. Note that this is a user-facing string.
+                            let title = if self.flycheck.len() == 1 {
+                                "cargo check".to_string()
+                            } else {
+                                format!("cargo check (#{})", id + 1)
+                            };
+                            self.report_progress(&title, state, message, None);
+                        }
+                    }
+                    // Coalesce many flycheck updates into a single loop turn
+                    task = match self.flycheck_receiver.try_recv() {
+                        Ok(task) => task,
+                        Err(_) => break,
+                    }
                }
-            },
+            }
        }
        let state_changed = self.process_changes();
@@ -348,13 +362,7 @@ impl GlobalState {
        }
        if self.status == Status::Ready && (state_changed || prev_status == Status::Loading) {
-            let subscriptions = self
+            self.update_file_notifications_on_threadpool();
-                .mem_docs
-                .keys()
-                .map(|path| self.vfs.read().0.file_id(&path).unwrap())
-                .collect::<Vec<_>>();
-            self.update_file_notifications_on_threadpool(subscriptions);
            // Refresh semantic tokens if the client supports it.
            if self.config.semantic_tokens_refresh {
@@ -498,12 +506,19 @@ impl GlobalState {
                        .write()
                        .0
                        .set_file_contents(path, Some(params.text_document.text.into_bytes()));
+                    this.update_file_notifications_on_threadpool();
                }
                Ok(())
            })?
            .on::<lsp_types::notification::DidChangeTextDocument>(|this, params| {
                if let Ok(path) = from_proto::vfs_path(&params.text_document.uri) {
-                    let doc = this.mem_docs.get_mut(&path).unwrap();
+                    let doc = match this.mem_docs.get_mut(&path) {
+                        Some(doc) => doc,
+                        None => {
+                            log::error!("expected DidChangeTextDocument: {}", path);
+                            return Ok(());
+                        }
+                    };
                    let vfs = &mut this.vfs.write().0;
                    let file_id = vfs.file_id(&path).unwrap();
                    let mut text = String::from_utf8(vfs.file_contents(file_id).to_vec()).unwrap();
@@ -600,7 +615,13 @@ impl GlobalState {
            .finish();
        Ok(())
    }
-    fn update_file_notifications_on_threadpool(&mut self, subscriptions: Vec<FileId>) {
+    fn update_file_notifications_on_threadpool(&mut self) {
+        let subscriptions = self
+            .mem_docs
+            .keys()
+            .map(|path| self.vfs.read().0.file_id(&path).unwrap())
+            .collect::<Vec<_>>();
        log::trace!("updating notifications for {:?}", subscriptions);
        if self.config.publish_diagnostics {
            let snapshot = self.snapshot();
diff --git a/crates/rust-analyzer/src/reload.rs b/crates/rust-analyzer/src/reload.rs
index 001bf5949..b2d35f535 100644
--- a/crates/rust-analyzer/src/reload.rs
+++ b/crates/rust-analyzer/src/reload.rs
@@ -205,7 +205,7 @@ impl GlobalState {
                }
                let res = vfs.file_id(&vfs_path);
                if res.is_none() {
-                    log::error!("failed to load {}", path.display())
+                    log::warn!("failed to load {}", path.display())
                }
                res
            };
diff --git a/crates/rust-analyzer/src/to_proto.rs b/crates/rust-analyzer/src/to_proto.rs
index 2f35425bb..2052b800c 100644
--- a/crates/rust-analyzer/src/to_proto.rs
+++ b/crates/rust-analyzer/src/to_proto.rs
@@ -629,12 +629,21 @@ pub(crate) fn resource_op(
    match file_system_edit {
        FileSystemEdit::CreateFile { anchor, dst } => {
            let uri = snap.anchored_path(anchor, &dst);
-            lsp_types::ResourceOp::Create(lsp_types::CreateFile { uri, options: None })
+            lsp_types::ResourceOp::Create(lsp_types::CreateFile {
+                uri,
+                options: None,
+                annotation: None,
+            })
        }
        FileSystemEdit::MoveFile { src, anchor, dst } => {
            let old_uri = snap.file_id_to_url(src);
            let new_uri = snap.anchored_path(anchor, &dst);
-            lsp_types::ResourceOp::Rename(lsp_types::RenameFile { old_uri, new_uri, options: None })
+            lsp_types::ResourceOp::Rename(lsp_types::RenameFile {
+                old_uri,
+                new_uri,
+                options: None,
+                annotation: None,
+            })
        }
    }
 }
@@ -684,9 +693,11 @@ impl From<lsp_ext::SnippetWorkspaceEdit> for lsp_types::WorkspaceEdit {
                                        edits: edit
                                            .edits
                                            .into_iter()
-                                            .map(|edit| lsp_types::TextEdit {
+                                            .map(|edit| {
-                                                range: edit.range,
+                                                lsp_types::OneOf::Left(lsp_types::TextEdit {
-                                                new_text: edit.new_text,
+                                                    range: edit.range,
+                                                    new_text: edit.new_text,
+                                                })
                                            })
                                            .collect(),
                                    },
diff --git a/crates/syntax/Cargo.toml b/crates/syntax/Cargo.toml
index 1fe907753..ce62babc3 100644
--- a/crates/syntax/Cargo.toml
+++ b/crates/syntax/Cargo.toml
@@ -28,6 +28,7 @@ stdx = { path = "../stdx", version = "0.0.0" }
 text_edit = { path = "../text_edit", version = "0.0.0" }
 parser = { path = "../parser", version = "0.0.0" }
 test_utils = { path = "../test_utils", version = "0.0.0" }
+profile = { path = "../profile", version = "0.0.0" }
 [dev-dependencies]
 walkdir = "2.3.1"
diff --git a/crates/syntax/src/algo.rs b/crates/syntax/src/algo.rs
index 320c430c9..ee89d9867 100644
--- a/crates/syntax/src/algo.rs
+++ b/crates/syntax/src/algo.rs
@@ -127,6 +127,8 @@ pub struct TreeDiff {
 impl TreeDiff {
    pub fn into_text_edit(&self, builder: &mut TextEditBuilder) {
+        let _p = profile::span("into_text_edit");
        for (anchor, to) in self.insertions.iter() {
            let offset = match anchor {
                TreeDiffInsertPos::After(it) => it.text_range().end(),
@@ -154,6 +156,8 @@ impl TreeDiff {
 ///
 /// This function tries to find a fine-grained diff.
 pub fn diff(from: &SyntaxNode, to: &SyntaxNode) -> TreeDiff {
+    let _p = profile::span("diff");
    let mut diff = TreeDiff {
        replacements: FxHashMap::default(),
        insertions: FxIndexMap::default(),
@@ -467,6 +471,8 @@ impl<'a> SyntaxRewriter<'a> {
    }
    pub fn rewrite(&self, node: &SyntaxNode) -> SyntaxNode {
+        let _p = profile::span("rewrite");
        if self.f.is_none() && self.replacements.is_empty() && self.insertions.is_empty() {
            return node.clone();
        }
@@ -483,6 +489,7 @@ impl<'a> SyntaxRewriter<'a> {
    ///
    /// Returns `None` when there are no replacements.
    pub fn rewrite_root(&self) -> Option<SyntaxNode> {
+        let _p = profile::span("rewrite_root");
        fn element_to_node_or_parent(element: &SyntaxElement) -> SyntaxNode {
            match element {
                SyntaxElement::Node(it) => it.clone(),
@@ -517,6 +524,8 @@ impl<'a> SyntaxRewriter<'a> {
    }
    fn rewrite_children(&self, node: &SyntaxNode) -> SyntaxNode {
+        let _p = profile::span("rewrite_children");
        //  FIXME: this could be made much faster.
        let mut new_children = Vec::new();
        if let Some(elements) = self.insertions(&InsertPos::FirstChildOf(node.clone())) {
@@ -533,6 +542,8 @@ impl<'a> SyntaxRewriter<'a> {
        acc: &mut Vec<NodeOrToken<rowan::GreenNode, rowan::GreenToken>>,
        element: &SyntaxElement,
    ) {
+        let _p = profile::span("rewrite_self");
        if let Some(replacement) = self.replacement(&element) {
            match replacement {
                Replacement::Single(element) => acc.push(element_to_green(element)),
@@ -588,6 +599,8 @@ fn with_children(
    parent: &SyntaxNode,
    new_children: Vec<NodeOrToken<rowan::GreenNode, rowan::GreenToken>>,
 ) -> SyntaxNode {
+    let _p = profile::span("with_children");
    let len = new_children.iter().map(|it| it.text_len()).sum::<TextSize>();
    let new_node = rowan::GreenNode::new(rowan::SyntaxKind(parent.kind() as u16), new_children);
    let new_root_node = parent.replace_with(new_node);
diff --git a/crates/syntax/src/ast/token_ext.rs b/crates/syntax/src/ast/token_ext.rs
index ac0326420..b985861f2 100644
--- a/crates/syntax/src/ast/token_ext.rs
+++ b/crates/syntax/src/ast/token_ext.rs
@@ -130,19 +130,28 @@ impl ast::String {
        let text = self.text().as_str();
        let text = &text[self.text_range_between_quotes()? - self.syntax().text_range().start()];
-        let mut buf = String::with_capacity(text.len());
+        let mut buf = String::new();
+        let mut text_iter = text.chars();
        let mut has_error = false;
-        unescape_literal(text, Mode::Str, &mut |_, unescaped_char| match unescaped_char {
+        unescape_literal(text, Mode::Str, &mut |char_range, unescaped_char| match (
-            Ok(c) => buf.push(c),
+            unescaped_char,
-            Err(_) => has_error = true,
+            buf.capacity() == 0,
+        ) {
+            (Ok(c), false) => buf.push(c),
+            (Ok(c), true) if Some(c) == text_iter.next() => (),
+            (Ok(c), true) => {
+                buf.reserve_exact(text.len());
+                buf.push_str(&text[..char_range.start]);
+                buf.push(c);
+            }
+            (Err(_), _) => has_error = true,
        });
-        if has_error {
+        match (has_error, buf.capacity() == 0) {
-            return None;
+            (true, _) => None,
+            (false, true) => Some(Cow::Borrowed(text)),
+            (false, false) => Some(Cow::Owned(buf)),
        }
-        // FIXME: don't actually allocate for borrowed case
-        let res = if buf == text { Cow::Borrowed(text) } else { Cow::Owned(buf) };
-        Some(res)
    }
    pub fn quote_offsets(&self) -> Option<QuoteOffsets> {
diff --git a/crates/syntax/test_data/parser/ok/0068_item_modifiers.rast b/crates/syntax/test_data/parser/ok/0068_item_modifiers.rast
index 50a6d8ee9..87eebf185 100644
--- a/crates/syntax/test_data/parser/ok/0068_item_modifiers.rast
+++ b/crates/syntax/test_data/parser/ok/0068_item_modifiers.rast
@@ -1,4 +1,4 @@
-[email protected]04
+[email protected]28
  [email protected]
    [email protected] "async"
    [email protected] " "
@@ -215,4 +215,16 @@ [email protected]
    [email protected]
      [email protected] "{"
      [email protected] "}"
-  [email protected] "\n"
+  [email protected] "\n\n"
+  [email protected]
+    [email protected] "unsafe"
+    [email protected] " "
+    [email protected]
+      [email protected] "extern"
+      [email protected] " "
+      [email protected] "\"C++\""
+    [email protected] " "
+    [email protected]
+      [email protected] "{"
+      [email protected] "}"
+  [email protected] "\n"
diff --git a/crates/syntax/test_data/parser/ok/0068_item_modifiers.rs b/crates/syntax/test_data/parser/ok/0068_item_modifiers.rs
index 8d697c04b..6d27a082c 100644
--- a/crates/syntax/test_data/parser/ok/0068_item_modifiers.rs
+++ b/crates/syntax/test_data/parser/ok/0068_item_modifiers.rs
@@ -14,3 +14,5 @@ unsafe auto trait T {}
 unsafe impl Foo {}
 default impl Foo {}
 unsafe default impl Foo {}
+unsafe extern "C++" {}
diff --git a/crates/tt/src/lib.rs b/crates/tt/src/lib.rs
index 20c3f5eab..6c1bf8d09 100644
--- a/crates/tt/src/lib.rs
+++ b/crates/tt/src/lib.rs
@@ -1,10 +1,7 @@
 //! `tt` crate defines a `TokenTree` data structure: this is the interface (both
 //! input and output) of macros. It closely mirrors `proc_macro` crate's
 //! `TokenTree`.
-use std::{
+use std::{fmt, panic::RefUnwindSafe};
-    fmt::{self, Debug},
-    panic::RefUnwindSafe,
-};
 use stdx::impl_from;
@@ -139,7 +136,7 @@ fn print_debug_token(f: &mut fmt::Formatter<'_>, tkn: &TokenTree, level: usize)
    Ok(())
 }
-impl Debug for Subtree {
+impl fmt::Debug for Subtree {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        print_debug_subtree(f, self, 0)
    }
@@ -240,7 +237,18 @@ pub enum ExpansionError {
    ExpansionError(String),
 }
-pub trait TokenExpander: Debug + Send + Sync + RefUnwindSafe {
+impl fmt::Display for ExpansionError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            ExpansionError::IOError(e) => write!(f, "I/O error: {}", e),
+            ExpansionError::JsonError(e) => write!(f, "JSON decoding error: {}", e),
+            ExpansionError::Unknown(e) => e.fmt(f),
+            ExpansionError::ExpansionError(e) => write!(f, "proc macro returned error: {}", e),
+        }
+    }
+}
+pub trait TokenExpander: fmt::Debug + Send + Sync + RefUnwindSafe {
    fn expand(&self, subtree: &Subtree, attrs: Option<&Subtree>)
        -> Result<Subtree, ExpansionError>;
 }