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},
+};