124 files changed, 4286 insertions, 2535 deletions
diff --git a/Cargo.lock b/Cargo.lock
index ca519a474..15ccf4146 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -636,6 +636,7 @@ dependencies = [
 "ide_db",
 "itertools",
 "log",
+ "once_cell",
 "profile",
 "rustc-hash",
 "stdx",
diff --git a/crates/base_db/src/fixture.rs b/crates/base_db/src/fixture.rs
index 0132565e4..69ceba735 100644
--- a/crates/base_db/src/fixture.rs
+++ b/crates/base_db/src/fixture.rs
@@ -34,19 +34,13 @@ pub trait WithFixture: Default + SourceDatabaseExt + 'static {
    fn with_position(ra_fixture: &str) -> (Self, FilePosition) {
        let (db, file_id, range_or_offset) = Self::with_range_or_offset(ra_fixture);
-        let offset = match range_or_offset {
+        let offset = range_or_offset.expect_offset();
-            RangeOrOffset::Range(_) => panic!("Expected a cursor position, got a range instead"),
-            RangeOrOffset::Offset(it) => it,
-        };
        (db, FilePosition { file_id, offset })
    }
    fn with_range(ra_fixture: &str) -> (Self, FileRange) {
        let (db, file_id, range_or_offset) = Self::with_range_or_offset(ra_fixture);
-        let range = match range_or_offset {
+        let range = range_or_offset.expect_range();
-            RangeOrOffset::Range(it) => it,
-            RangeOrOffset::Offset(_) => panic!("Expected a cursor range, got a position instead"),
-        };
        (db, FileRange { file_id, range })
    }
diff --git a/crates/base_db/src/input.rs b/crates/base_db/src/input.rs
index 0ef77ef5d..23cb0c839 100644
--- a/crates/base_db/src/input.rs
+++ b/crates/base_db/src/input.rs
@@ -53,11 +53,15 @@ impl SourceRoot {
 }
 /// `CrateGraph` is a bit of information which turns a set of text files into a
-/// number of Rust crates. Each crate is defined by the `FileId` of its root module,
+/// number of Rust crates.
-/// the set of cfg flags (not yet implemented) and the set of dependencies. Note
+///
-/// that, due to cfg's, there might be several crates for a single `FileId`! As
+/// Each crate is defined by the `FileId` of its root module, the set of enabled
-/// in the rust-lang proper, a crate does not have a name. Instead, names are
+/// `cfg` flags and the set of dependencies.
-/// specified on dependency edges. That is, a crate might be known under
+///
+/// Note that, due to cfg's, there might be several crates for a single `FileId`!
+///
+/// For the purposes of analysis, a crate does not have a name. Instead, names
+/// are specified on dependency edges. That is, a crate might be known under
 /// different names in different dependent crates.
 ///
 /// Note that `CrateGraph` is build-system agnostic: it's a concept of the Rust
@@ -143,7 +147,7 @@ impl CrateDisplayName {
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 pub struct ProcMacroId(pub u32);
-#[derive(Copy, Clone, Eq, PartialEq, Debug)]
+#[derive(Copy, Clone, Eq, PartialEq, Debug, Hash)]
 pub enum ProcMacroKind {
    CustomDerive,
    FuncLike,
diff --git a/crates/hir/src/diagnostics.rs b/crates/hir/src/diagnostics.rs
index 414c3f35e..22ec7c6ac 100644
--- a/crates/hir/src/diagnostics.rs
+++ b/crates/hir/src/diagnostics.rs
@@ -3,13 +3,227 @@
 //!
 //! This probably isn't the best way to do this -- ideally, diagnistics should
 //! be expressed in terms of hir types themselves.
-pub use hir_def::diagnostics::{
+use std::any::Any;
-    InactiveCode, UnresolvedMacroCall, UnresolvedModule, UnresolvedProcMacro,
-};
+use cfg::{CfgExpr, CfgOptions, DnfExpr};
-pub use hir_expand::diagnostics::{
+use hir_def::path::ModPath;
-    Diagnostic, DiagnosticCode, DiagnosticSink, DiagnosticSinkBuilder,
+use hir_expand::{HirFileId, InFile};
-};
+use stdx::format_to;
-pub use hir_ty::diagnostics::{
+use syntax::{ast, AstPtr, SyntaxNodePtr, TextRange};
-    IncorrectCase, MismatchedArgCount, MissingFields, MissingMatchArms, MissingOkOrSomeInTailExpr,
-    NoSuchField, RemoveThisSemicolon, ReplaceFilterMapNextWithFindMap,
+pub use hir_ty::{
+    diagnostics::{
+        IncorrectCase, MismatchedArgCount, MissingFields, MissingMatchArms,
+        MissingOkOrSomeInTailExpr, NoSuchField, RemoveThisSemicolon,
+        ReplaceFilterMapNextWithFindMap,
+    },
+    diagnostics_sink::{Diagnostic, DiagnosticCode, DiagnosticSink, DiagnosticSinkBuilder},
 };
+// Diagnostic: unresolved-module
+//
+// This diagnostic is triggered if rust-analyzer is unable to discover referred module.
+#[derive(Debug)]
+pub struct UnresolvedModule {
+    pub file: HirFileId,
+    pub decl: AstPtr<ast::Module>,
+    pub candidate: String,
+}
+impl Diagnostic for UnresolvedModule {
+    fn code(&self) -> DiagnosticCode {
+        DiagnosticCode("unresolved-module")
+    }
+    fn message(&self) -> String {
+        "unresolved module".to_string()
+    }
+    fn display_source(&self) -> InFile<SyntaxNodePtr> {
+        InFile::new(self.file, self.decl.clone().into())
+    }
+    fn as_any(&self) -> &(dyn Any + Send + 'static) {
+        self
+    }
+}
+// Diagnostic: unresolved-extern-crate
+//
+// This diagnostic is triggered if rust-analyzer is unable to discover referred extern crate.
+#[derive(Debug)]
+pub struct UnresolvedExternCrate {
+    pub file: HirFileId,
+    pub item: AstPtr<ast::ExternCrate>,
+}
+impl Diagnostic for UnresolvedExternCrate {
+    fn code(&self) -> DiagnosticCode {
+        DiagnosticCode("unresolved-extern-crate")
+    }
+    fn message(&self) -> String {
+        "unresolved extern crate".to_string()
+    }
+    fn display_source(&self) -> InFile<SyntaxNodePtr> {
+        InFile::new(self.file, self.item.clone().into())
+    }
+    fn as_any(&self) -> &(dyn Any + Send + 'static) {
+        self
+    }
+}
+#[derive(Debug)]
+pub struct UnresolvedImport {
+    pub file: HirFileId,
+    pub node: AstPtr<ast::UseTree>,
+}
+impl Diagnostic for UnresolvedImport {
+    fn code(&self) -> DiagnosticCode {
+        DiagnosticCode("unresolved-import")
+    }
+    fn message(&self) -> String {
+        "unresolved import".to_string()
+    }
+    fn display_source(&self) -> InFile<SyntaxNodePtr> {
+        InFile::new(self.file, self.node.clone().into())
+    }
+    fn as_any(&self) -> &(dyn Any + Send + 'static) {
+        self
+    }
+    fn is_experimental(&self) -> bool {
+        // This currently results in false positives in the following cases:
+        // - `cfg_if!`-generated code in libstd (we don't load the sysroot correctly)
+        // - `core::arch` (we don't handle `#[path = "../<path>"]` correctly)
+        // - proc macros and/or proc macro generated code
+        true
+    }
+}
+// Diagnostic: unresolved-macro-call
+//
+// This diagnostic is triggered if rust-analyzer is unable to resolve the path to a
+// macro in a macro invocation.
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct UnresolvedMacroCall {
+    pub file: HirFileId,
+    pub node: AstPtr<ast::MacroCall>,
+    pub path: ModPath,
+}
+impl Diagnostic for UnresolvedMacroCall {
+    fn code(&self) -> DiagnosticCode {
+        DiagnosticCode("unresolved-macro-call")
+    }
+    fn message(&self) -> String {
+        format!("unresolved macro `{}!`", self.path)
+    }
+    fn display_source(&self) -> InFile<SyntaxNodePtr> {
+        InFile::new(self.file, self.node.clone().into())
+    }
+    fn as_any(&self) -> &(dyn Any + Send + 'static) {
+        self
+    }
+    fn is_experimental(&self) -> bool {
+        true
+    }
+}
+// Diagnostic: inactive-code
+//
+// This diagnostic is shown for code with inactive `#[cfg]` attributes.
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct InactiveCode {
+    pub file: HirFileId,
+    pub node: SyntaxNodePtr,
+    pub cfg: CfgExpr,
+    pub opts: CfgOptions,
+}
+impl Diagnostic for InactiveCode {
+    fn code(&self) -> DiagnosticCode {
+        DiagnosticCode("inactive-code")
+    }
+    fn message(&self) -> String {
+        let inactive = DnfExpr::new(self.cfg.clone()).why_inactive(&self.opts);
+        let mut buf = "code is inactive due to #[cfg] directives".to_string();
+        if let Some(inactive) = inactive {
+            format_to!(buf, ": {}", inactive);
+        }
+        buf
+    }
+    fn display_source(&self) -> InFile<SyntaxNodePtr> {
+        InFile::new(self.file, self.node.clone())
+    }
+    fn as_any(&self) -> &(dyn Any + Send + 'static) {
+        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.
+//
+// If you are seeing a lot of "proc macro not expanded" warnings, you can add this option to the
+// `rust-analyzer.diagnostics.disabled` list to prevent them from showing. Alternatively you can
+// enable support for procedural macros (see `rust-analyzer.procMacro.enable`).
+#[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/src/display.rs b/crates/hir/src/display.rs
index 508ac37c2..72f0d9b5f 100644
--- a/crates/hir/src/display.rs
+++ b/crates/hir/src/display.rs
@@ -92,7 +92,7 @@ impl HirDisplay for Function {
            &data.ret_type
        } else {
            match &*data.ret_type {
-                TypeRef::ImplTrait(bounds) => match &bounds[0] {
+                TypeRef::ImplTrait(bounds) => match bounds[0].as_ref() {
                    TypeBound::Path(path) => {
                        path.segments().iter().last().unwrap().args_and_bindings.unwrap().bindings
                            [0]
@@ -427,10 +427,6 @@ impl HirDisplay for Trait {
        write!(f, "trait {}", data.name)?;
        let def_id = GenericDefId::TraitId(self.id);
        write_generic_params(def_id, f)?;
-        if !data.bounds.is_empty() {
-            write!(f, ": ")?;
-            f.write_joined(&*data.bounds, " + ")?;
-        }
        write_where_clause(def_id, f)?;
        Ok(())
    }
diff --git a/crates/hir/src/lib.rs b/crates/hir/src/lib.rs
index ca9a7f7fa..975ae4869 100644
--- a/crates/hir/src/lib.rs
+++ b/crates/hir/src/lib.rs
@@ -35,12 +35,18 @@ use std::{iter, sync::Arc};
 use arrayvec::ArrayVec;
 use base_db::{CrateDisplayName, CrateId, Edition, FileId};
+use diagnostics::{
+    InactiveCode, MacroError, UnresolvedExternCrate, UnresolvedImport, UnresolvedMacroCall,
+    UnresolvedModule, UnresolvedProcMacro,
+};
 use either::Either;
 use hir_def::{
    adt::{ReprKind, VariantData},
+    body::BodyDiagnostic,
    expr::{BindingAnnotation, LabelId, Pat, PatId},
    item_tree::ItemTreeNode,
    lang_item::LangItemTarget,
+    nameres,
    per_ns::PerNs,
    resolver::{HasResolver, Resolver},
    src::HasSource as _,
@@ -50,11 +56,12 @@ use hir_def::{
    LocalEnumVariantId, LocalFieldId, Lookup, ModuleId, StaticId, StructId, TraitId, TypeAliasId,
    TypeParamId, UnionId,
 };
-use hir_expand::{diagnostics::DiagnosticSink, name::name, MacroDefKind};
+use hir_expand::{name::name, MacroCallKind, MacroDefKind};
 use hir_ty::{
    autoderef,
    consteval::ConstExt,
    could_unify,
+    diagnostics_sink::DiagnosticSink,
    method_resolution::{self, def_crates, TyFingerprint},
    primitive::UintTy,
    subst_prefix,
@@ -65,11 +72,12 @@ use hir_ty::{
    WhereClause,
 };
 use itertools::Itertools;
+use nameres::diagnostics::DefDiagnosticKind;
 use rustc_hash::FxHashSet;
 use stdx::{format_to, impl_from};
 use syntax::{
    ast::{self, AttrsOwner, NameOwner},
-    AstNode, SmolStr,
+    AstNode, AstPtr, SmolStr, SyntaxKind, SyntaxNodePtr,
 };
 use tt::{Ident, Leaf, Literal, TokenTree};
@@ -442,7 +450,123 @@ impl Module {
            format!("{:?}", self.name(db).map_or("<unknown>".into(), |name| name.to_string()))
        });
        let def_map = self.id.def_map(db.upcast());
-        def_map.add_diagnostics(db.upcast(), self.id.local_id, sink);
+        for diag in def_map.diagnostics() {
+            if diag.in_module != self.id.local_id {
+                // FIXME: This is accidentally quadratic.
+                continue;
+            }
+            match &diag.kind {
+                DefDiagnosticKind::UnresolvedModule { ast: declaration, candidate } => {
+                    let decl = declaration.to_node(db.upcast());
+                    sink.push(UnresolvedModule {
+                        file: declaration.file_id,
+                        decl: AstPtr::new(&decl),
+                        candidate: candidate.clone(),
+                    })
+                }
+                DefDiagnosticKind::UnresolvedExternCrate { ast } => {
+                    let item = ast.to_node(db.upcast());
+                    sink.push(UnresolvedExternCrate {
+                        file: ast.file_id,
+                        item: AstPtr::new(&item),
+                    });
+                }
+                DefDiagnosticKind::UnresolvedImport { id, index } => {
+                    let file_id = id.file_id();
+                    let item_tree = id.item_tree(db.upcast());
+                    let import = &item_tree[id.value];
+                    let use_tree = import.use_tree_to_ast(db.upcast(), file_id, *index);
+                    sink.push(UnresolvedImport { file: file_id, node: AstPtr::new(&use_tree) });
+                }
+                DefDiagnosticKind::UnconfiguredCode { ast, cfg, opts } => {
+                    let item = ast.to_node(db.upcast());
+                    sink.push(InactiveCode {
+                        file: ast.file_id,
+                        node: AstPtr::new(&item).into(),
+                        cfg: cfg.clone(),
+                        opts: opts.clone(),
+                    });
+                }
+                DefDiagnosticKind::UnresolvedProcMacro { ast } => {
+                    let mut precise_location = None;
+                    let (file, ast, name) = match ast {
+                        MacroCallKind::FnLike { ast_id, .. } => {
+                            let node = ast_id.to_node(db.upcast());
+                            (ast_id.file_id, SyntaxNodePtr::from(AstPtr::new(&node)), None)
+                        }
+                        MacroCallKind::Derive { ast_id, derive_name, .. } => {
+                            let node = ast_id.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.text() == derive_name.as_str()
+                                    {
+                                        precise_location = Some(token.text_range());
+                                        break 'outer;
+                                    }
+                                }
+                            }
+                            (
+                                ast_id.file_id,
+                                SyntaxNodePtr::from(AstPtr::new(&node)),
+                                Some(derive_name.clone()),
+                            )
+                        }
+                    };
+                    sink.push(UnresolvedProcMacro {
+                        file,
+                        node: ast,
+                        precise_location,
+                        macro_name: name,
+                    });
+                }
+                DefDiagnosticKind::UnresolvedMacroCall { ast, path } => {
+                    let node = ast.to_node(db.upcast());
+                    sink.push(UnresolvedMacroCall {
+                        file: ast.file_id,
+                        node: AstPtr::new(&node),
+                        path: path.clone(),
+                    });
+                }
+                DefDiagnosticKind::MacroError { ast, message } => {
+                    let (file, ast) = match ast {
+                        MacroCallKind::FnLike { ast_id, .. } => {
+                            let node = ast_id.to_node(db.upcast());
+                            (ast_id.file_id, SyntaxNodePtr::from(AstPtr::new(&node)))
+                        }
+                        MacroCallKind::Derive { ast_id, .. } => {
+                            let node = ast_id.to_node(db.upcast());
+                            (ast_id.file_id, SyntaxNodePtr::from(AstPtr::new(&node)))
+                        }
+                    };
+                    sink.push(MacroError { file, node: ast, message: message.clone() });
+                }
+            }
+        }
        for decl in self.declarations(db) {
            match decl {
                crate::ModuleDef::Function(f) => f.diagnostics(db, sink),
@@ -551,10 +675,6 @@ impl Struct {
        Module { id: self.id.lookup(db.upcast()).container }
    }
-    pub fn krate(self, db: &dyn HirDatabase) -> Option<Crate> {
-        Some(self.module(db).krate())
-    }
    pub fn name(self, db: &dyn HirDatabase) -> Name {
        db.struct_data(self.id).name.clone()
    }
@@ -639,10 +759,6 @@ impl Enum {
        Module { id: self.id.lookup(db.upcast()).container }
    }
-    pub fn krate(self, db: &dyn HirDatabase) -> Option<Crate> {
-        Some(self.module(db).krate())
-    }
    pub fn name(self, db: &dyn HirDatabase) -> Name {
        db.enum_data(self.id).name.clone()
    }
@@ -672,6 +788,7 @@ impl Variant {
    pub fn module(self, db: &dyn HirDatabase) -> Module {
        self.parent.module(db)
    }
    pub fn parent_enum(self, _db: &dyn HirDatabase) -> Enum {
        self.parent
    }
@@ -728,10 +845,6 @@ impl Adt {
        }
    }
-    pub fn krate(self, db: &dyn HirDatabase) -> Crate {
-        self.module(db).krate()
-    }
    pub fn name(self, db: &dyn HirDatabase) -> Name {
        match self {
            Adt::Struct(s) => s.name(db),
@@ -820,10 +933,6 @@ impl Function {
        self.id.lookup(db.upcast()).module(db.upcast()).into()
    }
-    pub fn krate(self, db: &dyn HirDatabase) -> Option<Crate> {
-        Some(self.module(db).krate())
-    }
    pub fn name(self, db: &dyn HirDatabase) -> Name {
        db.function_data(self.id).name.clone()
    }
@@ -880,7 +989,37 @@ impl Function {
    pub fn diagnostics(self, db: &dyn HirDatabase, sink: &mut DiagnosticSink) {
        let krate = self.module(db).id.krate();
-        hir_def::diagnostics::validate_body(db.upcast(), self.id.into(), sink);
+        let source_map = db.body_with_source_map(self.id.into()).1;
+        for diag in source_map.diagnostics() {
+            match diag {
+                BodyDiagnostic::InactiveCode { node, cfg, opts } => sink.push(InactiveCode {
+                    file: node.file_id,
+                    node: node.value.clone(),
+                    cfg: cfg.clone(),
+                    opts: opts.clone(),
+                }),
+                BodyDiagnostic::MacroError { node, message } => sink.push(MacroError {
+                    file: node.file_id,
+                    node: node.value.clone().into(),
+                    message: message.to_string(),
+                }),
+                BodyDiagnostic::UnresolvedProcMacro { node } => sink.push(UnresolvedProcMacro {
+                    file: node.file_id,
+                    node: node.value.clone().into(),
+                    precise_location: None,
+                    macro_name: None,
+                }),
+                BodyDiagnostic::UnresolvedMacroCall { node, path } => {
+                    sink.push(UnresolvedMacroCall {
+                        file: node.file_id,
+                        node: node.value.clone(),
+                        path: path.clone(),
+                    })
+                }
+            }
+        }
        hir_ty::diagnostics::validate_module_item(db, krate, self.id.into(), sink);
        hir_ty::diagnostics::validate_body(db, self.id.into(), sink);
    }
@@ -1013,10 +1152,6 @@ impl Const {
        Module { id: self.id.lookup(db.upcast()).module(db.upcast()) }
    }
-    pub fn krate(self, db: &dyn HirDatabase) -> Option<Crate> {
-        Some(self.module(db).krate())
-    }
    pub fn name(self, db: &dyn HirDatabase) -> Option<Name> {
        db.const_data(self.id).name.clone()
    }
@@ -1044,10 +1179,6 @@ impl Static {
        Module { id: self.id.lookup(db.upcast()).module(db.upcast()) }
    }
-    pub fn krate(self, db: &dyn HirDatabase) -> Option<Crate> {
-        Some(self.module(db).krate())
-    }
    pub fn name(self, db: &dyn HirDatabase) -> Option<Name> {
        db.static_data(self.id).name.clone()
    }
@@ -1111,10 +1242,6 @@ impl TypeAlias {
        Module { id: self.id.lookup(db.upcast()).module(db.upcast()) }
    }
-    pub fn krate(self, db: &dyn HirDatabase) -> Crate {
-        self.module(db).krate()
-    }
    pub fn type_ref(self, db: &dyn HirDatabase) -> Option<TypeRef> {
        db.type_alias_data(self.id).type_ref.as_deref().cloned()
    }
@@ -1155,10 +1282,16 @@ impl BuiltinType {
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub enum MacroKind {
+    /// `macro_rules!` or Macros 2.0 macro.
    Declarative,
-    ProcMacro,
+    /// A built-in or custom derive.
    Derive,
+    /// A built-in function-like macro.
    BuiltIn,
+    /// A procedural attribute macro.
+    Attr,
+    /// A function-like procedural macro.
+    ProcMacro,
 }
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
@@ -1188,11 +1321,13 @@ impl MacroDef {
    pub fn kind(&self) -> MacroKind {
        match self.id.kind {
            MacroDefKind::Declarative(_) => MacroKind::Declarative,
-            MacroDefKind::BuiltIn(_, _) => MacroKind::BuiltIn,
+            MacroDefKind::BuiltIn(_, _) | MacroDefKind::BuiltInEager(_, _) => MacroKind::BuiltIn,
            MacroDefKind::BuiltInDerive(_, _) => MacroKind::Derive,
-            MacroDefKind::BuiltInEager(_, _) => MacroKind::BuiltIn,
+            MacroDefKind::ProcMacro(_, base_db::ProcMacroKind::CustomDerive, _) => {
-            // FIXME might be a derive
+                MacroKind::Derive
-            MacroDefKind::ProcMacro(_, _) => MacroKind::ProcMacro,
+            }
+            MacroDefKind::ProcMacro(_, base_db::ProcMacroKind::Attr, _) => MacroKind::Attr,
+            MacroDefKind::ProcMacro(_, base_db::ProcMacroKind::FuncLike, _) => MacroKind::ProcMacro,
        }
    }
 }
@@ -1666,10 +1801,6 @@ impl Impl {
        self.id.lookup(db.upcast()).container.into()
    }
-    pub fn krate(self, db: &dyn HirDatabase) -> Crate {
-        Crate { id: self.module(db).id.krate() }
-    }
    pub fn is_builtin_derive(self, db: &dyn HirDatabase) -> Option<InFile<ast::Attr>> {
        let src = self.source(db)?;
        let item = src.file_id.is_builtin_derive(db.upcast())?;
diff --git a/crates/hir/src/semantics.rs b/crates/hir/src/semantics.rs
index 3aa467e3c..8d3c43d08 100644
--- a/crates/hir/src/semantics.rs
+++ b/crates/hir/src/semantics.rs
@@ -120,10 +120,10 @@ impl<'db, DB: HirDatabase> Semantics<'db, DB> {
    pub fn speculative_expand(
        &self,
        actual_macro_call: &ast::MacroCall,
-        hypothetical_args: &ast::TokenTree,
+        speculative_args: &ast::TokenTree,
        token_to_map: SyntaxToken,
    ) -> Option<(SyntaxNode, SyntaxToken)> {
-        self.imp.speculative_expand(actual_macro_call, hypothetical_args, token_to_map)
+        self.imp.speculative_expand(actual_macro_call, speculative_args, token_to_map)
    }
    pub fn descend_into_macros(&self, token: SyntaxToken) -> SyntaxToken {
@@ -335,7 +335,7 @@ impl<'db> SemanticsImpl<'db> {
    fn speculative_expand(
        &self,
        actual_macro_call: &ast::MacroCall,
-        hypothetical_args: &ast::TokenTree,
+        speculative_args: &ast::TokenTree,
        token_to_map: SyntaxToken,
    ) -> Option<(SyntaxNode, SyntaxToken)> {
        let sa = self.analyze(actual_macro_call.syntax());
@@ -344,10 +344,10 @@ impl<'db> SemanticsImpl<'db> {
        let macro_call_id = macro_call.as_call_id(self.db.upcast(), krate, |path| {
            sa.resolver.resolve_path_as_macro(self.db.upcast(), &path)
        })?;
-        hir_expand::db::expand_hypothetical(
+        hir_expand::db::expand_speculative(
            self.db.upcast(),
            macro_call_id,
-            hypothetical_args,
+            speculative_args,
            token_to_map,
        )
    }
diff --git a/crates/hir/src/source_analyzer.rs b/crates/hir/src/source_analyzer.rs
index 3f940124c..37a050415 100644
--- a/crates/hir/src/source_analyzer.rs
+++ b/crates/hir/src/source_analyzer.rs
@@ -308,7 +308,11 @@ impl SourceAnalyzer {
            }
        }
-        resolve_hir_path_(db, &self.resolver, &hir_path, prefer_value_ns)
+        if parent().map_or(false, |it| ast::Visibility::can_cast(it.kind())) {
+            resolve_hir_path_qualifier(db, &self.resolver, &hir_path)
+        } else {
+            resolve_hir_path_(db, &self.resolver, &hir_path, prefer_value_ns)
+        }
    }
    pub(crate) fn record_literal_missing_fields(
diff --git a/crates/hir_def/src/attr.rs b/crates/hir_def/src/attr.rs
index 89a1ea770..385ba8c80 100644
--- a/crates/hir_def/src/attr.rs
+++ b/crates/hir_def/src/attr.rs
@@ -105,7 +105,7 @@ impl RawAttrs {
                Either::Left(attr) => Attr::from_src(db, attr, hygiene, id),
                Either::Right(comment) => comment.doc_comment().map(|doc| Attr {
                    id,
-                    input: Some(AttrInput::Literal(SmolStr::new(doc))),
+                    input: Some(Interned::new(AttrInput::Literal(SmolStr::new(doc)))),
                    path: Interned::new(ModPath::from(hir_expand::name!(doc))),
                }),
            })
@@ -151,7 +151,7 @@ impl RawAttrs {
                    return smallvec![attr.clone()];
                }
-                let subtree = match &attr.input {
+                let subtree = match attr.input.as_deref() {
                    Some(AttrInput::TokenTree(it)) => it,
                    _ => return smallvec![attr.clone()],
                };
@@ -251,7 +251,7 @@ impl Attrs {
    }
    pub fn docs(&self) -> Option<Documentation> {
-        let docs = self.by_key("doc").attrs().flat_map(|attr| match attr.input.as_ref()? {
+        let docs = self.by_key("doc").attrs().flat_map(|attr| match attr.input.as_deref()? {
            AttrInput::Literal(s) => Some(s),
            AttrInput::TokenTree(_) => None,
        });
@@ -454,7 +454,7 @@ impl AttrsWithOwner {
        db: &dyn DefDatabase,
    ) -> Option<(Documentation, DocsRangeMap)> {
        // FIXME: code duplication in `docs` above
-        let docs = self.by_key("doc").attrs().flat_map(|attr| match attr.input.as_ref()? {
+        let docs = self.by_key("doc").attrs().flat_map(|attr| match attr.input.as_deref()? {
            AttrInput::Literal(s) => Some((s, attr.id)),
            AttrInput::TokenTree(_) => None,
        });
@@ -637,10 +637,10 @@ pub(crate) struct AttrId {
 pub struct Attr {
    pub(crate) id: AttrId,
    pub(crate) path: Interned<ModPath>,
-    pub(crate) input: Option<AttrInput>,
+    pub(crate) input: Option<Interned<AttrInput>>,
 }
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub enum AttrInput {
    /// `#[attr = "string"]`
    Literal(SmolStr),
@@ -670,9 +670,9 @@ impl Attr {
                ast::LiteralKind::String(string) => string.value()?.into(),
                _ => lit.syntax().first_token()?.text().trim_matches('"').into(),
            };
-            Some(AttrInput::Literal(value))
+            Some(Interned::new(AttrInput::Literal(value)))
        } else if let Some(tt) = ast.token_tree() {
-            Some(AttrInput::TokenTree(ast_to_token_tree(&tt).0))
+            Some(Interned::new(AttrInput::TokenTree(ast_to_token_tree(&tt).0)))
        } else {
            None
        };
@@ -688,7 +688,7 @@ impl Attr {
            return None;
        }
-        match &self.input {
+        match self.input.as_deref() {
            Some(AttrInput::TokenTree(args)) => {
                let mut counter = 0;
                let paths = args
@@ -720,7 +720,7 @@ impl Attr {
    }
    pub fn string_value(&self) -> Option<&SmolStr> {
-        match self.input.as_ref()? {
+        match self.input.as_deref()? {
            AttrInput::Literal(it) => Some(it),
            _ => None,
        }
@@ -735,14 +735,14 @@ pub struct AttrQuery<'a> {
 impl<'a> AttrQuery<'a> {
    pub fn tt_values(self) -> impl Iterator<Item = &'a Subtree> {
-        self.attrs().filter_map(|attr| match attr.input.as_ref()? {
+        self.attrs().filter_map(|attr| match attr.input.as_deref()? {
            AttrInput::TokenTree(it) => Some(it),
            _ => None,
        })
    }
    pub fn string_value(self) -> Option<&'a SmolStr> {
-        self.attrs().find_map(|attr| match attr.input.as_ref()? {
+        self.attrs().find_map(|attr| match attr.input.as_deref()? {
            AttrInput::Literal(it) => Some(it),
            _ => None,
        })
diff --git a/crates/hir_def/src/body.rs b/crates/hir_def/src/body.rs
index 98b485b60..c521879c8 100644
--- a/crates/hir_def/src/body.rs
+++ b/crates/hir_def/src/body.rs
@@ -1,7 +1,6 @@
 //! Defines `Body`: a lowered representation of bodies of functions, statics and
 //! consts.
 mod lower;
-mod diagnostics;
 #[cfg(test)]
 mod tests;
 pub mod scope;
@@ -9,17 +8,16 @@ pub mod scope;
 use std::{mem, ops::Index, sync::Arc};
 use base_db::CrateId;
-use cfg::CfgOptions;
+use cfg::{CfgExpr, CfgOptions};
 use drop_bomb::DropBomb;
 use either::Either;
 use hir_expand::{
-    ast_id_map::AstIdMap, diagnostics::DiagnosticSink, hygiene::Hygiene, AstId, ExpandResult,
+    ast_id_map::AstIdMap, hygiene::Hygiene, AstId, ExpandResult, HirFileId, InFile, MacroDefId,
-    HirFileId, InFile, MacroDefId,
 };
 use la_arena::{Arena, ArenaMap};
 use profile::Count;
 use rustc_hash::FxHashMap;
-use syntax::{ast, AstNode, AstPtr};
+use syntax::{ast, AstNode, AstPtr, SyntaxNodePtr};
 use crate::{
    attr::{Attrs, RawAttrs},
@@ -273,12 +271,20 @@ pub struct BodySourceMap {
    /// Diagnostics accumulated during body lowering. These contain `AstPtr`s and so are stored in
    /// the source map (since they're just as volatile).
-    diagnostics: Vec<diagnostics::BodyDiagnostic>,
+    diagnostics: Vec<BodyDiagnostic>,
 }
 #[derive(Default, Debug, Eq, PartialEq, Clone, Copy)]
 pub struct SyntheticSyntax;
+#[derive(Debug, Eq, PartialEq)]
+pub enum BodyDiagnostic {
+    InactiveCode { node: InFile<SyntaxNodePtr>, cfg: CfgExpr, opts: CfgOptions },
+    MacroError { node: InFile<AstPtr<ast::MacroCall>>, message: String },
+    UnresolvedProcMacro { node: InFile<AstPtr<ast::MacroCall>> },
+    UnresolvedMacroCall { node: InFile<AstPtr<ast::MacroCall>>, path: ModPath },
+}
 impl Body {
    pub(crate) fn body_with_source_map_query(
        db: &dyn DefDatabase,
@@ -416,9 +422,8 @@ impl BodySourceMap {
        self.field_map.get(&src).cloned()
    }
-    pub(crate) fn add_diagnostics(&self, _db: &dyn DefDatabase, sink: &mut DiagnosticSink<'_>) {
+    /// Get a reference to the body source map's diagnostics.
-        for diag in &self.diagnostics {
+    pub fn diagnostics(&self) -> &[BodyDiagnostic] {
-            diag.add_to(sink);
+        &self.diagnostics
-        }
    }
 }
diff --git a/crates/hir_def/src/body/diagnostics.rs b/crates/hir_def/src/body/diagnostics.rs
deleted file mode 100644
index f6992c9a8..000000000
--- a/crates/hir_def/src/body/diagnostics.rs
+++ /dev/null
@@ -1,32 +0,0 @@
-//! Diagnostics emitted during body lowering.
-use hir_expand::diagnostics::DiagnosticSink;
-use crate::diagnostics::{InactiveCode, MacroError, UnresolvedMacroCall, UnresolvedProcMacro};
-#[derive(Debug, Eq, PartialEq)]
-pub(crate) enum BodyDiagnostic {
-    InactiveCode(InactiveCode),
-    MacroError(MacroError),
-    UnresolvedProcMacro(UnresolvedProcMacro),
-    UnresolvedMacroCall(UnresolvedMacroCall),
-}
-impl BodyDiagnostic {
-    pub(crate) fn add_to(&self, sink: &mut DiagnosticSink<'_>) {
-        match self {
-            BodyDiagnostic::InactiveCode(diag) => {
-                sink.push(diag.clone());
-            }
-            BodyDiagnostic::MacroError(diag) => {
-                sink.push(diag.clone());
-            }
-            BodyDiagnostic::UnresolvedProcMacro(diag) => {
-                sink.push(diag.clone());
-            }
-            BodyDiagnostic::UnresolvedMacroCall(diag) => {
-                sink.push(diag.clone());
-            }
-        }
-    }
-}
diff --git a/crates/hir_def/src/body/lower.rs b/crates/hir_def/src/body/lower.rs
index 2a7e0205f..da1fdac33 100644
--- a/crates/hir_def/src/body/lower.rs
+++ b/crates/hir_def/src/body/lower.rs
@@ -8,7 +8,7 @@ use hir_expand::{
    ast_id_map::{AstIdMap, FileAstId},
    hygiene::Hygiene,
    name::{name, AsName, Name},
-    ExpandError, HirFileId,
+    ExpandError, HirFileId, InFile,
 };
 use la_arena::Arena;
 use profile::Count;
@@ -23,9 +23,9 @@ use syntax::{
 use crate::{
    adt::StructKind,
    body::{Body, BodySourceMap, Expander, LabelSource, PatPtr, SyntheticSyntax},
+    body::{BodyDiagnostic, ExprSource, PatSource},
    builtin_type::{BuiltinFloat, BuiltinInt, BuiltinUint},
    db::DefDatabase,
-    diagnostics::{InactiveCode, MacroError, UnresolvedMacroCall, UnresolvedProcMacro},
    expr::{
        dummy_expr_id, ArithOp, Array, BinaryOp, BindingAnnotation, CmpOp, Expr, ExprId, Label,
        LabelId, Literal, LogicOp, MatchArm, Ordering, Pat, PatId, RecordFieldPat, RecordLitField,
@@ -38,8 +38,6 @@ use crate::{
    AdtId, BlockLoc, ModuleDefId, UnresolvedMacro,
 };
-use super::{diagnostics::BodyDiagnostic, ExprSource, PatSource};
 pub struct LowerCtx<'a> {
    pub db: &'a dyn DefDatabase,
    hygiene: Hygiene,
@@ -592,13 +590,10 @@ impl ExprCollector<'_> {
        let res = match res {
            Ok(res) => res,
            Err(UnresolvedMacro { path }) => {
-                self.source_map.diagnostics.push(BodyDiagnostic::UnresolvedMacroCall(
+                self.source_map.diagnostics.push(BodyDiagnostic::UnresolvedMacroCall {
-                    UnresolvedMacroCall {
+                    node: InFile::new(outer_file, syntax_ptr),
-                        file: outer_file,
+                    path,
-                        node: syntax_ptr.cast().unwrap(),
+                });
-                        path,
-                    },
-                ));
                collector(self, None);
                return;
            }
@@ -606,21 +601,15 @@ impl ExprCollector<'_> {
        match &res.err {
            Some(ExpandError::UnresolvedProcMacro) => {
-                self.source_map.diagnostics.push(BodyDiagnostic::UnresolvedProcMacro(
+                self.source_map.diagnostics.push(BodyDiagnostic::UnresolvedProcMacro {
-                    UnresolvedProcMacro {
+                    node: InFile::new(outer_file, syntax_ptr),
-                        file: outer_file,
+                });
-                        node: syntax_ptr.into(),
-                        precise_location: None,
-                        macro_name: None,
-                    },
-                ));
            }
            Some(err) => {
-                self.source_map.diagnostics.push(BodyDiagnostic::MacroError(MacroError {
+                self.source_map.diagnostics.push(BodyDiagnostic::MacroError {
-                    file: outer_file,
+                    node: InFile::new(outer_file, syntax_ptr),
-                    node: syntax_ptr.into(),
                    message: err.to_string(),
-                }));
+                });
            }
            None => {}
        }
@@ -945,12 +934,14 @@ impl ExprCollector<'_> {
                    return Some(());
                }
-                self.source_map.diagnostics.push(BodyDiagnostic::InactiveCode(InactiveCode {
+                self.source_map.diagnostics.push(BodyDiagnostic::InactiveCode {
-                    file: self.expander.current_file_id,
+                    node: InFile::new(
-                    node: SyntaxNodePtr::new(owner.syntax()),
+                        self.expander.current_file_id,
+                        SyntaxNodePtr::new(owner.syntax()),
+                    ),
                    cfg,
                    opts: self.expander.cfg_options().clone(),
-                }));
+                });
                None
            }
diff --git a/crates/hir_def/src/body/tests.rs b/crates/hir_def/src/body/tests.rs
index 3e8f16306..d4fae05a6 100644
--- a/crates/hir_def/src/body/tests.rs
+++ b/crates/hir_def/src/body/tests.rs
@@ -96,26 +96,26 @@ fn f() {
    // The three g̶e̶n̶d̶e̶r̶s̶ statements:
    #[cfg(a)] fn f() {}  // Item statement
-  //^^^^^^^^^^^^^^^^^^^ code is inactive due to #[cfg] directives: a is disabled
+  //^^^^^^^^^^^^^^^^^^^ InactiveCode
    #[cfg(a)] {}         // Expression statement
-  //^^^^^^^^^^^^ code is inactive due to #[cfg] directives: a is disabled
+  //^^^^^^^^^^^^ InactiveCode
    #[cfg(a)] let x = 0; // let statement
-  //^^^^^^^^^^^^^^^^^^^^ code is inactive due to #[cfg] directives: a is disabled
+  //^^^^^^^^^^^^^^^^^^^^ InactiveCode
    abc(#[cfg(a)] 0);
-      //^^^^^^^^^^^ code is inactive due to #[cfg] directives: a is disabled
+      //^^^^^^^^^^^ InactiveCode
    let x = Struct {
        #[cfg(a)] f: 0,
-      //^^^^^^^^^^^^^^ code is inactive due to #[cfg] directives: a is disabled
+      //^^^^^^^^^^^^^^ InactiveCode
    };
    match () {
        () => (),
        #[cfg(a)] () => (),
-      //^^^^^^^^^^^^^^^^^^ code is inactive due to #[cfg] directives: a is disabled
+      //^^^^^^^^^^^^^^^^^^ InactiveCode
    }
    #[cfg(a)] 0          // Trailing expression of block
-  //^^^^^^^^^^^ code is inactive due to #[cfg] directives: a is disabled
+  //^^^^^^^^^^^ InactiveCode
 }
    ",
    );
@@ -188,7 +188,7 @@ fn unresolved_macro_diag() {
        r#"
 fn f() {
    m!();
-  //^^^^ unresolved macro `m!`
+  //^^^^ UnresolvedMacroCall
 }
      "#,
    );
diff --git a/crates/hir_def/src/data.rs b/crates/hir_def/src/data.rs
index 135a6698e..d2bb381be 100644
--- a/crates/hir_def/src/data.rs
+++ b/crates/hir_def/src/data.rs
@@ -22,6 +22,7 @@ pub struct FunctionData {
    pub name: Name,
    pub params: Vec<Interned<TypeRef>>,
    pub ret_type: Interned<TypeRef>,
+    pub async_ret_type: Option<Interned<TypeRef>>,
    pub attrs: Attrs,
    pub visibility: RawVisibility,
    pub abi: Option<Interned<str>>,
@@ -63,6 +64,7 @@ impl FunctionData {
                })
                .collect(),
            ret_type: func.ret_type.clone(),
+            async_ret_type: func.async_ret_type.clone(),
            attrs: item_tree.attrs(db, krate, ModItem::from(loc.id.value).into()),
            visibility: item_tree[func.visibility].clone(),
            abi: func.abi.clone(),
@@ -112,7 +114,7 @@ pub struct TypeAliasData {
    pub visibility: RawVisibility,
    pub is_extern: bool,
    /// Bounds restricting the type alias itself (eg. `type Ty: Bound;` in a trait or impl).
-    pub bounds: Vec<TypeBound>,
+    pub bounds: Vec<Interned<TypeBound>>,
 }
 impl TypeAliasData {
@@ -141,7 +143,6 @@ pub struct TraitData {
    pub is_auto: bool,
    pub is_unsafe: bool,
    pub visibility: RawVisibility,
-    pub bounds: Box<[TypeBound]>,
 }
 impl TraitData {
@@ -155,7 +156,6 @@ impl TraitData {
        let module_id = tr_loc.container;
        let container = AssocContainerId::TraitId(tr);
        let visibility = item_tree[tr_def.visibility].clone();
-        let bounds = tr_def.bounds.clone();
        let mut expander = Expander::new(db, tr_loc.id.file_id(), module_id);
        let items = collect_items(
@@ -168,7 +168,7 @@ impl TraitData {
            100,
        );
-        Arc::new(TraitData { name, items, is_auto, is_unsafe, visibility, bounds })
+        Arc::new(TraitData { name, items, is_auto, is_unsafe, visibility })
    }
    pub fn associated_types(&self) -> impl Iterator<Item = TypeAliasId> + '_ {
diff --git a/crates/hir_def/src/diagnostics.rs b/crates/hir_def/src/diagnostics.rs
deleted file mode 100644
index a71ae2668..000000000
--- a/crates/hir_def/src/diagnostics.rs
+++ /dev/null
@@ -1,227 +0,0 @@
-//! Diagnostics produced by `hir_def`.
-use std::any::Any;
-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, TextRange};
-use crate::{db::DefDatabase, path::ModPath, DefWithBodyId};
-pub fn validate_body(db: &dyn DefDatabase, owner: DefWithBodyId, sink: &mut DiagnosticSink<'_>) {
-    let source_map = db.body_with_source_map(owner).1;
-    source_map.add_diagnostics(db, sink);
-}
-// Diagnostic: unresolved-module
-//
-// This diagnostic is triggered if rust-analyzer is unable to discover referred module.
-#[derive(Debug)]
-pub struct UnresolvedModule {
-    pub file: HirFileId,
-    pub decl: AstPtr<ast::Module>,
-    pub candidate: String,
-}
-impl Diagnostic for UnresolvedModule {
-    fn code(&self) -> DiagnosticCode {
-        DiagnosticCode("unresolved-module")
-    }
-    fn message(&self) -> String {
-        "unresolved module".to_string()
-    }
-    fn display_source(&self) -> InFile<SyntaxNodePtr> {
-        InFile::new(self.file, self.decl.clone().into())
-    }
-    fn as_any(&self) -> &(dyn Any + Send + 'static) {
-        self
-    }
-}
-// Diagnostic: unresolved-extern-crate
-//
-// This diagnostic is triggered if rust-analyzer is unable to discover referred extern crate.
-#[derive(Debug)]
-pub struct UnresolvedExternCrate {
-    pub file: HirFileId,
-    pub item: AstPtr<ast::ExternCrate>,
-}
-impl Diagnostic for UnresolvedExternCrate {
-    fn code(&self) -> DiagnosticCode {
-        DiagnosticCode("unresolved-extern-crate")
-    }
-    fn message(&self) -> String {
-        "unresolved extern crate".to_string()
-    }
-    fn display_source(&self) -> InFile<SyntaxNodePtr> {
-        InFile::new(self.file, self.item.clone().into())
-    }
-    fn as_any(&self) -> &(dyn Any + Send + 'static) {
-        self
-    }
-}
-// Diagnostic: unresolved-import
-//
-// This diagnostic is triggered if rust-analyzer is unable to discover imported module.
-#[derive(Debug)]
-pub struct UnresolvedImport {
-    pub file: HirFileId,
-    pub node: AstPtr<ast::UseTree>,
-}
-impl Diagnostic for UnresolvedImport {
-    fn code(&self) -> DiagnosticCode {
-        DiagnosticCode("unresolved-import")
-    }
-    fn message(&self) -> String {
-        "unresolved import".to_string()
-    }
-    fn display_source(&self) -> InFile<SyntaxNodePtr> {
-        InFile::new(self.file, self.node.clone().into())
-    }
-    fn as_any(&self) -> &(dyn Any + Send + 'static) {
-        self
-    }
-    fn is_experimental(&self) -> bool {
-        // This currently results in false positives in the following cases:
-        // - `cfg_if!`-generated code in libstd (we don't load the sysroot correctly)
-        // - `core::arch` (we don't handle `#[path = "../<path>"]` correctly)
-        // - proc macros and/or proc macro generated code
-        true
-    }
-}
-// Diagnostic: unresolved-macro-call
-//
-// This diagnostic is triggered if rust-analyzer is unable to resolve the path to a
-// macro in a macro invocation.
-#[derive(Debug, Clone, Eq, PartialEq)]
-pub struct UnresolvedMacroCall {
-    pub file: HirFileId,
-    pub node: AstPtr<ast::MacroCall>,
-    pub path: ModPath,
-}
-impl Diagnostic for UnresolvedMacroCall {
-    fn code(&self) -> DiagnosticCode {
-        DiagnosticCode("unresolved-macro-call")
-    }
-    fn message(&self) -> String {
-        format!("unresolved macro `{}!`", self.path)
-    }
-    fn display_source(&self) -> InFile<SyntaxNodePtr> {
-        InFile::new(self.file, self.node.clone().into())
-    }
-    fn as_any(&self) -> &(dyn Any + Send + 'static) {
-        self
-    }
-    fn is_experimental(&self) -> bool {
-        true
-    }
-}
-// Diagnostic: inactive-code
-//
-// This diagnostic is shown for code with inactive `#[cfg]` attributes.
-#[derive(Debug, Clone, Eq, PartialEq)]
-pub struct InactiveCode {
-    pub file: HirFileId,
-    pub node: SyntaxNodePtr,
-    pub cfg: CfgExpr,
-    pub opts: CfgOptions,
-}
-impl Diagnostic for InactiveCode {
-    fn code(&self) -> DiagnosticCode {
-        DiagnosticCode("inactive-code")
-    }
-    fn message(&self) -> String {
-        let inactive = DnfExpr::new(self.cfg.clone()).why_inactive(&self.opts);
-        let mut buf = "code is inactive due to #[cfg] directives".to_string();
-        if let Some(inactive) = inactive {
-            format_to!(buf, ": {}", inactive);
-        }
-        buf
-    }
-    fn display_source(&self) -> InFile<SyntaxNodePtr> {
-        InFile::new(self.file, self.node.clone())
-    }
-    fn as_any(&self) -> &(dyn Any + Send + 'static) {
-        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.
-//
-// If you are seeing a lot of "proc macro not expanded" warnings, you can add this option to the
-// `rust-analyzer.diagnostics.disabled` list to prevent them from showing. Alternatively you can
-// enable support for procedural macros (see `rust-analyzer.procMacro.enable`).
-#[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/generics.rs b/crates/hir_def/src/generics.rs
index de5acced8..44d22b918 100644
--- a/crates/hir_def/src/generics.rs
+++ b/crates/hir_def/src/generics.rs
@@ -68,9 +68,19 @@ pub struct GenericParams {
 /// associated type bindings like `Iterator<Item = u32>`.
 #[derive(Clone, PartialEq, Eq, Debug, Hash)]
 pub enum WherePredicate {
-    TypeBound { target: WherePredicateTypeTarget, bound: TypeBound },
+    TypeBound {
-    Lifetime { target: LifetimeRef, bound: LifetimeRef },
+        target: WherePredicateTypeTarget,
-    ForLifetime { lifetimes: Box<[Name]>, target: WherePredicateTypeTarget, bound: TypeBound },
+        bound: Interned<TypeBound>,
+    },
+    Lifetime {
+        target: LifetimeRef,
+        bound: LifetimeRef,
+    },
+    ForLifetime {
+        lifetimes: Box<[Name]>,
+        target: WherePredicateTypeTarget,
+        bound: Interned<TypeBound>,
+    },
 }
 #[derive(Clone, PartialEq, Eq, Debug, Hash)]
@@ -339,11 +349,11 @@ impl GenericParams {
                Some(hrtb_lifetimes) => WherePredicate::ForLifetime {
                    lifetimes: hrtb_lifetimes.clone(),
                    target: WherePredicateTypeTarget::TypeRef(Interned::new(type_ref)),
-                    bound,
+                    bound: Interned::new(bound),
                },
                None => WherePredicate::TypeBound {
                    target: WherePredicateTypeTarget::TypeRef(Interned::new(type_ref)),
-                    bound,
+                    bound: Interned::new(bound),
                },
            },
            (Either::Right(lifetime), TypeBound::Lifetime(bound)) => {
diff --git a/crates/hir_def/src/intern.rs b/crates/hir_def/src/intern.rs
index 5cc7f2df6..79ba970e7 100644
--- a/crates/hir_def/src/intern.rs
+++ b/crates/hir_def/src/intern.rs
@@ -216,7 +216,10 @@ pub use crate::_impl_internable as impl_internable;
 impl_internable!(
    crate::type_ref::TypeRef,
    crate::type_ref::TraitRef,
+    crate::type_ref::TypeBound,
    crate::path::ModPath,
+    crate::path::GenericArgs,
+    crate::attr::AttrInput,
    GenericParams,
    str,
 );
diff --git a/crates/hir_def/src/item_tree.rs b/crates/hir_def/src/item_tree.rs
index 4a5f44027..227337a8d 100644
--- a/crates/hir_def/src/item_tree.rs
+++ b/crates/hir_def/src/item_tree.rs
@@ -523,21 +523,38 @@ impl<N: ItemTreeNode> Index<FileItemTreeId<N>> for ItemTree {
    }
 }
-/// A desugared `use` import.
 #[derive(Debug, Clone, Eq, PartialEq)]
 pub struct Import {
-    pub path: Interned<ModPath>,
-    pub alias: Option<ImportAlias>,
    pub visibility: RawVisibilityId,
-    pub is_glob: bool,
-    /// AST ID of the `use` item this import was derived from. Note that many `Import`s can map to
-    /// the same `use` item.
    pub ast_id: FileAstId<ast::Use>,
-    /// Index of this `Import` when the containing `Use` is visited via `ModPath::expand_use_item`.
+    pub use_tree: UseTree,
-    ///
+}
-    /// This can be used to get the `UseTree` this `Import` corresponds to and allows emitting
-    /// precise diagnostics.
+#[derive(Debug, Clone, Eq, PartialEq)]
-    pub index: usize,
+pub struct UseTree {
+    pub index: Idx<ast::UseTree>,
+    kind: UseTreeKind,
+}
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub enum UseTreeKind {
+    /// ```
+    /// use path::to::Item;
+    /// use path::to::Item as Renamed;
+    /// use path::to::Trait as _;
+    /// ```
+    Single { path: Interned<ModPath>, alias: Option<ImportAlias> },
+    /// ```
+    /// use *;  // (invalid, but can occur in nested tree)
+    /// use path::*;
+    /// ```
+    Glob { path: Option<Interned<ModPath>> },
+    /// ```
+    /// use prefix::{self, Item, ...};
+    /// ```
+    Prefixed { prefix: Option<Interned<ModPath>>, list: Box<[UseTree]> },
 }
 #[derive(Debug, Clone, Eq, PartialEq)]
@@ -563,6 +580,7 @@ pub struct Function {
    pub abi: Option<Interned<str>>,
    pub params: IdRange<Param>,
    pub ret_type: Interned<TypeRef>,
+    pub async_ret_type: Option<Interned<TypeRef>>,
    pub ast_id: FileAstId<ast::Fn>,
    pub(crate) flags: FnFlags,
 }
@@ -644,7 +662,6 @@ pub struct Trait {
    pub generic_params: Interned<GenericParams>,
    pub is_auto: bool,
    pub is_unsafe: bool,
-    pub bounds: Box<[TypeBound]>,
    pub items: Box<[AssocItem]>,
    pub ast_id: FileAstId<ast::Trait>,
 }
@@ -664,7 +681,7 @@ pub struct TypeAlias {
    pub name: Name,
    pub visibility: RawVisibilityId,
    /// Bounds on the type alias itself. Only valid in trait declarations, eg. `type Assoc: Copy;`.
-    pub bounds: Box<[TypeBound]>,
+    pub bounds: Box<[Interned<TypeBound>]>,
    pub generic_params: Interned<GenericParams>,
    pub type_ref: Option<Interned<TypeRef>>,
    pub is_extern: bool,
@@ -711,6 +728,97 @@ pub struct MacroDef {
    pub ast_id: FileAstId<ast::MacroDef>,
 }
+impl Import {
+    /// Maps a `UseTree` contained in this import back to its AST node.
+    pub fn use_tree_to_ast(
+        &self,
+        db: &dyn DefDatabase,
+        file_id: HirFileId,
+        index: Idx<ast::UseTree>,
+    ) -> ast::UseTree {
+        // Re-lower the AST item and get the source map.
+        // Note: The AST unwraps are fine, since if they fail we should have never obtained `index`.
+        let ast = InFile::new(file_id, self.ast_id).to_node(db.upcast());
+        let ast_use_tree = ast.use_tree().expect("missing `use_tree`");
+        let hygiene = Hygiene::new(db.upcast(), file_id);
+        let (_, source_map) =
+            lower::lower_use_tree(db, &hygiene, ast_use_tree).expect("failed to lower use tree");
+        source_map[index].clone()
+    }
+}
+impl UseTree {
+    /// Expands the `UseTree` into individually imported `ModPath`s.
+    pub fn expand(
+        &self,
+        mut cb: impl FnMut(Idx<ast::UseTree>, ModPath, /* is_glob */ bool, Option<ImportAlias>),
+    ) {
+        self.expand_impl(None, &mut cb)
+    }
+    fn expand_impl(
+        &self,
+        prefix: Option<ModPath>,
+        cb: &mut dyn FnMut(
+            Idx<ast::UseTree>,
+            ModPath,
+            /* is_glob */ bool,
+            Option<ImportAlias>,
+        ),
+    ) {
+        fn concat_mod_paths(prefix: Option<ModPath>, path: &ModPath) -> Option<ModPath> {
+            match (prefix, &path.kind) {
+                (None, _) => Some(path.clone()),
+                (Some(mut prefix), PathKind::Plain) => {
+                    for segment in path.segments() {
+                        prefix.push_segment(segment.clone());
+                    }
+                    Some(prefix)
+                }
+                (Some(prefix), PathKind::Super(0)) => {
+                    // `some::path::self` == `some::path`
+                    if path.segments().is_empty() {
+                        Some(prefix)
+                    } else {
+                        None
+                    }
+                }
+                (Some(_), _) => None,
+            }
+        }
+        match &self.kind {
+            UseTreeKind::Single { path, alias } => {
+                if let Some(path) = concat_mod_paths(prefix, path) {
+                    cb(self.index, path, false, alias.clone());
+                }
+            }
+            UseTreeKind::Glob { path: Some(path) } => {
+                if let Some(path) = concat_mod_paths(prefix, path) {
+                    cb(self.index, path, true, None);
+                }
+            }
+            UseTreeKind::Glob { path: None } => {
+                if let Some(prefix) = prefix {
+                    cb(self.index, prefix, true, None);
+                }
+            }
+            UseTreeKind::Prefixed { prefix: additional_prefix, list } => {
+                let prefix = match additional_prefix {
+                    Some(path) => match concat_mod_paths(prefix, path) {
+                        Some(path) => Some(path),
+                        None => return,
+                    },
+                    None => prefix,
+                };
+                for tree in &**list {
+                    tree.expand_impl(prefix.clone(), cb);
+                }
+            }
+        }
+    }
+}
 macro_rules! impl_froms {
    ($e:ident { $($v:ident ($t:ty)),* $(,)? }) => {
        $(
diff --git a/crates/hir_def/src/item_tree/lower.rs b/crates/hir_def/src/item_tree/lower.rs
index 91cf75371..6208facd5 100644
--- a/crates/hir_def/src/item_tree/lower.rs
+++ b/crates/hir_def/src/item_tree/lower.rs
@@ -3,7 +3,6 @@
 use std::{collections::hash_map::Entry, mem, sync::Arc};
 use hir_expand::{ast_id_map::AstIdMap, hygiene::Hygiene, name::known, HirFileId};
-use smallvec::SmallVec;
 use syntax::{
    ast::{self, ModuleItemOwner},
    SyntaxNode, WalkEvent,
@@ -20,22 +19,10 @@ fn id<N: ItemTreeNode>(index: Idx<N>) -> FileItemTreeId<N> {
    FileItemTreeId { index, _p: PhantomData }
 }
-struct ModItems(SmallVec<[ModItem; 1]>);
-impl<T> From<T> for ModItems
-where
-    T: Into<ModItem>,
-{
-    fn from(t: T) -> Self {
-        ModItems(SmallVec::from_buf([t.into(); 1]))
-    }
-}
 pub(super) struct Ctx<'a> {
    db: &'a dyn DefDatabase,
    tree: ItemTree,
    hygiene: Hygiene,
-    file: HirFileId,
    source_ast_id_map: Arc<AstIdMap>,
    body_ctx: crate::body::LowerCtx<'a>,
    forced_visibility: Option<RawVisibilityId>,
@@ -47,7 +34,6 @@ impl<'a> Ctx<'a> {
            db,
            tree: ItemTree::default(),
            hygiene,
-            file,
            source_ast_id_map: db.ast_id_map(file),
            body_ctx: crate::body::LowerCtx::new(db, file),
            forced_visibility: None,
@@ -55,11 +41,8 @@ impl<'a> Ctx<'a> {
    }
    pub(super) fn lower_module_items(mut self, item_owner: &dyn ModuleItemOwner) -> ItemTree {
-        self.tree.top_level = item_owner
+        self.tree.top_level =
-            .items()
+            item_owner.items().flat_map(|item| self.lower_mod_item(&item, false)).collect();
-            .flat_map(|item| self.lower_mod_item(&item, false))
-            .flat_map(|items| items.0)
-            .collect();
        self.tree
    }
@@ -71,7 +54,6 @@ impl<'a> Ctx<'a> {
                _ => None,
            })
            .flat_map(|item| self.lower_mod_item(&item, false))
-            .flat_map(|items| items.0)
            .collect();
        // Non-items need to have their inner items collected.
@@ -98,7 +80,7 @@ impl<'a> Ctx<'a> {
        self.tree.data_mut()
    }
-    fn lower_mod_item(&mut self, item: &ast::Item, inner: bool) -> Option<ModItems> {
+    fn lower_mod_item(&mut self, item: &ast::Item, inner: bool) -> Option<ModItem> {
        // Collect inner items for 1-to-1-lowered items.
        match item {
            ast::Item::Struct(_)
@@ -129,34 +111,28 @@ impl<'a> Ctx<'a> {
        };
        let attrs = RawAttrs::new(self.db, item, &self.hygiene);
-        let items = match item {
+        let item: ModItem = match item {
-            ast::Item::Struct(ast) => self.lower_struct(ast).map(Into::into),
+            ast::Item::Struct(ast) => self.lower_struct(ast)?.into(),
-            ast::Item::Union(ast) => self.lower_union(ast).map(Into::into),
+            ast::Item::Union(ast) => self.lower_union(ast)?.into(),
-            ast::Item::Enum(ast) => self.lower_enum(ast).map(Into::into),
+            ast::Item::Enum(ast) => self.lower_enum(ast)?.into(),
-            ast::Item::Fn(ast) => self.lower_function(ast).map(Into::into),
+            ast::Item::Fn(ast) => self.lower_function(ast)?.into(),
-            ast::Item::TypeAlias(ast) => self.lower_type_alias(ast).map(Into::into),
+            ast::Item::TypeAlias(ast) => self.lower_type_alias(ast)?.into(),
-            ast::Item::Static(ast) => self.lower_static(ast).map(Into::into),
+            ast::Item::Static(ast) => self.lower_static(ast)?.into(),
-            ast::Item::Const(ast) => Some(self.lower_const(ast).into()),
+            ast::Item::Const(ast) => self.lower_const(ast).into(),
-            ast::Item::Module(ast) => self.lower_module(ast).map(Into::into),
+            ast::Item::Module(ast) => self.lower_module(ast)?.into(),
-            ast::Item::Trait(ast) => self.lower_trait(ast).map(Into::into),
+            ast::Item::Trait(ast) => self.lower_trait(ast)?.into(),
-            ast::Item::Impl(ast) => self.lower_impl(ast).map(Into::into),
+            ast::Item::Impl(ast) => self.lower_impl(ast)?.into(),
-            ast::Item::Use(ast) => Some(ModItems(
+            ast::Item::Use(ast) => self.lower_use(ast)?.into(),
-                self.lower_use(ast).into_iter().map(Into::into).collect::<SmallVec<_>>(),
+            ast::Item::ExternCrate(ast) => self.lower_extern_crate(ast)?.into(),
-            )),
+            ast::Item::MacroCall(ast) => self.lower_macro_call(ast)?.into(),
-            ast::Item::ExternCrate(ast) => self.lower_extern_crate(ast).map(Into::into),
+            ast::Item::MacroRules(ast) => self.lower_macro_rules(ast)?.into(),
-            ast::Item::MacroCall(ast) => self.lower_macro_call(ast).map(Into::into),
+            ast::Item::MacroDef(ast) => self.lower_macro_def(ast)?.into(),
-            ast::Item::MacroRules(ast) => self.lower_macro_rules(ast).map(Into::into),
+            ast::Item::ExternBlock(ast) => self.lower_extern_block(ast).into(),
-            ast::Item::MacroDef(ast) => self.lower_macro_def(ast).map(Into::into),
-            ast::Item::ExternBlock(ast) => Some(self.lower_extern_block(ast).into()),
        };
-        if !attrs.is_empty() {
+        self.add_attrs(item.into(), attrs.clone());
-            for item in items.iter().flat_map(|items| &items.0) {
-                self.add_attrs((*item).into(), attrs.clone());
-            }
-        }
-        items
+        Some(item)
    }
    fn add_attrs(&mut self, item: AttrOwner, attrs: RawAttrs) {
@@ -190,12 +166,10 @@ impl<'a> Ctx<'a> {
                            },
                            ast::Item(item) => {
                                // FIXME: This triggers for macro calls in expression/pattern/type position
-                                let mod_items = self.lower_mod_item(&item, true);
+                                let mod_item = self.lower_mod_item(&item, true);
                                let current_block = block_stack.last();
-                                if let (Some(mod_items), Some(block)) = (mod_items, current_block) {
+                                if let (Some(mod_item), Some(block)) = (mod_item, current_block) {
-                                    if !mod_items.0.is_empty() {
+                                        self.data().inner_items.entry(*block).or_default().push(mod_item);
-                                        self.data().inner_items.entry(*block).or_default().extend(mod_items.0.iter().copied());
-                                    }
                                }
                            },
                            _ => {}
@@ -382,12 +356,13 @@ impl<'a> Ctx<'a> {
            _ => TypeRef::unit(),
        };
-        let ret_type = if func.async_token().is_some() {
+        let (ret_type, async_ret_type) = if func.async_token().is_some() {
+            let async_ret_type = ret_type.clone();
            let future_impl = desugar_future_path(ret_type);
-            let ty_bound = TypeBound::Path(future_impl);
+            let ty_bound = Interned::new(TypeBound::Path(future_impl));
-            TypeRef::ImplTrait(vec![ty_bound])
+            (TypeRef::ImplTrait(vec![ty_bound]), Some(async_ret_type))
        } else {
-            ret_type
+            (ret_type, None)
        };
        let abi = func.abi().map(lower_abi);
@@ -421,6 +396,7 @@ impl<'a> Ctx<'a> {
            abi,
            params,
            ret_type: Interned::new(ret_type),
+            async_ret_type: async_ret_type.map(Interned::new),
            ast_id,
            flags,
        };
@@ -480,10 +456,7 @@ impl<'a> Ctx<'a> {
                items: module
                    .item_list()
                    .map(|list| {
-                        list.items()
+                        list.items().flat_map(|item| self.lower_mod_item(&item, false)).collect()
-                            .flat_map(|item| self.lower_mod_item(&item, false))
-                            .flat_map(|items| items.0)
-                            .collect()
                    })
                    .unwrap_or_else(|| {
                        cov_mark::hit!(name_res_works_for_broken_modules);
@@ -503,7 +476,6 @@ impl<'a> Ctx<'a> {
            self.lower_generic_params_and_inner_items(GenericsOwner::Trait(trait_def), trait_def);
        let is_auto = trait_def.auto_token().is_some();
        let is_unsafe = trait_def.unsafe_token().is_some();
-        let bounds = self.lower_type_bounds(trait_def);
        let items = trait_def.assoc_item_list().map(|list| {
            let db = self.db;
            self.with_inherited_visibility(visibility, |this| {
@@ -526,7 +498,6 @@ impl<'a> Ctx<'a> {
            generic_params,
            is_auto,
            is_unsafe,
-            bounds: bounds.into(),
            items: items.unwrap_or_default(),
            ast_id,
        };
@@ -561,30 +532,13 @@ impl<'a> Ctx<'a> {
        Some(id(self.data().impls.alloc(res)))
    }
-    fn lower_use(&mut self, use_item: &ast::Use) -> Vec<FileItemTreeId<Import>> {
+    fn lower_use(&mut self, use_item: &ast::Use) -> Option<FileItemTreeId<Import>> {
        let visibility = self.lower_visibility(use_item);
        let ast_id = self.source_ast_id_map.ast_id(use_item);
+        let (use_tree, _) = lower_use_tree(self.db, &self.hygiene, use_item.use_tree()?)?;
-        // Every use item can expand to many `Import`s.
+        let res = Import { visibility, ast_id, use_tree };
-        let mut imports = Vec::new();
+        Some(id(self.data().imports.alloc(res)))
-        let tree = self.tree.data_mut();
-        ModPath::expand_use_item(
-            self.db,
-            InFile::new(self.file, use_item.clone()),
-            &self.hygiene,
-            |path, _use_tree, is_glob, alias| {
-                imports.push(id(tree.imports.alloc(Import {
-                    path: Interned::new(path),
-                    alias,
-                    visibility,
-                    is_glob,
-                    ast_id,
-                    index: imports.len(),
-                })));
-            },
-        );
-        imports
    }
    fn lower_extern_crate(
@@ -738,11 +692,12 @@ impl<'a> Ctx<'a> {
        Interned::new(generics)
    }
-    fn lower_type_bounds(&mut self, node: &impl ast::TypeBoundsOwner) -> Vec<TypeBound> {
+    fn lower_type_bounds(&mut self, node: &impl ast::TypeBoundsOwner) -> Vec<Interned<TypeBound>> {
        match node.type_bound_list() {
-            Some(bound_list) => {
+            Some(bound_list) => bound_list
-                bound_list.bounds().map(|it| TypeBound::from_ast(&self.body_ctx, it)).collect()
+                .bounds()
-            }
+                .map(|it| Interned::new(TypeBound::from_ast(&self.body_ctx, it)))
+                .collect(),
            None => Vec::new(),
        }
    }
@@ -810,7 +765,7 @@ fn desugar_future_path(orig: TypeRef) -> Path {
    let binding =
        AssociatedTypeBinding { name: name![Output], type_ref: Some(orig), bounds: Vec::new() };
    last.bindings.push(binding);
-    generic_args.push(Some(Arc::new(last)));
+    generic_args.push(Some(Interned::new(last)));
    Path::from_known_path(path, generic_args)
 }
@@ -883,3 +838,81 @@ fn lower_abi(abi: ast::Abi) -> Interned<str> {
        }
    }
 }
+struct UseTreeLowering<'a> {
+    db: &'a dyn DefDatabase,
+    hygiene: &'a Hygiene,
+    mapping: Arena<ast::UseTree>,
+}
+impl UseTreeLowering<'_> {
+    fn lower_use_tree(&mut self, tree: ast::UseTree) -> Option<UseTree> {
+        if let Some(use_tree_list) = tree.use_tree_list() {
+            let prefix = match tree.path() {
+                // E.g. use something::{{{inner}}};
+                None => None,
+                // E.g. `use something::{inner}` (prefix is `None`, path is `something`)
+                // or `use something::{path::{inner::{innerer}}}` (prefix is `something::path`, path is `inner`)
+                Some(path) => {
+                    match ModPath::from_src(self.db, path, &self.hygiene) {
+                        Some(it) => Some(it),
+                        None => return None, // FIXME: report errors somewhere
+                    }
+                }
+            };
+            let list =
+                use_tree_list.use_trees().filter_map(|tree| self.lower_use_tree(tree)).collect();
+            Some(
+                self.use_tree(
+                    UseTreeKind::Prefixed { prefix: prefix.map(Interned::new), list },
+                    tree,
+                ),
+            )
+        } else {
+            let is_glob = tree.star_token().is_some();
+            let path = match tree.path() {
+                Some(path) => Some(ModPath::from_src(self.db, path, &self.hygiene)?),
+                None => None,
+            };
+            let alias = tree.rename().map(|a| {
+                a.name().map(|it| it.as_name()).map_or(ImportAlias::Underscore, ImportAlias::Alias)
+            });
+            if alias.is_some() && is_glob {
+                return None;
+            }
+            match (path, alias, is_glob) {
+                (path, None, true) => {
+                    if path.is_none() {
+                        cov_mark::hit!(glob_enum_group);
+                    }
+                    Some(self.use_tree(UseTreeKind::Glob { path: path.map(Interned::new) }, tree))
+                }
+                // Globs can't be renamed
+                (_, Some(_), true) | (None, None, false) => None,
+                // `bla::{ as Name}` is invalid
+                (None, Some(_), false) => None,
+                (Some(path), alias, false) => Some(
+                    self.use_tree(UseTreeKind::Single { path: Interned::new(path), alias }, tree),
+                ),
+            }
+        }
+    }
+    fn use_tree(&mut self, kind: UseTreeKind, ast: ast::UseTree) -> UseTree {
+        let index = self.mapping.alloc(ast);
+        UseTree { index, kind }
+    }
+}
+pub(super) fn lower_use_tree(
+    db: &dyn DefDatabase,
+    hygiene: &Hygiene,
+    tree: ast::UseTree,
+) -> Option<(UseTree, Arena<ast::UseTree>)> {
+    let mut lowering = UseTreeLowering { db, hygiene, mapping: Arena::new() };
+    let tree = lowering.lower_use_tree(tree)?;
+    Some((tree, lowering.mapping))
+}
diff --git a/crates/hir_def/src/item_tree/pretty.rs b/crates/hir_def/src/item_tree/pretty.rs
index 4bc87a0e2..cc9944a22 100644
--- a/crates/hir_def/src/item_tree/pretty.rs
+++ b/crates/hir_def/src/item_tree/pretty.rs
@@ -163,21 +163,46 @@ impl<'a> Printer<'a> {
        }
    }
+    fn print_use_tree(&mut self, use_tree: &UseTree) {
+        match &use_tree.kind {
+            UseTreeKind::Single { path, alias } => {
+                w!(self, "{}", path);
+                if let Some(alias) = alias {
+                    w!(self, " as {}", alias);
+                }
+            }
+            UseTreeKind::Glob { path } => {
+                if let Some(path) = path {
+                    w!(self, "{}::", path);
+                }
+                w!(self, "*");
+            }
+            UseTreeKind::Prefixed { prefix, list } => {
+                if let Some(prefix) = prefix {
+                    w!(self, "{}::", prefix);
+                }
+                w!(self, "{{");
+                for (i, tree) in list.iter().enumerate() {
+                    if i != 0 {
+                        w!(self, ", ");
+                    }
+                    self.print_use_tree(tree);
+                }
+                w!(self, "}}");
+            }
+        }
+    }
    fn print_mod_item(&mut self, item: ModItem) {
        self.print_attrs_of(item);
        match item {
            ModItem::Import(it) => {
-                let Import { visibility, path, is_glob, alias, ast_id: _, index } = &self.tree[it];
+                let Import { visibility, use_tree, ast_id: _ } = &self.tree[it];
                self.print_visibility(*visibility);
-                w!(self, "use {}", path);
+                w!(self, "use ");
-                if *is_glob {
+                self.print_use_tree(use_tree);
-                    w!(self, "::*");
+                wln!(self, ";");
-                }
-                if let Some(alias) = alias {
-                    w!(self, " as {}", alias);
-                }
-                wln!(self, ";  // {}", index);
            }
            ModItem::ExternCrate(it) => {
                let ExternCrate { name, alias, visibility, ast_id: _ } = &self.tree[it];
@@ -210,6 +235,7 @@ impl<'a> Printer<'a> {
                    abi,
                    params,
                    ret_type,
+                    async_ret_type: _,
                    ast_id: _,
                    flags,
                } = &self.tree[it];
@@ -320,7 +346,6 @@ impl<'a> Printer<'a> {
                    visibility,
                    is_auto,
                    is_unsafe,
-                    bounds,
                    items,
                    generic_params,
                    ast_id: _,
@@ -334,10 +359,6 @@ impl<'a> Printer<'a> {
                }
                w!(self, "trait {}", name);
                self.print_generic_params(generic_params);
-                if !bounds.is_empty() {
-                    w!(self, ": ");
-                    self.print_type_bounds(bounds);
-                }
                self.print_where_clause_and_opening_brace(generic_params);
                self.indented(|this| {
                    for item in &**items {
@@ -513,13 +534,13 @@ impl<'a> Printer<'a> {
        }
    }
-    fn print_type_bounds(&mut self, bounds: &[TypeBound]) {
+    fn print_type_bounds(&mut self, bounds: &[Interned<TypeBound>]) {
        for (i, bound) in bounds.iter().enumerate() {
            if i != 0 {
                w!(self, " + ");
            }
-            match bound {
+            match bound.as_ref() {
                TypeBound::Path(path) => self.print_path(path),
                TypeBound::Lifetime(lt) => w!(self, "{}", lt.name),
                TypeBound::Error => w!(self, "{{unknown}}"),
diff --git a/crates/hir_def/src/item_tree/tests.rs b/crates/hir_def/src/item_tree/tests.rs
index 6407871b5..b362add5c 100644
--- a/crates/hir_def/src/item_tree/tests.rs
+++ b/crates/hir_def/src/item_tree/tests.rs
@@ -26,6 +26,8 @@ use globs::*;
 /// docs on import
 use crate::{A, B};
+use a::{c, d::{e}};
        "#,
        expect![[r##"
            #![doc = " file comment"]  // AttrId { is_doc_comment: true, ast_index: 0 }
@@ -36,19 +38,14 @@ use crate::{A, B};
            pub(super) extern crate bli;
-            pub use crate::path::nested;  // 0
+            pub use crate::path::{nested, items as renamed, Trait as _};
-            pub use crate::path::items as renamed;  // 1
-            pub use crate::path::Trait as _;  // 2
+            pub(self) use globs::*;
-            pub(self) use globs::*;  // 0
            #[doc = " docs on import"]  // AttrId { is_doc_comment: true, ast_index: 0 }
-            pub(self) use crate::A;  // 0
+            pub(self) use crate::{A, B};
-            #[doc = " docs on import"]  // AttrId { is_doc_comment: true, ast_index: 0 }
+            pub(self) use a::{c, d::{e}};
-            pub(self) use crate::B;  // 1
        "##]],
    );
 }
@@ -183,7 +180,7 @@ trait Tr: SuperTrait + 'lifetime {
                _: (),
            ) -> ();
-            pub(self) trait Tr<Self>: SuperTrait + 'lifetime
+            pub(self) trait Tr<Self>
            where
                Self: SuperTrait,
                Self: 'lifetime
@@ -218,7 +215,7 @@ mod outline;
            #[doc = " outer"]  // AttrId { is_doc_comment: true, ast_index: 0 }
            #[doc = " inner"]  // AttrId { is_doc_comment: true, ast_index: 1 }
            pub(self) mod inline {
-                pub(self) use super::*;  // 0
+                pub(self) use super::*;
                // flags = 0x2
                pub(self) fn fn_in_module() -> ();
@@ -353,7 +350,7 @@ trait Tr<'a, T: 'a>: Super {}
            pub(self) union Union<'a, T, const U: u8> {
            }
-            pub(self) trait Tr<'a, Self, T>: Super
+            pub(self) trait Tr<'a, Self, T>
            where
                Self: Super,
                T: 'a
diff --git a/crates/hir_def/src/lib.rs b/crates/hir_def/src/lib.rs
index 70001cac8..9aa95720a 100644
--- a/crates/hir_def/src/lib.rs
+++ b/crates/hir_def/src/lib.rs
@@ -19,7 +19,6 @@ pub mod path;
 pub mod type_ref;
 pub mod builtin_type;
 pub mod builtin_attr;
-pub mod diagnostics;
 pub mod per_ns;
 pub mod item_scope;
@@ -56,7 +55,6 @@ use std::{
    sync::Arc,
 };
-use adt::VariantData;
 use base_db::{impl_intern_key, salsa, CrateId};
 use hir_expand::{
    ast_id_map::FileAstId,
@@ -67,15 +65,18 @@ use hir_expand::{
 use la_arena::Idx;
 use nameres::DefMap;
 use path::ModPath;
+use stdx::impl_from;
 use syntax::ast;
-use crate::attr::AttrId;
+use crate::{
-use crate::builtin_type::BuiltinType;
+    adt::VariantData,
-use item_tree::{
+    attr::AttrId,
-    Const, Enum, Function, Impl, ItemTreeId, ItemTreeNode, ModItem, Static, Struct, Trait,
+    builtin_type::BuiltinType,
-    TypeAlias, Union,
+    item_tree::{
+        Const, Enum, Function, Impl, ItemTreeId, ItemTreeNode, ModItem, Static, Struct, Trait,
+        TypeAlias, Union,
+    },
 };
-use stdx::impl_from;
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct ModuleId {
diff --git a/crates/hir_def/src/nameres.rs b/crates/hir_def/src/nameres.rs
index 249af6fc8..ebfcc26c4 100644
--- a/crates/hir_def/src/nameres.rs
+++ b/crates/hir_def/src/nameres.rs
@@ -47,18 +47,19 @@
 //! path and, upon success, we run macro expansion and "collect module" phase on
 //! the result
+pub mod diagnostics;
 mod collector;
 mod mod_resolution;
 mod path_resolution;
+mod proc_macro;
 #[cfg(test)]
 mod tests;
-mod proc_macro;
 use std::sync::Arc;
 use base_db::{CrateId, Edition, FileId};
-use hir_expand::{diagnostics::DiagnosticSink, name::Name, InFile, MacroDefId};
+use hir_expand::{name::Name, InFile, MacroDefId};
 use la_arena::Arena;
 use profile::Count;
 use rustc_hash::FxHashMap;
@@ -254,15 +255,6 @@ impl DefMap {
        }
    }
-    pub fn add_diagnostics(
-        &self,
-        db: &dyn DefDatabase,
-        module: LocalModuleId,
-        sink: &mut DiagnosticSink,
-    ) {
-        self.diagnostics.iter().for_each(|it| it.add_to(db, module, sink))
-    }
    pub fn modules_for_file(&self, file_id: FileId) -> impl Iterator<Item = LocalModuleId> + '_ {
        self.modules
            .iter()
@@ -448,6 +440,11 @@ impl DefMap {
            module.scope.shrink_to_fit();
        }
    }
+    /// Get a reference to the def map's diagnostics.
+    pub fn diagnostics(&self) -> &[DefDiagnostic] {
+        self.diagnostics.as_slice()
+    }
 }
 impl ModuleData {
@@ -471,236 +468,3 @@ pub enum ModuleSource {
    Module(ast::Module),
    BlockExpr(ast::BlockExpr),
 }
-mod diagnostics {
-    use cfg::{CfgExpr, CfgOptions};
-    use hir_expand::diagnostics::DiagnosticSink;
-    use hir_expand::hygiene::Hygiene;
-    use hir_expand::{InFile, MacroCallKind};
-    use syntax::ast::AttrsOwner;
-    use syntax::{ast, AstNode, AstPtr, SyntaxKind, SyntaxNodePtr};
-    use crate::path::ModPath;
-    use crate::{db::DefDatabase, diagnostics::*, nameres::LocalModuleId, AstId};
-    #[derive(Debug, PartialEq, Eq)]
-    enum DiagnosticKind {
-        UnresolvedModule { declaration: AstId<ast::Module>, candidate: String },
-        UnresolvedExternCrate { ast: AstId<ast::ExternCrate> },
-        UnresolvedImport { ast: AstId<ast::Use>, index: usize },
-        UnconfiguredCode { ast: AstId<ast::Item>, cfg: CfgExpr, opts: CfgOptions },
-        UnresolvedProcMacro { ast: MacroCallKind },
-        UnresolvedMacroCall { ast: AstId<ast::MacroCall>, path: ModPath },
-        MacroError { ast: MacroCallKind, message: String },
-    }
-    #[derive(Debug, PartialEq, Eq)]
-    pub(super) struct DefDiagnostic {
-        in_module: LocalModuleId,
-        kind: DiagnosticKind,
-    }
-    impl DefDiagnostic {
-        pub(super) fn unresolved_module(
-            container: LocalModuleId,
-            declaration: AstId<ast::Module>,
-            candidate: String,
-        ) -> Self {
-            Self {
-                in_module: container,
-                kind: DiagnosticKind::UnresolvedModule { declaration, candidate },
-            }
-        }
-        pub(super) fn unresolved_extern_crate(
-            container: LocalModuleId,
-            declaration: AstId<ast::ExternCrate>,
-        ) -> Self {
-            Self {
-                in_module: container,
-                kind: DiagnosticKind::UnresolvedExternCrate { ast: declaration },
-            }
-        }
-        pub(super) fn unresolved_import(
-            container: LocalModuleId,
-            ast: AstId<ast::Use>,
-            index: usize,
-        ) -> Self {
-            Self { in_module: container, kind: DiagnosticKind::UnresolvedImport { ast, index } }
-        }
-        pub(super) fn unconfigured_code(
-            container: LocalModuleId,
-            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 unresolved_macro_call(
-            container: LocalModuleId,
-            ast: AstId<ast::MacroCall>,
-            path: ModPath,
-        ) -> Self {
-            Self { in_module: container, kind: DiagnosticKind::UnresolvedMacroCall { ast, path } }
-        }
-        pub(super) fn add_to(
-            &self,
-            db: &dyn DefDatabase,
-            target_module: LocalModuleId,
-            sink: &mut DiagnosticSink,
-        ) {
-            if self.in_module != target_module {
-                return;
-            }
-            match &self.kind {
-                DiagnosticKind::UnresolvedModule { declaration, candidate } => {
-                    let decl = declaration.to_node(db.upcast());
-                    sink.push(UnresolvedModule {
-                        file: declaration.file_id,
-                        decl: AstPtr::new(&decl),
-                        candidate: candidate.clone(),
-                    })
-                }
-                DiagnosticKind::UnresolvedExternCrate { ast } => {
-                    let item = ast.to_node(db.upcast());
-                    sink.push(UnresolvedExternCrate {
-                        file: ast.file_id,
-                        item: AstPtr::new(&item),
-                    });
-                }
-                DiagnosticKind::UnresolvedImport { ast, index } => {
-                    let use_item = ast.to_node(db.upcast());
-                    let hygiene = Hygiene::new(db.upcast(), ast.file_id);
-                    let mut cur = 0;
-                    let mut tree = None;
-                    ModPath::expand_use_item(
-                        db,
-                        InFile::new(ast.file_id, use_item),
-                        &hygiene,
-                        |_mod_path, use_tree, _is_glob, _alias| {
-                            if cur == *index {
-                                tree = Some(use_tree.clone());
-                            }
-                            cur += 1;
-                        },
-                    );
-                    if let Some(tree) = tree {
-                        sink.push(UnresolvedImport { file: ast.file_id, node: AstPtr::new(&tree) });
-                    }
-                }
-                DiagnosticKind::UnconfiguredCode { ast, cfg, opts } => {
-                    let item = ast.to_node(db.upcast());
-                    sink.push(InactiveCode {
-                        file: ast.file_id,
-                        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_id, .. } => {
-                            let node = ast_id.to_node(db.upcast());
-                            (ast_id.file_id, SyntaxNodePtr::from(AstPtr::new(&node)), None)
-                        }
-                        MacroCallKind::Derive { ast_id, derive_name, .. } => {
-                            let node = ast_id.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.text() == derive_name.as_str()
-                                    {
-                                        precise_location = Some(token.text_range());
-                                        break 'outer;
-                                    }
-                                }
-                            }
-                            (
-                                ast_id.file_id,
-                                SyntaxNodePtr::from(AstPtr::new(&node)),
-                                Some(derive_name.clone()),
-                            )
-                        }
-                    };
-                    sink.push(UnresolvedProcMacro {
-                        file,
-                        node: ast,
-                        precise_location,
-                        macro_name: name,
-                    });
-                }
-                DiagnosticKind::UnresolvedMacroCall { ast, path } => {
-                    let node = ast.to_node(db.upcast());
-                    sink.push(UnresolvedMacroCall {
-                        file: ast.file_id,
-                        node: AstPtr::new(&node),
-                        path: path.clone(),
-                    });
-                }
-                DiagnosticKind::MacroError { ast, message } => {
-                    let (file, ast) = match ast {
-                        MacroCallKind::FnLike { ast_id, .. } => {
-                            let node = ast_id.to_node(db.upcast());
-                            (ast_id.file_id, SyntaxNodePtr::from(AstPtr::new(&node)))
-                        }
-                        MacroCallKind::Derive { ast_id, .. } => {
-                            let node = ast_id.to_node(db.upcast());
-                            (ast_id.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 014ea4de4..d9d6c91a8 100644
--- a/crates/hir_def/src/nameres/collector.rs
+++ b/crates/hir_def/src/nameres/collector.rs
@@ -17,6 +17,7 @@ use hir_expand::{
 };
 use hir_expand::{InFile, MacroCallLoc};
 use itertools::Itertools;
+use la_arena::Idx;
 use rustc_hash::{FxHashMap, FxHashSet};
 use syntax::ast;
@@ -33,7 +34,10 @@ use crate::{
    },
    macro_call_as_call_id,
    nameres::{
-        diagnostics::DefDiagnostic, mod_resolution::ModDir, path_resolution::ReachedFixedPoint,
+        diagnostics::DefDiagnostic,
+        mod_resolution::ModDir,
+        path_resolution::ReachedFixedPoint,
+        proc_macro::{ProcMacroDef, ProcMacroKind},
        BuiltinShadowMode, DefMap, ModuleData, ModuleOrigin, ResolveMode,
    },
    path::{ImportAlias, ModPath, PathKind},
@@ -44,8 +48,6 @@ use crate::{
    UnresolvedMacro,
 };
-use super::proc_macro::{ProcMacroDef, ProcMacroKind};
 const GLOB_RECURSION_LIMIT: usize = 100;
 const EXPANSION_DEPTH_LIMIT: usize = 128;
 const FIXED_POINT_LIMIT: usize = 8192;
@@ -142,7 +144,7 @@ impl PartialResolvedImport {
 #[derive(Clone, Debug, Eq, PartialEq)]
 enum ImportSource {
-    Import(ItemTreeId<item_tree::Import>),
+    Import { id: ItemTreeId<item_tree::Import>, use_tree: Idx<ast::UseTree> },
    ExternCrate(ItemTreeId<item_tree::ExternCrate>),
 }
@@ -164,20 +166,26 @@ impl Import {
        krate: CrateId,
        tree: &ItemTree,
        id: ItemTreeId<item_tree::Import>,
-    ) -> Self {
+    ) -> Vec<Self> {
        let it = &tree[id.value];
        let attrs = &tree.attrs(db, krate, ModItem::from(id.value).into());
        let visibility = &tree[it.visibility];
-        Self {
+        let is_prelude = attrs.by_key("prelude_import").exists();
-            path: it.path.clone(),
-            alias: it.alias.clone(),
+        let mut res = Vec::new();
-            visibility: visibility.clone(),
+        it.use_tree.expand(|idx, path, is_glob, alias| {
-            is_glob: it.is_glob,
+            res.push(Self {
-            is_prelude: attrs.by_key("prelude_import").exists(),
+                path: Interned::new(path), // FIXME this makes little sense
-            is_extern_crate: false,
+                alias,
-            is_macro_use: false,
+                visibility: visibility.clone(),
-            source: ImportSource::Import(id),
+                is_glob,
-        }
+                is_prelude,
+                is_extern_crate: false,
+                is_macro_use: false,
+                source: ImportSource::Import { id, use_tree: idx },
+            });
+        });
+        res
    }
    fn from_extern_crate(
@@ -285,7 +293,7 @@ impl DefCollector<'_> {
                let registered_name = if *attr_name == hir_expand::name![register_attr]
                    || *attr_name == hir_expand::name![register_tool]
                {
-                    match &attr.input {
+                    match attr.input.as_deref() {
                        Some(AttrInput::TokenTree(subtree)) => match &*subtree.token_trees {
                            [tt::TokenTree::Leaf(tt::Leaf::Ident(name))] => name.as_name(),
                            _ => continue,
@@ -469,16 +477,21 @@ impl DefCollector<'_> {
    /// going out of sync with what the build system sees (since we resolve using VFS state, but
    /// Cargo builds only on-disk files). We could and probably should add diagnostics for that.
    fn export_proc_macro(&mut self, def: ProcMacroDef, ast_id: AstId<ast::Fn>) {
+        let kind = def.kind.to_basedb_kind();
        self.exports_proc_macros = true;
        let macro_def = match self.proc_macros.iter().find(|(n, _)| n == &def.name) {
            Some((_, expander)) => MacroDefId {
                krate: self.def_map.krate,
-                kind: MacroDefKind::ProcMacro(*expander, ast_id),
+                kind: MacroDefKind::ProcMacro(*expander, kind, ast_id),
                local_inner: false,
            },
            None => MacroDefId {
                krate: self.def_map.krate,
-                kind: MacroDefKind::ProcMacro(ProcMacroExpander::dummy(self.def_map.krate), ast_id),
+                kind: MacroDefKind::ProcMacro(
+                    ProcMacroExpander::dummy(self.def_map.krate),
+                    kind,
+                    ast_id,
+                ),
                local_inner: false,
            },
        };
@@ -1129,11 +1142,8 @@ impl DefCollector<'_> {
        }
        for directive in &self.unresolved_imports {
-            if let ImportSource::Import(import) = &directive.import.source {
+            if let ImportSource::Import { id: import, use_tree } = &directive.import.source {
-                let item_tree = import.item_tree(self.db);
+                match (directive.import.path.segments().first(), &directive.import.path.kind) {
-                let import_data = &item_tree[import.value];
-                match (import_data.path.segments().first(), &import_data.path.kind) {
                    (Some(krate), PathKind::Plain) | (Some(krate), PathKind::Abs) => {
                        if diagnosed_extern_crates.contains(krate) {
                            continue;
@@ -1144,8 +1154,8 @@ impl DefCollector<'_> {
                self.def_map.diagnostics.push(DefDiagnostic::unresolved_import(
                    directive.module_id,
-                    InFile::new(import.file_id(), import_data.ast_id),
+                    *import,
-                    import_data.index,
+                    *use_tree,
                ));
            }
        }
@@ -1221,16 +1231,20 @@ impl ModCollector<'_, '_> {
            match item {
                ModItem::Mod(m) => self.collect_module(&self.item_tree[m], &attrs),
                ModItem::Import(import_id) => {
-                    self.def_collector.unresolved_imports.push(ImportDirective {
+                    let module_id = self.module_id;
-                        module_id: self.module_id,
+                    let imports = Import::from_use(
-                        import: Import::from_use(
+                        self.def_collector.db,
-                            self.def_collector.db,
+                        krate,
-                            krate,
+                        &self.item_tree,
-                            &self.item_tree,
+                        ItemTreeId::new(self.file_id, import_id),
-                            ItemTreeId::new(self.file_id, import_id),
+                    );
-                        ),
+                    self.def_collector.unresolved_imports.extend(imports.into_iter().map(
-                        status: PartialResolvedImport::Unresolved,
+                        |import| ImportDirective {
-                    })
+                            module_id,
+                            import,
+                            status: PartialResolvedImport::Unresolved,
+                        },
+                    ));
                }
                ModItem::ExternCrate(import_id) => {
                    self.def_collector.unresolved_imports.push(ImportDirective {
diff --git a/crates/hir_def/src/nameres/diagnostics.rs b/crates/hir_def/src/nameres/diagnostics.rs
new file mode 100644
index 000000000..57c36c3c6
--- /dev/null
+++ b/crates/hir_def/src/nameres/diagnostics.rs
@@ -0,0 +1,96 @@
+//! Diagnostics emitted during DefMap construction.
+use cfg::{CfgExpr, CfgOptions};
+use hir_expand::MacroCallKind;
+use la_arena::Idx;
+use syntax::ast;
+use crate::{
+    item_tree::{self, ItemTreeId},
+    nameres::LocalModuleId,
+    path::ModPath,
+    AstId,
+};
+#[derive(Debug, PartialEq, Eq)]
+pub enum DefDiagnosticKind {
+    UnresolvedModule { ast: AstId<ast::Module>, candidate: String },
+    UnresolvedExternCrate { ast: AstId<ast::ExternCrate> },
+    UnresolvedImport { id: ItemTreeId<item_tree::Import>, index: Idx<ast::UseTree> },
+    UnconfiguredCode { ast: AstId<ast::Item>, cfg: CfgExpr, opts: CfgOptions },
+    UnresolvedProcMacro { ast: MacroCallKind },
+    UnresolvedMacroCall { ast: AstId<ast::MacroCall>, path: ModPath },
+    MacroError { ast: MacroCallKind, message: String },
+}
+#[derive(Debug, PartialEq, Eq)]
+pub struct DefDiagnostic {
+    pub in_module: LocalModuleId,
+    pub kind: DefDiagnosticKind,
+}
+impl DefDiagnostic {
+    pub(super) fn unresolved_module(
+        container: LocalModuleId,
+        declaration: AstId<ast::Module>,
+        candidate: String,
+    ) -> Self {
+        Self {
+            in_module: container,
+            kind: DefDiagnosticKind::UnresolvedModule { ast: declaration, candidate },
+        }
+    }
+    pub(super) fn unresolved_extern_crate(
+        container: LocalModuleId,
+        declaration: AstId<ast::ExternCrate>,
+    ) -> Self {
+        Self {
+            in_module: container,
+            kind: DefDiagnosticKind::UnresolvedExternCrate { ast: declaration },
+        }
+    }
+    pub(super) fn unresolved_import(
+        container: LocalModuleId,
+        id: ItemTreeId<item_tree::Import>,
+        index: Idx<ast::UseTree>,
+    ) -> Self {
+        Self { in_module: container, kind: DefDiagnosticKind::UnresolvedImport { id, index } }
+    }
+    pub(super) fn unconfigured_code(
+        container: LocalModuleId,
+        ast: AstId<ast::Item>,
+        cfg: CfgExpr,
+        opts: CfgOptions,
+    ) -> Self {
+        Self { in_module: container, kind: DefDiagnosticKind::UnconfiguredCode { ast, cfg, opts } }
+    }
+    pub(super) fn unresolved_proc_macro(container: LocalModuleId, ast: MacroCallKind) -> Self {
+        Self { in_module: container, kind: DefDiagnosticKind::UnresolvedProcMacro { ast } }
+    }
+    pub(super) fn macro_error(
+        container: LocalModuleId,
+        ast: MacroCallKind,
+        message: String,
+    ) -> Self {
+        Self { in_module: container, kind: DefDiagnosticKind::MacroError { ast, message } }
+    }
+    pub(super) fn unresolved_macro_call(
+        container: LocalModuleId,
+        ast: AstId<ast::MacroCall>,
+        path: ModPath,
+    ) -> Self {
+        Self { in_module: container, kind: DefDiagnosticKind::UnresolvedMacroCall { ast, path } }
+    }
+}
diff --git a/crates/hir_def/src/nameres/proc_macro.rs b/crates/hir_def/src/nameres/proc_macro.rs
index 156598f19..3f095d623 100644
--- a/crates/hir_def/src/nameres/proc_macro.rs
+++ b/crates/hir_def/src/nameres/proc_macro.rs
@@ -18,6 +18,16 @@ pub(super) enum ProcMacroKind {
    Attr,
 }
+impl ProcMacroKind {
+    pub(super) fn to_basedb_kind(&self) -> base_db::ProcMacroKind {
+        match self {
+            ProcMacroKind::CustomDerive { .. } => base_db::ProcMacroKind::CustomDerive,
+            ProcMacroKind::FnLike => base_db::ProcMacroKind::FuncLike,
+            ProcMacroKind::Attr => base_db::ProcMacroKind::Attr,
+        }
+    }
+}
 impl Attrs {
    #[rustfmt::skip]
    pub(super) fn parse_proc_macro_decl(&self, func_name: &Name) -> Option<ProcMacroDef> {
diff --git a/crates/hir_def/src/nameres/tests/diagnostics.rs b/crates/hir_def/src/nameres/tests/diagnostics.rs
index 75147d973..ec6670952 100644
--- a/crates/hir_def/src/nameres/tests/diagnostics.rs
+++ b/crates/hir_def/src/nameres/tests/diagnostics.rs
@@ -18,7 +18,7 @@ fn unresolved_import() {
        r"
        use does_exist;
        use does_not_exist;
-          //^^^^^^^^^^^^^^ unresolved import
+      //^^^^^^^^^^^^^^^^^^^ UnresolvedImport
        mod does_exist {}
        ",
@@ -26,40 +26,13 @@ fn unresolved_import() {
 }
 #[test]
-fn unresolved_import_in_use_tree() {
-    // Only the relevant part of a nested `use` item should be highlighted.
-    check_diagnostics(
-        r"
-        use does_exist::{Exists, DoesntExist};
-                               //^^^^^^^^^^^ unresolved import
-        use {does_not_exist::*, does_exist};
-           //^^^^^^^^^^^^^^^^^ unresolved import
-        use does_not_exist::{
-            a,
-          //^ unresolved import
-            b,
-          //^ unresolved import
-            c,
-          //^ unresolved import
-        };
-        mod does_exist {
-            pub struct Exists;
-        }
-        ",
-    );
-}
-#[test]
 fn unresolved_extern_crate() {
    check_diagnostics(
        r"
        //- /main.rs crate:main deps:core
        extern crate core;
          extern crate doesnotexist;
-        //^^^^^^^^^^^^^^^^^^^^^^^^^^ unresolved extern crate
+        //^^^^^^^^^^^^^^^^^^^^^^^^^^ UnresolvedExternCrate
        //- /lib.rs crate:core
        ",
    );
@@ -72,7 +45,7 @@ fn extern_crate_self_as() {
        r"
        //- /lib.rs
          extern crate doesnotexist;
-        //^^^^^^^^^^^^^^^^^^^^^^^^^^ unresolved extern crate
+        //^^^^^^^^^^^^^^^^^^^^^^^^^^ UnresolvedExternCrate
        // Should not error.
        extern crate self as foo;
        struct Foo;
@@ -88,18 +61,18 @@ fn dedup_unresolved_import_from_unresolved_crate() {
        //- /main.rs crate:main
        mod a {
            extern crate doesnotexist;
-          //^^^^^^^^^^^^^^^^^^^^^^^^^^ unresolved extern crate
+          //^^^^^^^^^^^^^^^^^^^^^^^^^^ UnresolvedExternCrate
            // Should not error, since we already errored for the missing crate.
            use doesnotexist::{self, bla, *};
            use crate::doesnotexist;
-              //^^^^^^^^^^^^^^^^^^^ unresolved import
+          //^^^^^^^^^^^^^^^^^^^^^^^^ UnresolvedImport
        }
        mod m {
            use super::doesnotexist;
-              //^^^^^^^^^^^^^^^^^^^ unresolved import
+          //^^^^^^^^^^^^^^^^^^^^^^^^ UnresolvedImport
        }
        ",
    );
@@ -112,7 +85,7 @@ fn unresolved_module() {
        //- /lib.rs
        mod foo;
          mod bar;
-        //^^^^^^^^ unresolved module
+        //^^^^^^^^ UnresolvedModule
        mod baz {}
        //- /foo.rs
        ",
@@ -127,16 +100,16 @@ fn inactive_item() {
        r#"
        //- /lib.rs
          #[cfg(no)] pub fn f() {}
-        //^^^^^^^^^^^^^^^^^^^^^^^^ code is inactive due to #[cfg] directives: no is disabled
+        //^^^^^^^^^^^^^^^^^^^^^^^^ UnconfiguredCode
          #[cfg(no)] #[cfg(no2)] mod m;
-        //^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ code is inactive due to #[cfg] directives: no and no2 are disabled
+        //^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ UnconfiguredCode
          #[cfg(all(not(a), b))] enum E {}
-        //^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ code is inactive due to #[cfg] directives: b is disabled
+        //^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ UnconfiguredCode
          #[cfg(feature = "std")] use std;
-        //^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ code is inactive due to #[cfg] directives: feature = "std" is disabled
+        //^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ UnconfiguredCode
        "#,
    );
 }
@@ -149,14 +122,14 @@ fn inactive_via_cfg_attr() {
        r#"
        //- /lib.rs
          #[cfg_attr(not(never), cfg(no))] fn f() {}
-        //^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ code is inactive due to #[cfg] directives: no is disabled
+        //^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ UnconfiguredCode
          #[cfg_attr(not(never), cfg(not(no)))] fn f() {}
          #[cfg_attr(never, cfg(no))] fn g() {}
          #[cfg_attr(not(never), inline, cfg(no))] fn h() {}
-        //^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ code is inactive due to #[cfg] directives: no is disabled
+        //^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ UnconfiguredCode
        "#,
    );
 }
@@ -170,7 +143,7 @@ fn unresolved_legacy_scope_macro() {
          m!();
          m2!();
-        //^^^^^^ unresolved macro `self::m2!`
+        //^^^^^^ UnresolvedMacroCall
        "#,
    );
 }
@@ -187,7 +160,7 @@ fn unresolved_module_scope_macro() {
          self::m!();
          self::m2!();
-        //^^^^^^^^^^^^ unresolved macro `self::m2!`
+        //^^^^^^^^^^^^ UnresolvedMacroCall
        "#,
    );
 }
diff --git a/crates/hir_def/src/nameres/tests/incremental.rs b/crates/hir_def/src/nameres/tests/incremental.rs
index d884a6eb4..7bf152e26 100644
--- a/crates/hir_def/src/nameres/tests/incremental.rs
+++ b/crates/hir_def/src/nameres/tests/incremental.rs
@@ -1,6 +1,8 @@
 use std::sync::Arc;
-use base_db::SourceDatabaseExt;
+use base_db::{salsa::SweepStrategy, SourceDatabaseExt};
+use crate::{AdtId, ModuleDefId};
 use super::*;
@@ -163,3 +165,73 @@ m!(Z);
        assert_eq!(n_reparsed_macros, 0);
    }
 }
+#[test]
+fn item_tree_prevents_reparsing() {
+    // The `ItemTree` is used by both name resolution and the various queries in `adt.rs` and
+    // `data.rs`. After computing the `ItemTree` and deleting the parse tree, we should be able to
+    // run those other queries without triggering a reparse.
+    let (db, pos) = TestDB::with_position(
+        r#"
+pub struct S;
+pub union U {}
+pub enum E {
+    Variant,
+}
+pub fn f(_: S) { $0 }
+pub trait Tr {}
+impl Tr for () {}
+pub const C: u8 = 0;
+pub static ST: u8 = 0;
+pub type Ty = ();
+"#,
+    );
+    let krate = db.test_crate();
+    {
+        let events = db.log_executed(|| {
+            db.file_item_tree(pos.file_id.into());
+        });
+        let n_calculated_item_trees = events.iter().filter(|it| it.contains("item_tree")).count();
+        assert_eq!(n_calculated_item_trees, 1);
+        let n_parsed_files = events.iter().filter(|it| it.contains("parse(")).count();
+        assert_eq!(n_parsed_files, 1);
+    }
+    // Delete the parse tree.
+    let sweep = SweepStrategy::default().discard_values().sweep_all_revisions();
+    base_db::ParseQuery.in_db(&db).sweep(sweep);
+    {
+        let events = db.log_executed(|| {
+            let crate_def_map = db.crate_def_map(krate);
+            let (_, module_data) = crate_def_map.modules.iter().last().unwrap();
+            assert_eq!(module_data.scope.resolutions().count(), 8);
+            assert_eq!(module_data.scope.impls().count(), 1);
+            for imp in module_data.scope.impls() {
+                db.impl_data(imp);
+            }
+            for (_, res) in module_data.scope.resolutions() {
+                match res.values.or(res.types).unwrap().0 {
+                    ModuleDefId::FunctionId(f) => drop(db.function_data(f)),
+                    ModuleDefId::AdtId(adt) => match adt {
+                        AdtId::StructId(it) => drop(db.struct_data(it)),
+                        AdtId::UnionId(it) => drop(db.union_data(it)),
+                        AdtId::EnumId(it) => drop(db.enum_data(it)),
+                    },
+                    ModuleDefId::ConstId(it) => drop(db.const_data(it)),
+                    ModuleDefId::StaticId(it) => drop(db.static_data(it)),
+                    ModuleDefId::TraitId(it) => drop(db.trait_data(it)),
+                    ModuleDefId::TypeAliasId(it) => drop(db.type_alias_data(it)),
+                    ModuleDefId::EnumVariantId(_)
+                    | ModuleDefId::ModuleId(_)
+                    | ModuleDefId::BuiltinType(_) => unreachable!(),
+                }
+            }
+        });
+        let n_reparsed_files = events.iter().filter(|it| it.contains("parse(")).count();
+        assert_eq!(n_reparsed_files, 0);
+    }
+}
diff --git a/crates/hir_def/src/path.rs b/crates/hir_def/src/path.rs
index 9b8873fd2..16440041d 100644
--- a/crates/hir_def/src/path.rs
+++ b/crates/hir_def/src/path.rs
@@ -4,7 +4,6 @@ mod lower;
 use std::{
    fmt::{self, Display},
    iter,
-    sync::Arc,
 };
 use crate::{body::LowerCtx, db::DefDatabase, intern::Interned, type_ref::LifetimeRef};
@@ -15,10 +14,7 @@ use hir_expand::{
 };
 use syntax::ast;
-use crate::{
+use crate::type_ref::{TypeBound, TypeRef};
-    type_ref::{TypeBound, TypeRef},
-    InFile,
-};
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct ModPath {
@@ -57,8 +53,7 @@ impl Display for ImportAlias {
 impl ModPath {
    pub fn from_src(db: &dyn DefDatabase, path: ast::Path, hygiene: &Hygiene) -> Option<ModPath> {
-        let ctx = LowerCtx::with_hygiene(db, hygiene);
+        lower::convert_path(db, None, path, hygiene)
-        lower::lower_path(path, &ctx).map(|it| (*it.mod_path).clone())
    }
    pub fn from_segments(kind: PathKind, segments: impl IntoIterator<Item = Name>) -> ModPath {
@@ -71,18 +66,6 @@ impl ModPath {
        ModPath { kind, segments: Vec::new() }
    }
-    /// Calls `cb` with all paths, represented by this use item.
-    pub(crate) fn expand_use_item(
-        db: &dyn DefDatabase,
-        item_src: InFile<ast::Use>,
-        hygiene: &Hygiene,
-        mut cb: impl FnMut(ModPath, &ast::UseTree, /* is_glob */ bool, Option<ImportAlias>),
-    ) {
-        if let Some(tree) = item_src.value.use_tree() {
-            lower::lower_use_tree(db, None, tree, hygiene, &mut cb);
-        }
-    }
    pub fn segments(&self) -> &[Name] {
        &self.segments
    }
@@ -136,7 +119,7 @@ pub struct Path {
    type_anchor: Option<Interned<TypeRef>>,
    mod_path: Interned<ModPath>,
    /// Invariant: the same len as `self.mod_path.segments`
-    generic_args: Vec<Option<Arc<GenericArgs>>>,
+    generic_args: Vec<Option<Interned<GenericArgs>>>,
 }
 /// Generic arguments to a path segment (e.g. the `i32` in `Option<i32>`). This
@@ -165,7 +148,7 @@ pub struct AssociatedTypeBinding {
    /// Bounds for the associated type, like in `Iterator<Item:
    /// SomeOtherTrait>`. (This is the unstable `associated_type_bounds`
    /// feature.)
-    pub bounds: Vec<TypeBound>,
+    pub bounds: Vec<Interned<TypeBound>>,
 }
 /// A single generic argument.
@@ -185,7 +168,7 @@ impl Path {
    /// Converts a known mod path to `Path`.
    pub(crate) fn from_known_path(
        path: ModPath,
-        generic_args: Vec<Option<Arc<GenericArgs>>>,
+        generic_args: Vec<Option<Interned<GenericArgs>>>,
    ) -> Path {
        Path { type_anchor: None, mod_path: Interned::new(path), generic_args }
    }
@@ -239,7 +222,7 @@ pub struct PathSegment<'a> {
 pub struct PathSegments<'a> {
    segments: &'a [Name],
-    generic_args: &'a [Option<Arc<GenericArgs>>],
+    generic_args: &'a [Option<Interned<GenericArgs>>],
 }
 impl<'a> PathSegments<'a> {
diff --git a/crates/hir_def/src/path/lower.rs b/crates/hir_def/src/path/lower.rs
index a873325b2..f6220aa92 100644
--- a/crates/hir_def/src/path/lower.rs
+++ b/crates/hir_def/src/path/lower.rs
@@ -3,7 +3,6 @@
 mod lower_use;
 use crate::intern::Interned;
-use std::sync::Arc;
 use either::Either;
 use hir_expand::name::{name, AsName};
@@ -16,7 +15,7 @@ use crate::{
    type_ref::{LifetimeRef, TypeBound, TypeRef},
 };
-pub(super) use lower_use::lower_use_tree;
+pub(super) use lower_use::convert_path;
 /// Converts an `ast::Path` to `Path`. Works with use trees.
 /// It correctly handles `$crate` based path from macro call.
@@ -48,7 +47,7 @@ pub(super) fn lower_path(mut path: ast::Path, ctx: &LowerCtx) -> Option<Path> {
                                    segment.ret_type(),
                                )
                            })
-                            .map(Arc::new);
+                            .map(Interned::new);
                        segments.push(name);
                        generic_args.push(args)
                    }
@@ -87,13 +86,13 @@ pub(super) fn lower_path(mut path: ast::Path, ctx: &LowerCtx) -> Option<Path> {
                        // Insert the type reference (T in the above example) as Self parameter for the trait
                        let last_segment =
                            generic_args.iter_mut().rev().nth(num_segments.saturating_sub(1))?;
-                        if last_segment.is_none() {
+                        let mut args_inner = match last_segment {
-                            *last_segment = Some(Arc::new(GenericArgs::empty()));
+                            Some(it) => it.as_ref().clone(),
+                            None => GenericArgs::empty(),
                        };
-                        let args = last_segment.as_mut().unwrap();
-                        let mut args_inner = Arc::make_mut(args);
                        args_inner.has_self_type = true;
                        args_inner.args.insert(0, GenericArg::Type(self_type));
+                        *last_segment = Some(Interned::new(args_inner));
                    }
                }
            }
@@ -171,7 +170,9 @@ pub(super) fn lower_generic_args(
                    let name = name_ref.as_name();
                    let type_ref = assoc_type_arg.ty().map(|it| TypeRef::from_ast(lower_ctx, it));
                    let bounds = if let Some(l) = assoc_type_arg.type_bound_list() {
-                        l.bounds().map(|it| TypeBound::from_ast(lower_ctx, it)).collect()
+                        l.bounds()
+                            .map(|it| Interned::new(TypeBound::from_ast(lower_ctx, it)))
+                            .collect()
                    } else {
                        Vec::new()
                    };
@@ -204,15 +205,14 @@ fn lower_generic_args_from_fn_path(
 ) -> Option<GenericArgs> {
    let mut args = Vec::new();
    let mut bindings = Vec::new();
-    if let Some(params) = params {
+    let params = params?;
-        let mut param_types = Vec::new();
+    let mut param_types = Vec::new();
-        for param in params.params() {
+    for param in params.params() {
-            let type_ref = TypeRef::from_ast_opt(&ctx, param.ty());
+        let type_ref = TypeRef::from_ast_opt(&ctx, param.ty());
-            param_types.push(type_ref);
+        param_types.push(type_ref);
-        }
-        let arg = GenericArg::Type(TypeRef::Tuple(param_types));
-        args.push(arg);
    }
+    let arg = GenericArg::Type(TypeRef::Tuple(param_types));
+    args.push(arg);
    if let Some(ret_type) = ret_type {
        let type_ref = TypeRef::from_ast_opt(&ctx, ret_type.ty());
        bindings.push(AssociatedTypeBinding {
@@ -220,10 +220,14 @@ fn lower_generic_args_from_fn_path(
            type_ref: Some(type_ref),
            bounds: Vec::new(),
        });
-    }
-    if args.is_empty() && bindings.is_empty() {
-        None
    } else {
-        Some(GenericArgs { args, has_self_type: false, bindings })
+        // -> ()
+        let type_ref = TypeRef::Tuple(Vec::new());
+        bindings.push(AssociatedTypeBinding {
+            name: name![Output],
+            type_ref: Some(type_ref),
+            bounds: Vec::new(),
+        });
    }
+    Some(GenericArgs { args, has_self_type: false, bindings })
 }
diff --git a/crates/hir_def/src/path/lower/lower_use.rs b/crates/hir_def/src/path/lower/lower_use.rs
index ee80e3df3..0ee406f63 100644
--- a/crates/hir_def/src/path/lower/lower_use.rs
+++ b/crates/hir_def/src/path/lower/lower_use.rs
@@ -4,68 +4,15 @@
 use std::iter;
 use either::Either;
-use hir_expand::{hygiene::Hygiene, name::AsName};
+use hir_expand::hygiene::Hygiene;
-use syntax::ast::{self, NameOwner};
+use syntax::{ast, AstNode};
 use crate::{
    db::DefDatabase,
-    path::{ImportAlias, ModPath, PathKind},
+    path::{ModPath, PathKind},
 };
-pub(crate) fn lower_use_tree(
+pub(crate) fn convert_path(
-    db: &dyn DefDatabase,
-    prefix: Option<ModPath>,
-    tree: ast::UseTree,
-    hygiene: &Hygiene,
-    cb: &mut dyn FnMut(ModPath, &ast::UseTree, bool, Option<ImportAlias>),
-) {
-    if let Some(use_tree_list) = tree.use_tree_list() {
-        let prefix = match tree.path() {
-            // E.g. use something::{{{inner}}};
-            None => prefix,
-            // E.g. `use something::{inner}` (prefix is `None`, path is `something`)
-            // or `use something::{path::{inner::{innerer}}}` (prefix is `something::path`, path is `inner`)
-            Some(path) => match convert_path(db, prefix, path, hygiene) {
-                Some(it) => Some(it),
-                None => return, // FIXME: report errors somewhere
-            },
-        };
-        for child_tree in use_tree_list.use_trees() {
-            lower_use_tree(db, prefix.clone(), child_tree, hygiene, cb);
-        }
-    } else {
-        let alias = tree.rename().map(|a| {
-            a.name().map(|it| it.as_name()).map_or(ImportAlias::Underscore, ImportAlias::Alias)
-        });
-        let is_glob = tree.star_token().is_some();
-        if let Some(ast_path) = tree.path() {
-            // Handle self in a path.
-            // E.g. `use something::{self, <...>}`
-            if ast_path.qualifier().is_none() {
-                if let Some(segment) = ast_path.segment() {
-                    if segment.kind() == Some(ast::PathSegmentKind::SelfKw) {
-                        if let Some(prefix) = prefix {
-                            cb(prefix, &tree, false, alias);
-                            return;
-                        }
-                    }
-                }
-            }
-            if let Some(path) = convert_path(db, prefix, ast_path, hygiene) {
-                cb(path, &tree, is_glob, alias)
-            }
-        // FIXME: report errors somewhere
-        // We get here if we do
-        } else if is_glob {
-            cov_mark::hit!(glob_enum_group);
-            if let Some(prefix) = prefix {
-                cb(prefix, &tree, is_glob, None)
-            }
-        }
-    }
-}
-fn convert_path(
    db: &dyn DefDatabase,
    prefix: Option<ModPath>,
    path: ast::Path,
@@ -78,7 +25,7 @@ fn convert_path(
    };
    let segment = path.segment()?;
-    let res = match segment.kind()? {
+    let mut mod_path = match segment.kind()? {
        ast::PathSegmentKind::Name(name_ref) => {
            match hygiene.name_ref_to_name(db.upcast(), name_ref) {
                Either::Left(name) => {
@@ -125,5 +72,18 @@ fn convert_path(
            return None;
        }
    };
-    Some(res)
+    // handle local_inner_macros :
+    // Basically, even in rustc it is quite hacky:
+    // https://github.com/rust-lang/rust/blob/614f273e9388ddd7804d5cbc80b8865068a3744e/src/librustc_resolve/macros.rs#L456
+    // We follow what it did anyway :)
+    if mod_path.segments.len() == 1 && mod_path.kind == PathKind::Plain {
+        if let Some(_macro_call) = path.syntax().parent().and_then(ast::MacroCall::cast) {
+            if let Some(crate_id) = hygiene.local_inner_macros(db.upcast(), path) {
+                mod_path.kind = PathKind::DollarCrate(crate_id);
+            }
+        }
+    }
+    Some(mod_path)
 }
diff --git a/crates/hir_def/src/resolver.rs b/crates/hir_def/src/resolver.rs
index 0391cc49b..fb8a6f260 100644
--- a/crates/hir_def/src/resolver.rs
+++ b/crates/hir_def/src/resolver.rs
@@ -337,22 +337,34 @@ impl Resolver {
    pub fn traits_in_scope(&self, db: &dyn DefDatabase) -> FxHashSet<TraitId> {
        let mut traits = FxHashSet::default();
        for scope in &self.scopes {
-            if let Scope::ModuleScope(m) = scope {
+            match scope {
-                if let Some(prelude) = m.def_map.prelude() {
+                Scope::ModuleScope(m) => {
-                    let prelude_def_map = prelude.def_map(db);
+                    if let Some(prelude) = m.def_map.prelude() {
-                    traits.extend(prelude_def_map[prelude.local_id].scope.traits());
-                }
-                traits.extend(m.def_map[m.module_id].scope.traits());
-                // Add all traits that are in scope because of the containing DefMaps
-                m.def_map.with_ancestor_maps(db, m.module_id, &mut |def_map, module| {
-                    if let Some(prelude) = def_map.prelude() {
                        let prelude_def_map = prelude.def_map(db);
                        traits.extend(prelude_def_map[prelude.local_id].scope.traits());
                    }
-                    traits.extend(def_map[module].scope.traits());
+                    traits.extend(m.def_map[m.module_id].scope.traits());
-                    None::<()>
-                });
+                    // Add all traits that are in scope because of the containing DefMaps
+                    m.def_map.with_ancestor_maps(db, m.module_id, &mut |def_map, module| {
+                        if let Some(prelude) = def_map.prelude() {
+                            let prelude_def_map = prelude.def_map(db);
+                            traits.extend(prelude_def_map[prelude.local_id].scope.traits());
+                        }
+                        traits.extend(def_map[module].scope.traits());
+                        None::<()>
+                    });
+                }
+                &Scope::ImplDefScope(impl_) => {
+                    if let Some(target_trait) = &db.impl_data(impl_).target_trait {
+                        if let Some(TypeNs::TraitId(trait_)) =
+                            self.resolve_path_in_type_ns_fully(db, target_trait.path.mod_path())
+                        {
+                            traits.insert(trait_);
+                        }
+                    }
+                }
+                _ => (),
            }
        }
        traits
diff --git a/crates/hir_def/src/test_db.rs b/crates/hir_def/src/test_db.rs
index 8fa703a57..a9c1e13e2 100644
--- a/crates/hir_def/src/test_db.rs
+++ b/crates/hir_def/src/test_db.rs
@@ -5,19 +5,20 @@ use std::{
    sync::{Arc, Mutex},
 };
-use base_db::{salsa, CrateId, FileId, FileLoader, FileLoaderDelegate, FilePosition, Upcast};
+use base_db::{
+    salsa, CrateId, FileId, FileLoader, FileLoaderDelegate, FilePosition, FileRange, Upcast,
+};
 use base_db::{AnchoredPath, SourceDatabase};
-use hir_expand::diagnostics::Diagnostic;
-use hir_expand::diagnostics::DiagnosticSinkBuilder;
 use hir_expand::{db::AstDatabase, InFile};
 use rustc_hash::FxHashMap;
 use rustc_hash::FxHashSet;
-use syntax::{algo, ast, AstNode, TextRange, TextSize};
+use syntax::{algo, ast, AstNode, SyntaxNode, SyntaxNodePtr, TextRange, TextSize};
 use test_utils::extract_annotations;
 use crate::{
+    body::BodyDiagnostic,
    db::DefDatabase,
-    nameres::{DefMap, ModuleSource},
+    nameres::{diagnostics::DefDiagnosticKind, DefMap, ModuleSource},
    src::HasSource,
    LocalModuleId, Lookup, ModuleDefId, ModuleId,
 };
@@ -262,19 +263,72 @@ impl TestDB {
            .collect()
    }
-    pub(crate) fn diagnostics<F: FnMut(&dyn Diagnostic)>(&self, mut cb: F) {
+    pub(crate) fn diagnostics(&self, cb: &mut dyn FnMut(FileRange, String)) {
        let crate_graph = self.crate_graph();
        for krate in crate_graph.iter() {
            let crate_def_map = self.crate_def_map(krate);
-            let mut sink = DiagnosticSinkBuilder::new().build(&mut cb);
+            for diag in crate_def_map.diagnostics() {
-            for (module_id, module) in crate_def_map.modules() {
+                let (node, message): (InFile<SyntaxNode>, &str) = match &diag.kind {
-                crate_def_map.add_diagnostics(self, module_id, &mut sink);
+                    DefDiagnosticKind::UnresolvedModule { ast, .. } => {
+                        let node = ast.to_node(self.upcast());
+                        (InFile::new(ast.file_id, node.syntax().clone()), "UnresolvedModule")
+                    }
+                    DefDiagnosticKind::UnresolvedExternCrate { ast, .. } => {
+                        let node = ast.to_node(self.upcast());
+                        (InFile::new(ast.file_id, node.syntax().clone()), "UnresolvedExternCrate")
+                    }
+                    DefDiagnosticKind::UnresolvedImport { id, .. } => {
+                        let item_tree = id.item_tree(self.upcast());
+                        let import = &item_tree[id.value];
+                        let node = InFile::new(id.file_id(), import.ast_id).to_node(self.upcast());
+                        (InFile::new(id.file_id(), node.syntax().clone()), "UnresolvedImport")
+                    }
+                    DefDiagnosticKind::UnconfiguredCode { ast, .. } => {
+                        let node = ast.to_node(self.upcast());
+                        (InFile::new(ast.file_id, node.syntax().clone()), "UnconfiguredCode")
+                    }
+                    DefDiagnosticKind::UnresolvedProcMacro { ast, .. } => {
+                        (ast.to_node(self.upcast()), "UnresolvedProcMacro")
+                    }
+                    DefDiagnosticKind::UnresolvedMacroCall { ast, .. } => {
+                        let node = ast.to_node(self.upcast());
+                        (InFile::new(ast.file_id, node.syntax().clone()), "UnresolvedMacroCall")
+                    }
+                    DefDiagnosticKind::MacroError { ast, message } => {
+                        (ast.to_node(self.upcast()), message.as_str())
+                    }
+                };
+                let frange = node.as_ref().original_file_range(self);
+                cb(frange, message.to_string())
+            }
+            for (_module_id, module) in crate_def_map.modules() {
                for decl in module.scope.declarations() {
                    if let ModuleDefId::FunctionId(it) = decl {
                        let source_map = self.body_with_source_map(it.into()).1;
-                        source_map.add_diagnostics(self, &mut sink);
+                        for diag in source_map.diagnostics() {
+                            let (ptr, message): (InFile<SyntaxNodePtr>, &str) = match diag {
+                                BodyDiagnostic::InactiveCode { node, .. } => {
+                                    (node.clone().map(|it| it.into()), "InactiveCode")
+                                }
+                                BodyDiagnostic::MacroError { node, message } => {
+                                    (node.clone().map(|it| it.into()), message.as_str())
+                                }
+                                BodyDiagnostic::UnresolvedProcMacro { node } => {
+                                    (node.clone().map(|it| it.into()), "UnresolvedProcMacro")
+                                }
+                                BodyDiagnostic::UnresolvedMacroCall { node, .. } => {
+                                    (node.clone().map(|it| it.into()), "UnresolvedMacroCall")
+                                }
+                            };
+                            let root = self.parse_or_expand(ptr.file_id).unwrap();
+                            let node = ptr.map(|ptr| ptr.to_node(&root));
+                            let frange = node.as_ref().original_file_range(self);
+                            cb(frange, message.to_string())
+                        }
                    }
                }
            }
@@ -287,14 +341,7 @@ impl TestDB {
        assert!(!annotations.is_empty());
        let mut actual: FxHashMap<FileId, Vec<(TextRange, String)>> = FxHashMap::default();
-        db.diagnostics(|d| {
+        db.diagnostics(&mut |frange, message| {
-            let src = d.display_source();
-            let root = db.parse_or_expand(src.file_id).unwrap();
-            let node = src.map(|ptr| ptr.to_node(&root));
-            let frange = node.as_ref().original_file_range(db);
-            let message = d.message();
            actual.entry(frange.file_id).or_default().push((frange.range, message));
        });
@@ -319,7 +366,7 @@ impl TestDB {
        assert!(annotations.is_empty());
        let mut has_diagnostics = false;
-        db.diagnostics(|_| {
+        db.diagnostics(&mut |_, _| {
            has_diagnostics = true;
        });
diff --git a/crates/hir_def/src/type_ref.rs b/crates/hir_def/src/type_ref.rs
index cdcab7110..cbde6b940 100644
--- a/crates/hir_def/src/type_ref.rs
+++ b/crates/hir_def/src/type_ref.rs
@@ -5,7 +5,7 @@ use hir_expand::{name::Name, AstId, InFile};
 use std::convert::TryInto;
 use syntax::ast;
-use crate::{body::LowerCtx, path::Path};
+use crate::{body::LowerCtx, intern::Interned, path::Path};
 #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
 pub enum Mutability {
@@ -91,8 +91,8 @@ pub enum TypeRef {
    /// A fn pointer. Last element of the vector is the return type.
    Fn(Vec<TypeRef>, bool /*varargs*/),
    // For
-    ImplTrait(Vec<TypeBound>),
+    ImplTrait(Vec<Interned<TypeBound>>),
-    DynTrait(Vec<TypeBound>),
+    DynTrait(Vec<Interned<TypeBound>>),
    Macro(AstId<ast::MacroCall>),
    Error,
 }
@@ -232,7 +232,7 @@ impl TypeRef {
                | TypeRef::Slice(type_ref) => go(&type_ref, f),
                TypeRef::ImplTrait(bounds) | TypeRef::DynTrait(bounds) => {
                    for bound in bounds {
-                        match bound {
+                        match bound.as_ref() {
                            TypeBound::Path(path) => go_path(path, f),
                            TypeBound::Lifetime(_) | TypeBound::Error => (),
                        }
@@ -262,7 +262,7 @@ impl TypeRef {
                            go(type_ref, f);
                        }
                        for bound in &binding.bounds {
-                            match bound {
+                            match bound.as_ref() {
                                TypeBound::Path(path) => go_path(path, f),
                                TypeBound::Lifetime(_) | TypeBound::Error => (),
                            }
@@ -277,9 +277,9 @@ impl TypeRef {
 pub(crate) fn type_bounds_from_ast(
    lower_ctx: &LowerCtx,
    type_bounds_opt: Option<ast::TypeBoundList>,
-) -> Vec<TypeBound> {
+) -> Vec<Interned<TypeBound>> {
    if let Some(type_bounds) = type_bounds_opt {
-        type_bounds.bounds().map(|it| TypeBound::from_ast(lower_ctx, it)).collect()
+        type_bounds.bounds().map(|it| Interned::new(TypeBound::from_ast(lower_ctx, it))).collect()
    } else {
        vec![]
    }
diff --git a/crates/hir_expand/src/builtin_macro.rs b/crates/hir_expand/src/builtin_macro.rs
index 94d7aecb6..0b310ba2f 100644
--- a/crates/hir_expand/src/builtin_macro.rs
+++ b/crates/hir_expand/src/builtin_macro.rs
@@ -8,7 +8,6 @@ use base_db::{AnchoredPath, Edition, FileId};
 use cfg::CfgExpr;
 use either::Either;
 use mbe::{parse_exprs_with_sep, parse_to_token_tree, ExpandResult};
-use parser::FragmentKind;
 use syntax::ast::{self, AstToken};
 macro_rules! register_builtin {
@@ -47,7 +46,7 @@ macro_rules! register_builtin {
                let expander = match *self {
                    $( EagerExpander::$e_kind => $e_expand, )*
                };
-                expander(db,arg_id,tt)
+                expander(db, arg_id, tt)
            }
        }
@@ -64,14 +63,13 @@ macro_rules! register_builtin {
 #[derive(Debug)]
 pub struct ExpandedEager {
    pub(crate) subtree: tt::Subtree,
-    pub(crate) fragment: FragmentKind,
    /// The included file ID of the include macro.
    pub(crate) included_file: Option<FileId>,
 }
 impl ExpandedEager {
-    fn new(subtree: tt::Subtree, fragment: FragmentKind) -> Self {
+    fn new(subtree: tt::Subtree) -> Self {
-        ExpandedEager { subtree, fragment, included_file: None }
+        ExpandedEager { subtree, included_file: None }
    }
 }
@@ -340,7 +338,7 @@ fn compile_error_expand(
        _ => mbe::ExpandError::BindingError("`compile_error!` argument must be a string".into()),
    };
-    ExpandResult { value: Some(ExpandedEager::new(quote! {}, FragmentKind::Items)), err: Some(err) }
+    ExpandResult { value: Some(ExpandedEager::new(quote! {})), err: Some(err) }
 }
 fn concat_expand(
@@ -371,7 +369,7 @@ fn concat_expand(
            }
        }
    }
-    ExpandResult { value: Some(ExpandedEager::new(quote!(#text), FragmentKind::Expr)), err }
+    ExpandResult { value: Some(ExpandedEager::new(quote!(#text))), err }
 }
 fn concat_idents_expand(
@@ -393,7 +391,7 @@ fn concat_idents_expand(
        }
    }
    let ident = tt::Ident { text: ident.into(), id: tt::TokenId::unspecified() };
-    ExpandResult { value: Some(ExpandedEager::new(quote!(#ident), FragmentKind::Expr)), err }
+    ExpandResult { value: Some(ExpandedEager::new(quote!(#ident))), err }
 }
 fn relative_file(
@@ -442,14 +440,7 @@ fn include_expand(
    match res {
        Ok((subtree, file_id)) => {
-            // FIXME:
+            ExpandResult::ok(Some(ExpandedEager { subtree, included_file: Some(file_id) }))
-            // Handle include as expression
-            ExpandResult::ok(Some(ExpandedEager {
-                subtree,
-                fragment: FragmentKind::Items,
-                included_file: Some(file_id),
-            }))
        }
        Err(e) => ExpandResult::only_err(e),
    }
@@ -472,7 +463,7 @@ fn include_bytes_expand(
            id: tt::TokenId::unspecified(),
        }))],
    };
-    ExpandResult::ok(Some(ExpandedEager::new(res, FragmentKind::Expr)))
+    ExpandResult::ok(Some(ExpandedEager::new(res)))
 }
 fn include_str_expand(
@@ -492,14 +483,14 @@ fn include_str_expand(
    let file_id = match relative_file(db, arg_id.into(), &path, true) {
        Ok(file_id) => file_id,
        Err(_) => {
-            return ExpandResult::ok(Some(ExpandedEager::new(quote!(""), FragmentKind::Expr)));
+            return ExpandResult::ok(Some(ExpandedEager::new(quote!(""))));
        }
    };
    let text = db.file_text(file_id);
    let text = &*text;
-    ExpandResult::ok(Some(ExpandedEager::new(quote!(#text), FragmentKind::Expr)))
+    ExpandResult::ok(Some(ExpandedEager::new(quote!(#text))))
 }
 fn get_env_inner(db: &dyn AstDatabase, arg_id: MacroCallId, key: &str) -> Option<String> {
@@ -535,7 +526,7 @@ fn env_expand(
    });
    let expanded = quote! { #s };
-    ExpandResult { value: Some(ExpandedEager::new(expanded, FragmentKind::Expr)), err }
+    ExpandResult { value: Some(ExpandedEager::new(expanded)), err }
 }
 fn option_env_expand(
@@ -553,7 +544,7 @@ fn option_env_expand(
        Some(s) => quote! { std::option::Some(#s) },
    };
-    ExpandResult::ok(Some(ExpandedEager::new(expanded, FragmentKind::Expr)))
+    ExpandResult::ok(Some(ExpandedEager::new(expanded)))
 }
 #[cfg(test)]
@@ -565,6 +556,7 @@ mod tests {
    };
    use base_db::{fixture::WithFixture, SourceDatabase};
    use expect_test::{expect, Expect};
+    use parser::FragmentKind;
    use std::sync::Arc;
    use syntax::ast::NameOwner;
@@ -617,6 +609,7 @@ mod tests {
                    local_inner: false,
                };
+                let fragment = crate::to_fragment_kind(&macro_call);
                let args = macro_call.token_tree().unwrap();
                let parsed_args = mbe::ast_to_token_tree(&args).0;
                let call_id = AstId::new(file_id.into(), ast_id_map.ast_id(&macro_call));
@@ -639,7 +632,7 @@ mod tests {
                        arg_or_expansion: Arc::new(expanded.subtree),
                        included_file: expanded.included_file,
                    }),
-                    kind: MacroCallKind::FnLike { ast_id: call_id, fragment: expanded.fragment },
+                    kind: MacroCallKind::FnLike { ast_id: call_id, fragment },
                };
                let id: MacroCallId = db.intern_macro(loc).into();
diff --git a/crates/hir_expand/src/db.rs b/crates/hir_expand/src/db.rs
index 5c769c1bf..e8f4af309 100644
--- a/crates/hir_expand/src/db.rs
+++ b/crates/hir_expand/src/db.rs
@@ -131,15 +131,15 @@ pub trait AstDatabase: SourceDatabase {
 /// used for completion, where we want to see what 'would happen' if we insert a
 /// token. The `token_to_map` mapped down into the expansion, with the mapped
 /// token returned.
-pub fn expand_hypothetical(
+pub fn expand_speculative(
    db: &dyn AstDatabase,
    actual_macro_call: MacroCallId,
-    hypothetical_args: &ast::TokenTree,
+    speculative_args: &ast::TokenTree,
    token_to_map: SyntaxToken,
 ) -> Option<(SyntaxNode, SyntaxToken)> {
-    let (tt, tmap_1) = mbe::syntax_node_to_token_tree(hypothetical_args.syntax());
+    let (tt, tmap_1) = mbe::syntax_node_to_token_tree(speculative_args.syntax());
    let range =
-        token_to_map.text_range().checked_sub(hypothetical_args.syntax().text_range().start())?;
+        token_to_map.text_range().checked_sub(speculative_args.syntax().text_range().start())?;
    let token_id = tmap_1.token_by_range(range)?;
    let macro_def = {
@@ -147,15 +147,15 @@ pub fn expand_hypothetical(
        db.macro_def(loc.def)?
    };
-    let hypothetical_expansion = macro_def.expand(db, actual_macro_call, &tt);
+    let speculative_expansion = macro_def.expand(db, actual_macro_call, &tt);
    let fragment_kind = macro_fragment_kind(db, actual_macro_call);
    let (node, tmap_2) =
-        mbe::token_tree_to_syntax_node(&hypothetical_expansion.value, fragment_kind).ok()?;
+        mbe::token_tree_to_syntax_node(&speculative_expansion.value, fragment_kind).ok()?;
    let token_id = macro_def.map_id_down(token_id);
-    let range = tmap_2.range_by_token(token_id)?.by_kind(token_to_map.kind())?;
+    let range = tmap_2.range_by_token(token_id, token_to_map.kind())?;
    let token = node.syntax_node().covering_element(range).into_token()?;
    Some((node.syntax_node(), token))
 }
@@ -186,7 +186,7 @@ fn parse_macro_expansion(
        // The final goal we would like to make all parse_macro success,
        // such that the following log will not call anyway.
        let loc: MacroCallLoc = db.lookup_intern_macro(macro_file.macro_call_id);
-        let node = loc.kind.node(db);
+        let node = loc.kind.to_node(db);
        // collect parent information for warning log
        let parents =
@@ -325,7 +325,7 @@ fn macro_expand_with_arg(
    if let Some(eager) = &loc.eager {
        if arg.is_some() {
            return ExpandResult::str_err(
-                "hypothetical macro expansion not implemented for eager macro".to_owned(),
+                "speculative macro expansion not implemented for eager macro".to_owned(),
            );
        } else {
            return ExpandResult {
diff --git a/crates/hir_expand/src/eager.rs b/crates/hir_expand/src/eager.rs
index e165b9c5f..14af628a1 100644
--- a/crates/hir_expand/src/eager.rs
+++ b/crates/hir_expand/src/eager.rs
@@ -113,6 +113,7 @@ pub fn expand_eager_macro(
    let ast_map = db.ast_id_map(macro_call.file_id);
    let call_id = InFile::new(macro_call.file_id, ast_map.ast_id(&macro_call.value));
+    let fragment = crate::to_fragment_kind(&macro_call.value);
    // Note:
    // When `lazy_expand` is called, its *parent* file must be already exists.
@@ -152,7 +153,7 @@ pub fn expand_eager_macro(
                arg_or_expansion: Arc::new(expanded.subtree),
                included_file: expanded.included_file,
            }),
-            kind: MacroCallKind::FnLike { ast_id: call_id, fragment: expanded.fragment },
+            kind: MacroCallKind::FnLike { ast_id: call_id, fragment },
        };
        Ok(db.intern_macro(loc))
@@ -197,7 +198,7 @@ fn eager_macro_recur(
    macro_resolver: &dyn Fn(ast::Path) -> Option<MacroDefId>,
    mut diagnostic_sink: &mut dyn FnMut(mbe::ExpandError),
 ) -> Result<SyntaxNode, ErrorEmitted> {
-    let original = curr.value.clone().clone_for_update();
+    let original = curr.value.clone_for_update();
    let children = original.descendants().filter_map(ast::MacroCall::cast);
    let mut replacements = Vec::new();
diff --git a/crates/hir_expand/src/hygiene.rs b/crates/hir_expand/src/hygiene.rs
index 38e09fdd4..d98913907 100644
--- a/crates/hir_expand/src/hygiene.rs
+++ b/crates/hir_expand/src/hygiene.rs
@@ -154,7 +154,7 @@ impl HygieneInfo {
            },
        };
-        let range = token_map.range_by_token(token_id)?.by_kind(SyntaxKind::IDENT)?;
+        let range = token_map.range_by_token(token_id, SyntaxKind::IDENT)?;
        Some((tt.with_value(range + tt.value), origin))
    }
 }
diff --git a/crates/hir_expand/src/lib.rs b/crates/hir_expand/src/lib.rs
index 92c679dd2..90d8ae240 100644
--- a/crates/hir_expand/src/lib.rs
+++ b/crates/hir_expand/src/lib.rs
@@ -8,7 +8,6 @@ pub mod db;
 pub mod ast_id_map;
 pub mod name;
 pub mod hygiene;
-pub mod diagnostics;
 pub mod builtin_derive;
 pub mod builtin_macro;
 pub mod proc_macro;
@@ -16,6 +15,7 @@ pub mod quote;
 pub mod eager;
 mod input;
+use base_db::ProcMacroKind;
 use either::Either;
 pub use mbe::{ExpandError, ExpandResult};
@@ -108,7 +108,7 @@ impl HirFileId {
            HirFileIdRepr::FileId(_) => None,
            HirFileIdRepr::MacroFile(macro_file) => {
                let loc: MacroCallLoc = db.lookup_intern_macro(macro_file.macro_call_id);
-                Some(loc.kind.node(db))
+                Some(loc.kind.to_node(db))
            }
        }
    }
@@ -153,7 +153,7 @@ impl HirFileId {
            HirFileIdRepr::MacroFile(macro_file) => {
                let loc: MacroCallLoc = db.lookup_intern_macro(macro_file.macro_call_id);
                let item = match loc.def.kind {
-                    MacroDefKind::BuiltInDerive(..) => loc.kind.node(db),
+                    MacroDefKind::BuiltInDerive(..) => loc.kind.to_node(db),
                    _ => return None,
                };
                Some(item.with_value(ast::Item::cast(item.value.clone())?))
@@ -208,7 +208,7 @@ impl MacroDefId {
            MacroDefKind::BuiltIn(_, id) => id,
            MacroDefKind::BuiltInDerive(_, id) => id,
            MacroDefKind::BuiltInEager(_, id) => id,
-            MacroDefKind::ProcMacro(_, id) => return Either::Right(*id),
+            MacroDefKind::ProcMacro(.., id) => return Either::Right(*id),
        };
        Either::Left(*id)
    }
@@ -225,7 +225,7 @@ pub enum MacroDefKind {
    // FIXME: maybe just Builtin and rename BuiltinFnLikeExpander to BuiltinExpander
    BuiltInDerive(BuiltinDeriveExpander, AstId<ast::Macro>),
    BuiltInEager(EagerExpander, AstId<ast::Macro>),
-    ProcMacro(ProcMacroExpander, AstId<ast::Fn>),
+    ProcMacro(ProcMacroExpander, ProcMacroKind, AstId<ast::Fn>),
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -269,7 +269,7 @@ impl MacroCallKind {
        }
    }
-    fn node(&self, db: &dyn db::AstDatabase) -> InFile<SyntaxNode> {
+    pub fn to_node(&self, db: &dyn db::AstDatabase) -> InFile<SyntaxNode> {
        match self {
            MacroCallKind::FnLike { ast_id, .. } => {
                ast_id.with_value(ast_id.to_node(db).syntax().clone())
@@ -329,7 +329,7 @@ impl ExpansionInfo {
        let token_id = self.macro_arg.1.token_by_range(range)?;
        let token_id = self.macro_def.map_id_down(token_id);
-        let range = self.exp_map.range_by_token(token_id)?.by_kind(token.value.kind())?;
+        let range = self.exp_map.range_by_token(token_id, token.value.kind())?;
        let token = self.expanded.value.covering_element(range).into_token()?;
@@ -354,7 +354,7 @@ impl ExpansionInfo {
            },
        };
-        let range = token_map.range_by_token(token_id)?.by_kind(token.value.kind())?;
+        let range = token_map.range_by_token(token_id, token.value.kind())?;
        let token =
            tt.value.covering_element(range + tt.value.text_range().start()).into_token()?;
        Some((tt.with_value(token), origin))
diff --git a/crates/hir_ty/src/diagnostics.rs b/crates/hir_ty/src/diagnostics.rs
index 84fc8ce14..7598e2193 100644
--- a/crates/hir_ty/src/diagnostics.rs
+++ b/crates/hir_ty/src/diagnostics.rs
@@ -8,12 +8,14 @@ use std::{any::Any, fmt};
 use base_db::CrateId;
 use hir_def::{DefWithBodyId, ModuleDefId};
-use hir_expand::diagnostics::{Diagnostic, DiagnosticCode, DiagnosticSink};
 use hir_expand::{name::Name, HirFileId, InFile};
 use stdx::format_to;
 use syntax::{ast, AstPtr, SyntaxNodePtr};
-use crate::db::HirDatabase;
+use crate::{
+    db::HirDatabase,
+    diagnostics_sink::{Diagnostic, DiagnosticCode, DiagnosticSink},
+};
 pub use crate::diagnostics::expr::{record_literal_missing_fields, record_pattern_missing_fields};
@@ -446,15 +448,13 @@ impl Diagnostic for ReplaceFilterMapNextWithFindMap {
 mod tests {
    use base_db::{fixture::WithFixture, FileId, SourceDatabase, SourceDatabaseExt};
    use hir_def::{db::DefDatabase, AssocItemId, ModuleDefId};
-    use hir_expand::{
+    use hir_expand::db::AstDatabase;
-        db::AstDatabase,
-        diagnostics::{Diagnostic, DiagnosticSinkBuilder},
-    };
    use rustc_hash::FxHashMap;
    use syntax::{TextRange, TextSize};
    use crate::{
        diagnostics::{validate_body, validate_module_item},
+        diagnostics_sink::{Diagnostic, DiagnosticSinkBuilder},
        test_db::TestDB,
    };
diff --git a/crates/hir_ty/src/diagnostics/decl_check.rs b/crates/hir_ty/src/diagnostics/decl_check.rs
index 075dc4131..ef982cbcd 100644
--- a/crates/hir_ty/src/diagnostics/decl_check.rs
+++ b/crates/hir_ty/src/diagnostics/decl_check.rs
@@ -19,10 +19,7 @@ use hir_def::{
    src::HasSource,
    AdtId, AttrDefId, ConstId, EnumId, FunctionId, Lookup, ModuleDefId, StaticId, StructId,
 };
-use hir_expand::{
+use hir_expand::name::{AsName, Name};
-    diagnostics::DiagnosticSink,
-    name::{AsName, Name},
-};
 use stdx::{always, never};
 use syntax::{
    ast::{self, NameOwner},
@@ -32,6 +29,7 @@ use syntax::{
 use crate::{
    db::HirDatabase,
    diagnostics::{decl_check::case_conv::*, CaseType, IdentType, IncorrectCase},
+    diagnostics_sink::DiagnosticSink,
 };
 mod allow {
diff --git a/crates/hir_ty/src/diagnostics/expr.rs b/crates/hir_ty/src/diagnostics/expr.rs
index d1f113e7f..86f82e3fa 100644
--- a/crates/hir_ty/src/diagnostics/expr.rs
+++ b/crates/hir_ty/src/diagnostics/expr.rs
@@ -5,7 +5,7 @@
 use std::sync::Arc;
 use hir_def::{expr::Statement, path::path, resolver::HasResolver, AssocItemId, DefWithBodyId};
-use hir_expand::{diagnostics::DiagnosticSink, name};
+use hir_expand::name;
 use rustc_hash::FxHashSet;
 use syntax::{ast, AstPtr};
@@ -16,6 +16,7 @@ use crate::{
        MismatchedArgCount, MissingFields, MissingMatchArms, MissingOkOrSomeInTailExpr,
        MissingPatFields, RemoveThisSemicolon,
    },
+    diagnostics_sink::DiagnosticSink,
    AdtId, InferenceResult, Interner, TyExt, TyKind,
 };
diff --git a/crates/hir_ty/src/diagnostics/unsafe_check.rs b/crates/hir_ty/src/diagnostics/unsafe_check.rs
index 5d13bddea..c3c483425 100644
--- a/crates/hir_ty/src/diagnostics/unsafe_check.rs
+++ b/crates/hir_ty/src/diagnostics/unsafe_check.rs
@@ -9,10 +9,10 @@ use hir_def::{
    resolver::{resolver_for_expr, ResolveValueResult, ValueNs},
    DefWithBodyId,
 };
-use hir_expand::diagnostics::DiagnosticSink;
 use crate::{
-    db::HirDatabase, diagnostics::MissingUnsafe, InferenceResult, Interner, TyExt, TyKind,
+    db::HirDatabase, diagnostics::MissingUnsafe, diagnostics_sink::DiagnosticSink, InferenceResult,
+    Interner, TyExt, TyKind,
 };
 pub(super) struct UnsafeValidator<'a, 'b: 'a> {
diff --git a/crates/hir_expand/src/diagnostics.rs b/crates/hir_ty/src/diagnostics_sink.rs
index bf0b85ce9..084fa8b06 100644
--- a/crates/hir_expand/src/diagnostics.rs
+++ b/crates/hir_ty/src/diagnostics_sink.rs
@@ -16,10 +16,9 @@
 use std::{any::Any, fmt};
+use hir_expand::InFile;
 use syntax::SyntaxNodePtr;
-use crate::InFile;
 #[derive(Copy, Clone, Debug, PartialEq)]
 pub struct DiagnosticCode(pub &'static str);
diff --git a/crates/hir_ty/src/display.rs b/crates/hir_ty/src/display.rs
index 7bbd1a1f7..44f843bf3 100644
--- a/crates/hir_ty/src/display.rs
+++ b/crates/hir_ty/src/display.rs
@@ -13,6 +13,7 @@ use hir_def::{
    db::DefDatabase,
    find_path,
    generics::TypeParamProvenance,
+    intern::{Internable, Interned},
    item_scope::ItemInNs,
    path::{Path, PathKind},
    type_ref::{TypeBound, TypeRef},
@@ -256,6 +257,12 @@ impl<T: HirDisplay> HirDisplay for &'_ T {
    }
 }
+impl<T: HirDisplay + Internable> HirDisplay for Interned<T> {
+    fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
+        HirDisplay::hir_fmt(self.as_ref(), f)
+    }
+}
 impl HirDisplay for ProjectionTy {
    fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
        if f.should_truncate() {
@@ -771,8 +778,10 @@ fn write_bounds_like_dyn_trait(
            }
            WhereClause::AliasEq(alias_eq) if is_fn_trait => {
                is_fn_trait = false;
-                write!(f, " -> ")?;
+                if !alias_eq.ty.is_unit() {
-                alias_eq.ty.hir_fmt(f)?;
+                    write!(f, " -> ")?;
+                    alias_eq.ty.hir_fmt(f)?;
+                }
            }
            WhereClause::AliasEq(AliasEq { ty, alias }) => {
                // in types in actual Rust, these will always come
diff --git a/crates/hir_ty/src/infer.rs b/crates/hir_ty/src/infer.rs
index db3c937ff..7a4268819 100644
--- a/crates/hir_ty/src/infer.rs
+++ b/crates/hir_ty/src/infer.rs
@@ -28,13 +28,14 @@ use hir_def::{
    AdtId, AssocItemId, DefWithBodyId, EnumVariantId, FieldId, FunctionId, HasModule, Lookup,
    TraitId, TypeAliasId, VariantId,
 };
-use hir_expand::{diagnostics::DiagnosticSink, name::name};
+use hir_expand::name::name;
 use la_arena::ArenaMap;
 use rustc_hash::FxHashMap;
 use stdx::impl_from;
 use syntax::SmolStr;
 use super::{DomainGoal, InEnvironment, ProjectionTy, TraitEnvironment, TraitRef, Ty};
+use crate::diagnostics_sink::DiagnosticSink;
 use crate::{
    db::HirDatabase, fold_tys, infer::diagnostics::InferenceDiagnostic,
    lower::ImplTraitLoweringMode, to_assoc_type_id, AliasEq, AliasTy, Goal, Interner, Substitution,
@@ -557,7 +558,13 @@ impl<'a> InferenceContext<'a> {
            self.infer_pat(*pat, &ty, BindingMode::default());
        }
-        let return_ty = self.make_ty_with_mode(&data.ret_type, ImplTraitLoweringMode::Disallowed); // FIXME implement RPIT
+        let error_ty = &TypeRef::Error;
+        let return_ty = if data.is_async() {
+            data.async_ret_type.as_deref().unwrap_or(error_ty)
+        } else {
+            &*data.ret_type
+        };
+        let return_ty = self.make_ty_with_mode(return_ty, ImplTraitLoweringMode::Disallowed); // FIXME implement RPIT
        self.return_ty = return_ty;
    }
@@ -578,9 +585,14 @@ impl<'a> InferenceContext<'a> {
    }
    fn resolve_ops_try_ok(&self) -> Option<TypeAliasId> {
+        // FIXME resolve via lang_item once try v2 is stable
        let path = path![core::ops::Try];
        let trait_ = self.resolver.resolve_known_trait(self.db.upcast(), &path)?;
-        self.db.trait_data(trait_).associated_type_by_name(&name![Ok])
+        let trait_data = self.db.trait_data(trait_);
+        trait_data
+            // FIXME remove once try v2 is stable
+            .associated_type_by_name(&name![Ok])
+            .or_else(|| trait_data.associated_type_by_name(&name![Output]))
    }
    fn resolve_ops_neg_output(&self) -> Option<TypeAliasId> {
@@ -793,11 +805,11 @@ impl std::ops::BitOrAssign for Diverges {
 mod diagnostics {
    use hir_def::{expr::ExprId, DefWithBodyId};
-    use hir_expand::diagnostics::DiagnosticSink;
    use crate::{
        db::HirDatabase,
        diagnostics::{BreakOutsideOfLoop, NoSuchField},
+        diagnostics_sink::DiagnosticSink,
    };
    #[derive(Debug, PartialEq, Eq, Clone)]
diff --git a/crates/hir_ty/src/infer/coerce.rs b/crates/hir_ty/src/infer/coerce.rs
index 765a02b1c..03b97e7db 100644
--- a/crates/hir_ty/src/infer/coerce.rs
+++ b/crates/hir_ty/src/infer/coerce.rs
@@ -76,17 +76,17 @@ impl<'a> InferenceContext<'a> {
        // way around first would mean we make the type variable `!`, instead of
        // just marking it as possibly diverging.
        if self.coerce(&ty2, &ty1) {
-            ty1.clone()
+            ty1
        } else if self.coerce(&ty1, &ty2) {
-            ty2.clone()
+            ty2
        } else {
            if let Some(id) = id {
                self.result
                    .type_mismatches
-                    .insert(id.into(), TypeMismatch { expected: ty1.clone(), actual: ty2.clone() });
+                    .insert(id.into(), TypeMismatch { expected: ty1.clone(), actual: ty2 });
            }
            cov_mark::hit!(coerce_merge_fail_fallback);
-            ty1.clone()
+            ty1
        }
    }
@@ -183,7 +183,7 @@ impl<'a> InferenceContext<'a> {
        // details of coercion errors though, so I think it's useful to leave
        // the structure like it is.
-        let canonicalized = self.canonicalize(from_ty.clone());
+        let canonicalized = self.canonicalize(from_ty);
        let autoderef = autoderef::autoderef(
            self.db,
            self.resolver.krate(),
@@ -389,7 +389,7 @@ impl<'a> InferenceContext<'a> {
                // The CoerceUnsized trait should have two generic params: Self and T.
                return Err(TypeError);
            }
-            b.push(coerce_from.clone()).push(to_ty.clone()).build()
+            b.push(coerce_from).push(to_ty.clone()).build()
        };
        let goal: InEnvironment<DomainGoal> =
diff --git a/crates/hir_ty/src/infer/expr.rs b/crates/hir_ty/src/infer/expr.rs
index eab8fac91..97507305c 100644
--- a/crates/hir_ty/src/infer/expr.rs
+++ b/crates/hir_ty/src/infer/expr.rs
@@ -44,7 +44,7 @@ impl<'a> InferenceContext<'a> {
            if !could_unify {
                self.result.type_mismatches.insert(
                    tgt_expr.into(),
-                    TypeMismatch { expected: expected_ty.clone(), actual: ty.clone() },
+                    TypeMismatch { expected: expected_ty, actual: ty.clone() },
                );
            }
        }
@@ -57,15 +57,14 @@ impl<'a> InferenceContext<'a> {
        let ty = self.infer_expr_inner(expr, &expected);
        let ty = if let Some(target) = expected.only_has_type(&mut self.table) {
            if !self.coerce(&ty, &target) {
-                self.result.type_mismatches.insert(
+                self.result
-                    expr.into(),
+                    .type_mismatches
-                    TypeMismatch { expected: target.clone(), actual: ty.clone() },
+                    .insert(expr.into(), TypeMismatch { expected: target, actual: ty.clone() });
-                );
                // Return actual type when type mismatch.
                // This is needed for diagnostic when return type mismatch.
                ty
            } else {
-                target.clone()
+                target
            }
        } else {
            ty
@@ -805,7 +804,7 @@ impl<'a> InferenceContext<'a> {
                    None => self.table.new_float_var(),
                },
            },
-            Expr::MacroStmts { tail } => self.infer_expr(*tail, expected),
+            Expr::MacroStmts { tail } => self.infer_expr_inner(*tail, expected),
        };
        // use a new type variable if we got unknown here
        let ty = self.insert_type_vars_shallow(ty);
diff --git a/crates/hir_ty/src/infer/pat.rs b/crates/hir_ty/src/infer/pat.rs
index 9c8e3b6ae..83e0a7a9e 100644
--- a/crates/hir_ty/src/infer/pat.rs
+++ b/crates/hir_ty/src/infer/pat.rs
@@ -196,7 +196,7 @@ impl<'a> InferenceContext<'a> {
                let inner_ty = if let Some(subpat) = subpat {
                    self.infer_pat(*subpat, &expected, default_bm)
                } else {
-                    expected.clone()
+                    expected
                };
                let inner_ty = self.insert_type_vars_shallow(inner_ty);
@@ -266,10 +266,9 @@ impl<'a> InferenceContext<'a> {
        // use a new type variable if we got error type here
        let ty = self.insert_type_vars_shallow(ty);
        if !self.unify(&ty, &expected) {
-            self.result.type_mismatches.insert(
+            self.result
-                pat.into(),
+                .type_mismatches
-                TypeMismatch { expected: expected.clone(), actual: ty.clone() },
+                .insert(pat.into(), TypeMismatch { expected: expected, actual: ty.clone() });
-            );
        }
        self.write_pat_ty(pat, ty.clone());
        ty
diff --git a/crates/hir_ty/src/lib.rs b/crates/hir_ty/src/lib.rs
index ef021978a..50e0d6333 100644
--- a/crates/hir_ty/src/lib.rs
+++ b/crates/hir_ty/src/lib.rs
@@ -21,6 +21,7 @@ mod utils;
 mod walk;
 pub mod db;
 pub mod diagnostics;
+pub mod diagnostics_sink;
 pub mod display;
 pub mod method_resolution;
 pub mod primitive;
diff --git a/crates/hir_ty/src/lower.rs b/crates/hir_ty/src/lower.rs
index 8a375b973..c83933c73 100644
--- a/crates/hir_ty/src/lower.rs
+++ b/crates/hir_ty/src/lower.rs
@@ -10,6 +10,7 @@ use std::{iter, sync::Arc};
 use base_db::CrateId;
 use chalk_ir::{cast::Cast, fold::Shift, interner::HasInterner, Mutability, Safety};
+use hir_def::intern::Interned;
 use hir_def::{
    adt::StructKind,
    body::{Expander, LowerCtx},
@@ -843,7 +844,7 @@ impl<'a> TyLoweringContext<'a> {
            })
    }
-    fn lower_impl_trait(&self, bounds: &[TypeBound]) -> ReturnTypeImplTrait {
+    fn lower_impl_trait(&self, bounds: &[Interned<TypeBound>]) -> ReturnTypeImplTrait {
        cov_mark::hit!(lower_rpit);
        let self_ty =
            TyKind::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, 0)).intern(&Interner);
@@ -1025,7 +1026,7 @@ pub(crate) fn trait_environment_query(
    };
    if let Some(AssocContainerId::TraitId(trait_id)) = container {
        // add `Self: Trait<T1, T2, ...>` to the environment in trait
-        // function default implementations (and hypothetical code
+        // function default implementations (and speculative code
        // inside consts or type aliases)
        cov_mark::hit!(trait_self_implements_self);
        let substs = TyBuilder::type_params_subst(db, trait_id);
diff --git a/crates/hir_ty/src/tests.rs b/crates/hir_ty/src/tests.rs
index cc819373c..9d726b024 100644
--- a/crates/hir_ty/src/tests.rs
+++ b/crates/hir_ty/src/tests.rs
@@ -7,6 +7,7 @@ mod traits;
 mod method_resolution;
 mod macros;
 mod display_source_code;
+mod incremental;
 use std::{env, sync::Arc};
@@ -317,50 +318,6 @@ fn ellipsize(mut text: String, max_len: usize) -> String {
    text
 }
-#[test]
-fn typing_whitespace_inside_a_function_should_not_invalidate_types() {
-    let (mut db, pos) = TestDB::with_position(
-        "
-        //- /lib.rs
-        fn foo() -> i32 {
-            $01 + 1
-        }
-    ",
-    );
-    {
-        let events = db.log_executed(|| {
-            let module = db.module_for_file(pos.file_id);
-            let crate_def_map = module.def_map(&db);
-            visit_module(&db, &crate_def_map, module.local_id, &mut |def| {
-                db.infer(def);
-            });
-        });
-        assert!(format!("{:?}", events).contains("infer"))
-    }
-    let new_text = "
-        fn foo() -> i32 {
-            1
-            +
-            1
-        }
-    "
-    .to_string();
-    db.set_file_text(pos.file_id, Arc::new(new_text));
-    {
-        let events = db.log_executed(|| {
-            let module = db.module_for_file(pos.file_id);
-            let crate_def_map = module.def_map(&db);
-            visit_module(&db, &crate_def_map, module.local_id, &mut |def| {
-                db.infer(def);
-            });
-        });
-        assert!(!format!("{:?}", events).contains("infer"), "{:#?}", events)
-    }
-}
 fn check_infer(ra_fixture: &str, expect: Expect) {
    let mut actual = infer(ra_fixture);
    actual.push('\n');
diff --git a/crates/hir_ty/src/tests/coercion.rs b/crates/hir_ty/src/tests/coercion.rs
index bb568ea37..6dac7e103 100644
--- a/crates/hir_ty/src/tests/coercion.rs
+++ b/crates/hir_ty/src/tests/coercion.rs
@@ -832,11 +832,9 @@ fn coerce_unsize_super_trait_cycle() {
    );
 }
-#[ignore]
 #[test]
 fn coerce_unsize_generic() {
-    // FIXME: Implement this
+    // FIXME: fix the type mismatches here
-    // https://doc.rust-lang.org/reference/type-coercions.html#unsized-coercions
    check_infer_with_mismatches(
        r#"
        #[lang = "unsize"]
@@ -854,8 +852,58 @@ fn coerce_unsize_generic() {
            let _: &Bar<[usize]> = &Bar(Foo { t: [1, 2, 3] });
        }
        "#,
-        expect![[r"
+        expect![[r#"
-        "]],
+            209..317 '{     ... }); }': ()
+            219..220 '_': &Foo<[usize]>
+            238..259 '&Foo {..., 3] }': &Foo<[usize]>
+            239..259 'Foo { ..., 3] }': Foo<[usize]>
+            248..257 '[1, 2, 3]': [usize; 3]
+            249..250 '1': usize
+            252..253 '2': usize
+            255..256 '3': usize
+            269..270 '_': &Bar<[usize]>
+            288..314 '&Bar(F... 3] })': &Bar<[i32; 3]>
+            289..292 'Bar': Bar<[i32; 3]>(Foo<[i32; 3]>) -> Bar<[i32; 3]>
+            289..314 'Bar(Fo... 3] })': Bar<[i32; 3]>
+            293..313 'Foo { ..., 3] }': Foo<[i32; 3]>
+            302..311 '[1, 2, 3]': [i32; 3]
+            303..304 '1': i32
+            306..307 '2': i32
+            309..310 '3': i32
+            248..257: expected [usize], got [usize; 3]
+            288..314: expected &Bar<[usize]>, got &Bar<[i32; 3]>
+        "#]],
+    );
+}
+#[test]
+fn coerce_unsize_apit() {
+    // FIXME: #8984
+    check_infer_with_mismatches(
+        r#"
+#[lang = "sized"]
+pub trait Sized {}
+#[lang = "unsize"]
+pub trait Unsize<T> {}
+#[lang = "coerce_unsized"]
+pub trait CoerceUnsized<T> {}
+impl<T: Unsize<U>, U> CoerceUnsized<&U> for &T {}
+trait Foo {}
+fn test(f: impl Foo) {
+    let _: &dyn Foo = &f;
+}
+        "#,
+        expect![[r#"
+            210..211 'f': impl Foo
+            223..252 '{     ... &f; }': ()
+            233..234 '_': &dyn Foo
+            247..249 '&f': &impl Foo
+            248..249 'f': impl Foo
+            247..249: expected &dyn Foo, got &impl Foo
+        "#]],
    );
 }
@@ -912,3 +960,46 @@ fn test() -> i32 {
        "#,
    )
 }
+#[test]
+fn panic_macro() {
+    check_infer_with_mismatches(
+        r#"
+mod panic {
+    #[macro_export]
+    pub macro panic_2015 {
+        () => (
+            $crate::panicking::panic()
+        ),
+    }
+}
+mod panicking {
+    pub fn panic() -> ! { loop {} }
+}
+#[rustc_builtin_macro = "core_panic"]
+macro_rules! panic {
+    // Expands to either `$crate::panic::panic_2015` or `$crate::panic::panic_2021`
+    // depending on the edition of the caller.
+    ($($arg:tt)*) => {
+        /* compiler built-in */
+    };
+}
+fn main() {
+    panic!()
+}
+        "#,
+        expect![[r#"
+            174..185 '{ loop {} }': !
+            176..183 'loop {}': !
+            181..183 '{}': ()
+            !0..24 '$crate...:panic': fn panic() -> !
+            !0..26 '$crate...anic()': !
+            !0..26 '$crate...anic()': !
+            !0..28 '$crate...015!()': !
+            454..470 '{     ...c!() }': ()
+        "#]],
+    );
+}
diff --git a/crates/hir_ty/src/tests/incremental.rs b/crates/hir_ty/src/tests/incremental.rs
new file mode 100644
index 000000000..3e08e83e8
--- /dev/null
+++ b/crates/hir_ty/src/tests/incremental.rs
@@ -0,0 +1,51 @@
+use std::sync::Arc;
+use base_db::{fixture::WithFixture, SourceDatabaseExt};
+use crate::{db::HirDatabase, test_db::TestDB};
+use super::visit_module;
+#[test]
+fn typing_whitespace_inside_a_function_should_not_invalidate_types() {
+    let (mut db, pos) = TestDB::with_position(
+        "
+        //- /lib.rs
+        fn foo() -> i32 {
+            $01 + 1
+        }
+    ",
+    );
+    {
+        let events = db.log_executed(|| {
+            let module = db.module_for_file(pos.file_id);
+            let crate_def_map = module.def_map(&db);
+            visit_module(&db, &crate_def_map, module.local_id, &mut |def| {
+                db.infer(def);
+            });
+        });
+        assert!(format!("{:?}", events).contains("infer"))
+    }
+    let new_text = "
+        fn foo() -> i32 {
+            1
+            +
+            1
+        }
+    "
+    .to_string();
+    db.set_file_text(pos.file_id, Arc::new(new_text));
+    {
+        let events = db.log_executed(|| {
+            let module = db.module_for_file(pos.file_id);
+            let crate_def_map = module.def_map(&db);
+            visit_module(&db, &crate_def_map, module.local_id, &mut |def| {
+                db.infer(def);
+            });
+        });
+        assert!(!format!("{:?}", events).contains("infer"), "{:#?}", events)
+    }
+}
diff --git a/crates/hir_ty/src/tests/macros.rs b/crates/hir_ty/src/tests/macros.rs
index 6588aa46c..7647bb08b 100644
--- a/crates/hir_ty/src/tests/macros.rs
+++ b/crates/hir_ty/src/tests/macros.rs
@@ -752,6 +752,24 @@ fn bar() -> u32 {0}
 }
 #[test]
+fn infer_builtin_macros_include_expression() {
+    check_types(
+        r#"
+//- /main.rs
+#[rustc_builtin_macro]
+macro_rules! include {() => {}}
+fn main() {
+    let i = include!("bla.rs");
+    i;
+  //^ i32
+}
+//- /bla.rs
+0
+        "#,
+    )
+}
+#[test]
 fn infer_builtin_macros_include_child_mod() {
    check_types(
        r#"
diff --git a/crates/hir_ty/src/tests/traits.rs b/crates/hir_ty/src/tests/traits.rs
index a5a2df54c..7c0ff2170 100644
--- a/crates/hir_ty/src/tests/traits.rs
+++ b/crates/hir_ty/src/tests/traits.rs
@@ -161,6 +161,43 @@ mod result {
 }
 #[test]
+fn infer_tryv2() {
+    check_types(
+        r#"
+//- /main.rs crate:main deps:core
+fn test() {
+    let r: Result<i32, u64> = Result::Ok(1);
+    let v = r?;
+    v;
+} //^ i32
+//- /core.rs crate:core
+#[prelude_import] use ops::*;
+mod ops {
+    trait Try {
+        type Output;
+        type Residual;
+    }
+}
+#[prelude_import] use result::*;
+mod result {
+    enum Infallible {}
+    enum Result<O, E> {
+        Ok(O),
+        Err(E)
+    }
+    impl<O, E> crate::ops::Try for Result<O, E> {
+        type Output = O;
+        type Error = Result<Infallible, E>;
+    }
+}
+"#,
+    );
+}
+#[test]
 fn infer_for_loop() {
    check_types(
        r#"
@@ -3041,7 +3078,7 @@ fn infer_fn_trait_arg() {
 #[test]
 fn infer_box_fn_arg() {
-    // The type mismatch is a bug
+    // The type mismatch is because we don't define Unsize and CoerceUnsized
    check_infer_with_mismatches(
        r#"
 //- /lib.rs deps:std
@@ -3101,7 +3138,7 @@ fn foo() {
            555..557 'ps': {unknown}
            559..561 '{}': ()
            568..569 'f': Box<dyn FnOnce(&Option<i32>)>
-            568..573 'f(&s)': FnOnce::Output<dyn FnOnce(&Option<i32>), (&Option<i32>,)>
+            568..573 'f(&s)': ()
            570..572 '&s': &Option<i32>
            571..572 's': Option<i32>
            549..562: expected Box<dyn FnOnce(&Option<i32>)>, got Box<|{unknown}| -> ()>
@@ -3571,3 +3608,104 @@ fn main() {
        "#]],
    )
 }
+#[test]
+fn fn_returning_unit() {
+    check_infer_with_mismatches(
+        r#"
+#[lang = "fn_once"]
+trait FnOnce<Args> {
+    type Output;
+}
+fn test<F: FnOnce()>(f: F) {
+    let _: () = f();
+}"#,
+        expect![[r#"
+            82..83 'f': F
+            88..112 '{     ...f(); }': ()
+            98..99 '_': ()
+            106..107 'f': F
+            106..109 'f()': ()
+        "#]],
+    );
+}
+#[test]
+fn trait_in_scope_of_trait_impl() {
+    check_infer(
+        r#"
+mod foo {
+    pub trait Foo {
+        fn foo(self);
+        fn bar(self) -> usize { 0 }
+    }
+}
+impl foo::Foo for u32 {
+    fn foo(self) {
+        let _x = self.bar();
+    }
+}
+    "#,
+        expect![[r#"
+            45..49 'self': Self
+            67..71 'self': Self
+            82..87 '{ 0 }': usize
+            84..85 '0': usize
+            131..135 'self': u32
+            137..173 '{     ...     }': ()
+            151..153 '_x': usize
+            156..160 'self': u32
+            156..166 'self.bar()': usize
+        "#]],
+    );
+}
+#[test]
+fn infer_async_ret_type() {
+    check_types(
+        r#"
+//- /main.rs crate:main deps:core
+enum Result<T, E> {
+    Ok(T),
+    Err(E),
+}
+use Result::*;
+struct Fooey;
+impl Fooey {
+    fn collect<B: Convert>(self) -> B {
+        B::new()
+    }
+}
+trait Convert {
+    fn new() -> Self;
+}
+impl Convert for u32 {
+    fn new() -> Self {
+        0
+    }
+}
+async fn get_accounts() -> Result<u32, ()> {
+    let ret = Fooey.collect();
+    //                      ^ u32
+    Ok(ret)
+}
+//- /core.rs crate:core
+#[prelude_import] use future::*;
+mod future {
+    #[lang = "future_trait"]
+    trait Future {
+        type Output;
+    }
+}
+"#,
+    );
+}
diff --git a/crates/ide/src/annotations.rs b/crates/ide/src/annotations.rs
index 5ebe7fd0e..8d68dce05 100644
--- a/crates/ide/src/annotations.rs
+++ b/crates/ide/src/annotations.rs
@@ -5,7 +5,7 @@ use ide_db::{
    helpers::visit_file_defs,
    RootDatabase,
 };
-use syntax::{ast::NameOwner, AstNode, TextRange, TextSize};
+use syntax::{ast::NameOwner, AstNode, TextRange};
 use crate::{
    fn_references::find_all_methods,
@@ -58,7 +58,7 @@ pub(crate) fn annotations(
            }
            let action = runnable.action();
-            let range = runnable.nav.full_range;
+            let range = runnable.nav.focus_or_full_range();
            if config.run {
                annotations.push(Annotation {
@@ -80,26 +80,26 @@ pub(crate) fn annotations(
    visit_file_defs(&Semantics::new(db), file_id, &mut |def| match def {
        Either::Left(def) => {
-            let node = match def {
+            let range = match def {
                hir::ModuleDef::Const(konst) => {
-                    konst.source(db).and_then(|node| range_and_position_of(&node, file_id))
+                    konst.source(db).and_then(|node| name_range(&node, file_id))
                }
                hir::ModuleDef::Trait(trait_) => {
-                    trait_.source(db).and_then(|node| range_and_position_of(&node, file_id))
+                    trait_.source(db).and_then(|node| name_range(&node, file_id))
                }
                hir::ModuleDef::Adt(hir::Adt::Struct(strukt)) => {
-                    strukt.source(db).and_then(|node| range_and_position_of(&node, file_id))
+                    strukt.source(db).and_then(|node| name_range(&node, file_id))
                }
                hir::ModuleDef::Adt(hir::Adt::Enum(enum_)) => {
-                    enum_.source(db).and_then(|node| range_and_position_of(&node, file_id))
+                    enum_.source(db).and_then(|node| name_range(&node, file_id))
                }
                hir::ModuleDef::Adt(hir::Adt::Union(union)) => {
-                    union.source(db).and_then(|node| range_and_position_of(&node, file_id))
+                    union.source(db).and_then(|node| name_range(&node, file_id))
                }
                _ => None,
            };
-            let (offset, range) = match node {
+            let (range, offset) = match range {
-                Some(node) => node,
+                Some(range) => (range, range.start()),
                None => return,
            };
@@ -122,18 +122,12 @@ pub(crate) fn annotations(
                });
            }
-            fn range_and_position_of<T: NameOwner>(
+            fn name_range<T: NameOwner>(node: &InFile<T>, file_id: FileId) -> Option<TextRange> {
-                node: &InFile<T>,
+                if node.file_id == file_id.into() {
-                file_id: FileId,
+                    node.value.name().map(|it| it.syntax().text_range())
-            ) -> Option<(TextSize, TextRange)> {
+                } else {
-                if node.file_id != file_id.into() {
                    // Node is outside the file we are adding annotations to (e.g. macros).
                    None
-                } else {
-                    Some((
-                        node.value.name()?.syntax().text_range().start(),
-                        node.value.syntax().text_range(),
-                    ))
                }
            }
        }
@@ -141,13 +135,15 @@ pub(crate) fn annotations(
    });
    if config.annotate_method_references {
-        annotations.extend(find_all_methods(db, file_id).into_iter().map(|method| Annotation {
+        annotations.extend(find_all_methods(db, file_id).into_iter().map(
-            range: method.range,
+            |FileRange { file_id, range }| Annotation {
-            kind: AnnotationKind::HasReferences {
+                range,
-                position: FilePosition { file_id, offset: method.range.start() },
+                kind: AnnotationKind::HasReferences {
-                data: None,
+                    position: FilePosition { file_id, offset: range.start() },
+                    data: None,
+                },
            },
-        }));
+        ));
    }
    annotations
@@ -228,7 +224,7 @@ fn main() {
            expect![[r#"
                [
                    Annotation {
-                        range: 50..85,
+                        range: 53..57,
                        kind: Runnable {
                            debug: false,
                            runnable: Runnable {
@@ -247,7 +243,7 @@ fn main() {
                        },
                    },
                    Annotation {
-                        range: 50..85,
+                        range: 53..57,
                        kind: Runnable {
                            debug: true,
                            runnable: Runnable {
@@ -266,7 +262,7 @@ fn main() {
                        },
                    },
                    Annotation {
-                        range: 0..22,
+                        range: 6..10,
                        kind: HasReferences {
                            position: FilePosition {
                                file_id: FileId(
@@ -287,7 +283,7 @@ fn main() {
                        },
                    },
                    Annotation {
-                        range: 24..48,
+                        range: 30..36,
                        kind: HasReferences {
                            position: FilePosition {
                                file_id: FileId(
@@ -332,7 +328,7 @@ fn main() {
            expect![[r#"
                [
                    Annotation {
-                        range: 14..48,
+                        range: 17..21,
                        kind: Runnable {
                            debug: false,
                            runnable: Runnable {
@@ -351,7 +347,7 @@ fn main() {
                        },
                    },
                    Annotation {
-                        range: 14..48,
+                        range: 17..21,
                        kind: Runnable {
                            debug: true,
                            runnable: Runnable {
@@ -370,7 +366,7 @@ fn main() {
                        },
                    },
                    Annotation {
-                        range: 0..12,
+                        range: 7..11,
                        kind: HasImpls {
                            position: FilePosition {
                                file_id: FileId(
@@ -384,7 +380,7 @@ fn main() {
                        },
                    },
                    Annotation {
-                        range: 0..12,
+                        range: 7..11,
                        kind: HasReferences {
                            position: FilePosition {
                                file_id: FileId(
@@ -440,7 +436,7 @@ fn main() {
            expect![[r#"
                [
                    Annotation {
-                        range: 66..100,
+                        range: 69..73,
                        kind: Runnable {
                            debug: false,
                            runnable: Runnable {
@@ -459,7 +455,7 @@ fn main() {
                        },
                    },
                    Annotation {
-                        range: 66..100,
+                        range: 69..73,
                        kind: Runnable {
                            debug: true,
                            runnable: Runnable {
@@ -478,7 +474,7 @@ fn main() {
                        },
                    },
                    Annotation {
-                        range: 0..12,
+                        range: 7..11,
                        kind: HasImpls {
                            position: FilePosition {
                                file_id: FileId(
@@ -502,7 +498,7 @@ fn main() {
                        },
                    },
                    Annotation {
-                        range: 0..12,
+                        range: 7..11,
                        kind: HasReferences {
                            position: FilePosition {
                                file_id: FileId(
@@ -529,7 +525,7 @@ fn main() {
                        },
                    },
                    Annotation {
-                        range: 14..34,
+                        range: 20..31,
                        kind: HasImpls {
                            position: FilePosition {
                                file_id: FileId(
@@ -553,7 +549,7 @@ fn main() {
                        },
                    },
                    Annotation {
-                        range: 14..34,
+                        range: 20..31,
                        kind: HasReferences {
                            position: FilePosition {
                                file_id: FileId(
@@ -601,7 +597,7 @@ fn main() {}
            expect![[r#"
                [
                    Annotation {
-                        range: 0..12,
+                        range: 3..7,
                        kind: Runnable {
                            debug: false,
                            runnable: Runnable {
@@ -620,7 +616,7 @@ fn main() {}
                        },
                    },
                    Annotation {
-                        range: 0..12,
+                        range: 3..7,
                        kind: Runnable {
                            debug: true,
                            runnable: Runnable {
@@ -674,7 +670,7 @@ fn main() {
            expect![[r#"
                [
                    Annotation {
-                        range: 58..95,
+                        range: 61..65,
                        kind: Runnable {
                            debug: false,
                            runnable: Runnable {
@@ -693,7 +689,7 @@ fn main() {
                        },
                    },
                    Annotation {
-                        range: 58..95,
+                        range: 61..65,
                        kind: Runnable {
                            debug: true,
                            runnable: Runnable {
@@ -712,7 +708,7 @@ fn main() {
                        },
                    },
                    Annotation {
-                        range: 0..12,
+                        range: 7..11,
                        kind: HasImpls {
                            position: FilePosition {
                                file_id: FileId(
@@ -736,7 +732,7 @@ fn main() {
                        },
                    },
                    Annotation {
-                        range: 0..12,
+                        range: 7..11,
                        kind: HasReferences {
                            position: FilePosition {
                                file_id: FileId(
@@ -816,7 +812,7 @@ mod tests {
            expect![[r#"
                [
                    Annotation {
-                        range: 0..12,
+                        range: 3..7,
                        kind: Runnable {
                            debug: false,
                            runnable: Runnable {
@@ -835,7 +831,7 @@ mod tests {
                        },
                    },
                    Annotation {
-                        range: 0..12,
+                        range: 3..7,
                        kind: Runnable {
                            debug: true,
                            runnable: Runnable {
@@ -854,7 +850,7 @@ mod tests {
                        },
                    },
                    Annotation {
-                        range: 14..64,
+                        range: 18..23,
                        kind: Runnable {
                            debug: false,
                            runnable: Runnable {
@@ -875,7 +871,7 @@ mod tests {
                        },
                    },
                    Annotation {
-                        range: 14..64,
+                        range: 18..23,
                        kind: Runnable {
                            debug: true,
                            runnable: Runnable {
@@ -896,7 +892,7 @@ mod tests {
                        },
                    },
                    Annotation {
-                        range: 30..62,
+                        range: 45..57,
                        kind: Runnable {
                            debug: false,
                            runnable: Runnable {
@@ -922,7 +918,7 @@ mod tests {
                        },
                    },
                    Annotation {
-                        range: 30..62,
+                        range: 45..57,
                        kind: Runnable {
                            debug: true,
                            runnable: Runnable {
diff --git a/crates/ide/src/diagnostics.rs b/crates/ide/src/diagnostics.rs
index 27d347dbd..6cf5810fa 100644
--- a/crates/ide/src/diagnostics.rs
+++ b/crates/ide/src/diagnostics.rs
@@ -299,10 +299,10 @@ fn unresolved_fix(id: &'static str, label: &str, target: TextRange) -> Assist {
 #[cfg(test)]
 mod tests {
-    use expect_test::{expect, Expect};
+    use expect_test::Expect;
    use ide_assists::AssistResolveStrategy;
    use stdx::trim_indent;
-    use test_utils::assert_eq_text;
+    use test_utils::{assert_eq_text, extract_annotations};
    use crate::{fixture, DiagnosticsConfig};
@@ -311,6 +311,7 @@ mod tests {
    ///  * a diagnostic is produced
    ///  * the first diagnostic fix trigger range touches the input cursor position
    ///  * that the contents of the file containing the cursor match `after` after the diagnostic fix is applied
+    #[track_caller]
    pub(crate) fn check_fix(ra_fixture_before: &str, ra_fixture_after: &str) {
        check_nth_fix(0, ra_fixture_before, ra_fixture_after);
    }
@@ -325,6 +326,7 @@ mod tests {
        }
    }
+    #[track_caller]
    fn check_nth_fix(nth: usize, ra_fixture_before: &str, ra_fixture_after: &str) {
        let after = trim_indent(ra_fixture_after);
@@ -396,26 +398,51 @@ mod tests {
        expect.assert_debug_eq(&diagnostics)
    }
+    pub(crate) fn check_diagnostics(ra_fixture: &str) {
+        let (analysis, file_id) = fixture::file(ra_fixture);
+        let diagnostics = analysis
+            .diagnostics(&DiagnosticsConfig::default(), AssistResolveStrategy::All, file_id)
+            .unwrap();
+        let expected = extract_annotations(&*analysis.file_text(file_id).unwrap());
+        let actual = diagnostics.into_iter().map(|d| (d.range, d.message)).collect::<Vec<_>>();
+        assert_eq!(expected, actual);
+    }
    #[test]
    fn test_unresolved_macro_range() {
-        check_expect(
+        check_diagnostics(
-            r#"foo::bar!(92);"#,
+            r#"
-            expect![[r#"
+foo::bar!(92);
-                [
+   //^^^ unresolved macro `foo::bar!`
-                    Diagnostic {
+"#,
-                        message: "unresolved macro `foo::bar!`",
+        );
-                        range: 5..8,
+    }
-                        severity: Error,
-                        fixes: None,
+    #[test]
-                        unused: false,
+    fn unresolved_import_in_use_tree() {
-                        code: Some(
+        // Only the relevant part of a nested `use` item should be highlighted.
-                            DiagnosticCode(
+        check_diagnostics(
-                                "unresolved-macro-call",
+            r#"
-                            ),
+use does_exist::{Exists, DoesntExist};
-                        ),
+                       //^^^^^^^^^^^ unresolved import
-                    },
-                ]
+use {does_not_exist::*, does_exist};
-            "#]],
+   //^^^^^^^^^^^^^^^^^ unresolved import
+use does_not_exist::{
+    a,
+  //^ unresolved import
+    b,
+  //^ unresolved import
+    c,
+  //^ unresolved import
+};
+mod does_exist {
+    pub struct Exists;
+}
+"#,
        );
    }
diff --git a/crates/ide/src/fixture.rs b/crates/ide/src/fixture.rs
index cc6641ba1..6780af617 100644
--- a/crates/ide/src/fixture.rs
+++ b/crates/ide/src/fixture.rs
@@ -1,7 +1,7 @@
 //! Utilities for creating `Analysis` instances for tests.
 use ide_db::base_db::fixture::ChangeFixture;
 use syntax::{TextRange, TextSize};
-use test_utils::{extract_annotations, RangeOrOffset};
+use test_utils::extract_annotations;
 use crate::{Analysis, AnalysisHost, FileId, FilePosition, FileRange};
@@ -27,10 +27,7 @@ pub(crate) fn position(ra_fixture: &str) -> (Analysis, FilePosition) {
    let change_fixture = ChangeFixture::parse(ra_fixture);
    host.db.apply_change(change_fixture.change);
    let (file_id, range_or_offset) = change_fixture.file_position.expect("expected a marker ($0)");
-    let offset = match range_or_offset {
+    let offset = range_or_offset.expect_offset();
-        RangeOrOffset::Range(_) => panic!(),
-        RangeOrOffset::Offset(it) => it,
-    };
    (host.analysis(), FilePosition { file_id, offset })
 }
@@ -40,10 +37,7 @@ pub(crate) fn range(ra_fixture: &str) -> (Analysis, FileRange) {
    let change_fixture = ChangeFixture::parse(ra_fixture);
    host.db.apply_change(change_fixture.change);
    let (file_id, range_or_offset) = change_fixture.file_position.expect("expected a marker ($0)");
-    let range = match range_or_offset {
+    let range = range_or_offset.expect_range();
-        RangeOrOffset::Range(it) => it,
-        RangeOrOffset::Offset(_) => panic!(),
-    };
    (host.analysis(), FileRange { file_id, range })
 }
@@ -53,10 +47,7 @@ pub(crate) fn annotations(ra_fixture: &str) -> (Analysis, FilePosition, Vec<(Fil
    let change_fixture = ChangeFixture::parse(ra_fixture);
    host.db.apply_change(change_fixture.change);
    let (file_id, range_or_offset) = change_fixture.file_position.expect("expected a marker ($0)");
-    let offset = match range_or_offset {
+    let offset = range_or_offset.expect_offset();
-        RangeOrOffset::Range(_) => panic!(),
-        RangeOrOffset::Offset(it) => it,
-    };
    let annotations = change_fixture
        .files
diff --git a/crates/ide/src/folding_ranges.rs b/crates/ide/src/folding_ranges.rs
index b893c1c54..c5015a345 100755
--- a/crates/ide/src/folding_ranges.rs
+++ b/crates/ide/src/folding_ranges.rs
@@ -19,6 +19,7 @@ pub enum FoldKind {
    Statics,
    Array,
    WhereClause,
+    ReturnType,
 }
 #[derive(Debug)]
@@ -131,6 +132,7 @@ fn fold_kind(kind: SyntaxKind) -> Option<FoldKind> {
        COMMENT => Some(FoldKind::Comment),
        ARG_LIST | PARAM_LIST => Some(FoldKind::ArgList),
        ARRAY_EXPR => Some(FoldKind::Array),
+        RET_TYPE => Some(FoldKind::ReturnType),
        ASSOC_ITEM_LIST
        | RECORD_FIELD_LIST
        | RECORD_PAT_FIELD_LIST
@@ -300,6 +302,7 @@ mod tests {
                FoldKind::Statics => "statics",
                FoldKind::Array => "array",
                FoldKind::WhereClause => "whereclause",
+                FoldKind::ReturnType => "returntype",
            };
            assert_eq!(kind, &attr.unwrap());
        }
@@ -560,4 +563,18 @@ where
 "#,
        )
    }
+    #[test]
+    fn fold_return_type() {
+        check(
+            r#"
+fn foo()<fold returntype>-> (
+    bool,
+    bool,
+)</fold> { (true, true) }
+fn bar() -> (bool, bool) { (true, true) }
+            "#,
+        )
+    }
 }
diff --git a/crates/ide/src/goto_implementation.rs b/crates/ide/src/goto_implementation.rs
index 05130a237..43356a94e 100644
--- a/crates/ide/src/goto_implementation.rs
+++ b/crates/ide/src/goto_implementation.rs
@@ -1,4 +1,4 @@
-use hir::{Impl, Semantics};
+use hir::{AsAssocItem, Impl, Semantics};
 use ide_db::{
    defs::{Definition, NameClass, NameRefClass},
    RootDatabase,
@@ -36,6 +36,7 @@ pub(crate) fn goto_implementation(
        }
        ast::NameLike::Lifetime(_) => None,
    }?;
    let def = match def {
        Definition::ModuleDef(def) => def,
        _ => return None,
@@ -48,6 +49,18 @@ pub(crate) fn goto_implementation(
            let module = sema.to_module_def(position.file_id)?;
            impls_for_ty(&sema, builtin.ty(sema.db, module))
        }
+        hir::ModuleDef::Function(f) => {
+            let assoc = f.as_assoc_item(sema.db)?;
+            let name = assoc.name(sema.db)?;
+            let trait_ = assoc.containing_trait(sema.db)?;
+            impls_for_trait_item(&sema, trait_, name)
+        }
+        hir::ModuleDef::Const(c) => {
+            let assoc = c.as_assoc_item(sema.db)?;
+            let name = assoc.name(sema.db)?;
+            let trait_ = assoc.containing_trait(sema.db)?;
+            impls_for_trait_item(&sema, trait_, name)
+        }
        _ => return None,
    };
    Some(RangeInfo { range: node.syntax().text_range(), info: navs })
@@ -64,6 +77,23 @@ fn impls_for_trait(sema: &Semantics<RootDatabase>, trait_: hir::Trait) -> Vec<Na
        .collect()
 }
+fn impls_for_trait_item(
+    sema: &Semantics<RootDatabase>,
+    trait_: hir::Trait,
+    fun_name: hir::Name,
+) -> Vec<NavigationTarget> {
+    Impl::all_for_trait(sema.db, trait_)
+        .into_iter()
+        .filter_map(|imp| {
+            let item = imp.items(sema.db).iter().find_map(|itm| {
+                let itm_name = itm.name(sema.db)?;
+                (itm_name == fun_name).then(|| itm.clone())
+            })?;
+            item.try_to_nav(sema.db)
+        })
+        .collect()
+}
 #[cfg(test)]
 mod tests {
    use ide_db::base_db::FileRange;
@@ -262,4 +292,42 @@ impl bool {}
 "#,
        );
    }
+    #[test]
+    fn goto_implementation_trait_functions() {
+        check(
+            r#"
+trait Tr {
+    fn f$0();
+}
+struct S;
+impl Tr for S {
+    fn f() {
+     //^
+        println!("Hello, world!");
+    }
+}
+"#,
+        );
+    }
+    #[test]
+    fn goto_implementation_trait_assoc_const() {
+        check(
+            r#"
+trait Tr {
+    const C$0: usize;
+}
+struct S;
+impl Tr for S {
+    const C: usize = 4;
+        //^
+}
+"#,
+        );
+    }
 }
diff --git a/crates/ide/src/goto_type_definition.rs b/crates/ide/src/goto_type_definition.rs
index f3284bb96..004d9cb68 100644
--- a/crates/ide/src/goto_type_definition.rs
+++ b/crates/ide/src/goto_type_definition.rs
@@ -1,3 +1,4 @@
+use ide_db::base_db::Upcast;
 use ide_db::RootDatabase;
 use syntax::{ast, match_ast, AstNode, SyntaxKind::*, SyntaxToken, TokenAtOffset, T};
@@ -31,6 +32,7 @@ pub(crate) fn goto_type_definition(
                ast::Pat(it) => sema.type_of_pat(&it)?,
                ast::SelfParam(it) => sema.type_of_self(&it)?,
                ast::Type(it) => sema.resolve_type(&it)?,
+                ast::RecordField(it) => sema.to_def(&it).map(|d| d.ty(db.upcast()))?,
                _ => return None,
            }
        };
@@ -161,4 +163,34 @@ impl Foo$0 {}
 "#,
        )
    }
+    #[test]
+    fn goto_def_for_struct_field() {
+        check(
+            r#"
+struct Bar;
+     //^^^
+struct Foo {
+    bar$0: Bar,
+}
+"#,
+        );
+    }
+    #[test]
+    fn goto_def_for_enum_struct_field() {
+        check(
+            r#"
+struct Bar;
+     //^^^
+enum Foo {
+    Bar {
+        bar$0: Bar
+    },
+}
+"#,
+        );
+    }
 }
diff --git a/crates/ide/src/inlay_hints.rs b/crates/ide/src/inlay_hints.rs
index 8f490e922..85f887737 100644
--- a/crates/ide/src/inlay_hints.rs
+++ b/crates/ide/src/inlay_hints.rs
@@ -219,7 +219,7 @@ fn hint_iterator(
 ) -> Option<SmolStr> {
    let db = sema.db;
    let strukt = ty.strip_references().as_adt()?;
-    let krate = strukt.krate(db);
+    let krate = strukt.module(db).krate();
    if krate != famous_defs.core()? {
        return None;
    }
diff --git a/crates/ide/src/runnables.rs b/crates/ide/src/runnables.rs
index f76715d84..ce1c76f37 100644
--- a/crates/ide/src/runnables.rs
+++ b/crates/ide/src/runnables.rs
@@ -227,7 +227,7 @@ pub(crate) fn runnable_fn(sema: &Semantics<RootDatabase>, def: hir::Function) ->
    let func = def.source(sema.db)?;
    let name_string = def.name(sema.db).to_string();
-    let root = def.krate(sema.db)?.root_module(sema.db);
+    let root = def.module(sema.db).krate().root_module(sema.db);
    let kind = if name_string == "main" && def.module(sema.db) == root {
        RunnableKind::Bin
diff --git a/crates/ide/src/syntax_highlighting.rs b/crates/ide/src/syntax_highlighting.rs
index 9df8d21af..79c2f4a1e 100644
--- a/crates/ide/src/syntax_highlighting.rs
+++ b/crates/ide/src/syntax_highlighting.rs
@@ -42,13 +42,107 @@ pub struct HlRange {
 // Feature: Semantic Syntax Highlighting
 //
 // rust-analyzer highlights the code semantically.
-// For example, `bar` in `foo::Bar` might be colored differently depending on whether `Bar` is an enum or a trait.
+// For example, `Bar` in `foo::Bar` might be colored differently depending on whether `Bar` is an enum or a trait.
-// rust-analyzer does not specify colors directly, instead it assigns tag (like `struct`) and a set of modifiers (like `declaration`) to each token.
+// rust-analyzer does not specify colors directly, instead it assigns a tag (like `struct`) and a set of modifiers (like `declaration`) to each token.
 // It's up to the client to map those to specific colors.
 //
 // The general rule is that a reference to an entity gets colored the same way as the entity itself.
 // We also give special modifier for `mut` and `&mut` local variables.
 //
+//
+// .Token Tags
+//
+// Rust-analyzer currently emits the following token tags:
+//
+// - For items:
+// +
+// [horizontal]
+// enum:: Emitted for enums.
+// function:: Emitted for free-standing functions.
+// macro:: Emitted for macros.
+// method:: Emitted for associated functions, also knowns as methods.
+// namespace:: Emitted for modules.
+// struct:: Emitted for structs.
+// trait:: Emitted for traits.
+// typeAlias:: Emitted for type aliases and `Self` in `impl`s.
+// union:: Emitted for unions.
+//
+// - For literals:
+// +
+// [horizontal]
+// boolean:: Emitted for the boolean literals `true` and `false`.
+// character:: Emitted for character literals.
+// number:: Emitted for numeric literals.
+// string:: Emitted for string literals.
+// escapeSequence:: Emitted for escaped sequences inside strings like `\n`.
+// formatSpecifier:: Emitted for format specifiers `{:?}` in `format!`-like macros.
+//
+// - For operators:
+// +
+// [horizontal]
+// operator:: Emitted for general operators.
+// arithmetic:: Emitted for the arithmetic operators `+`, `-`, `*`, `/`, `+=`, `-=`, `*=`, `/=`.
+// bitwise:: Emitted for the bitwise operators `|`, `&`, `!`, `^`, `|=`, `&=`, `^=`.
+// comparison:: Emitted for the comparison operators `>`, `<`, `==`, `>=`, `<=`, `!=`.
+// logical:: Emitted for the logical operators `||`, `&&`, `!`.
+//
+// - For punctuation:
+// +
+// [horizontal]
+// punctuation:: Emitted for general punctuation.
+// angle:: Emitted for `<>` angle brackets.
+// brace:: Emitted for `{}` braces.
+// bracket:: Emitted for `[]` brackets.
+// parenthesis:: Emitted for `()` parentheses.
+// colon:: Emitted for the `:` token.
+// comma:: Emitted for the `,` token.
+// dot:: Emitted for the `.` token.
+// Semi:: Emitted for the `;` token.
+//
+// //-
+//
+// [horizontal]
+// attribute:: Emitted for attributes.
+// builtinType:: Emitted for builtin types like `u32`, `str` and `f32`.
+// comment:: Emitted for comments.
+// constParameter:: Emitted for const parameters.
+// enumMember:: Emitted for enum variants.
+// generic:: Emitted for generic tokens that have no mapping.
+// keyword:: Emitted for keywords.
+// label:: Emitted for labels.
+// lifetime:: Emitted for lifetimes.
+// parameter:: Emitted for non-self function parameters.
+// property:: Emitted for struct and union fields.
+// selfKeyword:: Emitted for the self function parameter and self path-specifier.
+// typeParameter:: Emitted for type parameters.
+// unresolvedReference:: Emitted for unresolved references, names that rust-analyzer can't find the definition of.
+// variable:: Emitted for locals, constants and statics.
+//
+//
+// .Token Modifiers
+//
+// Token modifiers allow to style some elements in the source code more precisely.
+//
+// Rust-analyzer currently emits the following token modifiers:
+//
+// [horizontal]
+// async:: Emitted for async functions and the `async` and `await` keywords.
+// attribute:: Emitted for tokens inside attributes.
+// callable:: Emitted for locals whose types implements one of the `Fn*` traits.
+// constant:: Emitted for consts.
+// consuming:: Emitted for locals that are being consumed when use in a function call.
+// controlFlow:: Emitted for control-flow related tokens, this includes the `?` operator.
+// declaration:: Emitted for names of definitions, like `foo` in `fn foo() {}`.
+// documentation:: Emitted for documentation comments.
+// injected:: Emitted for doc-string injected highlighting like rust source blocks in documentation.
+// intraDocLink:: Emitted for intra doc links in doc-strings.
+// library:: Emitted for items that are defined outside of the current crate.
+// mutable:: Emitted for mutable locals and statics.
+// static:: Emitted for "static" functions, also known as functions that do not take a `self` param, as well as statics and consts.
+// trait:: Emitted for associated trait items.
+// unsafe:: Emitted for unsafe operations, like unsafe function calls, as well as the `unsafe` token.
+//
+//
 // image::https://user-images.githubusercontent.com/48062697/113164457-06cfb980-9239-11eb-819b-0f93e646acf8.png[]
 // image::https://user-images.githubusercontent.com/48062697/113187625-f7f50100-9250-11eb-825e-91c58f236071.png[]
 pub(crate) fn highlight(
@@ -80,6 +174,7 @@ pub(crate) fn highlight(
        &mut hl,
        &sema,
        InFile::new(file_id.into(), &root),
+        sema.scope(&root).krate(),
        range_to_highlight,
        syntactic_name_ref_highlighting,
    );
@@ -90,6 +185,7 @@ fn traverse(
    hl: &mut Highlights,
    sema: &Semantics<RootDatabase>,
    root: InFile<&SyntaxNode>,
+    krate: Option<hir::Crate>,
    range_to_highlight: TextRange,
    syntactic_name_ref_highlighting: bool,
 ) {
@@ -209,6 +305,7 @@ fn traverse(
        if let Some((mut highlight, binding_hash)) = highlight::element(
            &sema,
+            krate,
            &mut bindings_shadow_count,
            syntactic_name_ref_highlighting,
            element_to_highlight.clone(),
diff --git a/crates/ide/src/syntax_highlighting/highlight.rs b/crates/ide/src/syntax_highlighting/highlight.rs
index 058e37ff0..9503c936d 100644
--- a/crates/ide/src/syntax_highlighting/highlight.rs
+++ b/crates/ide/src/syntax_highlighting/highlight.rs
@@ -19,6 +19,7 @@ use crate::{
 pub(super) fn element(
    sema: &Semantics<RootDatabase>,
+    krate: Option<hir::Crate>,
    bindings_shadow_count: &mut FxHashMap<hir::Name, u32>,
    syntactic_name_ref_highlighting: bool,
    element: SyntaxElement,
@@ -46,8 +47,10 @@ pub(super) fn element(
            match name_kind {
                Some(NameClass::ExternCrate(_)) => SymbolKind::Module.into(),
-                Some(NameClass::Definition(def)) => highlight_def(db, def) | HlMod::Definition,
+                Some(NameClass::Definition(def)) => {
-                Some(NameClass::ConstReference(def)) => highlight_def(db, def),
+                    highlight_def(db, krate, def) | HlMod::Definition
+                }
+                Some(NameClass::ConstReference(def)) => highlight_def(db, krate, def),
                Some(NameClass::PatFieldShorthand { field_ref, .. }) => {
                    let mut h = HlTag::Symbol(SymbolKind::Field).into();
                    if let Definition::Field(field) = field_ref {
@@ -68,7 +71,7 @@ pub(super) fn element(
        }
        NAME_REF => {
            let name_ref = element.into_node().and_then(ast::NameRef::cast).unwrap();
-            highlight_func_by_name_ref(sema, &name_ref).unwrap_or_else(|| {
+            highlight_func_by_name_ref(sema, krate, &name_ref).unwrap_or_else(|| {
                let is_self = name_ref.self_token().is_some();
                let h = match NameRefClass::classify(sema, &name_ref) {
                    Some(name_kind) => match name_kind {
@@ -82,7 +85,7 @@ pub(super) fn element(
                                }
                            };
-                            let mut h = highlight_def(db, def);
+                            let mut h = highlight_def(db, krate, def);
                            if let Definition::Local(local) = &def {
                                if is_consumed_lvalue(name_ref.syntax().clone().into(), local, db) {
@@ -105,7 +108,7 @@ pub(super) fn element(
                        NameRefClass::FieldShorthand { .. } => SymbolKind::Field.into(),
                    },
                    None if syntactic_name_ref_highlighting => {
-                        highlight_name_ref_by_syntax(name_ref, sema)
+                        highlight_name_ref_by_syntax(name_ref, sema, krate)
                    }
                    None => HlTag::UnresolvedReference.into(),
                };
@@ -136,9 +139,11 @@ pub(super) fn element(
            let lifetime = element.into_node().and_then(ast::Lifetime::cast).unwrap();
            match NameClass::classify_lifetime(sema, &lifetime) {
-                Some(NameClass::Definition(def)) => highlight_def(db, def) | HlMod::Definition,
+                Some(NameClass::Definition(def)) => {
+                    highlight_def(db, krate, def) | HlMod::Definition
+                }
                None => match NameRefClass::classify_lifetime(sema, &lifetime) {
-                    Some(NameRefClass::Definition(def)) => highlight_def(db, def),
+                    Some(NameRefClass::Definition(def)) => highlight_def(db, krate, def),
                    _ => SymbolKind::LifetimeParam.into(),
                },
                _ => Highlight::from(SymbolKind::LifetimeParam) | HlMod::Definition,
@@ -277,12 +282,12 @@ pub(super) fn element(
        hash((name, shadow_count))
    }
 }
-fn highlight_def(db: &RootDatabase, def: Definition) -> Highlight {
+fn highlight_def(db: &RootDatabase, krate: Option<hir::Crate>, def: Definition) -> Highlight {
-    match def {
+    let mut h = match def {
-        Definition::Macro(_) => HlTag::Symbol(SymbolKind::Macro),
+        Definition::Macro(_) => Highlight::new(HlTag::Symbol(SymbolKind::Macro)),
-        Definition::Field(_) => HlTag::Symbol(SymbolKind::Field),
+        Definition::Field(_) => Highlight::new(HlTag::Symbol(SymbolKind::Field)),
        Definition::ModuleDef(def) => match def {
-            hir::ModuleDef::Module(_) => HlTag::Symbol(SymbolKind::Module),
+            hir::ModuleDef::Module(_) => Highlight::new(HlTag::Symbol(SymbolKind::Module)),
            hir::ModuleDef::Function(func) => {
                let mut h = Highlight::new(HlTag::Symbol(SymbolKind::Function));
                if let Some(item) = func.as_assoc_item(db) {
@@ -314,14 +319,22 @@ fn highlight_def(db: &RootDatabase, def: Definition) -> Highlight {
                if func.is_async(db) {
                    h |= HlMod::Async;
                }
-                return h;
+                h
+            }
+            hir::ModuleDef::Adt(adt) => {
+                let h = match adt {
+                    hir::Adt::Struct(_) => HlTag::Symbol(SymbolKind::Struct),
+                    hir::Adt::Enum(_) => HlTag::Symbol(SymbolKind::Enum),
+                    hir::Adt::Union(_) => HlTag::Symbol(SymbolKind::Union),
+                };
+                Highlight::new(h)
            }
-            hir::ModuleDef::Adt(hir::Adt::Struct(_)) => HlTag::Symbol(SymbolKind::Struct),
+            hir::ModuleDef::Variant(_) => Highlight::new(HlTag::Symbol(SymbolKind::Variant)),
-            hir::ModuleDef::Adt(hir::Adt::Enum(_)) => HlTag::Symbol(SymbolKind::Enum),
-            hir::ModuleDef::Adt(hir::Adt::Union(_)) => HlTag::Symbol(SymbolKind::Union),
-            hir::ModuleDef::Variant(_) => HlTag::Symbol(SymbolKind::Variant),
            hir::ModuleDef::Const(konst) => {
                let mut h = Highlight::new(HlTag::Symbol(SymbolKind::Const));
                if let Some(item) = konst.as_assoc_item(db) {
                    h |= HlMod::Associated;
                    match item.container(db) {
@@ -336,7 +349,7 @@ fn highlight_def(db: &RootDatabase, def: Definition) -> Highlight {
                    }
                }
-                return h;
+                h
            }
            hir::ModuleDef::Trait(trait_) => {
                let mut h = Highlight::new(HlTag::Symbol(SymbolKind::Trait));
@@ -344,10 +357,12 @@ fn highlight_def(db: &RootDatabase, def: Definition) -> Highlight {
                if trait_.is_unsafe(db) {
                    h |= HlMod::Unsafe;
                }
-                return h;
+                h
            }
            hir::ModuleDef::TypeAlias(type_) => {
                let mut h = Highlight::new(HlTag::Symbol(SymbolKind::TypeAlias));
                if let Some(item) = type_.as_assoc_item(db) {
                    h |= HlMod::Associated;
                    match item.container(db) {
@@ -361,23 +376,30 @@ fn highlight_def(db: &RootDatabase, def: Definition) -> Highlight {
                        }
                    }
                }
-                return h;
+                h
            }
-            hir::ModuleDef::BuiltinType(_) => HlTag::BuiltinType,
+            hir::ModuleDef::BuiltinType(_) => Highlight::new(HlTag::BuiltinType),
            hir::ModuleDef::Static(s) => {
                let mut h = Highlight::new(HlTag::Symbol(SymbolKind::Static));
                if s.is_mut(db) {
                    h |= HlMod::Mutable;
                    h |= HlMod::Unsafe;
                }
-                return h;
+                h
            }
        },
-        Definition::SelfType(_) => HlTag::Symbol(SymbolKind::Impl),
+        Definition::SelfType(_) => Highlight::new(HlTag::Symbol(SymbolKind::Impl)),
        Definition::GenericParam(it) => match it {
-            hir::GenericParam::TypeParam(_) => HlTag::Symbol(SymbolKind::TypeParam),
+            hir::GenericParam::TypeParam(_) => Highlight::new(HlTag::Symbol(SymbolKind::TypeParam)),
-            hir::GenericParam::ConstParam(_) => HlTag::Symbol(SymbolKind::ConstParam),
+            hir::GenericParam::ConstParam(_) => {
-            hir::GenericParam::LifetimeParam(_) => HlTag::Symbol(SymbolKind::LifetimeParam),
+                Highlight::new(HlTag::Symbol(SymbolKind::ConstParam))
+            }
+            hir::GenericParam::LifetimeParam(_) => {
+                Highlight::new(HlTag::Symbol(SymbolKind::LifetimeParam))
+            }
        },
        Definition::Local(local) => {
            let tag = if local.is_self(db) {
@@ -395,28 +417,40 @@ fn highlight_def(db: &RootDatabase, def: Definition) -> Highlight {
            if ty.as_callable(db).is_some() || ty.impls_fnonce(db) {
                h |= HlMod::Callable;
            }
-            return h;
+            h
        }
-        Definition::Label(_) => HlTag::Symbol(SymbolKind::Label),
+        Definition::Label(_) => Highlight::new(HlTag::Symbol(SymbolKind::Label)),
+    };
+    let is_from_other_crate = def.module(db).map(hir::Module::krate) != krate;
+    let is_builtin_type = matches!(def, Definition::ModuleDef(hir::ModuleDef::BuiltinType(_)));
+    if is_from_other_crate && !is_builtin_type {
+        h |= HlMod::Library;
    }
-    .into()
+    h
 }
 fn highlight_func_by_name_ref(
    sema: &Semantics<RootDatabase>,
+    krate: Option<hir::Crate>,
    name_ref: &ast::NameRef,
 ) -> Option<Highlight> {
    let mc = name_ref.syntax().parent().and_then(ast::MethodCallExpr::cast)?;
-    highlight_method_call(sema, &mc)
+    highlight_method_call(sema, krate, &mc)
 }
 fn highlight_method_call(
    sema: &Semantics<RootDatabase>,
+    krate: Option<hir::Crate>,
    method_call: &ast::MethodCallExpr,
 ) -> Option<Highlight> {
    let func = sema.resolve_method_call(&method_call)?;
    let mut h = SymbolKind::Function.into();
    h |= HlMod::Associated;
    if func.is_unsafe(sema.db) || sema.is_unsafe_method_call(&method_call) {
        h |= HlMod::Unsafe;
    }
@@ -424,7 +458,10 @@ fn highlight_method_call(
        h |= HlMod::Async;
    }
    if func.as_assoc_item(sema.db).and_then(|it| it.containing_trait(sema.db)).is_some() {
-        h |= HlMod::Trait
+        h |= HlMod::Trait;
+    }
+    if Some(func.module(sema.db).krate()) != krate {
+        h |= HlMod::Library;
    }
    if let Some(self_param) = func.self_param(sema.db) {
@@ -473,7 +510,11 @@ fn highlight_name_by_syntax(name: ast::Name) -> Highlight {
    tag.into()
 }
-fn highlight_name_ref_by_syntax(name: ast::NameRef, sema: &Semantics<RootDatabase>) -> Highlight {
+fn highlight_name_ref_by_syntax(
+    name: ast::NameRef,
+    sema: &Semantics<RootDatabase>,
+    krate: Option<hir::Crate>,
+) -> Highlight {
    let default = HlTag::UnresolvedReference;
    let parent = match name.syntax().parent() {
@@ -484,7 +525,7 @@ fn highlight_name_ref_by_syntax(name: ast::NameRef, sema: &Semantics<RootDatabas
    match parent.kind() {
        METHOD_CALL_EXPR => {
            return ast::MethodCallExpr::cast(parent)
-                .and_then(|it| highlight_method_call(sema, &it))
+                .and_then(|it| highlight_method_call(sema, krate, &it))
                .unwrap_or_else(|| SymbolKind::Function.into());
        }
        FIELD_EXPR => {
diff --git a/crates/ide/src/syntax_highlighting/tags.rs b/crates/ide/src/syntax_highlighting/tags.rs
index 27473a2f9..9d481deae 100644
--- a/crates/ide/src/syntax_highlighting/tags.rs
+++ b/crates/ide/src/syntax_highlighting/tags.rs
@@ -37,6 +37,8 @@ pub enum HlTag {
    None,
 }
+// Don't forget to adjust the feature description in crates/ide/src/syntax_highlighting.rs.
+// And make sure to use the lsp strings used when converting to the protocol in crates\rust-analyzer\src\semantic_tokens.rs, not the names of the variants here.
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
 #[repr(u8)]
 pub enum HlMod {
@@ -67,6 +69,8 @@ pub enum HlMod {
    Trait,
    /// Used with keywords like `async` and `await`.
    Async,
+    /// Used for items from other crates.
+    Library,
    // Keep this last!
    /// Used for unsafe functions, unsafe traits, mutable statics, union accesses and unsafe operations.
    Unsafe,
@@ -189,6 +193,7 @@ impl HlMod {
        HlMod::Static,
        HlMod::Trait,
        HlMod::Async,
+        HlMod::Library,
        HlMod::Unsafe,
    ];
@@ -207,6 +212,7 @@ impl HlMod {
            HlMod::Static => "static",
            HlMod::Trait => "trait",
            HlMod::Async => "async",
+            HlMod::Library => "library",
            HlMod::Unsafe => "unsafe",
        }
    }
diff --git a/crates/ide/src/syntax_highlighting/test_data/highlighting.html b/crates/ide/src/syntax_highlighting/test_data/highlighting.html
index 878431b56..0264e39a3 100644
--- a/crates/ide/src/syntax_highlighting/test_data/highlighting.html
+++ b/crates/ide/src/syntax_highlighting/test_data/highlighting.html
@@ -248,4 +248,20 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 <span class="brace">}</span>
 <span class="keyword unsafe">unsafe</span> <span class="keyword">trait</span> <span class="trait declaration unsafe">Dangerous</span> <span class="brace">{</span><span class="brace">}</span>
-<span class="keyword">impl</span> <span class="trait unsafe">Dangerous</span> <span class="keyword">for</span> <span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="brace">{</span><span class="brace">}</span></code></pre>
-\ No newline at end of file
+<span class="keyword">impl</span> <span class="trait unsafe">Dangerous</span> <span class="keyword">for</span> <span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="brace">{</span><span class="brace">}</span>
+<span class="keyword">fn</span> <span class="function declaration">use_foo_items</span><span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="brace">{</span>
+    <span class="keyword">let</span> <span class="variable declaration">bob</span> <span class="operator">=</span> <span class="module library">foo</span><span class="operator">::</span><span class="struct library">Person</span> <span class="brace">{</span>
+        <span class="field library">name</span><span class="colon">:</span> <span class="string_literal">"Bob"</span><span class="comma">,</span>
+        <span class="field library">age</span><span class="colon">:</span> <span class="module library">foo</span><span class="operator">::</span><span class="module library">consts</span><span class="operator">::</span><span class="constant library">NUMBER</span><span class="comma">,</span>
+    <span class="brace">}</span><span class="semicolon">;</span>
+    <span class="keyword">let</span> <span class="variable declaration">control_flow</span> <span class="operator">=</span> <span class="module library">foo</span><span class="operator">::</span><span class="function library">identity</span><span class="parenthesis">(</span><span class="module library">foo</span><span class="operator">::</span><span class="enum library">ControlFlow</span><span class="operator">::</span><span class="enum_variant library">Continue</span><span class="parenthesis">)</span><span class="semicolon">;</span>
+    <span class="keyword control">if</span> <span class="variable">control_flow</span><span class="operator">.</span><span class="function associated consuming library">should_die</span><span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="brace">{</span>
+        foo::<span class="macro">die!</span><span class="parenthesis">(</span><span class="parenthesis">)</span><span class="semicolon">;</span>
+    <span class="brace">}</span>
+<span class="brace">}</span>
+</code></pre>
+\ No newline at end of file
diff --git a/crates/ide/src/syntax_highlighting/tests.rs b/crates/ide/src/syntax_highlighting/tests.rs
index 9ce26e930..662b53481 100644
--- a/crates/ide/src/syntax_highlighting/tests.rs
+++ b/crates/ide/src/syntax_highlighting/tests.rs
@@ -10,6 +10,7 @@ use crate::{fixture, FileRange, HlTag, TextRange};
 fn test_highlighting() {
    check_highlighting(
        r#"
+//- /main.rs crate:main deps:foo
 use inner::{self as inner_mod};
 mod inner {}
@@ -222,6 +223,49 @@ async fn async_main() {
 unsafe trait Dangerous {}
 impl Dangerous for () {}
+fn use_foo_items() {
+    let bob = foo::Person {
+        name: "Bob",
+        age: foo::consts::NUMBER,
+    };
+    let control_flow = foo::identity(foo::ControlFlow::Continue);
+    if control_flow.should_die() {
+        foo::die!();
+    }
+}
+//- /foo.rs crate:foo
+pub struct Person {
+    pub name: &'static str,
+    pub age: u8,
+}
+pub enum ControlFlow {
+    Continue,
+    Die,
+}
+impl ControlFlow {
+    pub fn should_die(self) -> bool {
+        matches!(self, ControlFlow::Die)
+    }
+}
+pub fn identity<T>(x: T) -> T { x }
+pub mod consts {
+    pub const NUMBER: i64 = 92;
+}
+macro_rules! die {
+    () => {
+        panic!();
+    };
+}
 "#
        .trim(),
        expect_file!["./test_data/highlighting.html"],
diff --git a/crates/ide_assists/src/handlers/expand_glob_import.rs b/crates/ide_assists/src/handlers/expand_glob_import.rs
index 79cb08d69..6da880b52 100644
--- a/crates/ide_assists/src/handlers/expand_glob_import.rs
+++ b/crates/ide_assists/src/handlers/expand_glob_import.rs
@@ -55,7 +55,7 @@ pub(crate) fn expand_glob_import(acc: &mut Assists, ctx: &AssistContext) -> Opti
    let refs_in_target = find_refs_in_mod(ctx, target_module, Some(current_module))?;
    let imported_defs = find_imported_defs(ctx, star)?;
-    let target = parent.clone().either(|n| n.syntax().clone(), |n| n.syntax().clone());
+    let target = parent.either(|n| n.syntax().clone(), |n| n.syntax().clone());
    acc.add(
        AssistId("expand_glob_import", AssistKind::RefactorRewrite),
        "Expand glob import",
diff --git a/crates/ide_assists/src/handlers/fill_match_arms.rs b/crates/ide_assists/src/handlers/fill_match_arms.rs
index 97435f021..3d2cd739a 100644
--- a/crates/ide_assists/src/handlers/fill_match_arms.rs
+++ b/crates/ide_assists/src/handlers/fill_match_arms.rs
@@ -31,8 +31,8 @@ use crate::{
 //
 // fn handle(action: Action) {
 //     match action {
-//         $0Action::Move { distance } => {}
+//         $0Action::Move { distance } => todo!(),
-//         Action::Stop => {}
+//         Action::Stop => todo!(),
 //     }
 // }
 // ```
@@ -129,7 +129,7 @@ pub(crate) fn fill_match_arms(acc: &mut Assists, ctx: &AssistContext) -> Option<
        |builder| {
            let new_match_arm_list = match_arm_list.clone_for_update();
            let missing_arms = missing_pats
-                .map(|pat| make::match_arm(iter::once(pat), make::expr_empty_block()))
+                .map(|pat| make::match_arm(iter::once(pat), make::ext::expr_todo()))
                .map(|it| it.clone_for_update());
            let catch_all_arm = new_match_arm_list
@@ -350,8 +350,8 @@ fn foo(a: bool) {
            r#"
 fn foo(a: bool) {
    match a {
-        $0true => {}
+        $0true => todo!(),
-        false => {}
+        false => todo!(),
    }
 }
 "#,
@@ -373,7 +373,7 @@ fn foo(a: bool) {
 fn foo(a: bool) {
    match a {
        true => {}
-        $0false => {}
+        $0false => todo!(),
    }
 }
 "#,
@@ -410,10 +410,10 @@ fn foo(a: bool) {
            r#"
 fn foo(a: bool) {
    match (a, a) {
-        $0(true, true) => {}
+        $0(true, true) => todo!(),
-        (true, false) => {}
+        (true, false) => todo!(),
-        (false, true) => {}
+        (false, true) => todo!(),
-        (false, false) => {}
+        (false, false) => todo!(),
    }
 }
 "#,
@@ -435,9 +435,9 @@ fn foo(a: bool) {
 fn foo(a: bool) {
    match (a, a) {
        (false, true) => {}
-        $0(true, true) => {}
+        $0(true, true) => todo!(),
-        (true, false) => {}
+        (true, false) => todo!(),
-        (false, false) => {}
+        (false, false) => todo!(),
    }
 }
 "#,
@@ -471,7 +471,7 @@ fn main() {
    match A::As {
        A::Bs { x, y: Some(_) } => {}
        A::Cs(_, Some(_)) => {}
-        $0A::As => {}
+        $0A::As => todo!(),
    }
 }
 "#,
@@ -499,7 +499,7 @@ use Option::*;
 fn main() {
    match None {
        None => {}
-        Some(${0:_}) => {}
+        Some(${0:_}) => todo!(),
    }
 }
            "#,
@@ -523,7 +523,7 @@ enum A { As, Bs, Cs(Option<i32>) }
 fn main() {
    match A::As {
        A::Cs(_) | A::Bs => {}
-        $0A::As => {}
+        $0A::As => todo!(),
    }
 }
 "#,
@@ -553,8 +553,8 @@ fn main() {
        A::Bs if 0 < 1 => {}
        A::Ds(_value) => { let x = 1; }
        A::Es(B::Xs) => (),
-        $0A::As => {}
+        $0A::As => todo!(),
-        A::Cs => {}
+        A::Cs => todo!(),
    }
 }
 "#,
@@ -580,7 +580,7 @@ fn main() {
    match A::As {
        A::As(_) => {}
        a @ A::Bs(_) => {}
-        A::Cs(${0:_}) => {}
+        A::Cs(${0:_}) => todo!(),
    }
 }
 "#,
@@ -605,11 +605,11 @@ enum A { As, Bs, Cs(String), Ds(String, String), Es { x: usize, y: usize } }
 fn main() {
    let a = A::As;
    match a {
-        $0A::As => {}
+        $0A::As => todo!(),
-        A::Bs => {}
+        A::Bs => todo!(),
-        A::Cs(_) => {}
+        A::Cs(_) => todo!(),
-        A::Ds(_, _) => {}
+        A::Ds(_, _) => todo!(),
-        A::Es { x, y } => {}
+        A::Es { x, y } => todo!(),
    }
 }
 "#,
@@ -638,10 +638,10 @@ fn main() {
    let a = A::One;
    let b = B::One;
    match (a, b) {
-        $0(A::One, B::One) => {}
+        $0(A::One, B::One) => todo!(),
-        (A::One, B::Two) => {}
+        (A::One, B::Two) => todo!(),
-        (A::Two, B::One) => {}
+        (A::Two, B::One) => todo!(),
-        (A::Two, B::Two) => {}
+        (A::Two, B::Two) => todo!(),
    }
 }
 "#,
@@ -670,10 +670,10 @@ fn main() {
    let a = A::One;
    let b = B::One;
    match (&a, &b) {
-        $0(A::One, B::One) => {}
+        $0(A::One, B::One) => todo!(),
-        (A::One, B::Two) => {}
+        (A::One, B::Two) => todo!(),
-        (A::Two, B::One) => {}
+        (A::Two, B::One) => todo!(),
-        (A::Two, B::Two) => {}
+        (A::Two, B::Two) => todo!(),
    }
 }
 "#,
@@ -705,9 +705,9 @@ fn main() {
    let b = B::One;
    match (a, b) {
        (A::Two, B::One) => {}
-        $0(A::One, B::One) => {}
+        $0(A::One, B::One) => todo!(),
-        (A::One, B::Two) => {}
+        (A::One, B::Two) => todo!(),
-        (A::Two, B::Two) => {}
+        (A::Two, B::Two) => todo!(),
    }
 }
 "#,
@@ -736,7 +736,7 @@ fn main() {
    match (a, b) {
        (Some(_), _) => {}
        (None, Some(_)) => {}
-        $0(None, None) => {}
+        $0(None, None) => todo!(),
    }
 }
 "#,
@@ -801,8 +801,8 @@ enum A { One, Two }
 fn main() {
    let a = A::One;
    match (a, ) {
-        $0(A::One,) => {}
+        $0(A::One,) => todo!(),
-        (A::Two,) => {}
+        (A::Two,) => todo!(),
    }
 }
 "#,
@@ -826,7 +826,7 @@ enum A { As }
 fn foo(a: &A) {
    match a {
-        $0A::As => {}
+        $0A::As => todo!(),
    }
 }
 "#,
@@ -851,7 +851,7 @@ enum A {
 fn foo(a: &mut A) {
    match a {
-        $0A::Es { x, y } => {}
+        $0A::Es { x, y } => todo!(),
    }
 }
 "#,
@@ -891,8 +891,8 @@ enum E { X, Y }
 fn main() {
    match E::X {
-        $0E::X => {}
+        $0E::X => todo!(),
-        E::Y => {}
+        E::Y => todo!(),
    }
 }
 "#,
@@ -919,8 +919,8 @@ use foo::E::X;
 fn main() {
    match X {
-        $0X => {}
+        $0X => todo!(),
-        foo::E::Y => {}
+        foo::E::Y => todo!(),
    }
 }
 "#,
@@ -947,7 +947,7 @@ fn foo(a: A) {
    match a {
        // foo bar baz
        A::One => {}
-        $0A::Two => {}
+        $0A::Two => todo!(),
        // This is where the rest should be
    }
 }
@@ -971,8 +971,8 @@ fn foo(a: A) {
 enum A { One, Two }
 fn foo(a: A) {
    match a {
-        $0A::One => {}
+        $0A::One => todo!(),
-        A::Two => {}
+        A::Two => todo!(),
        // foo bar baz
    }
 }
@@ -996,8 +996,8 @@ fn foo(a: A) {
 enum A { One, Two, }
 fn foo(a: A) {
    match a {
-        $0A::One => {}
+        $0A::One => todo!(),
-        A::Two => {}
+        A::Two => todo!(),
    }
 }
 "#,
@@ -1021,8 +1021,8 @@ fn foo(opt: Option<i32>) {
            r#"
 fn foo(opt: Option<i32>) {
    match opt {
-        Some(${0:_}) => {}
+        Some(${0:_}) => todo!(),
-        None => {}
+        None => todo!(),
    }
 }
 "#,
@@ -1054,9 +1054,9 @@ enum Test {
 fn foo(t: Test) {
    m!(match t {
-    $0Test::A => {}
+    $0Test::A => todo!(),
-    Test::B => {}
+    Test::B => todo!(),
-    Test::C => {}
+    Test::C => todo!(),
 });
 }"#,
        );
@@ -1076,4 +1076,44 @@ fn foo(tuple: (A, A)) {
 "#,
        );
    }
+    #[test]
+    fn adds_comma_before_new_arms() {
+        check_assist(
+            fill_match_arms,
+            r#"
+fn foo(t: bool) {
+    match $0t {
+        true => 1 + 2
+    }
+}"#,
+            r#"
+fn foo(t: bool) {
+    match t {
+        true => 1 + 2,
+        $0false => todo!(),
+    }
+}"#,
+        );
+    }
+    #[test]
+    fn does_not_add_extra_comma() {
+        check_assist(
+            fill_match_arms,
+            r#"
+fn foo(t: bool) {
+    match $0t {
+        true => 1 + 2,
+    }
+}"#,
+            r#"
+fn foo(t: bool) {
+    match t {
+        true => 1 + 2,
+        $0false => todo!(),
+    }
+}"#,
+        );
+    }
 }
diff --git a/crates/ide_assists/src/tests/generated.rs b/crates/ide_assists/src/tests/generated.rs
index 8a9b0777c..de5d9e55a 100644
--- a/crates/ide_assists/src/tests/generated.rs
+++ b/crates/ide_assists/src/tests/generated.rs
@@ -455,8 +455,8 @@ enum Action { Move { distance: u32 }, Stop }
 fn handle(action: Action) {
    match action {
-        $0Action::Move { distance } => {}
+        $0Action::Move { distance } => todo!(),
-        Action::Stop => {}
+        Action::Stop => todo!(),
    }
 }
 "#####,
diff --git a/crates/ide_completion/Cargo.toml b/crates/ide_completion/Cargo.toml
index 6bd8a5500..ba81c9e04 100644
--- a/crates/ide_completion/Cargo.toml
+++ b/crates/ide_completion/Cargo.toml
@@ -15,6 +15,7 @@ itertools = "0.10.0"
 log = "0.4.8"
 rustc-hash = "1.1.0"
 either = "1.6.1"
+once_cell = "1.7"
 stdx = { path = "../stdx", version = "0.0.0" }
 syntax = { path = "../syntax", version = "0.0.0" }
diff --git a/crates/ide_completion/src/completions/attribute.rs b/crates/ide_completion/src/completions/attribute.rs
index b1505c74b..13d5b90c9 100644
--- a/crates/ide_completion/src/completions/attribute.rs
+++ b/crates/ide_completion/src/completions/attribute.rs
@@ -3,9 +3,9 @@
 //! This module uses a bit of static metadata to provide completions
 //! for built-in attributes.
-use itertools::Itertools;
+use once_cell::sync::Lazy;
-use rustc_hash::FxHashSet;
+use rustc_hash::{FxHashMap, FxHashSet};
-use syntax::{ast, AstNode, T};
+use syntax::{ast, AstNode, NodeOrToken, SyntaxKind, T};
 use crate::{
    context::CompletionContext,
@@ -14,33 +14,40 @@ use crate::{
    Completions,
 };
-pub(crate) fn complete_attribute(acc: &mut Completions, ctx: &CompletionContext) -> Option<()> {
+mod derive;
-    if ctx.mod_declaration_under_caret.is_some() {
+mod lint;
-        return None;
+pub(crate) use self::lint::LintCompletion;
-    }
+pub(crate) fn complete_attribute(acc: &mut Completions, ctx: &CompletionContext) -> Option<()> {
    let attribute = ctx.attribute_under_caret.as_ref()?;
-    match (attribute.path(), attribute.token_tree()) {
+    match (attribute.path().and_then(|p| p.as_single_name_ref()), attribute.token_tree()) {
-        (Some(path), Some(token_tree)) => {
+        (Some(path), Some(token_tree)) => match path.text().as_str() {
-            let path = path.syntax().text();
+            "derive" => derive::complete_derive(acc, ctx, token_tree),
-            if path == "derive" {
+            "feature" => lint::complete_lint(acc, ctx, token_tree, FEATURES),
-                complete_derive(acc, ctx, token_tree)
+            "allow" | "warn" | "deny" | "forbid" => {
-            } else if path == "feature" {
+                lint::complete_lint(acc, ctx, token_tree.clone(), lint::DEFAULT_LINT_COMPLETIONS);
-                complete_lint(acc, ctx, token_tree, FEATURES)
+                lint::complete_lint(acc, ctx, token_tree, CLIPPY_LINTS);
-            } else if path == "allow" || path == "warn" || path == "deny" || path == "forbid" {
-                complete_lint(acc, ctx, token_tree.clone(), DEFAULT_LINT_COMPLETIONS);
-                complete_lint(acc, ctx, token_tree, CLIPPY_LINTS);
            }
-        }
+            _ => (),
-        (_, Some(_token_tree)) => {}
+        },
-        _ => complete_attribute_start(acc, ctx, attribute),
+        (None, Some(_)) => (),
+        _ => complete_new_attribute(acc, ctx, attribute),
    }
    Some(())
 }
-fn complete_attribute_start(acc: &mut Completions, ctx: &CompletionContext, attribute: &ast::Attr) {
+fn complete_new_attribute(acc: &mut Completions, ctx: &CompletionContext, attribute: &ast::Attr) {
+    let attribute_annotated_item_kind = attribute.syntax().parent().map(|it| it.kind());
+    let attributes = attribute_annotated_item_kind.and_then(|kind| {
+        if ast::Expr::can_cast(kind) {
+            Some(EXPR_ATTRIBUTES)
+        } else {
+            KIND_TO_ATTRIBUTES.get(&kind).copied()
+        }
+    });
    let is_inner = attribute.kind() == ast::AttrKind::Inner;
-    for attr_completion in ATTRIBUTES.iter().filter(|compl| is_inner || !compl.prefer_inner) {
+    let add_completion = |attr_completion: &AttrCompletion| {
        let mut item = CompletionItem::new(
            CompletionKind::Attribute,
            ctx.source_range(),
@@ -56,9 +63,19 @@ fn complete_attribute_start(acc: &mut Completions, ctx: &CompletionContext, attr
            item.insert_snippet(cap, snippet);
        }
-        if attribute.kind() == ast::AttrKind::Inner || !attr_completion.prefer_inner {
+        if is_inner || !attr_completion.prefer_inner {
            acc.add(item.build());
        }
+    };
+    match attributes {
+        Some(applicable) => applicable
+            .iter()
+            .flat_map(|name| ATTRIBUTES.binary_search_by(|attr| attr.key().cmp(name)).ok())
+            .flat_map(|idx| ATTRIBUTES.get(idx))
+            .for_each(add_completion),
+        None if is_inner => ATTRIBUTES.iter().for_each(add_completion),
+        None => ATTRIBUTES.iter().filter(|compl| !compl.prefer_inner).for_each(add_completion),
    }
 }
@@ -70,6 +87,10 @@ struct AttrCompletion {
 }
 impl AttrCompletion {
+    fn key(&self) -> &'static str {
+        self.lookup.unwrap_or(self.label)
+    }
    const fn prefer_inner(self) -> AttrCompletion {
        AttrCompletion { prefer_inner: true, ..self }
    }
@@ -83,26 +104,119 @@ const fn attr(
    AttrCompletion { label, lookup, snippet, prefer_inner: false }
 }
+macro_rules! attrs {
+    // attributes applicable to all items
+    [@ { item $($tt:tt)* } {$($acc:tt)*}] => {
+        attrs!(@ { $($tt)* } { $($acc)*, "deprecated", "doc", "dochidden", "docalias", "must_use", "no_mangle" })
+    };
+    // attributes applicable to all adts
+    [@ { adt $($tt:tt)* } {$($acc:tt)*}] => {
+        attrs!(@ { $($tt)* } { $($acc)*, "derive", "repr" })
+    };
+    // attributes applicable to all linkable things aka functions/statics
+    [@ { linkable $($tt:tt)* } {$($acc:tt)*}] => {
+        attrs!(@ { $($tt)* } { $($acc)*, "export_name", "link_name", "link_section" })
+    };
+    // error fallback for nicer error message
+    [@ { $ty:ident $($tt:tt)* } {$($acc:tt)*}] => {
+        compile_error!(concat!("unknown attr subtype ", stringify!($ty)))
+    };
+    // general push down accumulation
+    [@ { $lit:literal $($tt:tt)*} {$($acc:tt)*}] => {
+        attrs!(@ { $($tt)* } { $($acc)*, $lit })
+    };
+    [@ {$($tt:tt)+} {$($tt2:tt)*}] => {
+        compile_error!(concat!("Unexpected input ", stringify!($($tt)+)))
+    };
+    // final output construction
+    [@ {} {$($tt:tt)*}] => { &[$($tt)*] as _ };
+    // starting matcher
+    [$($tt:tt),*] => {
+        attrs!(@ { $($tt)* } { "allow", "cfg", "cfg_attr", "deny", "forbid", "warn" })
+    };
+}
+#[rustfmt::skip]
+static KIND_TO_ATTRIBUTES: Lazy<FxHashMap<SyntaxKind, &[&str]>> = Lazy::new(|| {
+    use SyntaxKind::*;
+    std::array::IntoIter::new([
+        (
+            SOURCE_FILE,
+            attrs!(
+                item,
+                "crate_name", "feature", "no_implicit_prelude", "no_main", "no_std",
+                "recursion_limit", "type_length_limit", "windows_subsystem"
+            ),
+        ),
+        (MODULE, attrs!(item, "no_implicit_prelude", "path")),
+        (ITEM_LIST, attrs!(item, "no_implicit_prelude")),
+        (MACRO_RULES, attrs!(item, "macro_export", "macro_use")),
+        (MACRO_DEF, attrs!(item)),
+        (EXTERN_CRATE, attrs!(item, "macro_use", "no_link")),
+        (USE, attrs!(item)),
+        (TYPE_ALIAS, attrs!(item)),
+        (STRUCT, attrs!(item, adt, "non_exhaustive")),
+        (ENUM, attrs!(item, adt, "non_exhaustive")),
+        (UNION, attrs!(item, adt)),
+        (CONST, attrs!(item)),
+        (
+            FN,
+            attrs!(
+                item, linkable,
+                "cold", "ignore", "inline", "must_use", "panic_handler", "proc_macro",
+                "proc_macro_derive", "proc_macro_attribute", "should_panic", "target_feature",
+                "test", "track_caller"
+            ),
+        ),
+        (STATIC, attrs!(item, linkable, "global_allocator", "used")),
+        (TRAIT, attrs!(item, "must_use")),
+        (IMPL, attrs!(item, "automatically_derived")),
+        (ASSOC_ITEM_LIST, attrs!(item)),
+        (EXTERN_BLOCK, attrs!(item, "link")),
+        (EXTERN_ITEM_LIST, attrs!(item, "link")),
+        (MACRO_CALL, attrs!()),
+        (SELF_PARAM, attrs!()),
+        (PARAM, attrs!()),
+        (RECORD_FIELD, attrs!()),
+        (VARIANT, attrs!("non_exhaustive")),
+        (TYPE_PARAM, attrs!()),
+        (CONST_PARAM, attrs!()),
+        (LIFETIME_PARAM, attrs!()),
+        (LET_STMT, attrs!()),
+        (EXPR_STMT, attrs!()),
+        (LITERAL, attrs!()),
+        (RECORD_EXPR_FIELD_LIST, attrs!()),
+        (RECORD_EXPR_FIELD, attrs!()),
+        (MATCH_ARM_LIST, attrs!()),
+        (MATCH_ARM, attrs!()),
+        (IDENT_PAT, attrs!()),
+        (RECORD_PAT_FIELD, attrs!()),
+    ])
+    .collect()
+});
+const EXPR_ATTRIBUTES: &[&str] = attrs!();
 /// https://doc.rust-lang.org/reference/attributes.html#built-in-attributes-index
+// Keep these sorted for the binary search!
 const ATTRIBUTES: &[AttrCompletion] = &[
    attr("allow(…)", Some("allow"), Some("allow(${0:lint})")),
    attr("automatically_derived", None, None),
-    attr("cfg_attr(…)", Some("cfg_attr"), Some("cfg_attr(${1:predicate}, ${0:attr})")),
    attr("cfg(…)", Some("cfg"), Some("cfg(${0:predicate})")),
+    attr("cfg_attr(…)", Some("cfg_attr"), Some("cfg_attr(${1:predicate}, ${0:attr})")),
    attr("cold", None, None),
    attr(r#"crate_name = """#, Some("crate_name"), Some(r#"crate_name = "${0:crate_name}""#))
        .prefer_inner(),
    attr("deny(…)", Some("deny"), Some("deny(${0:lint})")),
    attr(r#"deprecated"#, Some("deprecated"), Some(r#"deprecated"#)),
    attr("derive(…)", Some("derive"), Some(r#"derive(${0:Debug})"#)),
+    attr(r#"doc = "…""#, Some("doc"), Some(r#"doc = "${0:docs}""#)),
+    attr(r#"doc(alias = "…")"#, Some("docalias"), Some(r#"doc(alias = "${0:docs}")"#)),
+    attr(r#"doc(hidden)"#, Some("dochidden"), Some(r#"doc(hidden)"#)),
    attr(
        r#"export_name = "…""#,
        Some("export_name"),
        Some(r#"export_name = "${0:exported_symbol_name}""#),
    ),
-    attr(r#"doc(alias = "…")"#, Some("docalias"), Some(r#"doc(alias = "${0:docs}")"#)),
-    attr(r#"doc = "…""#, Some("doc"), Some(r#"doc = "${0:docs}""#)),
-    attr(r#"doc(hidden)"#, Some("dochidden"), Some(r#"doc(hidden)"#)),
    attr("feature(…)", Some("feature"), Some("feature(${0:flag})")).prefer_inner(),
    attr("forbid(…)", Some("forbid"), Some("forbid(${0:lint})")),
    // FIXME: resolve through macro resolution?
@@ -119,8 +233,8 @@ const ATTRIBUTES: &[AttrCompletion] = &[
    attr("macro_export", None, None),
    attr("macro_use", None, None),
    attr(r#"must_use"#, Some("must_use"), Some(r#"must_use"#)),
-    attr("no_link", None, None).prefer_inner(),
    attr("no_implicit_prelude", None, None).prefer_inner(),
+    attr("no_link", None, None).prefer_inner(),
    attr("no_main", None, None).prefer_inner(),
    attr("no_mangle", None, None),
    attr("no_std", None, None).prefer_inner(),
@@ -153,412 +267,492 @@ const ATTRIBUTES: &[AttrCompletion] = &[
    .prefer_inner(),
 ];
-fn complete_derive(acc: &mut Completions, ctx: &CompletionContext, derive_input: ast::TokenTree) {
+fn parse_comma_sep_input(derive_input: ast::TokenTree) -> Option<FxHashSet<String>> {
-    if let Ok(existing_derives) = parse_comma_sep_input(derive_input) {
+    let (l_paren, r_paren) = derive_input.l_paren_token().zip(derive_input.r_paren_token())?;
-        for derive_completion in DEFAULT_DERIVE_COMPLETIONS
+    let mut input_derives = FxHashSet::default();
-            .iter()
+    let mut tokens = derive_input
-            .filter(|completion| !existing_derives.contains(completion.label))
+        .syntax()
-        {
+        .children_with_tokens()
-            let mut components = vec![derive_completion.label];
+        .filter_map(NodeOrToken::into_token)
-            components.extend(
+        .skip_while(|token| token != &l_paren)
-                derive_completion
+        .skip(1)
-                    .dependencies
+        .take_while(|token| token != &r_paren)
-                    .iter()
+        .peekable();
-                    .filter(|&&dependency| !existing_derives.contains(dependency)),
+    let mut input = String::new();
-            );
+    while tokens.peek().is_some() {
-            let lookup = components.join(", ");
+        for token in tokens.by_ref().take_while(|t| t.kind() != T![,]) {
-            let label = components.iter().rev().join(", ");
+            input.push_str(token.text());
-            let mut item =
-                CompletionItem::new(CompletionKind::Attribute, ctx.source_range(), label);
-            item.lookup_by(lookup).kind(CompletionItemKind::Attribute);
-            item.add_to(acc);
-        }
-        for custom_derive_name in get_derive_names_in_scope(ctx).difference(&existing_derives) {
-            let mut item = CompletionItem::new(
-                CompletionKind::Attribute,
-                ctx.source_range(),
-                custom_derive_name,
-            );
-            item.kind(CompletionItemKind::Attribute);
-            item.add_to(acc);
        }
-    }
-}
-fn complete_lint(
+        if !input.is_empty() {
-    acc: &mut Completions,
+            input_derives.insert(input.trim().to_owned());
-    ctx: &CompletionContext,
-    derive_input: ast::TokenTree,
-    lints_completions: &[LintCompletion],
-) {
-    if let Ok(existing_lints) = parse_comma_sep_input(derive_input) {
-        for lint_completion in lints_completions
-            .into_iter()
-            .filter(|completion| !existing_lints.contains(completion.label))
-        {
-            let mut item = CompletionItem::new(
-                CompletionKind::Attribute,
-                ctx.source_range(),
-                lint_completion.label,
-            );
-            item.kind(CompletionItemKind::Attribute).detail(lint_completion.description);
-            item.add_to(acc)
        }
-    }
-}
-fn parse_comma_sep_input(derive_input: ast::TokenTree) -> Result<FxHashSet<String>, ()> {
-    match (derive_input.left_delimiter_token(), derive_input.right_delimiter_token()) {
-        (Some(left_paren), Some(right_paren))
-            if left_paren.kind() == T!['('] && right_paren.kind() == T![')'] =>
-        {
-            let mut input_derives = FxHashSet::default();
-            let mut current_derive = String::new();
-            for token in derive_input
-                .syntax()
-                .children_with_tokens()
-                .filter_map(|token| token.into_token())
-                .skip_while(|token| token != &left_paren)
-                .skip(1)
-                .take_while(|token| token != &right_paren)
-            {
-                if T![,] == token.kind() {
-                    if !current_derive.is_empty() {
-                        input_derives.insert(current_derive);
-                        current_derive = String::new();
-                    }
-                } else {
-                    current_derive.push_str(token.text().trim());
-                }
-            }
-            if !current_derive.is_empty() {
+        input.clear();
-                input_derives.insert(current_derive);
-            }
-            Ok(input_derives)
-        }
-        _ => Err(()),
    }
-}
-fn get_derive_names_in_scope(ctx: &CompletionContext) -> FxHashSet<String> {
+    Some(input_derives)
-    let mut result = FxHashSet::default();
-    ctx.scope.process_all_names(&mut |name, scope_def| {
-        if let hir::ScopeDef::MacroDef(mac) = scope_def {
-            // FIXME kind() doesn't check whether proc-macro is a derive
-            if mac.kind() == hir::MacroKind::Derive || mac.kind() == hir::MacroKind::ProcMacro {
-                result.insert(name.to_string());
-            }
-        }
-    });
-    result
-}
-struct DeriveCompletion {
-    label: &'static str,
-    dependencies: &'static [&'static str],
 }
-/// Standard Rust derives and the information about their dependencies
-/// (the dependencies are needed so that the main derive don't break the compilation when added)
-const DEFAULT_DERIVE_COMPLETIONS: &[DeriveCompletion] = &[
-    DeriveCompletion { label: "Clone", dependencies: &[] },
-    DeriveCompletion { label: "Copy", dependencies: &["Clone"] },
-    DeriveCompletion { label: "Debug", dependencies: &[] },
-    DeriveCompletion { label: "Default", dependencies: &[] },
-    DeriveCompletion { label: "Hash", dependencies: &[] },
-    DeriveCompletion { label: "PartialEq", dependencies: &[] },
-    DeriveCompletion { label: "Eq", dependencies: &["PartialEq"] },
-    DeriveCompletion { label: "PartialOrd", dependencies: &["PartialEq"] },
-    DeriveCompletion { label: "Ord", dependencies: &["PartialOrd", "Eq", "PartialEq"] },
-];
-pub(crate) struct LintCompletion {
-    pub(crate) label: &'static str,
-    pub(crate) description: &'static str,
-}
-#[rustfmt::skip]
-const DEFAULT_LINT_COMPLETIONS: &[LintCompletion] = &[
-    LintCompletion { label: "absolute_paths_not_starting_with_crate", description: r#"fully qualified paths that start with a module name instead of `crate`, `self`, or an extern crate name"# },
-    LintCompletion { label: "anonymous_parameters", description: r#"detects anonymous parameters"# },
-    LintCompletion { label: "box_pointers", description: r#"use of owned (Box type) heap memory"# },
-    LintCompletion { label: "deprecated_in_future", description: r#"detects use of items that will be deprecated in a future version"# },
-    LintCompletion { label: "elided_lifetimes_in_paths", description: r#"hidden lifetime parameters in types are deprecated"# },
-    LintCompletion { label: "explicit_outlives_requirements", description: r#"outlives requirements can be inferred"# },
-    LintCompletion { label: "indirect_structural_match", description: r#"pattern with const indirectly referencing non-structural-match type"# },
-    LintCompletion { label: "keyword_idents", description: r#"detects edition keywords being used as an identifier"# },
-    LintCompletion { label: "macro_use_extern_crate", description: r#"the `#[macro_use]` attribute is now deprecated in favor of using macros via the module system"# },
-    LintCompletion { label: "meta_variable_misuse", description: r#"possible meta-variable misuse at macro definition"# },
-    LintCompletion { label: "missing_copy_implementations", description: r#"detects potentially-forgotten implementations of `Copy`"# },
-    LintCompletion { label: "missing_crate_level_docs", description: r#"detects crates with no crate-level documentation"# },
-    LintCompletion { label: "missing_debug_implementations", description: r#"detects missing implementations of Debug"# },
-    LintCompletion { label: "missing_docs", description: r#"detects missing documentation for public members"# },
-    LintCompletion { label: "missing_doc_code_examples", description: r#"detects publicly-exported items without code samples in their documentation"# },
-    LintCompletion { label: "non_ascii_idents", description: r#"detects non-ASCII identifiers"# },
-    LintCompletion { label: "private_doc_tests", description: r#"detects code samples in docs of private items not documented by rustdoc"# },
-    LintCompletion { label: "single_use_lifetimes", description: r#"detects lifetime parameters that are only used once"# },
-    LintCompletion { label: "trivial_casts", description: r#"detects trivial casts which could be removed"# },
-    LintCompletion { label: "trivial_numeric_casts", description: r#"detects trivial casts of numeric types which could be removed"# },
-    LintCompletion { label: "unaligned_references", description: r#"detects unaligned references to fields of packed structs"# },
-    LintCompletion { label: "unreachable_pub", description: r#"`pub` items not reachable from crate root"# },
-    LintCompletion { label: "unsafe_code", description: r#"usage of `unsafe` code"# },
-    LintCompletion { label: "unsafe_op_in_unsafe_fn", description: r#"unsafe operations in unsafe functions without an explicit unsafe block are deprecated"# },
-    LintCompletion { label: "unstable_features", description: r#"enabling unstable features (deprecated. do not use)"# },
-    LintCompletion { label: "unused_crate_dependencies", description: r#"crate dependencies that are never used"# },
-    LintCompletion { label: "unused_extern_crates", description: r#"extern crates that are never used"# },
-    LintCompletion { label: "unused_import_braces", description: r#"unnecessary braces around an imported item"# },
-    LintCompletion { label: "unused_lifetimes", description: r#"detects lifetime parameters that are never used"# },
-    LintCompletion { label: "unused_qualifications", description: r#"detects unnecessarily qualified names"# },
-    LintCompletion { label: "unused_results", description: r#"unused result of an expression in a statement"# },
-    LintCompletion { label: "variant_size_differences", description: r#"detects enums with widely varying variant sizes"# },
-    LintCompletion { label: "array_into_iter", description: r#"detects calling `into_iter` on arrays"# },
-    LintCompletion { label: "asm_sub_register", description: r#"using only a subset of a register for inline asm inputs"# },
-    LintCompletion { label: "bare_trait_objects", description: r#"suggest using `dyn Trait` for trait objects"# },
-    LintCompletion { label: "bindings_with_variant_name", description: r#"detects pattern bindings with the same name as one of the matched variants"# },
-    LintCompletion { label: "cenum_impl_drop_cast", description: r#"a C-like enum implementing Drop is cast"# },
-    LintCompletion { label: "clashing_extern_declarations", description: r#"detects when an extern fn has been declared with the same name but different types"# },
-    LintCompletion { label: "coherence_leak_check", description: r#"distinct impls distinguished only by the leak-check code"# },
-    LintCompletion { label: "confusable_idents", description: r#"detects visually confusable pairs between identifiers"# },
-    LintCompletion { label: "dead_code", description: r#"detect unused, unexported items"# },
-    LintCompletion { label: "deprecated", description: r#"detects use of deprecated items"# },
-    LintCompletion { label: "ellipsis_inclusive_range_patterns", description: r#"`...` range patterns are deprecated"# },
-    LintCompletion { label: "exported_private_dependencies", description: r#"public interface leaks type from a private dependency"# },
-    LintCompletion { label: "illegal_floating_point_literal_pattern", description: r#"floating-point literals cannot be used in patterns"# },
-    LintCompletion { label: "improper_ctypes", description: r#"proper use of libc types in foreign modules"# },
-    LintCompletion { label: "improper_ctypes_definitions", description: r#"proper use of libc types in foreign item definitions"# },
-    LintCompletion { label: "incomplete_features", description: r#"incomplete features that may function improperly in some or all cases"# },
-    LintCompletion { label: "inline_no_sanitize", description: r#"detects incompatible use of `#[inline(always)]` and `#[no_sanitize(...)]`"# },
-    LintCompletion { label: "intra_doc_link_resolution_failure", description: r#"failures in resolving intra-doc link targets"# },
-    LintCompletion { label: "invalid_codeblock_attributes", description: r#"codeblock attribute looks a lot like a known one"# },
-    LintCompletion { label: "invalid_value", description: r#"an invalid value is being created (such as a NULL reference)"# },
-    LintCompletion { label: "irrefutable_let_patterns", description: r#"detects irrefutable patterns in if-let and while-let statements"# },
-    LintCompletion { label: "late_bound_lifetime_arguments", description: r#"detects generic lifetime arguments in path segments with late bound lifetime parameters"# },
-    LintCompletion { label: "mixed_script_confusables", description: r#"detects Unicode scripts whose mixed script confusables codepoints are solely used"# },
-    LintCompletion { label: "mutable_borrow_reservation_conflict", description: r#"reservation of a two-phased borrow conflicts with other shared borrows"# },
-    LintCompletion { label: "non_camel_case_types", description: r#"types, variants, traits and type parameters should have camel case names"# },
-    LintCompletion { label: "non_shorthand_field_patterns", description: r#"using `Struct { x: x }` instead of `Struct { x }` in a pattern"# },
-    LintCompletion { label: "non_snake_case", description: r#"variables, methods, functions, lifetime parameters and modules should have snake case names"# },
-    LintCompletion { label: "non_upper_case_globals", description: r#"static constants should have uppercase identifiers"# },
-    LintCompletion { label: "no_mangle_generic_items", description: r#"generic items must be mangled"# },
-    LintCompletion { label: "overlapping_patterns", description: r#"detects overlapping patterns"# },
-    LintCompletion { label: "path_statements", description: r#"path statements with no effect"# },
-    LintCompletion { label: "private_in_public", description: r#"detect private items in public interfaces not caught by the old implementation"# },
-    LintCompletion { label: "proc_macro_derive_resolution_fallback", description: r#"detects proc macro derives using inaccessible names from parent modules"# },
-    LintCompletion { label: "redundant_semicolons", description: r#"detects unnecessary trailing semicolons"# },
-    LintCompletion { label: "renamed_and_removed_lints", description: r#"lints that have been renamed or removed"# },
-    LintCompletion { label: "safe_packed_borrows", description: r#"safe borrows of fields of packed structs were erroneously allowed"# },
-    LintCompletion { label: "stable_features", description: r#"stable features found in `#[feature]` directive"# },
-    LintCompletion { label: "trivial_bounds", description: r#"these bounds don't depend on an type parameters"# },
-    LintCompletion { label: "type_alias_bounds", description: r#"bounds in type aliases are not enforced"# },
-    LintCompletion { label: "tyvar_behind_raw_pointer", description: r#"raw pointer to an inference variable"# },
-    LintCompletion { label: "uncommon_codepoints", description: r#"detects uncommon Unicode codepoints in identifiers"# },
-    LintCompletion { label: "unconditional_recursion", description: r#"functions that cannot return without calling themselves"# },
-    LintCompletion { label: "unknown_lints", description: r#"unrecognized lint attribute"# },
-    LintCompletion { label: "unnameable_test_items", description: r#"detects an item that cannot be named being marked as `#[test_case]`"# },
-    LintCompletion { label: "unreachable_code", description: r#"detects unreachable code paths"# },
-    LintCompletion { label: "unreachable_patterns", description: r#"detects unreachable patterns"# },
-    LintCompletion { label: "unstable_name_collisions", description: r#"detects name collision with an existing but unstable method"# },
-    LintCompletion { label: "unused_allocation", description: r#"detects unnecessary allocations that can be eliminated"# },
-    LintCompletion { label: "unused_assignments", description: r#"detect assignments that will never be read"# },
-    LintCompletion { label: "unused_attributes", description: r#"detects attributes that were not used by the compiler"# },
-    LintCompletion { label: "unused_braces", description: r#"unnecessary braces around an expression"# },
-    LintCompletion { label: "unused_comparisons", description: r#"comparisons made useless by limits of the types involved"# },
-    LintCompletion { label: "unused_doc_comments", description: r#"detects doc comments that aren't used by rustdoc"# },
-    LintCompletion { label: "unused_features", description: r#"unused features found in crate-level `#[feature]` directives"# },
-    LintCompletion { label: "unused_imports", description: r#"imports that are never used"# },
-    LintCompletion { label: "unused_labels", description: r#"detects labels that are never used"# },
-    LintCompletion { label: "unused_macros", description: r#"detects macros that were not used"# },
-    LintCompletion { label: "unused_must_use", description: r#"unused result of a type flagged as `#[must_use]`"# },
-    LintCompletion { label: "unused_mut", description: r#"detect mut variables which don't need to be mutable"# },
-    LintCompletion { label: "unused_parens", description: r#"`if`, `match`, `while` and `return` do not need parentheses"# },
-    LintCompletion { label: "unused_unsafe", description: r#"unnecessary use of an `unsafe` block"# },
-    LintCompletion { label: "unused_variables", description: r#"detect variables which are not used in any way"# },
-    LintCompletion { label: "warnings", description: r#"mass-change the level for lints which produce warnings"# },
-    LintCompletion { label: "where_clauses_object_safety", description: r#"checks the object safety of where clauses"# },
-    LintCompletion { label: "while_true", description: r#"suggest using `loop { }` instead of `while true { }`"# },
-    LintCompletion { label: "ambiguous_associated_items", description: r#"ambiguous associated items"# },
-    LintCompletion { label: "arithmetic_overflow", description: r#"arithmetic operation overflows"# },
-    LintCompletion { label: "conflicting_repr_hints", description: r#"conflicts between `#[repr(..)]` hints that were previously accepted and used in practice"# },
-    LintCompletion { label: "const_err", description: r#"constant evaluation detected erroneous expression"# },
-    LintCompletion { label: "ill_formed_attribute_input", description: r#"ill-formed attribute inputs that were previously accepted and used in practice"# },
-    LintCompletion { label: "incomplete_include", description: r#"trailing content in included file"# },
-    LintCompletion { label: "invalid_type_param_default", description: r#"type parameter default erroneously allowed in invalid location"# },
-    LintCompletion { label: "macro_expanded_macro_exports_accessed_by_absolute_paths", description: r#"macro-expanded `macro_export` macros from the current crate cannot be referred to by absolute paths"# },
-    LintCompletion { label: "missing_fragment_specifier", description: r#"detects missing fragment specifiers in unused `macro_rules!` patterns"# },
-    LintCompletion { label: "mutable_transmutes", description: r#"mutating transmuted &mut T from &T may cause undefined behavior"# },
-    LintCompletion { label: "no_mangle_const_items", description: r#"const items will not have their symbols exported"# },
-    LintCompletion { label: "order_dependent_trait_objects", description: r#"trait-object types were treated as different depending on marker-trait order"# },
-    LintCompletion { label: "overflowing_literals", description: r#"literal out of range for its type"# },
-    LintCompletion { label: "patterns_in_fns_without_body", description: r#"patterns in functions without body were erroneously allowed"# },
-    LintCompletion { label: "pub_use_of_private_extern_crate", description: r#"detect public re-exports of private extern crates"# },
-    LintCompletion { label: "soft_unstable", description: r#"a feature gate that doesn't break dependent crates"# },
-    LintCompletion { label: "unconditional_panic", description: r#"operation will cause a panic at runtime"# },
-    LintCompletion { label: "unknown_crate_types", description: r#"unknown crate type found in `#[crate_type]` directive"# },
-];
 #[cfg(test)]
 mod tests {
+    use super::*;
    use expect_test::{expect, Expect};
    use crate::{test_utils::completion_list, CompletionKind};
+    #[test]
+    fn attributes_are_sorted() {
+        let mut attrs = ATTRIBUTES.iter().map(|attr| attr.key());
+        let mut prev = attrs.next().unwrap();
+        attrs.for_each(|next| {
+            assert!(
+                prev < next,
+                r#"ATTRIBUTES array is not sorted, "{}" should come after "{}""#,
+                prev,
+                next
+            );
+            prev = next;
+        });
+    }
    fn check(ra_fixture: &str, expect: Expect) {
        let actual = completion_list(ra_fixture, CompletionKind::Attribute);
        expect.assert_eq(&actual);
    }
    #[test]
-    fn empty_derive_completion() {
+    fn test_attribute_completion_inside_nested_attr() {
+        check(r#"#[cfg($0)]"#, expect![[]])
+    }
+    #[test]
+    fn test_attribute_completion_with_existing_attr() {
        check(
-            r#"
+            r#"#[no_mangle] #[$0] mcall!();"#,
-#[derive($0)]
-struct Test {}
-        "#,
            expect![[r#"
-                at Clone
+                at allow(…)
-                at Clone, Copy
+                at cfg(…)
-                at Debug
+                at cfg_attr(…)
-                at Default
+                at deny(…)
-                at Hash
+                at forbid(…)
-                at PartialEq
+                at warn(…)
-                at PartialEq, Eq
+            "#]],
-                at PartialEq, PartialOrd
+        )
-                at PartialEq, Eq, PartialOrd, Ord
+    }
+    #[test]
+    fn complete_attribute_on_source_file() {
+        check(
+            r#"#![$0]"#,
+            expect![[r#"
+                at allow(…)
+                at cfg(…)
+                at cfg_attr(…)
+                at deny(…)
+                at forbid(…)
+                at warn(…)
+                at deprecated
+                at doc = "…"
+                at doc(hidden)
+                at doc(alias = "…")
+                at must_use
+                at no_mangle
+                at crate_name = ""
+                at feature(…)
+                at no_implicit_prelude
+                at no_main
+                at no_std
+                at recursion_limit = …
+                at type_length_limit = …
+                at windows_subsystem = "…"
            "#]],
        );
    }
    #[test]
-    fn no_completion_for_incorrect_derive() {
+    fn complete_attribute_on_module() {
        check(
-            r#"
+            r#"#[$0] mod foo;"#,
-#[derive{$0)]
+            expect![[r#"
-struct Test {}
+            at allow(…)
-"#,
+            at cfg(…)
-            expect![[r#""#]],
+            at cfg_attr(…)
-        )
+            at deny(…)
+            at forbid(…)
+            at warn(…)
+            at deprecated
+            at doc = "…"
+            at doc(hidden)
+            at doc(alias = "…")
+            at must_use
+            at no_mangle
+            at path = "…"
+        "#]],
+        );
+        check(
+            r#"mod foo {#![$0]}"#,
+            expect![[r#"
+                at allow(…)
+                at cfg(…)
+                at cfg_attr(…)
+                at deny(…)
+                at forbid(…)
+                at warn(…)
+                at deprecated
+                at doc = "…"
+                at doc(hidden)
+                at doc(alias = "…")
+                at must_use
+                at no_mangle
+                at no_implicit_prelude
+            "#]],
+        );
    }
    #[test]
-    fn derive_with_input_completion() {
+    fn complete_attribute_on_macro_rules() {
        check(
-            r#"
+            r#"#[$0] macro_rules! foo {}"#,
-#[derive(serde::Serialize, PartialEq, $0)]
-struct Test {}
-"#,
            expect![[r#"
-                at Clone
+                at allow(…)
-                at Clone, Copy
+                at cfg(…)
-                at Debug
+                at cfg_attr(…)
-                at Default
+                at deny(…)
-                at Hash
+                at forbid(…)
-                at Eq
+                at warn(…)
-                at PartialOrd
+                at deprecated
-                at Eq, PartialOrd, Ord
+                at doc = "…"
+                at doc(hidden)
+                at doc(alias = "…")
+                at must_use
+                at no_mangle
+                at macro_export
+                at macro_use
            "#]],
-        )
+        );
    }
    #[test]
-    fn test_attribute_completion() {
+    fn complete_attribute_on_macro_def() {
        check(
-            r#"#[$0]"#,
+            r#"#[$0] macro foo {}"#,
            expect![[r#"
                at allow(…)
-                at automatically_derived
+                at cfg(…)
                at cfg_attr(…)
+                at deny(…)
+                at forbid(…)
+                at warn(…)
+                at deprecated
+                at doc = "…"
+                at doc(hidden)
+                at doc(alias = "…")
+                at must_use
+                at no_mangle
+            "#]],
+        );
+    }
+    #[test]
+    fn complete_attribute_on_extern_crate() {
+        check(
+            r#"#[$0] extern crate foo;"#,
+            expect![[r#"
+                at allow(…)
                at cfg(…)
-                at cold
+                at cfg_attr(…)
                at deny(…)
+                at forbid(…)
+                at warn(…)
                at deprecated
-                at derive(…)
+                at doc = "…"
-                at export_name = "…"
+                at doc(hidden)
                at doc(alias = "…")
+                at must_use
+                at no_mangle
+                at macro_use
+            "#]],
+        );
+    }
+    #[test]
+    fn complete_attribute_on_use() {
+        check(
+            r#"#[$0] use foo;"#,
+            expect![[r#"
+                at allow(…)
+                at cfg(…)
+                at cfg_attr(…)
+                at deny(…)
+                at forbid(…)
+                at warn(…)
+                at deprecated
                at doc = "…"
                at doc(hidden)
+                at doc(alias = "…")
+                at must_use
+                at no_mangle
+            "#]],
+        );
+    }
+    #[test]
+    fn complete_attribute_on_type_alias() {
+        check(
+            r#"#[$0] type foo = ();"#,
+            expect![[r#"
+                at allow(…)
+                at cfg(…)
+                at cfg_attr(…)
+                at deny(…)
                at forbid(…)
-                at ignore = "…"
+                at warn(…)
-                at inline
+                at deprecated
-                at link
+                at doc = "…"
-                at link_name = "…"
+                at doc(hidden)
-                at link_section = "…"
+                at doc(alias = "…")
-                at macro_export
-                at macro_use
                at must_use
                at no_mangle
+            "#]],
+        );
+    }
+    #[test]
+    fn complete_attribute_on_struct() {
+        check(
+            r#"#[$0] struct Foo;"#,
+            expect![[r#"
+                at allow(…)
+                at cfg(…)
+                at cfg_attr(…)
+                at deny(…)
+                at forbid(…)
+                at warn(…)
+                at deprecated
+                at doc = "…"
+                at doc(hidden)
+                at doc(alias = "…")
+                at must_use
+                at no_mangle
+                at derive(…)
+                at repr(…)
                at non_exhaustive
-                at path = "…"
+            "#]],
-                at proc_macro
+        );
-                at proc_macro_attribute
+    }
-                at proc_macro_derive(…)
+    #[test]
+    fn complete_attribute_on_enum() {
+        check(
+            r#"#[$0] enum Foo {}"#,
+            expect![[r#"
+                at allow(…)
+                at cfg(…)
+                at cfg_attr(…)
+                at deny(…)
+                at forbid(…)
+                at warn(…)
+                at deprecated
+                at doc = "…"
+                at doc(hidden)
+                at doc(alias = "…")
+                at must_use
+                at no_mangle
+                at derive(…)
                at repr(…)
-                at should_panic
+                at non_exhaustive
-                at target_feature = "…"
+            "#]],
-                at test
+        );
-                at track_caller
+    }
-                at used
+    #[test]
+    fn complete_attribute_on_const() {
+        check(
+            r#"#[$0] const FOO: () = ();"#,
+            expect![[r#"
+                at allow(…)
+                at cfg(…)
+                at cfg_attr(…)
+                at deny(…)
+                at forbid(…)
                at warn(…)
+                at deprecated
+                at doc = "…"
+                at doc(hidden)
+                at doc(alias = "…")
+                at must_use
+                at no_mangle
            "#]],
-        )
+        );
    }
    #[test]
-    fn test_attribute_completion_inside_nested_attr() {
+    fn complete_attribute_on_static() {
-        check(r#"#[cfg($0)]"#, expect![[]])
+        check(
+            r#"#[$0] static FOO: () = ()"#,
+            expect![[r#"
+                at allow(…)
+                at cfg(…)
+                at cfg_attr(…)
+                at deny(…)
+                at forbid(…)
+                at warn(…)
+                at deprecated
+                at doc = "…"
+                at doc(hidden)
+                at doc(alias = "…")
+                at must_use
+                at no_mangle
+                at export_name = "…"
+                at link_name = "…"
+                at link_section = "…"
+                at used
+            "#]],
+        );
    }
    #[test]
-    fn test_inner_attribute_completion() {
+    fn complete_attribute_on_trait() {
        check(
-            r"#![$0]",
+            r#"#[$0] trait Foo {}"#,
            expect![[r#"
                at allow(…)
-                at automatically_derived
+                at cfg(…)
                at cfg_attr(…)
+                at deny(…)
+                at forbid(…)
+                at warn(…)
+                at deprecated
+                at doc = "…"
+                at doc(hidden)
+                at doc(alias = "…")
+                at must_use
+                at no_mangle
+                at must_use
+            "#]],
+        );
+    }
+    #[test]
+    fn complete_attribute_on_impl() {
+        check(
+            r#"#[$0] impl () {}"#,
+            expect![[r#"
+                at allow(…)
                at cfg(…)
-                at cold
+                at cfg_attr(…)
-                at crate_name = ""
                at deny(…)
+                at forbid(…)
+                at warn(…)
                at deprecated
-                at derive(…)
+                at doc = "…"
-                at export_name = "…"
+                at doc(hidden)
                at doc(alias = "…")
+                at must_use
+                at no_mangle
+                at automatically_derived
+            "#]],
+        );
+        check(
+            r#"impl () {#![$0]}"#,
+            expect![[r#"
+                at allow(…)
+                at cfg(…)
+                at cfg_attr(…)
+                at deny(…)
+                at forbid(…)
+                at warn(…)
+                at deprecated
                at doc = "…"
                at doc(hidden)
-                at feature(…)
+                at doc(alias = "…")
+                at must_use
+                at no_mangle
+            "#]],
+        );
+    }
+    #[test]
+    fn complete_attribute_on_extern_block() {
+        check(
+            r#"#[$0] extern {}"#,
+            expect![[r#"
+                at allow(…)
+                at cfg(…)
+                at cfg_attr(…)
+                at deny(…)
                at forbid(…)
-                at global_allocator
+                at warn(…)
-                at ignore = "…"
+                at deprecated
-                at inline
+                at doc = "…"
+                at doc(hidden)
+                at doc(alias = "…")
+                at must_use
+                at no_mangle
                at link
-                at link_name = "…"
+            "#]],
-                at link_section = "…"
+        );
-                at macro_export
+        check(
-                at macro_use
+            r#"extern {#![$0]}"#,
+            expect![[r#"
+                at allow(…)
+                at cfg(…)
+                at cfg_attr(…)
+                at deny(…)
+                at forbid(…)
+                at warn(…)
+                at deprecated
+                at doc = "…"
+                at doc(hidden)
+                at doc(alias = "…")
                at must_use
-                at no_link
-                at no_implicit_prelude
-                at no_main
                at no_mangle
-                at no_std
+                at link
+            "#]],
+        );
+    }
+    #[test]
+    fn complete_attribute_on_variant() {
+        check(
+            r#"enum Foo { #[$0] Bar }"#,
+            expect![[r#"
+                at allow(…)
+                at cfg(…)
+                at cfg_attr(…)
+                at deny(…)
+                at forbid(…)
+                at warn(…)
                at non_exhaustive
-                at panic_handler
+            "#]],
-                at path = "…"
+        );
-                at proc_macro
+    }
-                at proc_macro_attribute
-                at proc_macro_derive(…)
+    #[test]
-                at recursion_limit = …
+    fn complete_attribute_on_expr() {
-                at repr(…)
+        check(
-                at should_panic
+            r#"fn main() { #[$0] foo() }"#,
-                at target_feature = "…"
+            expect![[r#"
-                at test
+                at allow(…)
-                at track_caller
+                at cfg(…)
-                at type_length_limit = …
+                at cfg_attr(…)
-                at used
+                at deny(…)
+                at forbid(…)
+                at warn(…)
+            "#]],
+        );
+        check(
+            r#"fn main() { #[$0] foo(); }"#,
+            expect![[r#"
+                at allow(…)
+                at cfg(…)
+                at cfg_attr(…)
+                at deny(…)
+                at forbid(…)
                at warn(…)
-                at windows_subsystem = "…"
            "#]],
        );
    }
diff --git a/crates/ide_completion/src/completions/attribute/derive.rs b/crates/ide_completion/src/completions/attribute/derive.rs
new file mode 100644
index 000000000..0bc3eab98
--- /dev/null
+++ b/crates/ide_completion/src/completions/attribute/derive.rs
@@ -0,0 +1,147 @@
+//! Completion for derives
+use itertools::Itertools;
+use rustc_hash::FxHashSet;
+use syntax::ast;
+use crate::{
+    context::CompletionContext,
+    item::{CompletionItem, CompletionItemKind, CompletionKind},
+    Completions,
+};
+pub(super) fn complete_derive(
+    acc: &mut Completions,
+    ctx: &CompletionContext,
+    derive_input: ast::TokenTree,
+) {
+    if let Some(existing_derives) = super::parse_comma_sep_input(derive_input) {
+        for derive_completion in DEFAULT_DERIVE_COMPLETIONS
+            .iter()
+            .filter(|completion| !existing_derives.contains(completion.label))
+        {
+            let mut components = vec![derive_completion.label];
+            components.extend(
+                derive_completion
+                    .dependencies
+                    .iter()
+                    .filter(|&&dependency| !existing_derives.contains(dependency)),
+            );
+            let lookup = components.join(", ");
+            let label = components.iter().rev().join(", ");
+            let mut item =
+                CompletionItem::new(CompletionKind::Attribute, ctx.source_range(), label);
+            item.lookup_by(lookup).kind(CompletionItemKind::Attribute);
+            item.add_to(acc);
+        }
+        for custom_derive_name in get_derive_names_in_scope(ctx).difference(&existing_derives) {
+            let mut item = CompletionItem::new(
+                CompletionKind::Attribute,
+                ctx.source_range(),
+                custom_derive_name,
+            );
+            item.kind(CompletionItemKind::Attribute);
+            item.add_to(acc);
+        }
+    }
+}
+fn get_derive_names_in_scope(ctx: &CompletionContext) -> FxHashSet<String> {
+    let mut result = FxHashSet::default();
+    ctx.scope.process_all_names(&mut |name, scope_def| {
+        if let hir::ScopeDef::MacroDef(mac) = scope_def {
+            if mac.kind() == hir::MacroKind::Derive {
+                result.insert(name.to_string());
+            }
+        }
+    });
+    result
+}
+struct DeriveCompletion {
+    label: &'static str,
+    dependencies: &'static [&'static str],
+}
+/// Standard Rust derives and the information about their dependencies
+/// (the dependencies are needed so that the main derive don't break the compilation when added)
+const DEFAULT_DERIVE_COMPLETIONS: &[DeriveCompletion] = &[
+    DeriveCompletion { label: "Clone", dependencies: &[] },
+    DeriveCompletion { label: "Copy", dependencies: &["Clone"] },
+    DeriveCompletion { label: "Debug", dependencies: &[] },
+    DeriveCompletion { label: "Default", dependencies: &[] },
+    DeriveCompletion { label: "Hash", dependencies: &[] },
+    DeriveCompletion { label: "PartialEq", dependencies: &[] },
+    DeriveCompletion { label: "Eq", dependencies: &["PartialEq"] },
+    DeriveCompletion { label: "PartialOrd", dependencies: &["PartialEq"] },
+    DeriveCompletion { label: "Ord", dependencies: &["PartialOrd", "Eq", "PartialEq"] },
+];
+#[cfg(test)]
+mod tests {
+    use expect_test::{expect, Expect};
+    use crate::{test_utils::completion_list, CompletionKind};
+    fn check(ra_fixture: &str, expect: Expect) {
+        let actual = completion_list(ra_fixture, CompletionKind::Attribute);
+        expect.assert_eq(&actual);
+    }
+    #[test]
+    fn no_completion_for_incorrect_derive() {
+        check(r#"#[derive{$0)] struct Test;"#, expect![[]])
+    }
+    #[test]
+    fn empty_derive() {
+        check(
+            r#"#[derive($0)] struct Test;"#,
+            expect![[r#"
+                at Clone
+                at Clone, Copy
+                at Debug
+                at Default
+                at Hash
+                at PartialEq
+                at PartialEq, Eq
+                at PartialEq, PartialOrd
+                at PartialEq, Eq, PartialOrd, Ord
+            "#]],
+        );
+    }
+    #[test]
+    fn derive_with_input() {
+        check(
+            r#"#[derive(serde::Serialize, PartialEq, $0)] struct Test;"#,
+            expect![[r#"
+                at Clone
+                at Clone, Copy
+                at Debug
+                at Default
+                at Hash
+                at Eq
+                at PartialOrd
+                at Eq, PartialOrd, Ord
+            "#]],
+        )
+    }
+    #[test]
+    fn derive_with_input2() {
+        check(
+            r#"#[derive($0 serde::Serialize, PartialEq)] struct Test;"#,
+            expect![[r#"
+                at Clone
+                at Clone, Copy
+                at Debug
+                at Default
+                at Hash
+                at Eq
+                at PartialOrd
+                at Eq, PartialOrd, Ord
+            "#]],
+        )
+    }
+}
diff --git a/crates/ide_completion/src/completions/attribute/lint.rs b/crates/ide_completion/src/completions/attribute/lint.rs
new file mode 100644
index 000000000..403630dce
--- /dev/null
+++ b/crates/ide_completion/src/completions/attribute/lint.rs
@@ -0,0 +1,187 @@
+//! Completion for lints
+use syntax::ast;
+use crate::{
+    context::CompletionContext,
+    item::{CompletionItem, CompletionItemKind, CompletionKind},
+    Completions,
+};
+pub(super) fn complete_lint(
+    acc: &mut Completions,
+    ctx: &CompletionContext,
+    derive_input: ast::TokenTree,
+    lints_completions: &[LintCompletion],
+) {
+    if let Some(existing_lints) = super::parse_comma_sep_input(derive_input) {
+        for lint_completion in lints_completions
+            .into_iter()
+            .filter(|completion| !existing_lints.contains(completion.label))
+        {
+            let mut item = CompletionItem::new(
+                CompletionKind::Attribute,
+                ctx.source_range(),
+                lint_completion.label,
+            );
+            item.kind(CompletionItemKind::Attribute).detail(lint_completion.description);
+            item.add_to(acc)
+        }
+    }
+}
+pub(crate) struct LintCompletion {
+    pub(crate) label: &'static str,
+    pub(crate) description: &'static str,
+}
+#[rustfmt::skip]
+pub(super) const DEFAULT_LINT_COMPLETIONS: &[LintCompletion] = &[
+    LintCompletion { label: "absolute_paths_not_starting_with_crate", description: r#"fully qualified paths that start with a module name instead of `crate`, `self`, or an extern crate name"# },
+    LintCompletion { label: "anonymous_parameters", description: r#"detects anonymous parameters"# },
+    LintCompletion { label: "box_pointers", description: r#"use of owned (Box type) heap memory"# },
+    LintCompletion { label: "deprecated_in_future", description: r#"detects use of items that will be deprecated in a future version"# },
+    LintCompletion { label: "elided_lifetimes_in_paths", description: r#"hidden lifetime parameters in types are deprecated"# },
+    LintCompletion { label: "explicit_outlives_requirements", description: r#"outlives requirements can be inferred"# },
+    LintCompletion { label: "indirect_structural_match", description: r#"pattern with const indirectly referencing non-structural-match type"# },
+    LintCompletion { label: "keyword_idents", description: r#"detects edition keywords being used as an identifier"# },
+    LintCompletion { label: "macro_use_extern_crate", description: r#"the `#[macro_use]` attribute is now deprecated in favor of using macros via the module system"# },
+    LintCompletion { label: "meta_variable_misuse", description: r#"possible meta-variable misuse at macro definition"# },
+    LintCompletion { label: "missing_copy_implementations", description: r#"detects potentially-forgotten implementations of `Copy`"# },
+    LintCompletion { label: "missing_crate_level_docs", description: r#"detects crates with no crate-level documentation"# },
+    LintCompletion { label: "missing_debug_implementations", description: r#"detects missing implementations of Debug"# },
+    LintCompletion { label: "missing_docs", description: r#"detects missing documentation for public members"# },
+    LintCompletion { label: "missing_doc_code_examples", description: r#"detects publicly-exported items without code samples in their documentation"# },
+    LintCompletion { label: "non_ascii_idents", description: r#"detects non-ASCII identifiers"# },
+    LintCompletion { label: "private_doc_tests", description: r#"detects code samples in docs of private items not documented by rustdoc"# },
+    LintCompletion { label: "single_use_lifetimes", description: r#"detects lifetime parameters that are only used once"# },
+    LintCompletion { label: "trivial_casts", description: r#"detects trivial casts which could be removed"# },
+    LintCompletion { label: "trivial_numeric_casts", description: r#"detects trivial casts of numeric types which could be removed"# },
+    LintCompletion { label: "unaligned_references", description: r#"detects unaligned references to fields of packed structs"# },
+    LintCompletion { label: "unreachable_pub", description: r#"`pub` items not reachable from crate root"# },
+    LintCompletion { label: "unsafe_code", description: r#"usage of `unsafe` code"# },
+    LintCompletion { label: "unsafe_op_in_unsafe_fn", description: r#"unsafe operations in unsafe functions without an explicit unsafe block are deprecated"# },
+    LintCompletion { label: "unstable_features", description: r#"enabling unstable features (deprecated. do not use)"# },
+    LintCompletion { label: "unused_crate_dependencies", description: r#"crate dependencies that are never used"# },
+    LintCompletion { label: "unused_extern_crates", description: r#"extern crates that are never used"# },
+    LintCompletion { label: "unused_import_braces", description: r#"unnecessary braces around an imported item"# },
+    LintCompletion { label: "unused_lifetimes", description: r#"detects lifetime parameters that are never used"# },
+    LintCompletion { label: "unused_qualifications", description: r#"detects unnecessarily qualified names"# },
+    LintCompletion { label: "unused_results", description: r#"unused result of an expression in a statement"# },
+    LintCompletion { label: "variant_size_differences", description: r#"detects enums with widely varying variant sizes"# },
+    LintCompletion { label: "array_into_iter", description: r#"detects calling `into_iter` on arrays"# },
+    LintCompletion { label: "asm_sub_register", description: r#"using only a subset of a register for inline asm inputs"# },
+    LintCompletion { label: "bare_trait_objects", description: r#"suggest using `dyn Trait` for trait objects"# },
+    LintCompletion { label: "bindings_with_variant_name", description: r#"detects pattern bindings with the same name as one of the matched variants"# },
+    LintCompletion { label: "cenum_impl_drop_cast", description: r#"a C-like enum implementing Drop is cast"# },
+    LintCompletion { label: "clashing_extern_declarations", description: r#"detects when an extern fn has been declared with the same name but different types"# },
+    LintCompletion { label: "coherence_leak_check", description: r#"distinct impls distinguished only by the leak-check code"# },
+    LintCompletion { label: "confusable_idents", description: r#"detects visually confusable pairs between identifiers"# },
+    LintCompletion { label: "dead_code", description: r#"detect unused, unexported items"# },
+    LintCompletion { label: "deprecated", description: r#"detects use of deprecated items"# },
+    LintCompletion { label: "ellipsis_inclusive_range_patterns", description: r#"`...` range patterns are deprecated"# },
+    LintCompletion { label: "exported_private_dependencies", description: r#"public interface leaks type from a private dependency"# },
+    LintCompletion { label: "illegal_floating_point_literal_pattern", description: r#"floating-point literals cannot be used in patterns"# },
+    LintCompletion { label: "improper_ctypes", description: r#"proper use of libc types in foreign modules"# },
+    LintCompletion { label: "improper_ctypes_definitions", description: r#"proper use of libc types in foreign item definitions"# },
+    LintCompletion { label: "incomplete_features", description: r#"incomplete features that may function improperly in some or all cases"# },
+    LintCompletion { label: "inline_no_sanitize", description: r#"detects incompatible use of `#[inline(always)]` and `#[no_sanitize(...)]`"# },
+    LintCompletion { label: "intra_doc_link_resolution_failure", description: r#"failures in resolving intra-doc link targets"# },
+    LintCompletion { label: "invalid_codeblock_attributes", description: r#"codeblock attribute looks a lot like a known one"# },
+    LintCompletion { label: "invalid_value", description: r#"an invalid value is being created (such as a NULL reference)"# },
+    LintCompletion { label: "irrefutable_let_patterns", description: r#"detects irrefutable patterns in if-let and while-let statements"# },
+    LintCompletion { label: "late_bound_lifetime_arguments", description: r#"detects generic lifetime arguments in path segments with late bound lifetime parameters"# },
+    LintCompletion { label: "mixed_script_confusables", description: r#"detects Unicode scripts whose mixed script confusables codepoints are solely used"# },
+    LintCompletion { label: "mutable_borrow_reservation_conflict", description: r#"reservation of a two-phased borrow conflicts with other shared borrows"# },
+    LintCompletion { label: "non_camel_case_types", description: r#"types, variants, traits and type parameters should have camel case names"# },
+    LintCompletion { label: "non_shorthand_field_patterns", description: r#"using `Struct { x: x }` instead of `Struct { x }` in a pattern"# },
+    LintCompletion { label: "non_snake_case", description: r#"variables, methods, functions, lifetime parameters and modules should have snake case names"# },
+    LintCompletion { label: "non_upper_case_globals", description: r#"static constants should have uppercase identifiers"# },
+    LintCompletion { label: "no_mangle_generic_items", description: r#"generic items must be mangled"# },
+    LintCompletion { label: "overlapping_patterns", description: r#"detects overlapping patterns"# },
+    LintCompletion { label: "path_statements", description: r#"path statements with no effect"# },
+    LintCompletion { label: "private_in_public", description: r#"detect private items in public interfaces not caught by the old implementation"# },
+    LintCompletion { label: "proc_macro_derive_resolution_fallback", description: r#"detects proc macro derives using inaccessible names from parent modules"# },
+    LintCompletion { label: "redundant_semicolons", description: r#"detects unnecessary trailing semicolons"# },
+    LintCompletion { label: "renamed_and_removed_lints", description: r#"lints that have been renamed or removed"# },
+    LintCompletion { label: "safe_packed_borrows", description: r#"safe borrows of fields of packed structs were erroneously allowed"# },
+    LintCompletion { label: "stable_features", description: r#"stable features found in `#[feature]` directive"# },
+    LintCompletion { label: "trivial_bounds", description: r#"these bounds don't depend on an type parameters"# },
+    LintCompletion { label: "type_alias_bounds", description: r#"bounds in type aliases are not enforced"# },
+    LintCompletion { label: "tyvar_behind_raw_pointer", description: r#"raw pointer to an inference variable"# },
+    LintCompletion { label: "uncommon_codepoints", description: r#"detects uncommon Unicode codepoints in identifiers"# },
+    LintCompletion { label: "unconditional_recursion", description: r#"functions that cannot return without calling themselves"# },
+    LintCompletion { label: "unknown_lints", description: r#"unrecognized lint attribute"# },
+    LintCompletion { label: "unnameable_test_items", description: r#"detects an item that cannot be named being marked as `#[test_case]`"# },
+    LintCompletion { label: "unreachable_code", description: r#"detects unreachable code paths"# },
+    LintCompletion { label: "unreachable_patterns", description: r#"detects unreachable patterns"# },
+    LintCompletion { label: "unstable_name_collisions", description: r#"detects name collision with an existing but unstable method"# },
+    LintCompletion { label: "unused_allocation", description: r#"detects unnecessary allocations that can be eliminated"# },
+    LintCompletion { label: "unused_assignments", description: r#"detect assignments that will never be read"# },
+    LintCompletion { label: "unused_attributes", description: r#"detects attributes that were not used by the compiler"# },
+    LintCompletion { label: "unused_braces", description: r#"unnecessary braces around an expression"# },
+    LintCompletion { label: "unused_comparisons", description: r#"comparisons made useless by limits of the types involved"# },
+    LintCompletion { label: "unused_doc_comments", description: r#"detects doc comments that aren't used by rustdoc"# },
+    LintCompletion { label: "unused_features", description: r#"unused features found in crate-level `#[feature]` directives"# },
+    LintCompletion { label: "unused_imports", description: r#"imports that are never used"# },
+    LintCompletion { label: "unused_labels", description: r#"detects labels that are never used"# },
+    LintCompletion { label: "unused_macros", description: r#"detects macros that were not used"# },
+    LintCompletion { label: "unused_must_use", description: r#"unused result of a type flagged as `#[must_use]`"# },
+    LintCompletion { label: "unused_mut", description: r#"detect mut variables which don't need to be mutable"# },
+    LintCompletion { label: "unused_parens", description: r#"`if`, `match`, `while` and `return` do not need parentheses"# },
+    LintCompletion { label: "unused_unsafe", description: r#"unnecessary use of an `unsafe` block"# },
+    LintCompletion { label: "unused_variables", description: r#"detect variables which are not used in any way"# },
+    LintCompletion { label: "warnings", description: r#"mass-change the level for lints which produce warnings"# },
+    LintCompletion { label: "where_clauses_object_safety", description: r#"checks the object safety of where clauses"# },
+    LintCompletion { label: "while_true", description: r#"suggest using `loop { }` instead of `while true { }`"# },
+    LintCompletion { label: "ambiguous_associated_items", description: r#"ambiguous associated items"# },
+    LintCompletion { label: "arithmetic_overflow", description: r#"arithmetic operation overflows"# },
+    LintCompletion { label: "conflicting_repr_hints", description: r#"conflicts between `#[repr(..)]` hints that were previously accepted and used in practice"# },
+    LintCompletion { label: "const_err", description: r#"constant evaluation detected erroneous expression"# },
+    LintCompletion { label: "ill_formed_attribute_input", description: r#"ill-formed attribute inputs that were previously accepted and used in practice"# },
+    LintCompletion { label: "incomplete_include", description: r#"trailing content in included file"# },
+    LintCompletion { label: "invalid_type_param_default", description: r#"type parameter default erroneously allowed in invalid location"# },
+    LintCompletion { label: "macro_expanded_macro_exports_accessed_by_absolute_paths", description: r#"macro-expanded `macro_export` macros from the current crate cannot be referred to by absolute paths"# },
+    LintCompletion { label: "missing_fragment_specifier", description: r#"detects missing fragment specifiers in unused `macro_rules!` patterns"# },
+    LintCompletion { label: "mutable_transmutes", description: r#"mutating transmuted &mut T from &T may cause undefined behavior"# },
+    LintCompletion { label: "no_mangle_const_items", description: r#"const items will not have their symbols exported"# },
+    LintCompletion { label: "order_dependent_trait_objects", description: r#"trait-object types were treated as different depending on marker-trait order"# },
+    LintCompletion { label: "overflowing_literals", description: r#"literal out of range for its type"# },
+    LintCompletion { label: "patterns_in_fns_without_body", description: r#"patterns in functions without body were erroneously allowed"# },
+    LintCompletion { label: "pub_use_of_private_extern_crate", description: r#"detect public re-exports of private extern crates"# },
+    LintCompletion { label: "soft_unstable", description: r#"a feature gate that doesn't break dependent crates"# },
+    LintCompletion { label: "unconditional_panic", description: r#"operation will cause a panic at runtime"# },
+    LintCompletion { label: "unknown_crate_types", description: r#"unknown crate type found in `#[crate_type]` directive"# },
+];
+#[cfg(test)]
+mod tests {
+    use crate::test_utils::check_edit;
+    #[test]
+    fn check_empty() {
+        check_edit(
+            "deprecated",
+            r#"#[allow($0)] struct Test;"#,
+            r#"#[allow(deprecated)] struct Test;"#,
+        )
+    }
+    #[test]
+    fn check_with_existing() {
+        check_edit(
+            "deprecated",
+            r#"#[allow(keyword_idents, $0)] struct Test;"#,
+            r#"#[allow(keyword_idents, deprecated)] struct Test;"#,
+        )
+    }
+    #[test]
+    fn check_qualified() {
+        check_edit(
+            "deprecated",
+            r#"#[allow(keyword_idents, $0)] struct Test;"#,
+            r#"#[allow(keyword_idents, deprecated)] struct Test;"#,
+        )
+    }
+}
diff --git a/crates/ide_completion/src/completions/flyimport.rs b/crates/ide_completion/src/completions/flyimport.rs
index 9d5b61562..df27e7a84 100644
--- a/crates/ide_completion/src/completions/flyimport.rs
+++ b/crates/ide_completion/src/completions/flyimport.rs
@@ -111,11 +111,9 @@ pub(crate) fn import_on_the_fly(acc: &mut Completions, ctx: &CompletionContext)
        return None;
    }
    if ctx.use_item_syntax.is_some()
-        || ctx.attribute_under_caret.is_some()
+        || ctx.is_path_disallowed()
-        || ctx.mod_declaration_under_caret.is_some()
+        || ctx.expects_item()
-        || ctx.record_lit_syntax.is_some()
+        || ctx.expects_assoc_item()
-        || ctx.has_trait_parent
-        || ctx.has_impl_parent
    {
        return None;
    }
diff --git a/crates/ide_completion/src/completions/keyword.rs b/crates/ide_completion/src/completions/keyword.rs
index 61b667104..e71a04b6e 100644
--- a/crates/ide_completion/src/completions/keyword.rs
+++ b/crates/ide_completion/src/completions/keyword.rs
@@ -2,7 +2,7 @@
 use std::iter;
-use syntax::SyntaxKind;
+use syntax::{SyntaxKind, T};
 use crate::{CompletionContext, CompletionItem, CompletionItemKind, CompletionKind, Completions};
@@ -48,107 +48,102 @@ pub(crate) fn complete_expr_keyword(acc: &mut Completions, ctx: &CompletionConte
        cov_mark::hit!(no_keyword_completion_in_record_lit);
        return;
    }
+    let mut add_keyword = |kw, snippet| add_keyword(ctx, acc, kw, snippet);
-    let has_trait_or_impl_parent = ctx.has_impl_parent || ctx.has_trait_parent;
+    let expects_assoc_item = ctx.expects_assoc_item();
-    if ctx.trait_as_prev_sibling || ctx.impl_as_prev_sibling {
+    let has_block_expr_parent = ctx.has_block_expr_parent();
-        add_keyword(ctx, acc, "where", "where ");
+    let expects_item = ctx.expects_item();
+    if ctx.has_impl_or_trait_prev_sibling() {
+        // FIXME this also incorrectly shows up after a complete trait/impl
+        add_keyword("where", "where ");
        return;
    }
-    if ctx.unsafe_is_prev {
+    if ctx.previous_token_is(T![unsafe]) {
-        if ctx.has_item_list_or_source_file_parent || ctx.block_expr_parent {
+        if expects_item || expects_assoc_item || has_block_expr_parent {
-            add_keyword(ctx, acc, "fn", "fn $0() {}")
+            add_keyword("fn", "fn $1($2) {\n    $0\n}")
        }
-        if (ctx.has_item_list_or_source_file_parent) || ctx.block_expr_parent {
+        if expects_item || has_block_expr_parent {
-            add_keyword(ctx, acc, "trait", "trait $0 {}");
+            add_keyword("trait", "trait $1 {\n    $0\n}");
-            add_keyword(ctx, acc, "impl", "impl $0 {}");
+            add_keyword("impl", "impl $1 {\n    $0\n}");
        }
        return;
    }
-    if ctx.has_item_list_or_source_file_parent || has_trait_or_impl_parent || ctx.block_expr_parent
-    {
-        add_keyword(ctx, acc, "fn", "fn $0() {}");
-    }
-    if (ctx.has_item_list_or_source_file_parent) || ctx.block_expr_parent {
-        add_keyword(ctx, acc, "use", "use ");
-        add_keyword(ctx, acc, "impl", "impl $0 {}");
-        add_keyword(ctx, acc, "trait", "trait $0 {}");
-    }
-    if ctx.has_item_list_or_source_file_parent {
+    if expects_item || ctx.expects_non_trait_assoc_item() || ctx.expect_record_field() {
-        add_keyword(ctx, acc, "enum", "enum $0 {}");
+        add_keyword("pub(crate)", "pub(crate) ");
-        add_keyword(ctx, acc, "struct", "struct $0");
+        add_keyword("pub", "pub ");
-        add_keyword(ctx, acc, "union", "union $0 {}");
    }
-    if ctx.is_expr {
+    if expects_item || expects_assoc_item || has_block_expr_parent || ctx.is_match_arm {
-        add_keyword(ctx, acc, "match", "match $0 {}");
+        add_keyword("unsafe", "unsafe ");
-        add_keyword(ctx, acc, "while", "while $0 {}");
-        add_keyword(ctx, acc, "while let", "while let $1 = $0 {}");
-        add_keyword(ctx, acc, "loop", "loop {$0}");
-        add_keyword(ctx, acc, "if", "if $0 {}");
-        add_keyword(ctx, acc, "if let", "if let $1 = $0 {}");
-        add_keyword(ctx, acc, "for", "for $1 in $0 {}");
    }
-    if ctx.if_is_prev || ctx.block_expr_parent {
+    if expects_item || expects_assoc_item || has_block_expr_parent {
-        add_keyword(ctx, acc, "let", "let ");
+        add_keyword("fn", "fn $1($2) {\n    $0\n}");
+        add_keyword("const", "const $0");
+        add_keyword("type", "type $0");
    }
-    if ctx.after_if {
+    if expects_item || has_block_expr_parent {
-        add_keyword(ctx, acc, "else", "else {$0}");
+        add_keyword("use", "use $0");
-        add_keyword(ctx, acc, "else if", "else if $0 {}");
+        add_keyword("impl", "impl $1 {\n    $0\n}");
+        add_keyword("trait", "trait $1 {\n    $0\n}");
+        add_keyword("static", "static $0");
+        add_keyword("extern", "extern $0");
+        add_keyword("mod", "mod $0");
    }
-    if (ctx.has_item_list_or_source_file_parent) || ctx.block_expr_parent {
-        add_keyword(ctx, acc, "mod", "mod $0");
+    if expects_item {
+        add_keyword("enum", "enum $1 {\n    $0\n}");
+        add_keyword("struct", "struct $0");
+        add_keyword("union", "union $1 {\n    $0\n}");
    }
-    if ctx.bind_pat_parent || ctx.ref_pat_parent {
-        add_keyword(ctx, acc, "mut", "mut ");
+    if ctx.expects_expression() {
+        add_keyword("match", "match $1 {\n    $0\n}");
+        add_keyword("while", "while $1 {\n    $0\n}");
+        add_keyword("while let", "while let $1 = $2 {\n    $0\n}");
+        add_keyword("loop", "loop {\n    $0\n}");
+        add_keyword("if", "if $1 {\n    $0\n}");
+        add_keyword("if let", "if let $1 = $2 {\n    $0\n}");
+        add_keyword("for", "for $1 in $2 {\n    $0\n}");
    }
-    if ctx.has_item_list_or_source_file_parent || has_trait_or_impl_parent || ctx.block_expr_parent
-    {
+    if ctx.previous_token_is(T![if]) || ctx.previous_token_is(T![while]) || has_block_expr_parent {
-        add_keyword(ctx, acc, "const", "const ");
+        add_keyword("let", "let ");
-        add_keyword(ctx, acc, "type", "type ");
    }
-    if (ctx.has_item_list_or_source_file_parent) || ctx.block_expr_parent {
-        add_keyword(ctx, acc, "static", "static ");
+    if ctx.after_if() {
-    };
+        add_keyword("else", "else {\n    $0\n}");
-    if (ctx.has_item_list_or_source_file_parent) || ctx.block_expr_parent {
+        add_keyword("else if", "else if $1 {\n    $0\n}");
-        add_keyword(ctx, acc, "extern", "extern ");
    }
-    if ctx.has_item_list_or_source_file_parent
-        || has_trait_or_impl_parent
+    if ctx.expects_ident_pat_or_ref_expr() {
-        || ctx.block_expr_parent
+        add_keyword("mut", "mut ");
-        || ctx.is_match_arm
-    {
-        add_keyword(ctx, acc, "unsafe", "unsafe ");
    }
    if ctx.in_loop_body {
        if ctx.can_be_stmt {
-            add_keyword(ctx, acc, "continue", "continue;");
+            add_keyword("continue", "continue;");
-            add_keyword(ctx, acc, "break", "break;");
+            add_keyword("break", "break;");
        } else {
-            add_keyword(ctx, acc, "continue", "continue");
+            add_keyword("continue", "continue");
-            add_keyword(ctx, acc, "break", "break");
+            add_keyword("break", "break");
        }
    }
-    if ctx.has_item_list_or_source_file_parent || ctx.has_impl_parent | ctx.has_field_list_parent {
-        add_keyword(ctx, acc, "pub(crate)", "pub(crate) ");
-        add_keyword(ctx, acc, "pub", "pub ");
-    }
    if !ctx.is_trivial_path {
        return;
    }
-    let fn_def = match &ctx.function_syntax {
+    let fn_def = match &ctx.function_def {
        Some(it) => it,
        None => return,
    };
    add_keyword(
-        ctx,
-        acc,
        "return",
        match (ctx.can_be_stmt, fn_def.ret_type().is_some()) {
            (true, true) => "return $0;",
@@ -165,15 +160,12 @@ fn add_keyword(ctx: &CompletionContext, acc: &mut Completions, kw: &str, snippet
    match ctx.config.snippet_cap {
        Some(cap) => {
-            let tmp;
+            if snippet.ends_with('}') && ctx.incomplete_let {
-            let snippet = if snippet.ends_with('}') && ctx.incomplete_let {
                cov_mark::hit!(let_semi);
-                tmp = format!("{};", snippet);
+                item.insert_snippet(cap, format!("{};", snippet));
-                &tmp
            } else {
-                snippet
+                item.insert_snippet(cap, snippet);
-            };
+            }
-            item.insert_snippet(cap, snippet);
        }
        None => {
            item.insert_text(if snippet.contains('$') { kw } else { snippet });
@@ -236,21 +228,21 @@ mod tests {
        check(
            r"m$0",
            expect![[r#"
+                kw pub(crate)
+                kw pub
+                kw unsafe
                kw fn
+                kw const
+                kw type
                kw use
                kw impl
                kw trait
+                kw static
+                kw extern
+                kw mod
                kw enum
                kw struct
                kw union
-                kw mod
-                kw const
-                kw type
-                kw static
-                kw extern
-                kw unsafe
-                kw pub(crate)
-                kw pub
            "#]],
        );
    }
@@ -260,10 +252,16 @@ mod tests {
        check(
            r"fn quux() { $0 }",
            expect![[r#"
+                kw unsafe
                kw fn
+                kw const
+                kw type
                kw use
                kw impl
                kw trait
+                kw static
+                kw extern
+                kw mod
                kw match
                kw while
                kw while let
@@ -272,12 +270,6 @@ mod tests {
                kw if let
                kw for
                kw let
-                kw mod
-                kw const
-                kw type
-                kw static
-                kw extern
-                kw unsafe
                kw return
            "#]],
        );
@@ -288,10 +280,16 @@ mod tests {
        check(
            r"fn quux() { if true { $0 } }",
            expect![[r#"
+                kw unsafe
                kw fn
+                kw const
+                kw type
                kw use
                kw impl
                kw trait
+                kw static
+                kw extern
+                kw mod
                kw match
                kw while
                kw while let
@@ -300,12 +298,6 @@ mod tests {
                kw if let
                kw for
                kw let
-                kw mod
-                kw const
-                kw type
-                kw static
-                kw extern
-                kw unsafe
                kw return
            "#]],
        );
@@ -316,10 +308,16 @@ mod tests {
        check(
            r#"fn quux() { if true { () } $0 }"#,
            expect![[r#"
+                kw unsafe
                kw fn
+                kw const
+                kw type
                kw use
                kw impl
                kw trait
+                kw static
+                kw extern
+                kw mod
                kw match
                kw while
                kw while let
@@ -330,19 +328,15 @@ mod tests {
                kw let
                kw else
                kw else if
-                kw mod
-                kw const
-                kw type
-                kw static
-                kw extern
-                kw unsafe
                kw return
            "#]],
        );
        check_edit(
            "else",
            r#"fn quux() { if true { () } $0 }"#,
-            r#"fn quux() { if true { () } else {$0} }"#,
+            r#"fn quux() { if true { () } else {
+    $0
+} }"#,
        );
    }
@@ -355,6 +349,7 @@ fn quux() -> i32 {
 }
 "#,
            expect![[r#"
+                kw unsafe
                kw match
                kw while
                kw while let
@@ -362,7 +357,6 @@ fn quux() -> i32 {
                kw if
                kw if let
                kw for
-                kw unsafe
                kw return
            "#]],
        );
@@ -373,10 +367,10 @@ fn quux() -> i32 {
        check(
            r"trait My { $0 }",
            expect![[r#"
+                kw unsafe
                kw fn
                kw const
                kw type
-                kw unsafe
            "#]],
        );
    }
@@ -386,12 +380,27 @@ fn quux() -> i32 {
        check(
            r"impl My { $0 }",
            expect![[r#"
+                kw pub(crate)
+                kw pub
+                kw unsafe
                kw fn
                kw const
                kw type
-                kw unsafe
+            "#]],
+        );
+    }
+    #[test]
+    fn test_keywords_in_impl_def_with_attr() {
+        check(
+            r"impl My { #[foo] $0 }",
+            expect![[r#"
                kw pub(crate)
                kw pub
+                kw unsafe
+                kw fn
+                kw const
+                kw type
            "#]],
        );
    }
@@ -401,10 +410,16 @@ fn quux() -> i32 {
        check(
            r"fn my() { loop { $0 } }",
            expect![[r#"
+                kw unsafe
                kw fn
+                kw const
+                kw type
                kw use
                kw impl
                kw trait
+                kw static
+                kw extern
+                kw mod
                kw match
                kw while
                kw while let
@@ -413,12 +428,6 @@ fn quux() -> i32 {
                kw if let
                kw for
                kw let
-                kw mod
-                kw const
-                kw type
-                kw static
-                kw extern
-                kw unsafe
                kw continue
                kw break
                kw return
@@ -646,7 +655,9 @@ fn foo() {
 fn main() { let x = $0 }
 "#,
            r#"
-fn main() { let x = match $0 {}; }
+fn main() { let x = match $1 {
+    $0
+}; }
 "#,
        );
@@ -660,7 +671,9 @@ fn main() {
 "#,
            r#"
 fn main() {
-    let x = if $0 {};
+    let x = if $1 {
+    $0
+};
    let y = 92;
 }
 "#,
@@ -676,7 +689,9 @@ fn main() {
 "#,
            r#"
 fn main() {
-    let x = loop {$0};
+    let x = loop {
+    $0
+};
    bar();
 }
 "#,
diff --git a/crates/ide_completion/src/completions/lifetime.rs b/crates/ide_completion/src/completions/lifetime.rs
index 5eeddf7a4..5f6285b84 100644
--- a/crates/ide_completion/src/completions/lifetime.rs
+++ b/crates/ide_completion/src/completions/lifetime.rs
@@ -8,19 +8,24 @@ pub(crate) fn complete_lifetime(acc: &mut Completions, ctx: &CompletionContext)
    if !ctx.lifetime_allowed {
        return;
    }
+    let lp_string;
    let param_lifetime = match (
        &ctx.lifetime_syntax,
        ctx.lifetime_param_syntax.as_ref().and_then(|lp| lp.lifetime()),
    ) {
        (Some(lt), Some(lp)) if lp == lt.clone() => return,
-        (Some(_), Some(lp)) => Some(lp.to_string()),
+        (Some(_), Some(lp)) => {
+            lp_string = lp.to_string();
+            Some(&lp_string)
+        }
        _ => None,
    };
    ctx.scope.process_all_names(&mut |name, res| {
        if let ScopeDef::GenericParam(hir::GenericParam::LifetimeParam(_)) = res {
-            if param_lifetime != Some(name.to_string()) {
+            let name = name.to_string();
-                acc.add_resolution(ctx, name.to_string(), &res);
+            if param_lifetime != Some(&name) {
+                acc.add_resolution(ctx, name, &res);
            }
        }
    });
diff --git a/crates/ide_completion/src/completions/macro_in_item_position.rs b/crates/ide_completion/src/completions/macro_in_item_position.rs
index 2be299ac2..ec57aee30 100644
--- a/crates/ide_completion/src/completions/macro_in_item_position.rs
+++ b/crates/ide_completion/src/completions/macro_in_item_position.rs
@@ -2,15 +2,22 @@
 use crate::{CompletionContext, Completions};
+// Ideally this should be removed and moved into `(un)qualified_path` respectively
 pub(crate) fn complete_macro_in_item_position(acc: &mut Completions, ctx: &CompletionContext) {
    // Show only macros in top level.
-    if ctx.is_new_item {
+    if !ctx.is_new_item {
-        ctx.scope.process_all_names(&mut |name, res| {
+        return;
-            if let hir::ScopeDef::MacroDef(mac) = res {
-                acc.add_macro(ctx, Some(name.to_string()), mac);
-            }
-        })
    }
+    ctx.scope.process_all_names(&mut |name, res| {
+        if let hir::ScopeDef::MacroDef(mac) = res {
+            acc.add_macro(ctx, Some(name.to_string()), mac);
+        }
+        // FIXME: This should be done in qualified_path/unqualified_path instead?
+        if let hir::ScopeDef::ModuleDef(hir::ModuleDef::Module(_)) = res {
+            acc.add_resolution(ctx, name.to_string(), &res);
+        }
+    })
 }
 #[cfg(test)]
diff --git a/crates/ide_completion/src/completions/pattern.rs b/crates/ide_completion/src/completions/pattern.rs
index 8dc9ab73c..b84e9a967 100644
--- a/crates/ide_completion/src/completions/pattern.rs
+++ b/crates/ide_completion/src/completions/pattern.rs
@@ -1,17 +1,15 @@
 //! Completes constants and paths in patterns.
-use crate::{CompletionContext, Completions};
+use crate::{context::PatternRefutability, CompletionContext, Completions};
 /// Completes constants and paths in patterns.
 pub(crate) fn complete_pattern(acc: &mut Completions, ctx: &CompletionContext) {
-    if !(ctx.is_pat_binding_or_const || ctx.is_irrefutable_pat_binding) {
+    let refutable = match ctx.is_pat_or_const {
-        return;
+        Some(it) => it == PatternRefutability::Refutable,
-    }
+        None => return,
-    if ctx.record_pat_syntax.is_some() {
+    };
-        return;
-    }
-    if !ctx.is_irrefutable_pat_binding {
+    if refutable {
        if let Some(hir::Adt::Enum(e)) =
            ctx.expected_type.as_ref().and_then(|ty| ty.strip_references().as_adt())
        {
@@ -31,14 +29,14 @@ pub(crate) fn complete_pattern(acc: &mut Completions, ctx: &CompletionContext) {
                    acc.add_struct_pat(ctx, *strukt, Some(name.clone()));
                    true
                }
-                hir::ModuleDef::Variant(variant) if !ctx.is_irrefutable_pat_binding => {
+                hir::ModuleDef::Variant(variant) if refutable => {
                    acc.add_variant_pat(ctx, *variant, Some(name.clone()));
                    true
                }
                hir::ModuleDef::Adt(hir::Adt::Enum(..))
                | hir::ModuleDef::Variant(..)
                | hir::ModuleDef::Const(..)
-                | hir::ModuleDef::Module(..) => !ctx.is_irrefutable_pat_binding,
+                | hir::ModuleDef::Module(..) => refutable,
                _ => false,
            },
            hir::ScopeDef::MacroDef(_) => true,
@@ -47,7 +45,7 @@ pub(crate) fn complete_pattern(acc: &mut Completions, ctx: &CompletionContext) {
                    acc.add_struct_pat(ctx, strukt, Some(name.clone()));
                    true
                }
-                Some(hir::Adt::Enum(_)) => !ctx.is_irrefutable_pat_binding,
+                Some(hir::Adt::Enum(_)) => refutable,
                _ => true,
            },
            _ => false,
@@ -402,4 +400,31 @@ impl Foo {
            "#]],
        )
    }
+    #[test]
+    fn completes_in_record_field_pat() {
+        check_snippet(
+            r#"
+struct Foo { bar: Bar }
+struct Bar(u32);
+fn outer(Foo { bar: $0 }: Foo) {}
+"#,
+            expect![[r#"
+                bn Foo Foo { bar$1 }$0
+                bn Bar Bar($1)$0
+            "#]],
+        )
+    }
+    #[test]
+    fn skips_in_record_field_pat_name() {
+        check_snippet(
+            r#"
+struct Foo { bar: Bar }
+struct Bar(u32);
+fn outer(Foo { bar$0 }: Foo) {}
+"#,
+            expect![[r#""#]],
+        )
+    }
 }
diff --git a/crates/ide_completion/src/completions/qualified_path.rs b/crates/ide_completion/src/completions/qualified_path.rs
index eedb44873..7a0e1ead3 100644
--- a/crates/ide_completion/src/completions/qualified_path.rs
+++ b/crates/ide_completion/src/completions/qualified_path.rs
@@ -7,21 +7,33 @@ use syntax::AstNode;
 use crate::{CompletionContext, Completions};
 pub(crate) fn complete_qualified_path(acc: &mut Completions, ctx: &CompletionContext) {
+    if ctx.is_path_disallowed() || ctx.expects_item() {
+        return;
+    }
    let path = match &ctx.path_qual {
        Some(path) => path.clone(),
        None => return,
    };
-    if ctx.attribute_under_caret.is_some() || ctx.mod_declaration_under_caret.is_some() {
-        return;
-    }
-    let context_module = ctx.scope.module();
    let resolution = match ctx.sema.resolve_path(&path) {
        Some(res) => res,
        None => return,
    };
+    let context_module = ctx.scope.module();
+    if ctx.expects_assoc_item() {
+        if let PathResolution::Def(hir::ModuleDef::Module(module)) = resolution {
+            let module_scope = module.scope(ctx.db, context_module);
+            for (name, def) in module_scope {
+                if let ScopeDef::MacroDef(macro_def) = def {
+                    acc.add_macro(ctx, Some(name.to_string()), macro_def);
+                }
+                if let ScopeDef::ModuleDef(hir::ModuleDef::Module(_)) = def {
+                    acc.add_resolution(ctx, name.to_string(), &def);
+                }
+            }
+        }
+        return;
+    }
    // Add associated types on type parameters and `Self`.
    resolution.assoc_type_shorthand_candidates(ctx.db, |_, alias| {
@@ -596,7 +608,7 @@ fn main() { T::$0; }
 macro_rules! foo { () => {} }
 fn main() { let _ = crate::$0 }
-        "#,
+"#,
            expect![[r##"
                fn main()  fn()
                ma foo!(…) #[macro_export] macro_rules! foo
@@ -605,6 +617,44 @@ fn main() { let _ = crate::$0 }
    }
    #[test]
+    fn completes_in_assoc_item_list() {
+        check(
+            r#"
+#[macro_export]
+macro_rules! foo { () => {} }
+mod bar {}
+struct MyStruct {}
+impl MyStruct {
+    crate::$0
+}
+"#,
+            expect![[r##"
+                md bar
+                ma foo! #[macro_export] macro_rules! foo
+            "##]],
+        );
+    }
+    #[test]
+    #[ignore] // FIXME doesn't complete anything atm
+    fn completes_in_item_list() {
+        check(
+            r#"
+struct MyStruct {}
+macro_rules! foo {}
+mod bar {}
+crate::$0
+"#,
+            expect![[r#"
+                md bar
+                ma foo! macro_rules! foo
+            "#]],
+        )
+    }
+    #[test]
    fn test_super_super_completion() {
        check(
            r#"
diff --git a/crates/ide_completion/src/completions/record.rs b/crates/ide_completion/src/completions/record.rs
index 2f95b8687..e1526b70b 100644
--- a/crates/ide_completion/src/completions/record.rs
+++ b/crates/ide_completion/src/completions/record.rs
@@ -13,20 +13,19 @@ pub(crate) fn complete_record(acc: &mut Completions, ctx: &CompletionContext) ->
            let ty = ctx.sema.type_of_expr(&Expr::RecordExpr(record_lit.clone()));
            let default_trait = FamousDefs(&ctx.sema, ctx.krate).core_default_Default();
            let impl_default_trait = default_trait
-                .and_then(|default_trait| ty.map(|ty| ty.impls_trait(ctx.db, default_trait, &[])))
+                .zip(ty)
-                .unwrap_or(false);
+                .map_or(false, |(default_trait, ty)| ty.impls_trait(ctx.db, default_trait, &[]));
            let missing_fields = ctx.sema.record_literal_missing_fields(record_lit);
            if impl_default_trait && !missing_fields.is_empty() {
                let completion_text = "..Default::default()";
-                let completion_text = completion_text
-                    .strip_prefix(ctx.token.to_string().as_str())
-                    .unwrap_or(completion_text);
                let mut item = CompletionItem::new(
                    CompletionKind::Snippet,
                    ctx.source_range(),
-                    "..Default::default()",
+                    completion_text,
                );
+                let completion_text =
+                    completion_text.strip_prefix(ctx.token.text()).unwrap_or(completion_text);
                item.insert_text(completion_text).kind(SymbolKind::Field);
                item.add_to(acc);
            }
@@ -108,8 +107,6 @@ fn process(f: S) {
        check_snippet(
            test_code,
            expect![[r#"
-                sn pd
-                sn ppd
                fd ..Default::default()
            "#]],
        );
@@ -179,13 +176,7 @@ fn process(f: S) {
            "#]],
        );
-        check_snippet(
+        check_snippet(test_code, expect![[r#""#]]);
-            test_code,
-            expect![[r#"
-                sn pd
-                sn ppd
-            "#]],
-        );
    }
    #[test]
diff --git a/crates/ide_completion/src/completions/snippet.rs b/crates/ide_completion/src/completions/snippet.rs
index 7f7830976..defc25b00 100644
--- a/crates/ide_completion/src/completions/snippet.rs
+++ b/crates/ide_completion/src/completions/snippet.rs
@@ -14,7 +14,7 @@ fn snippet(ctx: &CompletionContext, cap: SnippetCap, label: &str, snippet: &str)
 }
 pub(crate) fn complete_expr_snippet(acc: &mut Completions, ctx: &CompletionContext) {
-    if !(ctx.is_trivial_path && ctx.function_syntax.is_some()) {
+    if !(ctx.is_trivial_path && ctx.function_def.is_some()) {
        return;
    }
    let cap = match ctx.config.snippet_cap {
@@ -22,8 +22,10 @@ pub(crate) fn complete_expr_snippet(acc: &mut Completions, ctx: &CompletionConte
        None => return,
    };
-    snippet(ctx, cap, "pd", "eprintln!(\"$0 = {:?}\", $0);").add_to(acc);
+    if ctx.can_be_stmt {
-    snippet(ctx, cap, "ppd", "eprintln!(\"$0 = {:#?}\", $0);").add_to(acc);
+        snippet(ctx, cap, "pd", "eprintln!(\"$0 = {:?}\", $0);").add_to(acc);
+        snippet(ctx, cap, "ppd", "eprintln!(\"$0 = {:#?}\", $0);").add_to(acc);
+    }
 }
 pub(crate) fn complete_item_snippet(acc: &mut Completions, ctx: &CompletionContext) {
diff --git a/crates/ide_completion/src/completions/unqualified_path.rs b/crates/ide_completion/src/completions/unqualified_path.rs
index 7875500c1..ede07f605 100644
--- a/crates/ide_completion/src/completions/unqualified_path.rs
+++ b/crates/ide_completion/src/completions/unqualified_path.rs
@@ -1,7 +1,6 @@
 //! Completion of names from the current scope, e.g. locals and imported items.
 use hir::ScopeDef;
-use syntax::AstNode;
 use crate::{CompletionContext, Completions};
@@ -9,14 +8,30 @@ pub(crate) fn complete_unqualified_path(acc: &mut Completions, ctx: &CompletionC
    if !ctx.is_trivial_path {
        return;
    }
-    if ctx.record_lit_syntax.is_some()
+    if ctx.is_path_disallowed() || ctx.expects_item() {
-        || ctx.record_pat_syntax.is_some()
+        return;
-        || ctx.attribute_under_caret.is_some()
+    }
-        || ctx.mod_declaration_under_caret.is_some()
+    if ctx.expects_assoc_item() {
-    {
+        ctx.scope.process_all_names(&mut |name, def| {
+            if let ScopeDef::MacroDef(macro_def) = def {
+                acc.add_macro(ctx, Some(name.to_string()), macro_def);
+            }
+            if let ScopeDef::ModuleDef(hir::ModuleDef::Module(_)) = def {
+                acc.add_resolution(ctx, name.to_string(), &def);
+            }
+        });
        return;
    }
+    if ctx.expects_use_tree() {
+        cov_mark::hit!(only_completes_modules_in_import);
+        ctx.scope.process_all_names(&mut |name, res| {
+            if let ScopeDef::ModuleDef(hir::ModuleDef::Module(_)) = res {
+                acc.add_resolution(ctx, name.to_string(), &res);
+            }
+        });
+        return;
+    }
    if let Some(hir::Adt::Enum(e)) =
        ctx.expected_type.as_ref().and_then(|ty| ty.strip_references().as_adt())
    {
@@ -30,14 +45,6 @@ pub(crate) fn complete_unqualified_path(acc: &mut Completions, ctx: &CompletionC
            cov_mark::hit!(skip_lifetime_completion);
            return;
        }
-        if ctx.use_item_syntax.is_some() {
-            if let (ScopeDef::Unknown, Some(name_ref)) = (&res, &ctx.name_ref_syntax) {
-                if name_ref.syntax().text() == name.to_string().as_str() {
-                    cov_mark::hit!(self_fulfilling_completion);
-                    return;
-                }
-            }
-        }
        acc.add_resolution(ctx, name.to_string(), &res);
    });
 }
@@ -61,15 +68,17 @@ mod tests {
    }
    #[test]
-    fn self_fulfilling_completion() {
+    fn only_completes_modules_in_import() {
-        cov_mark::check!(self_fulfilling_completion);
+        cov_mark::check!(only_completes_modules_in_import);
        check(
            r#"
-use foo$0
+use f$0
-use std::collections;
+struct Foo;
+mod foo {}
 "#,
            expect![[r#"
-                ?? collections
+                md foo
            "#]],
        );
    }
@@ -86,7 +95,7 @@ fn quux(x: Option<Enum>) {
    }
 }
 "#,
-            expect![[""]],
+            expect![[r#""#]],
        );
    }
@@ -102,7 +111,7 @@ fn quux(x: Option<Enum>) {
    }
 }
 "#,
-            expect![[""]],
+            expect![[r#""#]],
        );
    }
@@ -651,7 +660,7 @@ fn f() {}
    }
    #[test]
-    fn completes_type_or_trait_in_impl_block() {
+    fn completes_target_type_or_trait_in_impl_block() {
        check(
            r#"
 trait MyTrait {}
@@ -666,4 +675,41 @@ impl My$0
            "#]],
        )
    }
+    #[test]
+    fn completes_in_assoc_item_list() {
+        check(
+            r#"
+macro_rules! foo {}
+mod bar {}
+struct MyStruct {}
+impl MyStruct {
+    $0
+}
+"#,
+            expect![[r#"
+                md bar
+                ma foo! macro_rules! foo
+            "#]],
+        )
+    }
+    // FIXME: The completions here currently come from `macro_in_item_position`, but they shouldn't
+    #[test]
+    fn completes_in_item_list() {
+        check(
+            r#"
+struct MyStruct {}
+macro_rules! foo {}
+mod bar {}
+$0
+"#,
+            expect![[r#"
+                md bar
+                ma foo!(…) macro_rules! foo
+            "#]],
+        )
+    }
 }
diff --git a/crates/ide_completion/src/context.rs b/crates/ide_completion/src/context.rs
index 1ec59ff80..8d6440cb2 100644
--- a/crates/ide_completion/src/context.rs
+++ b/crates/ide_completion/src/context.rs
@@ -1,29 +1,34 @@
 //! See `CompletionContext` structure.
 use hir::{Local, ScopeDef, Semantics, SemanticsScope, Type};
-use ide_db::base_db::{FilePosition, SourceDatabase};
+use ide_db::{
-use ide_db::{call_info::ActiveParameter, RootDatabase};
+    base_db::{FilePosition, SourceDatabase},
+    call_info::ActiveParameter,
+    RootDatabase,
+};
 use syntax::{
    algo::find_node_at_offset,
    ast::{self, NameOrNameRef, NameOwner},
    match_ast, AstNode, NodeOrToken,
-    SyntaxKind::*,
+    SyntaxKind::{self, *},
-    SyntaxNode, SyntaxToken, TextRange, TextSize,
+    SyntaxNode, SyntaxToken, TextRange, TextSize, T,
 };
 use text_edit::Indel;
 use crate::{
    patterns::{
-        fn_is_prev, for_is_prev2, has_bind_pat_parent, has_block_expr_parent,
+        determine_location, determine_prev_sibling, for_is_prev2, inside_impl_trait_block,
-        has_field_list_parent, has_impl_as_prev_sibling, has_impl_parent,
+        is_in_loop_body, is_match_arm, previous_token, ImmediateLocation, ImmediatePrevSibling,
-        has_item_list_or_source_file_parent, has_ref_parent, has_trait_as_prev_sibling,
-        has_trait_parent, if_is_prev, inside_impl_trait_block, is_in_loop_body, is_match_arm,
-        unsafe_is_prev,
    },
    CompletionConfig,
 };
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub(crate) enum PatternRefutability {
+    Refutable,
+    Irrefutable,
+}
 /// `CompletionContext` is created early during completion to figure out, where
 /// exactly is the cursor, syntax-wise.
 #[derive(Debug)]
@@ -41,28 +46,38 @@ pub(crate) struct CompletionContext<'a> {
    pub(super) expected_name: Option<NameOrNameRef>,
    pub(super) expected_type: Option<Type>,
    pub(super) name_ref_syntax: Option<ast::NameRef>,
-    pub(super) lifetime_syntax: Option<ast::Lifetime>,
-    pub(super) lifetime_param_syntax: Option<ast::LifetimeParam>,
-    pub(super) function_syntax: Option<ast::Fn>,
    pub(super) use_item_syntax: Option<ast::Use>,
+    /// The parent function of the cursor position if it exists.
+    pub(super) function_def: Option<ast::Fn>,
+    /// The parent impl of the cursor position if it exists.
+    pub(super) impl_def: Option<ast::Impl>,
+    /// RecordExpr the token is a field of
    pub(super) record_lit_syntax: Option<ast::RecordExpr>,
+    /// RecordPat the token is a field of
    pub(super) record_pat_syntax: Option<ast::RecordPat>,
-    pub(super) record_field_syntax: Option<ast::RecordExprField>,
-    pub(super) impl_def: Option<ast::Impl>,
+    // potentially set if we are completing a lifetime
+    pub(super) lifetime_syntax: Option<ast::Lifetime>,
+    pub(super) lifetime_param_syntax: Option<ast::LifetimeParam>,
    pub(super) lifetime_allowed: bool,
+    pub(super) is_label_ref: bool,
+    // potentially set if we are completing a name
+    pub(super) is_pat_or_const: Option<PatternRefutability>,
+    pub(super) is_param: bool,
+    pub(super) completion_location: Option<ImmediateLocation>,
+    pub(super) prev_sibling: Option<ImmediatePrevSibling>,
    /// FIXME: `ActiveParameter` is string-based, which is very very wrong
    pub(super) active_parameter: Option<ActiveParameter>,
-    pub(super) is_param: bool,
-    pub(super) is_label_ref: bool,
-    /// 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_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).
    pub(super) path_qual: Option<ast::Path>,
-    pub(super) after_if: bool,
    /// `true` if we are a statement or a last expr in the block.
    pub(super) can_be_stmt: bool,
    /// `true` if we expect an expression at the cursor position.
@@ -82,24 +97,15 @@ pub(crate) struct CompletionContext<'a> {
    pub(super) has_type_args: bool,
    pub(super) attribute_under_caret: Option<ast::Attr>,
    pub(super) mod_declaration_under_caret: Option<ast::Module>,
-    pub(super) unsafe_is_prev: bool,
+    pub(super) locals: Vec<(String, Local)>,
-    pub(super) if_is_prev: bool,
-    pub(super) block_expr_parent: bool,
+    // keyword patterns
-    pub(super) bind_pat_parent: bool,
+    pub(super) previous_token: Option<SyntaxToken>,
-    pub(super) ref_pat_parent: bool,
    pub(super) in_loop_body: bool,
-    pub(super) has_trait_parent: bool,
-    pub(super) has_impl_parent: bool,
-    pub(super) inside_impl_trait_block: bool,
-    pub(super) has_field_list_parent: bool,
-    pub(super) trait_as_prev_sibling: bool,
-    pub(super) impl_as_prev_sibling: bool,
    pub(super) is_match_arm: bool,
-    pub(super) has_item_list_or_source_file_parent: bool,
-    pub(super) for_is_prev2: bool,
-    pub(super) fn_is_prev: bool,
    pub(super) incomplete_let: bool,
-    pub(super) locals: Vec<(String, Local)>,
+    no_completion_required: bool,
 }
 impl<'a> CompletionContext<'a> {
@@ -149,20 +155,17 @@ impl<'a> CompletionContext<'a> {
            name_ref_syntax: None,
            lifetime_syntax: None,
            lifetime_param_syntax: None,
-            function_syntax: None,
+            function_def: None,
            use_item_syntax: None,
            record_lit_syntax: None,
            record_pat_syntax: None,
-            record_field_syntax: None,
            impl_def: None,
            active_parameter: ActiveParameter::at(db, position),
            is_label_ref: false,
            is_param: false,
-            is_pat_binding_or_const: false,
+            is_pat_or_const: None,
-            is_irrefutable_pat_binding: false,
            is_trivial_path: false,
            path_qual: None,
-            after_if: false,
            can_be_stmt: false,
            is_expr: false,
            is_new_item: false,
@@ -175,67 +178,57 @@ impl<'a> CompletionContext<'a> {
            has_type_args: false,
            attribute_under_caret: None,
            mod_declaration_under_caret: None,
-            unsafe_is_prev: false,
+            previous_token: None,
-            if_is_prev: false,
-            block_expr_parent: false,
-            bind_pat_parent: false,
-            ref_pat_parent: false,
            in_loop_body: false,
-            has_trait_parent: false,
+            completion_location: None,
-            has_impl_parent: false,
+            prev_sibling: None,
-            inside_impl_trait_block: false,
-            has_field_list_parent: false,
-            trait_as_prev_sibling: false,
-            impl_as_prev_sibling: false,
            is_match_arm: false,
-            has_item_list_or_source_file_parent: false,
+            no_completion_required: false,
-            for_is_prev2: false,
-            fn_is_prev: false,
            incomplete_let: false,
            locals,
        };
        let mut original_file = original_file.syntax().clone();
-        let mut hypothetical_file = file_with_fake_ident.syntax().clone();
+        let mut speculative_file = file_with_fake_ident.syntax().clone();
        let mut offset = position.offset;
        let mut fake_ident_token = fake_ident_token;
        // Are we inside a macro call?
        while let (Some(actual_macro_call), Some(macro_call_with_fake_ident)) = (
            find_node_at_offset::<ast::MacroCall>(&original_file, offset),
-            find_node_at_offset::<ast::MacroCall>(&hypothetical_file, offset),
+            find_node_at_offset::<ast::MacroCall>(&speculative_file, offset),
        ) {
            if actual_macro_call.path().as_ref().map(|s| s.syntax().text())
                != macro_call_with_fake_ident.path().as_ref().map(|s| s.syntax().text())
            {
                break;
            }
-            let hypothetical_args = match macro_call_with_fake_ident.token_tree() {
+            let speculative_args = match macro_call_with_fake_ident.token_tree() {
                Some(tt) => tt,
                None => break,
            };
-            if let (Some(actual_expansion), Some(hypothetical_expansion)) = (
+            if let (Some(actual_expansion), Some(speculative_expansion)) = (
                ctx.sema.expand(&actual_macro_call),
                ctx.sema.speculative_expand(
                    &actual_macro_call,
-                    &hypothetical_args,
+                    &speculative_args,
                    fake_ident_token,
                ),
            ) {
-                let new_offset = hypothetical_expansion.1.text_range().start();
+                let new_offset = speculative_expansion.1.text_range().start();
                if new_offset > actual_expansion.text_range().end() {
                    break;
                }
                original_file = actual_expansion;
-                hypothetical_file = hypothetical_expansion.0;
+                speculative_file = speculative_expansion.0;
-                fake_ident_token = hypothetical_expansion.1;
+                fake_ident_token = speculative_expansion.1;
                offset = new_offset;
            } else {
                break;
            }
        }
-        ctx.fill_keyword_patterns(&hypothetical_file, offset);
+        ctx.fill_keyword_patterns(&speculative_file, offset);
-        ctx.fill(&original_file, hypothetical_file, offset);
+        ctx.fill(&original_file, speculative_file, offset);
        Some(ctx)
    }
@@ -245,7 +238,7 @@ impl<'a> CompletionContext<'a> {
    ///   Exception for this case is `impl Trait for Foo`, where we would like to hint trait method names.
    /// - `for _ i$0` -- obviously, it'll be "in" keyword.
    pub(crate) fn no_completion_required(&self) -> bool {
-        (self.fn_is_prev && !self.inside_impl_trait_block) || self.for_is_prev2
+        self.no_completion_required
    }
    /// The range of the identifier that is being completed.
@@ -264,33 +257,85 @@ impl<'a> CompletionContext<'a> {
        }
    }
+    pub(crate) fn previous_token_is(&self, kind: SyntaxKind) -> bool {
+        self.previous_token.as_ref().map_or(false, |tok| tok.kind() == kind)
+    }
+    pub(crate) fn expects_assoc_item(&self) -> bool {
+        matches!(
+            self.completion_location,
+            Some(ImmediateLocation::Trait) | Some(ImmediateLocation::Impl)
+        )
+    }
+    pub(crate) fn expects_use_tree(&self) -> bool {
+        matches!(self.completion_location, Some(ImmediateLocation::Use))
+    }
+    pub(crate) fn expects_non_trait_assoc_item(&self) -> bool {
+        matches!(self.completion_location, Some(ImmediateLocation::Impl))
+    }
+    pub(crate) fn expects_item(&self) -> bool {
+        matches!(self.completion_location, Some(ImmediateLocation::ItemList))
+    }
+    pub(crate) fn expects_expression(&self) -> bool {
+        self.is_expr
+    }
+    pub(crate) fn has_block_expr_parent(&self) -> bool {
+        matches!(self.completion_location, Some(ImmediateLocation::BlockExpr))
+    }
+    pub(crate) fn expects_ident_pat_or_ref_expr(&self) -> bool {
+        matches!(
+            self.completion_location,
+            Some(ImmediateLocation::IdentPat) | Some(ImmediateLocation::RefExpr)
+        )
+    }
+    pub(crate) fn expect_record_field(&self) -> bool {
+        matches!(self.completion_location, Some(ImmediateLocation::RecordField))
+    }
+    pub(crate) fn has_impl_or_trait_prev_sibling(&self) -> bool {
+        matches!(
+            self.prev_sibling,
+            Some(ImmediatePrevSibling::ImplDefType) | Some(ImmediatePrevSibling::TraitDefName)
+        )
+    }
+    pub(crate) fn after_if(&self) -> bool {
+        matches!(self.prev_sibling, Some(ImmediatePrevSibling::IfExpr))
+    }
+    pub(crate) fn is_path_disallowed(&self) -> bool {
+        self.record_lit_syntax.is_some()
+            || self.record_pat_syntax.is_some()
+            || self.attribute_under_caret.is_some()
+            || self.mod_declaration_under_caret.is_some()
+    }
    fn fill_keyword_patterns(&mut self, file_with_fake_ident: &SyntaxNode, offset: TextSize) {
        let fake_ident_token = file_with_fake_ident.token_at_offset(offset).right_biased().unwrap();
        let syntax_element = NodeOrToken::Token(fake_ident_token);
-        self.block_expr_parent = has_block_expr_parent(syntax_element.clone());
+        self.previous_token = previous_token(syntax_element.clone());
-        self.unsafe_is_prev = unsafe_is_prev(syntax_element.clone());
-        self.if_is_prev = if_is_prev(syntax_element.clone());
-        self.bind_pat_parent = has_bind_pat_parent(syntax_element.clone());
-        self.ref_pat_parent = has_ref_parent(syntax_element.clone());
        self.in_loop_body = is_in_loop_body(syntax_element.clone());
-        self.has_trait_parent = has_trait_parent(syntax_element.clone());
-        self.has_impl_parent = has_impl_parent(syntax_element.clone());
-        self.inside_impl_trait_block = inside_impl_trait_block(syntax_element.clone());
-        self.has_field_list_parent = has_field_list_parent(syntax_element.clone());
-        self.impl_as_prev_sibling = has_impl_as_prev_sibling(syntax_element.clone());
-        self.trait_as_prev_sibling = has_trait_as_prev_sibling(syntax_element.clone());
        self.is_match_arm = is_match_arm(syntax_element.clone());
-        self.has_item_list_or_source_file_parent =
-            has_item_list_or_source_file_parent(syntax_element.clone());
        self.mod_declaration_under_caret =
            find_node_at_offset::<ast::Module>(&file_with_fake_ident, offset)
                .filter(|module| module.item_list().is_none());
-        self.for_is_prev2 = for_is_prev2(syntax_element.clone());
-        self.fn_is_prev = fn_is_prev(syntax_element.clone());
        self.incomplete_let =
            syntax_element.ancestors().take(6).find_map(ast::LetStmt::cast).map_or(false, |it| {
                it.syntax().text_range().end() == syntax_element.text_range().end()
            });
+        let inside_impl_trait_block = inside_impl_trait_block(syntax_element.clone());
+        let fn_is_prev = self.previous_token_is(T![fn]);
+        let for_is_prev2 = for_is_prev2(syntax_element.clone());
+        self.no_completion_required = (fn_is_prev && !inside_impl_trait_block) || for_is_prev2;
    }
    fn fill_impl_def(&mut self) {
@@ -412,67 +457,21 @@ impl<'a> CompletionContext<'a> {
        self.expected_type = expected_type;
        self.expected_name = expected_name;
        self.attribute_under_caret = find_node_at_offset(&file_with_fake_ident, offset);
+        let name_like = match find_node_at_offset(&&file_with_fake_ident, offset) {
-        if let Some(lifetime) = find_node_at_offset::<ast::Lifetime>(&file_with_fake_ident, offset)
+            Some(it) => it,
-        {
+            None => return,
-            self.classify_lifetime(original_file, lifetime, offset);
+        };
-        }
+        self.completion_location = determine_location(&name_like);
+        self.prev_sibling = determine_prev_sibling(&name_like);
-        // First, let's try to complete a reference to some declaration.
+        match name_like {
-        if let Some(name_ref) = find_node_at_offset::<ast::NameRef>(&file_with_fake_ident, offset) {
+            ast::NameLike::Lifetime(lifetime) => {
-            // Special case, `trait T { fn foo(i_am_a_name_ref) {} }`.
+                self.classify_lifetime(original_file, lifetime, offset);
-            // See RFC#1685.
-            if is_node::<ast::Param>(name_ref.syntax()) {
-                self.is_param = true;
-                return;
-            }
-            // FIXME: remove this (V) duplication and make the check more precise
-            if name_ref.syntax().ancestors().find_map(ast::RecordPatFieldList::cast).is_some() {
-                self.record_pat_syntax =
-                    self.sema.find_node_at_offset_with_macros(&original_file, offset);
-            }
-            self.classify_name_ref(original_file, name_ref, offset);
-        }
-        // Otherwise, see if this is a declaration. We can use heuristics to
-        // suggest declaration names, see `CompletionKind::Magic`.
-        if let Some(name) = find_node_at_offset::<ast::Name>(&file_with_fake_ident, offset) {
-            if let Some(bind_pat) = name.syntax().ancestors().find_map(ast::IdentPat::cast) {
-                self.is_pat_binding_or_const = true;
-                if bind_pat.at_token().is_some()
-                    || bind_pat.ref_token().is_some()
-                    || bind_pat.mut_token().is_some()
-                {
-                    self.is_pat_binding_or_const = false;
-                }
-                if bind_pat.syntax().parent().and_then(ast::RecordPatFieldList::cast).is_some() {
-                    self.is_pat_binding_or_const = false;
-                }
-                if let Some(Some(pat)) = bind_pat.syntax().ancestors().find_map(|node| {
-                    match_ast! {
-                        match node {
-                            ast::LetStmt(it) => Some(it.pat()),
-                            ast::Param(it) => Some(it.pat()),
-                            _ => None,
-                        }
-                    }
-                }) {
-                    if pat.syntax().text_range().contains_range(bind_pat.syntax().text_range()) {
-                        self.is_pat_binding_or_const = false;
-                        self.is_irrefutable_pat_binding = true;
-                    }
-                }
-                self.fill_impl_def();
            }
-            if is_node::<ast::Param>(name.syntax()) {
+            ast::NameLike::NameRef(name_ref) => {
-                self.is_param = true;
+                self.classify_name_ref(original_file, name_ref, offset);
-                return;
            }
-            // FIXME: remove this (^) duplication and make the check more precise
+            ast::NameLike::Name(name) => {
-            if name.syntax().ancestors().find_map(ast::RecordPatFieldList::cast).is_some() {
+                self.classify_name(original_file, name, offset);
-                self.record_pat_syntax =
-                    self.sema.find_node_at_offset_with_macros(&original_file, offset);
            }
        }
    }
@@ -506,22 +505,71 @@ impl<'a> CompletionContext<'a> {
        }
    }
+    fn classify_name(&mut self, original_file: &SyntaxNode, name: ast::Name, offset: TextSize) {
+        if let Some(bind_pat) = name.syntax().parent().and_then(ast::IdentPat::cast) {
+            self.is_pat_or_const = Some(PatternRefutability::Refutable);
+            // if any of these is here our bind pat can't be a const pat anymore
+            let complex_ident_pat = bind_pat.at_token().is_some()
+                || bind_pat.ref_token().is_some()
+                || bind_pat.mut_token().is_some();
+            if complex_ident_pat {
+                self.is_pat_or_const = None;
+            } else {
+                let irrefutable_pat = bind_pat.syntax().ancestors().find_map(|node| {
+                    match_ast! {
+                        match node {
+                            ast::LetStmt(it) => Some(it.pat()),
+                            ast::Param(it) => Some(it.pat()),
+                            _ => None,
+                        }
+                    }
+                });
+                if let Some(Some(pat)) = irrefutable_pat {
+                    // This check is here since we could be inside a pattern in the initializer expression of the let statement.
+                    if pat.syntax().text_range().contains_range(bind_pat.syntax().text_range()) {
+                        self.is_pat_or_const = Some(PatternRefutability::Irrefutable);
+                    }
+                }
+                let is_name_in_field_pat = bind_pat
+                    .syntax()
+                    .parent()
+                    .and_then(ast::RecordPatField::cast)
+                    .map_or(false, |pat_field| pat_field.name_ref().is_none());
+                if is_name_in_field_pat {
+                    self.is_pat_or_const = None;
+                }
+            }
+            self.fill_impl_def();
+        }
+        self.is_param |= is_node::<ast::Param>(name.syntax());
+        if ast::RecordPatField::for_field_name(&name).is_some() {
+            self.record_pat_syntax =
+                self.sema.find_node_at_offset_with_macros(&original_file, offset);
+        }
+    }
    fn classify_name_ref(
        &mut self,
        original_file: &SyntaxNode,
        name_ref: ast::NameRef,
        offset: TextSize,
    ) {
-        self.name_ref_syntax =
+        self.fill_impl_def();
-            find_node_at_offset(original_file, name_ref.syntax().text_range().start());
-        let name_range = name_ref.syntax().text_range();
        if ast::RecordExprField::for_field_name(&name_ref).is_some() {
            self.record_lit_syntax =
                self.sema.find_node_at_offset_with_macros(original_file, offset);
        }
+        if ast::RecordPatField::for_field_name_ref(&name_ref).is_some() {
+            self.record_pat_syntax =
+                self.sema.find_node_at_offset_with_macros(&original_file, offset);
+        }
-        self.fill_impl_def();
+        self.name_ref_syntax =
+            find_node_at_offset(original_file, name_ref.syntax().text_range().start());
+        let name_range = name_ref.syntax().text_range();
        let top_node = name_ref
            .syntax()
            .ancestors()
@@ -529,31 +577,20 @@ impl<'a> CompletionContext<'a> {
            .last()
            .unwrap();
-        match top_node.parent().map(|it| it.kind()) {
+        if matches!(top_node.parent().map(|it| it.kind()), Some(SOURCE_FILE) | Some(ITEM_LIST)) {
-            Some(SOURCE_FILE) | Some(ITEM_LIST) => {
+            self.is_new_item = true;
-                self.is_new_item = true;
+            return;
-                return;
-            }
-            _ => (),
        }
        self.use_item_syntax =
            self.sema.token_ancestors_with_macros(self.token.clone()).find_map(ast::Use::cast);
-        self.function_syntax = self
+        self.function_def = self
            .sema
            .token_ancestors_with_macros(self.token.clone())
            .take_while(|it| it.kind() != SOURCE_FILE && it.kind() != MODULE)
            .find_map(ast::Fn::cast);
-        self.record_field_syntax = self
-            .sema
-            .token_ancestors_with_macros(self.token.clone())
-            .take_while(|it| {
-                it.kind() != SOURCE_FILE && it.kind() != MODULE && it.kind() != CALL_EXPR
-            })
-            .find_map(ast::RecordExprField::cast);
        let parent = match name_ref.syntax().parent() {
            Some(it) => it,
            None => return,
@@ -614,18 +651,8 @@ impl<'a> CompletionContext<'a> {
                })
                .unwrap_or(false);
            self.is_expr = path.syntax().parent().and_then(ast::PathExpr::cast).is_some();
-            if let Some(off) = name_ref.syntax().text_range().start().checked_sub(2.into()) {
-                if let Some(if_expr) =
-                    self.sema.find_node_at_offset_with_macros::<ast::IfExpr>(original_file, off)
-                {
-                    if if_expr.syntax().text_range().end() < name_ref.syntax().text_range().start()
-                    {
-                        self.after_if = true;
-                    }
-                }
-            }
        }
        if let Some(field_expr) = ast::FieldExpr::cast(parent.clone()) {
            // The receiver comes before the point of insertion of the fake
            // ident, so it should have the same range in the non-modified file
@@ -643,6 +670,7 @@ impl<'a> CompletionContext<'a> {
                    false
                };
        }
        if let Some(method_call_expr) = ast::MethodCallExpr::cast(parent) {
            // As above
            self.dot_receiver = method_call_expr
diff --git a/crates/ide_completion/src/lib.rs b/crates/ide_completion/src/lib.rs
index 645349215..1152a9850 100644
--- a/crates/ide_completion/src/lib.rs
+++ b/crates/ide_completion/src/lib.rs
@@ -107,7 +107,7 @@ pub use crate::{
 /// identifier prefix/fuzzy match should be done higher in the stack, together
 /// with ordering of completions (currently this is done by the client).
 ///
-/// # Hypothetical Completion Problem
+/// # Speculative Completion Problem
 ///
 /// There's a curious unsolved problem in the current implementation. Often, you
 /// want to compute completions on a *slightly different* text document.
@@ -121,7 +121,7 @@ pub use crate::{
 /// doesn't allow such "phantom" inputs.
 ///
 /// Another case where this would be instrumental is macro expansion. We want to
-/// insert a fake ident and re-expand code. There's `expand_hypothetical` as a
+/// insert a fake ident and re-expand code. There's `expand_speculative` as a
 /// work-around for this.
 ///
 /// A different use-case is completion of injection (examples and links in doc
diff --git a/crates/ide_completion/src/patterns.rs b/crates/ide_completion/src/patterns.rs
index d82564381..caf0ef39f 100644
--- a/crates/ide_completion/src/patterns.rs
+++ b/crates/ide_completion/src/patterns.rs
@@ -10,29 +10,143 @@ use syntax::{
 #[cfg(test)]
 use crate::test_utils::{check_pattern_is_applicable, check_pattern_is_not_applicable};
+/// Direct parent container of the cursor position
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub(crate) enum ImmediatePrevSibling {
+    IfExpr,
+    TraitDefName,
+    ImplDefType,
+}
-pub(crate) fn has_trait_parent(element: SyntaxElement) -> bool {
+/// Direct parent container of the cursor position
-    not_same_range_ancestor(element)
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
-        .filter(|it| it.kind() == ASSOC_ITEM_LIST)
+pub(crate) enum ImmediateLocation {
-        .and_then(|it| it.parent())
+    Use,
-        .filter(|it| it.kind() == TRAIT)
+    Impl,
-        .is_some()
+    Trait,
+    RecordField,
+    RefExpr,
+    IdentPat,
+    BlockExpr,
+    ItemList,
 }
-#[test]
-fn test_has_trait_parent() {
+pub(crate) fn determine_prev_sibling(name_like: &ast::NameLike) -> Option<ImmediatePrevSibling> {
-    check_pattern_is_applicable(r"trait A { f$0 }", has_trait_parent);
+    let node = maximize_name_ref(name_like)?;
+    let node = match node.parent().and_then(ast::MacroCall::cast) {
+        // When a path is being typed after the name of a trait/type of an impl it is being
+        // parsed as a macro, so when the trait/impl has a block following it an we are between the
+        // name and block the macro will attach the block to itself so maximizing fails to take
+        // that into account
+        // FIXME path expr and statement have a similar problem with attrs
+        Some(call)
+            if call.excl_token().is_none()
+                && call.token_tree().map_or(false, |t| t.l_curly_token().is_some())
+                && call.semicolon_token().is_none() =>
+        {
+            call.syntax().clone()
+        }
+        _ => node,
+    };
+    let prev_sibling = non_trivia_sibling(node.into(), Direction::Prev)?.into_node()?;
+    let res = match_ast! {
+        match prev_sibling {
+            ast::ExprStmt(it) => {
+                let node = it.expr().filter(|_| it.semicolon_token().is_none())?.syntax().clone();
+                match_ast! {
+                    match node {
+                        ast::IfExpr(_it) => ImmediatePrevSibling::IfExpr,
+                        _ => return None,
+                    }
+                }
+            },
+            ast::Trait(it) => if it.assoc_item_list().is_none() {
+                    ImmediatePrevSibling::TraitDefName
+                } else {
+                    return None
+            },
+            ast::Impl(it) => if it.assoc_item_list().is_none()
+                && (it.for_token().is_none() || it.self_ty().is_some()) {
+                    ImmediatePrevSibling::ImplDefType
+                } else {
+                    return None
+            },
+            _ => return None,
+        }
+    };
+    Some(res)
 }
-pub(crate) fn has_impl_parent(element: SyntaxElement) -> bool {
+pub(crate) fn determine_location(name_like: &ast::NameLike) -> Option<ImmediateLocation> {
-    not_same_range_ancestor(element)
+    let node = maximize_name_ref(name_like)?;
-        .filter(|it| it.kind() == ASSOC_ITEM_LIST)
+    let parent = match node.parent() {
-        .and_then(|it| it.parent())
+        Some(parent) => match ast::MacroCall::cast(parent.clone()) {
-        .filter(|it| it.kind() == IMPL)
+            // When a path is being typed in an (Assoc)ItemList the parser will always emit a macro_call.
-        .is_some()
+            // This is usually fine as the node expansion code above already accounts for that with
+            // the ancestors call, but there is one exception to this which is that when an attribute
+            // precedes it the code above will not walk the Path to the parent MacroCall as their ranges differ.
+            // FIXME path expr and statement have a similar problem
+            Some(call)
+                if call.excl_token().is_none()
+                    && call.token_tree().is_none()
+                    && call.semicolon_token().is_none() =>
+            {
+                call.syntax().parent()?
+            }
+            _ => parent,
+        },
+        // SourceFile
+        None => {
+            return match node.kind() {
+                MACRO_ITEMS | SOURCE_FILE => Some(ImmediateLocation::ItemList),
+                _ => None,
+            }
+        }
+    };
+    let res = match_ast! {
+        match parent {
+            ast::IdentPat(_it) => ImmediateLocation::IdentPat,
+            ast::Use(_it) => ImmediateLocation::Use,
+            ast::BlockExpr(_it) => ImmediateLocation::BlockExpr,
+            ast::SourceFile(_it) => ImmediateLocation::ItemList,
+            ast::ItemList(_it) => ImmediateLocation::ItemList,
+            ast::RefExpr(_it) => ImmediateLocation::RefExpr,
+            ast::RecordField(_it) => ImmediateLocation::RecordField,
+            ast::AssocItemList(it) => match it.syntax().parent().map(|it| it.kind()) {
+                Some(IMPL) => ImmediateLocation::Impl,
+                Some(TRAIT) => ImmediateLocation::Trait,
+                _ => return None,
+            },
+            _ => return None,
+        }
+    };
+    Some(res)
 }
-#[test]
-fn test_has_impl_parent() {
+fn maximize_name_ref(name_like: &ast::NameLike) -> Option<SyntaxNode> {
-    check_pattern_is_applicable(r"impl A { f$0 }", has_impl_parent);
+    // First walk the element we are completing up to its highest node that has the same text range
+    // as the element so that we can check in what context it immediately lies. We only do this for
+    // NameRef -> Path as that's the only thing that makes sense to being "expanded" semantically.
+    // We only wanna do this if the NameRef is the last segment of the path.
+    let node = match name_like {
+        ast::NameLike::NameRef(name_ref) => {
+            if let Some(segment) = name_ref.syntax().parent().and_then(ast::PathSegment::cast) {
+                let p = segment.parent_path();
+                if p.parent_path().is_none() {
+                    p.syntax()
+                        .ancestors()
+                        .take_while(|it| it.text_range() == p.syntax().text_range())
+                        .last()?
+                } else {
+                    return None;
+                }
+            } else {
+                return None;
+            }
+        }
+        it @ ast::NameLike::Name(_) | it @ ast::NameLike::Lifetime(_) => it.syntax().clone(),
+    };
+    Some(node)
 }
 pub(crate) fn inside_impl_trait_block(element: SyntaxElement) -> bool {
@@ -53,56 +167,6 @@ fn test_inside_impl_trait_block() {
    check_pattern_is_not_applicable(r"impl A { fn f$0 }", inside_impl_trait_block);
 }
-pub(crate) fn has_field_list_parent(element: SyntaxElement) -> bool {
-    not_same_range_ancestor(element).filter(|it| it.kind() == RECORD_FIELD_LIST).is_some()
-}
-#[test]
-fn test_has_field_list_parent() {
-    check_pattern_is_applicable(r"struct Foo { f$0 }", has_field_list_parent);
-    check_pattern_is_applicable(r"struct Foo { f$0 pub f: i32}", has_field_list_parent);
-}
-pub(crate) fn has_block_expr_parent(element: SyntaxElement) -> bool {
-    not_same_range_ancestor(element).filter(|it| it.kind() == BLOCK_EXPR).is_some()
-}
-#[test]
-fn test_has_block_expr_parent() {
-    check_pattern_is_applicable(r"fn my_fn() { let a = 2; f$0 }", has_block_expr_parent);
-}
-pub(crate) fn has_bind_pat_parent(element: SyntaxElement) -> bool {
-    element.ancestors().any(|it| it.kind() == IDENT_PAT)
-}
-#[test]
-fn test_has_bind_pat_parent() {
-    check_pattern_is_applicable(r"fn my_fn(m$0) {}", has_bind_pat_parent);
-    check_pattern_is_applicable(r"fn my_fn() { let m$0 }", has_bind_pat_parent);
-}
-pub(crate) fn has_ref_parent(element: SyntaxElement) -> bool {
-    not_same_range_ancestor(element)
-        .filter(|it| it.kind() == REF_PAT || it.kind() == REF_EXPR)
-        .is_some()
-}
-#[test]
-fn test_has_ref_parent() {
-    check_pattern_is_applicable(r"fn my_fn(&m$0) {}", has_ref_parent);
-    check_pattern_is_applicable(r"fn my() { let &m$0 }", has_ref_parent);
-}
-pub(crate) fn has_item_list_or_source_file_parent(element: SyntaxElement) -> bool {
-    let ancestor = not_same_range_ancestor(element);
-    if !ancestor.is_some() {
-        return true;
-    }
-    ancestor.filter(|it| it.kind() == SOURCE_FILE || it.kind() == ITEM_LIST).is_some()
-}
-#[test]
-fn test_has_item_list_or_source_file_parent() {
-    check_pattern_is_applicable(r"i$0", has_item_list_or_source_file_parent);
-    check_pattern_is_applicable(r"mod foo { f$0 }", has_item_list_or_source_file_parent);
-}
 pub(crate) fn is_match_arm(element: SyntaxElement) -> bool {
    not_same_range_ancestor(element.clone()).filter(|it| it.kind() == MATCH_ARM).is_some()
        && previous_sibling_or_ancestor_sibling(element)
@@ -115,36 +179,8 @@ fn test_is_match_arm() {
    check_pattern_is_applicable(r"fn my_fn() { match () { () => m$0 } }", is_match_arm);
 }
-pub(crate) fn unsafe_is_prev(element: SyntaxElement) -> bool {
+pub(crate) fn previous_token(element: SyntaxElement) -> Option<SyntaxToken> {
-    element
+    element.into_token().and_then(|it| previous_non_trivia_token(it))
-        .into_token()
-        .and_then(|it| previous_non_trivia_token(it))
-        .filter(|it| it.kind() == T![unsafe])
-        .is_some()
-}
-#[test]
-fn test_unsafe_is_prev() {
-    check_pattern_is_applicable(r"unsafe i$0", unsafe_is_prev);
-}
-pub(crate) fn if_is_prev(element: SyntaxElement) -> bool {
-    element
-        .into_token()
-        .and_then(|it| previous_non_trivia_token(it))
-        .filter(|it| it.kind() == T![if])
-        .is_some()
-}
-pub(crate) fn fn_is_prev(element: SyntaxElement) -> bool {
-    element
-        .into_token()
-        .and_then(|it| previous_non_trivia_token(it))
-        .filter(|it| it.kind() == T![fn])
-        .is_some()
-}
-#[test]
-fn test_fn_is_prev() {
-    check_pattern_is_applicable(r"fn l$0", fn_is_prev);
 }
 /// Check if the token previous to the previous one is `for`.
@@ -162,55 +198,26 @@ fn test_for_is_prev2() {
    check_pattern_is_applicable(r"for i i$0", for_is_prev2);
 }
-#[test]
-fn test_if_is_prev() {
-    check_pattern_is_applicable(r"if l$0", if_is_prev);
-}
-pub(crate) fn has_trait_as_prev_sibling(element: SyntaxElement) -> bool {
-    previous_sibling_or_ancestor_sibling(element).filter(|it| it.kind() == TRAIT).is_some()
-}
-#[test]
-fn test_has_trait_as_prev_sibling() {
-    check_pattern_is_applicable(r"trait A w$0 {}", has_trait_as_prev_sibling);
-}
-pub(crate) fn has_impl_as_prev_sibling(element: SyntaxElement) -> bool {
-    previous_sibling_or_ancestor_sibling(element).filter(|it| it.kind() == IMPL).is_some()
-}
-#[test]
-fn test_has_impl_as_prev_sibling() {
-    check_pattern_is_applicable(r"impl A w$0 {}", has_impl_as_prev_sibling);
-}
 pub(crate) fn is_in_loop_body(element: SyntaxElement) -> bool {
-    for node in element.ancestors() {
-        if node.kind() == FN || node.kind() == CLOSURE_EXPR {
-            break;
-        }
-        let loop_body = match_ast! {
-            match node {
-                ast::ForExpr(it) => it.loop_body(),
-                ast::WhileExpr(it) => it.loop_body(),
-                ast::LoopExpr(it) => it.loop_body(),
-                _ => None,
-            }
-        };
-        if let Some(body) = loop_body {
-            if body.syntax().text_range().contains_range(element.text_range()) {
-                return true;
-            }
-        }
-    }
-    false
-}
-fn not_same_range_ancestor(element: SyntaxElement) -> Option<SyntaxNode> {
    element
        .ancestors()
-        .take_while(|it| it.text_range() == element.text_range())
+        .take_while(|it| it.kind() != FN && it.kind() != CLOSURE_EXPR)
-        .last()
+        .find_map(|it| {
-        .and_then(|it| it.parent())
+            let loop_body = match_ast! {
+                match it {
+                    ast::ForExpr(it) => it.loop_body(),
+                    ast::WhileExpr(it) => it.loop_body(),
+                    ast::LoopExpr(it) => it.loop_body(),
+                    _ => None,
+                }
+            };
+            loop_body.filter(|it| it.syntax().text_range().contains_range(element.text_range()))
+        })
+        .is_some()
+}
+pub(crate) fn not_same_range_ancestor(element: SyntaxElement) -> Option<SyntaxNode> {
+    element.ancestors().skip_while(|it| it.text_range() == element.text_range()).next()
 }
 fn previous_non_trivia_token(token: SyntaxToken) -> Option<SyntaxToken> {
@@ -239,3 +246,111 @@ fn previous_sibling_or_ancestor_sibling(element: SyntaxElement) -> Option<Syntax
        non_trivia_sibling(NodeOrToken::Node(prev_sibling_node), Direction::Prev)
    }
 }
+#[cfg(test)]
+mod tests {
+    use super::*;
+    fn check_location(code: &str, loc: impl Into<Option<ImmediateLocation>>) {
+        check_pattern_is_applicable(code, |e| {
+            let name = &e.parent().and_then(ast::NameLike::cast).expect("Expected a namelike");
+            assert_eq!(determine_location(name), loc.into());
+            true
+        });
+    }
+    fn check_prev_sibling(code: &str, sibling: impl Into<Option<ImmediatePrevSibling>>) {
+        check_pattern_is_applicable(code, |e| {
+            let name = &e.parent().and_then(ast::NameLike::cast).expect("Expected a namelike");
+            assert_eq!(determine_prev_sibling(name), sibling.into());
+            true
+        });
+    }
+    #[test]
+    fn test_trait_loc() {
+        check_location(r"trait A { f$0 }", ImmediateLocation::Trait);
+        check_location(r"trait A { #[attr] f$0 }", ImmediateLocation::Trait);
+        check_location(r"trait A { f$0 fn f() {} }", ImmediateLocation::Trait);
+        check_location(r"trait A { fn f() {} f$0 }", ImmediateLocation::Trait);
+        check_location(r"trait A$0 {}", None);
+        check_location(r"trait A { fn f$0 }", None);
+    }
+    #[test]
+    fn test_impl_loc() {
+        check_location(r"impl A { f$0 }", ImmediateLocation::Impl);
+        check_location(r"impl A { #[attr] f$0 }", ImmediateLocation::Impl);
+        check_location(r"impl A { f$0 fn f() {} }", ImmediateLocation::Impl);
+        check_location(r"impl A { fn f() {} f$0 }", ImmediateLocation::Impl);
+        check_location(r"impl A$0 {}", None);
+        check_location(r"impl A { fn f$0 }", None);
+    }
+    #[test]
+    fn test_use_loc() {
+        check_location(r"use f$0", ImmediateLocation::Use);
+        check_location(r"use f$0;", ImmediateLocation::Use);
+        check_location(r"use f::{f$0}", None);
+        check_location(r"use {f$0}", None);
+    }
+    #[test]
+    fn test_record_field_loc() {
+        check_location(r"struct Foo { f$0 }", ImmediateLocation::RecordField);
+        check_location(r"struct Foo { f$0 pub f: i32}", ImmediateLocation::RecordField);
+        check_location(r"struct Foo { pub f: i32, f$0 }", ImmediateLocation::RecordField);
+    }
+    #[test]
+    fn test_block_expr_loc() {
+        check_location(r"fn my_fn() { let a = 2; f$0 }", ImmediateLocation::BlockExpr);
+        check_location(r"fn my_fn() { f$0 f }", ImmediateLocation::BlockExpr);
+    }
+    #[test]
+    fn test_ident_pat_loc() {
+        check_location(r"fn my_fn(m$0) {}", ImmediateLocation::IdentPat);
+        check_location(r"fn my_fn() { let m$0 }", ImmediateLocation::IdentPat);
+        check_location(r"fn my_fn(&m$0) {}", ImmediateLocation::IdentPat);
+        check_location(r"fn my_fn() { let &m$0 }", ImmediateLocation::IdentPat);
+    }
+    #[test]
+    fn test_ref_expr_loc() {
+        check_location(r"fn my_fn() { let x = &m$0 foo; }", ImmediateLocation::RefExpr);
+    }
+    #[test]
+    fn test_item_list_loc() {
+        check_location(r"i$0", ImmediateLocation::ItemList);
+        check_location(r"#[attr] i$0", ImmediateLocation::ItemList);
+        check_location(r"fn f() {} i$0", ImmediateLocation::ItemList);
+        check_location(r"mod foo { f$0 }", ImmediateLocation::ItemList);
+        check_location(r"mod foo { #[attr] f$0 }", ImmediateLocation::ItemList);
+        check_location(r"mod foo { fn f() {} f$0 }", ImmediateLocation::ItemList);
+        check_location(r"mod foo$0 {}", None);
+    }
+    #[test]
+    fn test_impl_prev_sibling() {
+        check_prev_sibling(r"impl A w$0 ", ImmediatePrevSibling::ImplDefType);
+        check_prev_sibling(r"impl A w$0 {}", ImmediatePrevSibling::ImplDefType);
+        check_prev_sibling(r"impl A for A w$0 ", ImmediatePrevSibling::ImplDefType);
+        check_prev_sibling(r"impl A for A w$0 {}", ImmediatePrevSibling::ImplDefType);
+        check_prev_sibling(r"impl A for w$0 {}", None);
+        check_prev_sibling(r"impl A for w$0", None);
+    }
+    #[test]
+    fn test_trait_prev_sibling() {
+        check_prev_sibling(r"trait A w$0 ", ImmediatePrevSibling::TraitDefName);
+        check_prev_sibling(r"trait A w$0 {}", ImmediatePrevSibling::TraitDefName);
+    }
+    #[test]
+    fn test_if_expr_prev_sibling() {
+        check_prev_sibling(r"fn foo() { if true {} w$0", ImmediatePrevSibling::IfExpr);
+        check_prev_sibling(r"fn foo() { if true {}; w$0", None);
+    }
+}
diff --git a/crates/ide_completion/src/render.rs b/crates/ide_completion/src/render.rs
index d7f96b864..91300c56e 100644
--- a/crates/ide_completion/src/render.rs
+++ b/crates/ide_completion/src/render.rs
@@ -187,10 +187,7 @@ impl<'a> Render<'a> {
            ScopeDef::ModuleDef(Function(func)) => {
                return render_fn(self.ctx, import_to_add, Some(local_name), *func);
            }
-            ScopeDef::ModuleDef(Variant(_))
+            ScopeDef::ModuleDef(Variant(_)) if self.ctx.completion.is_pat_or_const.is_some() => {
-                if self.ctx.completion.is_pat_binding_or_const
-                    | self.ctx.completion.is_irrefutable_pat_binding =>
-            {
                CompletionItemKind::SymbolKind(SymbolKind::Variant)
            }
            ScopeDef::ModuleDef(Variant(var)) => {
diff --git a/crates/ide_completion/src/render/macro_.rs b/crates/ide_completion/src/render/macro_.rs
index 7578ad50b..b90fd3890 100644
--- a/crates/ide_completion/src/render/macro_.rs
+++ b/crates/ide_completion/src/render/macro_.rs
@@ -74,7 +74,11 @@ impl<'a> MacroRender<'a> {
        if self.needs_bang() && self.ctx.snippet_cap().is_some() {
            format!("{}!{}…{}", self.name, self.bra, self.ket)
        } else {
-            self.banged_name()
+            if self.macro_.kind() == hir::MacroKind::Derive {
+                self.name.to_string()
+            } else {
+                self.banged_name()
+            }
        }
    }
diff --git a/crates/ide_completion/src/test_utils.rs b/crates/ide_completion/src/test_utils.rs
index 37be575e5..93c7c872c 100644
--- a/crates/ide_completion/src/test_utils.rs
+++ b/crates/ide_completion/src/test_utils.rs
@@ -12,7 +12,7 @@ use ide_db::{
 use itertools::Itertools;
 use stdx::{format_to, trim_indent};
 use syntax::{AstNode, NodeOrToken, SyntaxElement};
-use test_utils::{assert_eq_text, RangeOrOffset};
+use test_utils::assert_eq_text;
 use crate::{item::CompletionKind, CompletionConfig, CompletionItem};
@@ -36,10 +36,7 @@ pub(crate) fn position(ra_fixture: &str) -> (RootDatabase, FilePosition) {
    let mut database = RootDatabase::default();
    database.apply_change(change_fixture.change);
    let (file_id, range_or_offset) = change_fixture.file_position.expect("expected a marker ($0)");
-    let offset = match range_or_offset {
+    let offset = range_or_offset.expect_offset();
-        RangeOrOffset::Range(_) => panic!(),
-        RangeOrOffset::Offset(it) => it,
-    };
    (database, FilePosition { file_id, offset })
 }
@@ -52,10 +49,11 @@ pub(crate) fn do_completion_with_config(
    code: &str,
    kind: CompletionKind,
 ) -> Vec<CompletionItem> {
-    let mut kind_completions: Vec<CompletionItem> =
+    get_all_items(config, code)
-        get_all_items(config, code).into_iter().filter(|c| c.completion_kind == kind).collect();
+        .into_iter()
-    kind_completions.sort_by(|l, r| l.label().cmp(r.label()));
+        .filter(|c| c.completion_kind == kind)
-    kind_completions
+        .sorted_by(|l, r| l.label().cmp(r.label()))
+        .collect()
 }
 pub(crate) fn completion_list(code: &str, kind: CompletionKind) -> String {
@@ -132,7 +130,7 @@ pub(crate) fn check_edit_with_config(
    assert_eq_text!(&ra_fixture_after, &actual)
 }
-pub(crate) fn check_pattern_is_applicable(code: &str, check: fn(SyntaxElement) -> bool) {
+pub(crate) fn check_pattern_is_applicable(code: &str, check: impl FnOnce(SyntaxElement) -> bool) {
    let (db, pos) = position(code);
    let sema = Semantics::new(&db);
diff --git a/crates/ide_db/src/call_info/tests.rs b/crates/ide_db/src/call_info/tests.rs
index 1aeda08e5..b585085f3 100644
--- a/crates/ide_db/src/call_info/tests.rs
+++ b/crates/ide_db/src/call_info/tests.rs
@@ -1,6 +1,5 @@
 use base_db::{fixture::ChangeFixture, FilePosition};
 use expect_test::{expect, Expect};
-use test_utils::RangeOrOffset;
 use crate::RootDatabase;
@@ -10,10 +9,7 @@ pub(crate) fn position(ra_fixture: &str) -> (RootDatabase, FilePosition) {
    let mut database = RootDatabase::default();
    database.apply_change(change_fixture.change);
    let (file_id, range_or_offset) = change_fixture.file_position.expect("expected a marker ($0)");
-    let offset = match range_or_offset {
+    let offset = range_or_offset.expect_offset();
-        RangeOrOffset::Range(_) => panic!(),
-        RangeOrOffset::Offset(it) => it,
-    };
    (database, FilePosition { file_id, offset })
 }
diff --git a/crates/ide_db/src/helpers/import_assets.rs b/crates/ide_db/src/helpers/import_assets.rs
index 91d6a4665..ae52dd8bb 100644
--- a/crates/ide_db/src/helpers/import_assets.rs
+++ b/crates/ide_db/src/helpers/import_assets.rs
@@ -420,6 +420,8 @@ fn trait_applicable_items(
    let db = sema.db;
+    let related_dyn_traits =
+        trait_candidate.receiver_ty.applicable_inherent_traits(db).collect::<FxHashSet<_>>();
    let mut required_assoc_items = FxHashSet::default();
    let trait_candidates = items_locator::items_with_name(
        sema,
@@ -431,13 +433,15 @@ fn trait_applicable_items(
    .filter_map(|input| item_as_assoc(db, input))
    .filter_map(|assoc| {
        let assoc_item_trait = assoc.containing_trait(db)?;
-        required_assoc_items.insert(assoc);
+        if related_dyn_traits.contains(&assoc_item_trait) {
-        Some(assoc_item_trait.into())
+            None
+        } else {
+            required_assoc_items.insert(assoc);
+            Some(assoc_item_trait.into())
+        }
    })
    .collect();
-    let related_dyn_traits =
-        trait_candidate.receiver_ty.applicable_inherent_traits(db).collect::<FxHashSet<_>>();
    let mut located_imports = FxHashSet::default();
    if trait_assoc_item {
@@ -454,10 +458,6 @@ fn trait_applicable_items(
                        }
                    }
                    let located_trait = assoc.containing_trait(db)?;
-                    if related_dyn_traits.contains(&located_trait) {
-                        return None;
-                    }
                    let trait_item = ItemInNs::from(ModuleDef::from(located_trait));
                    let original_item = assoc_to_item(assoc);
                    located_imports.insert(LocatedImport::new(
@@ -480,9 +480,6 @@ fn trait_applicable_items(
                let assoc = function.as_assoc_item(db)?;
                if required_assoc_items.contains(&assoc) {
                    let located_trait = assoc.containing_trait(db)?;
-                    if related_dyn_traits.contains(&located_trait) {
-                        return None;
-                    }
                    let trait_item = ItemInNs::from(ModuleDef::from(located_trait));
                    let original_item = assoc_to_item(assoc);
                    located_imports.insert(LocatedImport::new(
diff --git a/crates/ide_db/src/traits/tests.rs b/crates/ide_db/src/traits/tests.rs
index 2a5482024..de994407c 100644
--- a/crates/ide_db/src/traits/tests.rs
+++ b/crates/ide_db/src/traits/tests.rs
@@ -2,7 +2,6 @@ use base_db::{fixture::ChangeFixture, FilePosition};
 use expect_test::{expect, Expect};
 use hir::Semantics;
 use syntax::ast::{self, AstNode};
-use test_utils::RangeOrOffset;
 use crate::RootDatabase;
@@ -12,10 +11,7 @@ pub(crate) fn position(ra_fixture: &str) -> (RootDatabase, FilePosition) {
    let mut database = RootDatabase::default();
    database.apply_change(change_fixture.change);
    let (file_id, range_or_offset) = change_fixture.file_position.expect("expected a marker ($0)");
-    let offset = match range_or_offset {
+    let offset = range_or_offset.expect_offset();
-        RangeOrOffset::Range(_) => panic!(),
-        RangeOrOffset::Offset(it) => it,
-    };
    (database, FilePosition { file_id, offset })
 }
diff --git a/crates/mbe/src/expander/matcher.rs b/crates/mbe/src/expander/matcher.rs
index 75d2f2eed..84ca3ff87 100644
--- a/crates/mbe/src/expander/matcher.rs
+++ b/crates/mbe/src/expander/matcher.rs
@@ -701,7 +701,7 @@ fn match_meta_var(kind: &str, input: &mut TtIter) -> ExpandResult<Option<Fragmen
        "path" => Path,
        "expr" => Expr,
        "ty" => Type,
-        "pat" => Pattern,
+        "pat" | "pat_param" => Pattern, // FIXME: edition2021
        "stmt" => Statement,
        "block" => Block,
        "meta" => MetaItem,
diff --git a/crates/mbe/src/lib.rs b/crates/mbe/src/lib.rs
index 3af5bc18b..b95374b76 100644
--- a/crates/mbe/src/lib.rs
+++ b/crates/mbe/src/lib.rs
@@ -14,6 +14,7 @@ mod tests;
 #[cfg(test)]
 mod benchmark;
+mod token_map;
 use std::fmt;
@@ -63,9 +64,12 @@ impl fmt::Display for ExpandError {
    }
 }
-pub use crate::syntax_bridge::{
+pub use crate::{
-    ast_to_token_tree, parse_exprs_with_sep, parse_to_token_tree, syntax_node_to_token_tree,
+    syntax_bridge::{
-    token_tree_to_syntax_node, TokenMap,
+        ast_to_token_tree, parse_exprs_with_sep, parse_to_token_tree, syntax_node_to_token_tree,
+        token_tree_to_syntax_node,
+    },
+    token_map::TokenMap,
 };
 /// This struct contains AST for a single `macro_rules` definition. What might
diff --git a/crates/mbe/src/syntax_bridge.rs b/crates/mbe/src/syntax_bridge.rs
index b13168bd3..b11172caf 100644
--- a/crates/mbe/src/syntax_bridge.rs
+++ b/crates/mbe/src/syntax_bridge.rs
@@ -10,36 +10,8 @@ use syntax::{
 };
 use tt::buffer::{Cursor, TokenBuffer};
-use crate::ExpandError;
 use crate::{subtree_source::SubtreeTokenSource, tt_iter::TtIter};
+use crate::{ExpandError, TokenMap};
-#[derive(Debug, PartialEq, Eq, Clone, Copy)]
-pub enum TokenTextRange {
-    Token(TextRange),
-    Delimiter(TextRange),
-}
-impl TokenTextRange {
-    pub fn by_kind(self, kind: SyntaxKind) -> Option<TextRange> {
-        match self {
-            TokenTextRange::Token(it) => Some(it),
-            TokenTextRange::Delimiter(it) => match kind {
-                T!['{'] | T!['('] | T!['['] => Some(TextRange::at(it.start(), 1.into())),
-                T!['}'] | T![')'] | T![']'] => {
-                    Some(TextRange::at(it.end() - TextSize::of('}'), 1.into()))
-                }
-                _ => None,
-            },
-        }
-    }
-}
-/// Maps `tt::TokenId` to the relative range of the original token.
-#[derive(Debug, PartialEq, Eq, Clone, Default)]
-pub struct TokenMap {
-    /// Maps `tt::TokenId` to the *relative* source range.
-    entries: Vec<(tt::TokenId, TokenTextRange)>,
-}
 /// Convert the syntax tree (what user has written) to a `TokenTree` (what macro
 /// will consume).
@@ -53,7 +25,7 @@ pub fn syntax_node_to_token_tree(node: &SyntaxNode) -> (tt::Subtree, TokenMap) {
    let global_offset = node.text_range().start();
    let mut c = Convertor::new(node, global_offset);
    let subtree = c.go();
-    c.id_alloc.map.entries.shrink_to_fit();
+    c.id_alloc.map.shrink_to_fit();
    (subtree, c.id_alloc.map)
 }
@@ -149,55 +121,6 @@ pub fn parse_exprs_with_sep(tt: &tt::Subtree, sep: char) -> Vec<tt::Subtree> {
    res
 }
-impl TokenMap {
-    pub fn token_by_range(&self, relative_range: TextRange) -> Option<tt::TokenId> {
-        let &(token_id, _) = self.entries.iter().find(|(_, range)| match range {
-            TokenTextRange::Token(it) => *it == relative_range,
-            TokenTextRange::Delimiter(it) => {
-                let open = TextRange::at(it.start(), 1.into());
-                let close = TextRange::at(it.end() - TextSize::of('}'), 1.into());
-                open == relative_range || close == relative_range
-            }
-        })?;
-        Some(token_id)
-    }
-    pub fn range_by_token(&self, token_id: tt::TokenId) -> Option<TokenTextRange> {
-        let &(_, range) = self.entries.iter().find(|(tid, _)| *tid == token_id)?;
-        Some(range)
-    }
-    fn insert(&mut self, token_id: tt::TokenId, relative_range: TextRange) {
-        self.entries.push((token_id, TokenTextRange::Token(relative_range)));
-    }
-    fn insert_delim(
-        &mut self,
-        token_id: tt::TokenId,
-        open_relative_range: TextRange,
-        close_relative_range: TextRange,
-    ) -> usize {
-        let res = self.entries.len();
-        let cover = open_relative_range.cover(close_relative_range);
-        self.entries.push((token_id, TokenTextRange::Delimiter(cover)));
-        res
-    }
-    fn update_close_delim(&mut self, idx: usize, close_relative_range: TextRange) {
-        let (_, token_text_range) = &mut self.entries[idx];
-        if let TokenTextRange::Delimiter(dim) = token_text_range {
-            let cover = dim.cover(close_relative_range);
-            *token_text_range = TokenTextRange::Delimiter(cover);
-        }
-    }
-    fn remove_delim(&mut self, idx: usize) {
-        // FIXME: This could be accidentally quadratic
-        self.entries.remove(idx);
-    }
-}
 /// Returns the textual content of a doc comment block as a quoted string
 /// That is, strips leading `///` (or `/**`, etc)
 /// and strips the ending `*/`
@@ -634,7 +557,7 @@ impl<'a> TtTreeSink<'a> {
    }
    fn finish(mut self) -> (Parse<SyntaxNode>, TokenMap) {
-        self.token_map.entries.shrink_to_fit();
+        self.token_map.shrink_to_fit();
        (self.inner.finish(), self.token_map)
    }
 }
diff --git a/crates/mbe/src/tests/expand.rs b/crates/mbe/src/tests/expand.rs
index 3a1d840ea..5f173f513 100644
--- a/crates/mbe/src/tests/expand.rs
+++ b/crates/mbe/src/tests/expand.rs
@@ -58,9 +58,8 @@ macro_rules! foobar {
    let (node, token_map) = token_tree_to_syntax_node(&expanded, FragmentKind::Items).unwrap();
    let content = node.syntax_node().to_string();
-    let get_text = |id, kind| -> String {
+    let get_text =
-        content[token_map.range_by_token(id).unwrap().by_kind(kind).unwrap()].to_string()
+        |id, kind| -> String { content[token_map.range_by_token(id, kind).unwrap()].to_string() };
-    };
    assert_eq!(expanded.token_trees.len(), 4);
    // {($e:ident) => { fn $e() {} }}
diff --git a/crates/mbe/src/token_map.rs b/crates/mbe/src/token_map.rs
new file mode 100644
index 000000000..6df3de3b3
--- /dev/null
+++ b/crates/mbe/src/token_map.rs
@@ -0,0 +1,85 @@
+//! Mapping between `TokenId`s and the token's position in macro definitions or inputs.
+use parser::{SyntaxKind, T};
+use syntax::{TextRange, TextSize};
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+enum TokenTextRange {
+    Token(TextRange),
+    Delimiter(TextRange),
+}
+impl TokenTextRange {
+    fn by_kind(self, kind: SyntaxKind) -> Option<TextRange> {
+        match self {
+            TokenTextRange::Token(it) => Some(it),
+            TokenTextRange::Delimiter(it) => match kind {
+                T!['{'] | T!['('] | T!['['] => Some(TextRange::at(it.start(), 1.into())),
+                T!['}'] | T![')'] | T![']'] => {
+                    Some(TextRange::at(it.end() - TextSize::of('}'), 1.into()))
+                }
+                _ => None,
+            },
+        }
+    }
+}
+/// Maps `tt::TokenId` to the relative range of the original token.
+#[derive(Debug, PartialEq, Eq, Clone, Default)]
+pub struct TokenMap {
+    /// Maps `tt::TokenId` to the *relative* source range.
+    entries: Vec<(tt::TokenId, TokenTextRange)>,
+}
+impl TokenMap {
+    pub fn token_by_range(&self, relative_range: TextRange) -> Option<tt::TokenId> {
+        let &(token_id, _) = self.entries.iter().find(|(_, range)| match range {
+            TokenTextRange::Token(it) => *it == relative_range,
+            TokenTextRange::Delimiter(it) => {
+                let open = TextRange::at(it.start(), 1.into());
+                let close = TextRange::at(it.end() - TextSize::of('}'), 1.into());
+                open == relative_range || close == relative_range
+            }
+        })?;
+        Some(token_id)
+    }
+    pub fn range_by_token(&self, token_id: tt::TokenId, kind: SyntaxKind) -> Option<TextRange> {
+        let &(_, range) = self.entries.iter().find(|(tid, _)| *tid == token_id)?;
+        range.by_kind(kind)
+    }
+    pub(crate) fn shrink_to_fit(&mut self) {
+        self.entries.shrink_to_fit();
+    }
+    pub(crate) fn insert(&mut self, token_id: tt::TokenId, relative_range: TextRange) {
+        self.entries.push((token_id, TokenTextRange::Token(relative_range)));
+    }
+    pub(crate) fn insert_delim(
+        &mut self,
+        token_id: tt::TokenId,
+        open_relative_range: TextRange,
+        close_relative_range: TextRange,
+    ) -> usize {
+        let res = self.entries.len();
+        let cover = open_relative_range.cover(close_relative_range);
+        self.entries.push((token_id, TokenTextRange::Delimiter(cover)));
+        res
+    }
+    pub(crate) fn update_close_delim(&mut self, idx: usize, close_relative_range: TextRange) {
+        let (_, token_text_range) = &mut self.entries[idx];
+        if let TokenTextRange::Delimiter(dim) = token_text_range {
+            let cover = dim.cover(close_relative_range);
+            *token_text_range = TokenTextRange::Delimiter(cover);
+        }
+    }
+    pub(crate) fn remove_delim(&mut self, idx: usize) {
+        // FIXME: This could be accidentally quadratic
+        self.entries.remove(idx);
+    }
+}
diff --git a/crates/project_model/src/build_data.rs b/crates/project_model/src/build_data.rs
index 3aa546980..33a4f8168 100644
--- a/crates/project_model/src/build_data.rs
+++ b/crates/project_model/src/build_data.rs
@@ -214,7 +214,7 @@ impl WorkspaceBuildData {
                            acc
                        };
                        let package_build_data =
-                            res.per_package.entry(package_id.repr.clone()).or_default();
+                            res.per_package.entry(package_id.repr).or_default();
                        // cargo_metadata crate returns default (empty) path for
                        // older cargos, which is not absolute, so work around that.
                        if !out_dir.as_str().is_empty() {
@@ -237,13 +237,13 @@ impl WorkspaceBuildData {
                            {
                                let filename = AbsPathBuf::assert(PathBuf::from(&filename));
                                let package_build_data =
-                                    res.per_package.entry(package_id.repr.clone()).or_default();
+                                    res.per_package.entry(package_id.repr).or_default();
                                package_build_data.proc_macro_dylib_path = Some(filename);
                            }
                        }
                    }
                    Message::CompilerMessage(message) => {
-                        progress(message.target.name.clone());
+                        progress(message.target.name);
                    }
                    Message::BuildFinished(_) => {}
                    Message::TextLine(_) => {}
diff --git a/crates/project_model/src/cargo_workspace.rs b/crates/project_model/src/cargo_workspace.rs
index ad705c752..b8ad08364 100644
--- a/crates/project_model/src/cargo_workspace.rs
+++ b/crates/project_model/src/cargo_workspace.rs
@@ -121,7 +121,7 @@ pub struct PackageDependency {
    pub kind: DepKind,
 }
-#[derive(Debug, Clone, Eq, PartialEq)]
+#[derive(Debug, Clone, Eq, PartialEq, PartialOrd, Ord)]
 pub enum DepKind {
    /// Available to the library, binary, and dev targets in the package (but not the build script).
    Normal,
@@ -132,17 +132,23 @@ pub enum DepKind {
 }
 impl DepKind {
-    fn new(list: &[cargo_metadata::DepKindInfo]) -> Self {
+    fn iter(list: &[cargo_metadata::DepKindInfo]) -> impl Iterator<Item = Self> + '_ {
+        let mut dep_kinds = Vec::new();
+        if list.is_empty() {
+            dep_kinds.push(Self::Normal);
+        }
        for info in list {
-            match info.kind {
+            let kind = match info.kind {
-                cargo_metadata::DependencyKind::Normal => return Self::Normal,
+                cargo_metadata::DependencyKind::Normal => Self::Normal,
-                cargo_metadata::DependencyKind::Development => return Self::Dev,
+                cargo_metadata::DependencyKind::Development => Self::Dev,
-                cargo_metadata::DependencyKind::Build => return Self::Build,
+                cargo_metadata::DependencyKind::Build => Self::Build,
                cargo_metadata::DependencyKind::Unknown => continue,
-            }
+            };
+            dep_kinds.push(kind);
        }
+        dep_kinds.sort_unstable();
-        Self::Normal
+        dep_kinds.dedup();
+        dep_kinds.into_iter()
    }
 }
@@ -317,7 +323,11 @@ impl CargoWorkspace {
                }
            };
            node.deps.sort_by(|a, b| a.pkg.cmp(&b.pkg));
-            for dep_node in node.deps {
+            for (dep_node, kind) in node
+                .deps
+                .iter()
+                .flat_map(|dep| DepKind::iter(&dep.dep_kinds).map(move |kind| (dep, kind)))
+            {
                let pkg = match pkg_by_id.get(&dep_node.pkg) {
                    Some(&pkg) => pkg,
                    None => {
@@ -328,11 +338,7 @@ impl CargoWorkspace {
                        continue;
                    }
                };
-                let dep = PackageDependency {
+                let dep = PackageDependency { name: dep_node.name.clone(), pkg, kind };
-                    name: dep_node.name,
-                    pkg,
-                    kind: DepKind::new(&dep_node.dep_kinds),
-                };
                packages[source].dependencies.push(dep);
            }
            packages[source].active_features.extend(node.features);
@@ -340,11 +346,8 @@ impl CargoWorkspace {
        let workspace_root =
            AbsPathBuf::assert(PathBuf::from(meta.workspace_root.into_os_string()));
-        let build_data_config = BuildDataConfig::new(
+        let build_data_config =
-            cargo_toml.to_path_buf(),
+            BuildDataConfig::new(cargo_toml.to_path_buf(), config.clone(), Arc::new(meta.packages));
-            config.clone(),
-            Arc::new(meta.packages.clone()),
-        );
        Ok(CargoWorkspace { packages, targets, workspace_root, build_data_config })
    }
diff --git a/crates/rust-analyzer/src/bin/main.rs b/crates/rust-analyzer/src/bin/main.rs
index 6c883dd58..2b842d393 100644
--- a/crates/rust-analyzer/src/bin/main.rs
+++ b/crates/rust-analyzer/src/bin/main.rs
@@ -158,7 +158,24 @@ fn run_server() -> Result<()> {
    let initialize_params =
        from_json::<lsp_types::InitializeParams>("InitializeParams", initialize_params)?;
-    let server_capabilities = rust_analyzer::server_capabilities(&initialize_params.capabilities);
+    let root_path = match initialize_params
+        .root_uri
+        .and_then(|it| it.to_file_path().ok())
+        .and_then(|it| AbsPathBuf::try_from(it).ok())
+    {
+        Some(it) => it,
+        None => {
+            let cwd = env::current_dir()?;
+            AbsPathBuf::assert(cwd)
+        }
+    };
+    let mut config = Config::new(root_path, initialize_params.capabilities);
+    if let Some(json) = initialize_params.initialization_options {
+        config.update(json);
+    }
+    let server_capabilities = rust_analyzer::server_capabilities(&config);
    let initialize_result = lsp_types::InitializeResult {
        capabilities: server_capabilities,
@@ -166,11 +183,7 @@ fn run_server() -> Result<()> {
            name: String::from("rust-analyzer"),
            version: Some(String::from(env!("REV"))),
        }),
-        offset_encoding: if supports_utf8(&initialize_params.capabilities) {
+        offset_encoding: if supports_utf8(&config.caps) { Some("utf-8".to_string()) } else { None },
-            Some("utf-8".to_string())
-        } else {
-            None
-        },
    };
    let initialize_result = serde_json::to_value(initialize_result).unwrap();
@@ -181,47 +194,26 @@ fn run_server() -> Result<()> {
        log::info!("Client '{}' {}", client_info.name, client_info.version.unwrap_or_default());
    }
-    let config = {
+    if config.linked_projects().is_empty() && config.detached_files().is_empty() {
-        let root_path = match initialize_params
+        let workspace_roots = initialize_params
-            .root_uri
+            .workspace_folders
-            .and_then(|it| it.to_file_path().ok())
+            .map(|workspaces| {
-            .and_then(|it| AbsPathBuf::try_from(it).ok())
+                workspaces
-        {
+                    .into_iter()
-            Some(it) => it,
+                    .filter_map(|it| it.uri.to_file_path().ok())
-            None => {
+                    .filter_map(|it| AbsPathBuf::try_from(it).ok())
-                let cwd = env::current_dir()?;
+                    .collect::<Vec<_>>()
-                AbsPathBuf::assert(cwd)
+            })
-            }
+            .filter(|workspaces| !workspaces.is_empty())
-        };
+            .unwrap_or_else(|| vec![config.root_path.clone()]);
-        let mut config = Config::new(root_path, initialize_params.capabilities);
+        let discovered = ProjectManifest::discover_all(&workspace_roots);
-        if let Some(json) = initialize_params.initialization_options {
+        log::info!("discovered projects: {:?}", discovered);
-            config.update(json);
+        if discovered.is_empty() {
-        }
+            log::error!("failed to find any projects in {:?}", workspace_roots);
-        if config.linked_projects().is_empty() && config.detached_files().is_empty() {
-            let workspace_roots = initialize_params
-                .workspace_folders
-                .map(|workspaces| {
-                    workspaces
-                        .into_iter()
-                        .filter_map(|it| it.uri.to_file_path().ok())
-                        .filter_map(|it| AbsPathBuf::try_from(it).ok())
-                        .collect::<Vec<_>>()
-                })
-                .filter(|workspaces| !workspaces.is_empty())
-                .unwrap_or_else(|| vec![config.root_path.clone()]);
-            let discovered = ProjectManifest::discover_all(&workspace_roots);
-            log::info!("discovered projects: {:?}", discovered);
-            if discovered.is_empty() {
-                log::error!("failed to find any projects in {:?}", workspace_roots);
-            }
-            config.discovered_projects = Some(discovered);
        }
+        config.discovered_projects = Some(discovered);
-        config
+    }
-    };
    rust_analyzer::main_loop(config, connection)?;
diff --git a/crates/rust-analyzer/src/caps.rs b/crates/rust-analyzer/src/caps.rs
index b2317618a..fe5255240 100644
--- a/crates/rust-analyzer/src/caps.rs
+++ b/crates/rust-analyzer/src/caps.rs
@@ -1,6 +1,4 @@
-//! Advertizes the capabilities of the LSP Server.
+//! Advertises the capabilities of the LSP Server.
-use std::env;
 use lsp_types::{
    CallHierarchyServerCapability, ClientCapabilities, CodeActionKind, CodeActionOptions,
    CodeActionProviderCapability, CodeLensOptions, CompletionOptions,
@@ -15,24 +13,21 @@ use lsp_types::{
 };
 use serde_json::json;
+use crate::config::{Config, RustfmtConfig};
 use crate::semantic_tokens;
-pub fn server_capabilities(client_caps: &ClientCapabilities) -> ServerCapabilities {
+pub fn server_capabilities(config: &Config) -> ServerCapabilities {
    ServerCapabilities {
        text_document_sync: Some(TextDocumentSyncCapability::Options(TextDocumentSyncOptions {
            open_close: Some(true),
-            change: Some(if env::var("RA_NO_INCREMENTAL_SYNC").is_ok() {
+            change: Some(TextDocumentSyncKind::Incremental),
-                TextDocumentSyncKind::Full
-            } else {
-                TextDocumentSyncKind::Incremental
-            }),
            will_save: None,
            will_save_wait_until: None,
            save: Some(SaveOptions::default().into()),
        })),
        hover_provider: Some(HoverProviderCapability::Simple(true)),
        completion_provider: Some(CompletionOptions {
-            resolve_provider: completions_resolve_provider(client_caps),
+            resolve_provider: completions_resolve_provider(&config.caps),
            trigger_characters: Some(vec![":".to_string(), ".".to_string(), "'".to_string()]),
            all_commit_characters: None,
            completion_item: None,
@@ -51,10 +46,13 @@ pub fn server_capabilities(client_caps: &ClientCapabilities) -> ServerCapabiliti
        document_highlight_provider: Some(OneOf::Left(true)),
        document_symbol_provider: Some(OneOf::Left(true)),
        workspace_symbol_provider: Some(OneOf::Left(true)),
-        code_action_provider: Some(code_action_capabilities(client_caps)),
+        code_action_provider: Some(code_action_capabilities(&config.caps)),
        code_lens_provider: Some(CodeLensOptions { resolve_provider: Some(true) }),
        document_formatting_provider: Some(OneOf::Left(true)),
-        document_range_formatting_provider: None,
+        document_range_formatting_provider: match config.rustfmt() {
+            RustfmtConfig::Rustfmt { enable_range_formatting: true, .. } => Some(OneOf::Left(true)),
+            _ => Some(OneOf::Left(false)),
+        },
        document_on_type_formatting_provider: Some(DocumentOnTypeFormattingOptions {
            first_trigger_character: "=".to_string(),
            more_trigger_character: Some(vec![".".to_string(), ">".to_string(), "{".to_string()]),
diff --git a/crates/rust-analyzer/src/config.rs b/crates/rust-analyzer/src/config.rs
index 7c02a507c..a67b0bb25 100644
--- a/crates/rust-analyzer/src/config.rs
+++ b/crates/rust-analyzer/src/config.rs
@@ -111,15 +111,15 @@ config_data! {
        /// Map of prefixes to be substituted when parsing diagnostic file paths.
        /// This should be the reverse mapping of what is passed to `rustc` as `--remap-path-prefix`.
        diagnostics_remapPrefix: FxHashMap<String, String> = "{}",
-        /// List of warnings that should be displayed with info severity.
-        ///
-        /// The warnings will be indicated by a blue squiggly underline in code
-        /// and a blue icon in the `Problems Panel`.
-        diagnostics_warningsAsHint: Vec<String> = "[]",
        /// List of warnings that should be displayed with hint severity.
        ///
        /// The warnings will be indicated by faded text or three dots in code
        /// and will not show up in the `Problems Panel`.
+        diagnostics_warningsAsHint: Vec<String> = "[]",
+        /// List of warnings that should be displayed with info severity.
+        ///
+        /// The warnings will be indicated by a blue squiggly underline in code
+        /// and a blue icon in the `Problems Panel`.
        diagnostics_warningsAsInfo: Vec<String> = "[]",
        /// Controls file watching implementation.
@@ -218,6 +218,10 @@ config_data! {
        /// Advanced option, fully override the command rust-analyzer uses for
        /// formatting.
        rustfmt_overrideCommand: Option<Vec<String>> = "null",
+        /// Enables the use of rustfmt's unstable range formatting command for the
+        /// `textDocument/rangeFormatting` request. The rustfmt option is unstable and only
+        /// available on a nightly build.
+        rustfmt_enableRangeFormatting: bool = "false",
        /// Workspace symbol search scope.
        workspace_symbol_search_scope: WorskpaceSymbolSearchScopeDef = "\"workspace\"",
@@ -234,7 +238,7 @@ impl Default for ConfigData {
 #[derive(Debug, Clone)]
 pub struct Config {
-    caps: lsp_types::ClientCapabilities,
+    pub caps: lsp_types::ClientCapabilities,
    data: ConfigData,
    detached_files: Vec<AbsPathBuf>,
    pub discovered_projects: Option<Vec<ProjectManifest>>,
@@ -305,7 +309,7 @@ pub struct NotificationsConfig {
 #[derive(Debug, Clone)]
 pub enum RustfmtConfig {
-    Rustfmt { extra_args: Vec<String> },
+    Rustfmt { extra_args: Vec<String>, enable_range_formatting: bool },
    CustomCommand { command: String, args: Vec<String> },
 }
@@ -584,9 +588,10 @@ impl Config {
                let command = args.remove(0);
                RustfmtConfig::CustomCommand { command, args }
            }
-            Some(_) | None => {
+            Some(_) | None => RustfmtConfig::Rustfmt {
-                RustfmtConfig::Rustfmt { extra_args: self.data.rustfmt_extraArgs.clone() }
+                extra_args: self.data.rustfmt_extraArgs.clone(),
-            }
+                enable_range_formatting: self.data.rustfmt_enableRangeFormatting,
+            },
        }
    }
    pub fn flycheck(&self) -> Option<FlycheckConfig> {
diff --git a/crates/rust-analyzer/src/handlers.rs b/crates/rust-analyzer/src/handlers.rs
index f48210424..456744603 100644
--- a/crates/rust-analyzer/src/handlers.rs
+++ b/crates/rust-analyzer/src/handlers.rs
@@ -27,7 +27,7 @@ use lsp_types::{
 };
 use project_model::TargetKind;
 use serde::{Deserialize, Serialize};
-use serde_json::to_value;
+use serde_json::{json, to_value};
 use stdx::format_to;
 use syntax::{algo, ast, AstNode, TextRange, TextSize};
@@ -955,104 +955,17 @@ pub(crate) fn handle_formatting(
    params: DocumentFormattingParams,
 ) -> Result<Option<Vec<lsp_types::TextEdit>>> {
    let _p = profile::span("handle_formatting");
-    let file_id = from_proto::file_id(&snap, &params.text_document.uri)?;
-    let file = snap.analysis.file_text(file_id)?;
-    let crate_ids = snap.analysis.crate_for(file_id)?;
-    let line_index = snap.file_line_index(file_id)?;
-    let mut rustfmt = match snap.config.rustfmt() {
-        RustfmtConfig::Rustfmt { extra_args } => {
-            let mut cmd = process::Command::new(toolchain::rustfmt());
-            cmd.args(extra_args);
-            // try to chdir to the file so we can respect `rustfmt.toml`
-            // FIXME: use `rustfmt --config-path` once
-            // https://github.com/rust-lang/rustfmt/issues/4660 gets fixed
-            match params.text_document.uri.to_file_path() {
-                Ok(mut path) => {
-                    // pop off file name
-                    if path.pop() && path.is_dir() {
-                        cmd.current_dir(path);
-                    }
-                }
-                Err(_) => {
-                    log::error!(
-                        "Unable to get file path for {}, rustfmt.toml might be ignored",
-                        params.text_document.uri
-                    );
-                }
-            }
-            if let Some(&crate_id) = crate_ids.first() {
-                // Assume all crates are in the same edition
-                let edition = snap.analysis.crate_edition(crate_id)?;
-                cmd.arg("--edition");
-                cmd.arg(edition.to_string());
-            }
-            cmd
-        }
-        RustfmtConfig::CustomCommand { command, args } => {
-            let mut cmd = process::Command::new(command);
-            cmd.args(args);
-            cmd
-        }
-    };
-    let mut rustfmt =
+    run_rustfmt(&snap, params.text_document, None)
-        rustfmt.stdin(Stdio::piped()).stdout(Stdio::piped()).stderr(Stdio::piped()).spawn()?;
+}
-    rustfmt.stdin.as_mut().unwrap().write_all(file.as_bytes())?;
-    let output = rustfmt.wait_with_output()?;
-    let captured_stdout = String::from_utf8(output.stdout)?;
-    let captured_stderr = String::from_utf8(output.stderr).unwrap_or_default();
-    if !output.status.success() {
-        let rustfmt_not_installed =
-            captured_stderr.contains("not installed") || captured_stderr.contains("not available");
-        return match output.status.code() {
-            Some(1) if !rustfmt_not_installed => {
-                // While `rustfmt` doesn't have a specific exit code for parse errors this is the
-                // likely cause exiting with 1. Most Language Servers swallow parse errors on
-                // formatting because otherwise an error is surfaced to the user on top of the
-                // syntax error diagnostics they're already receiving. This is especially jarring
-                // if they have format on save enabled.
-                log::info!("rustfmt exited with status 1, assuming parse error and ignoring");
-                Ok(None)
-            }
-            _ => {
-                // Something else happened - e.g. `rustfmt` is missing or caught a signal
-                Err(LspError::new(
-                    -32900,
-                    format!(
-                        r#"rustfmt exited with:
-                           Status: {}
-                           stdout: {}
-                           stderr: {}"#,
-                        output.status, captured_stdout, captured_stderr,
-                    ),
-                )
-                .into())
-            }
-        };
-    }
-    let (new_text, new_line_endings) = LineEndings::normalize(captured_stdout);
+pub(crate) fn handle_range_formatting(
+    snap: GlobalStateSnapshot,
+    params: lsp_types::DocumentRangeFormattingParams,
+) -> Result<Option<Vec<lsp_types::TextEdit>>> {
+    let _p = profile::span("handle_range_formatting");
-    if line_index.endings != new_line_endings {
+    run_rustfmt(&snap, params.text_document, Some(params.range))
-        // If line endings are different, send the entire file.
-        // Diffing would not work here, as the line endings might be the only
-        // difference.
-        Ok(Some(to_proto::text_edit_vec(
-            &line_index,
-            TextEdit::replace(TextRange::up_to(TextSize::of(&*file)), new_text),
-        )))
-    } else if *file == new_text {
-        // The document is already formatted correctly -- no edits needed.
-        Ok(None)
-    } else {
-        Ok(Some(to_proto::text_edit_vec(&line_index, diff(&file, &new_text))))
-    }
 }
 pub(crate) fn handle_code_action(
@@ -1675,6 +1588,140 @@ fn should_skip_target(runnable: &Runnable, cargo_spec: Option<&CargoTargetSpec>)
    }
 }
+fn run_rustfmt(
+    snap: &GlobalStateSnapshot,
+    text_document: TextDocumentIdentifier,
+    range: Option<lsp_types::Range>,
+) -> Result<Option<Vec<lsp_types::TextEdit>>> {
+    let file_id = from_proto::file_id(&snap, &text_document.uri)?;
+    let file = snap.analysis.file_text(file_id)?;
+    let crate_ids = snap.analysis.crate_for(file_id)?;
+    let line_index = snap.file_line_index(file_id)?;
+    let mut rustfmt = match snap.config.rustfmt() {
+        RustfmtConfig::Rustfmt { extra_args, enable_range_formatting } => {
+            let mut cmd = process::Command::new(toolchain::rustfmt());
+            cmd.args(extra_args);
+            // try to chdir to the file so we can respect `rustfmt.toml`
+            // FIXME: use `rustfmt --config-path` once
+            // https://github.com/rust-lang/rustfmt/issues/4660 gets fixed
+            match text_document.uri.to_file_path() {
+                Ok(mut path) => {
+                    // pop off file name
+                    if path.pop() && path.is_dir() {
+                        cmd.current_dir(path);
+                    }
+                }
+                Err(_) => {
+                    log::error!(
+                        "Unable to get file path for {}, rustfmt.toml might be ignored",
+                        text_document.uri
+                    );
+                }
+            }
+            if let Some(&crate_id) = crate_ids.first() {
+                // Assume all crates are in the same edition
+                let edition = snap.analysis.crate_edition(crate_id)?;
+                cmd.arg("--edition");
+                cmd.arg(edition.to_string());
+            }
+            if let Some(range) = range {
+                if !enable_range_formatting {
+                    return Err(LspError::new(
+                        ErrorCode::InvalidRequest as i32,
+                        String::from(
+                            "rustfmt range formatting is unstable. \
+                            Opt-in by using a nightly build of rustfmt and setting \
+                            `rustfmt.enableRangeFormatting` to true in your LSP configuration",
+                        ),
+                    )
+                    .into());
+                }
+                let frange = from_proto::file_range(&snap, text_document.clone(), range)?;
+                let start_line = line_index.index.line_col(frange.range.start()).line;
+                let end_line = line_index.index.line_col(frange.range.end()).line;
+                cmd.arg("--unstable-features");
+                cmd.arg("--file-lines");
+                cmd.arg(
+                    json!([{
+                        "file": "stdin",
+                        "range": [start_line, end_line]
+                    }])
+                    .to_string(),
+                );
+            }
+            cmd
+        }
+        RustfmtConfig::CustomCommand { command, args } => {
+            let mut cmd = process::Command::new(command);
+            cmd.args(args);
+            cmd
+        }
+    };
+    let mut rustfmt =
+        rustfmt.stdin(Stdio::piped()).stdout(Stdio::piped()).stderr(Stdio::piped()).spawn()?;
+    rustfmt.stdin.as_mut().unwrap().write_all(file.as_bytes())?;
+    let output = rustfmt.wait_with_output()?;
+    let captured_stdout = String::from_utf8(output.stdout)?;
+    let captured_stderr = String::from_utf8(output.stderr).unwrap_or_default();
+    if !output.status.success() {
+        let rustfmt_not_installed =
+            captured_stderr.contains("not installed") || captured_stderr.contains("not available");
+        return match output.status.code() {
+            Some(1) if !rustfmt_not_installed => {
+                // While `rustfmt` doesn't have a specific exit code for parse errors this is the
+                // likely cause exiting with 1. Most Language Servers swallow parse errors on
+                // formatting because otherwise an error is surfaced to the user on top of the
+                // syntax error diagnostics they're already receiving. This is especially jarring
+                // if they have format on save enabled.
+                log::info!("rustfmt exited with status 1, assuming parse error and ignoring");
+                Ok(None)
+            }
+            _ => {
+                // Something else happened - e.g. `rustfmt` is missing or caught a signal
+                Err(LspError::new(
+                    -32900,
+                    format!(
+                        r#"rustfmt exited with:
+                           Status: {}
+                           stdout: {}
+                           stderr: {}"#,
+                        output.status, captured_stdout, captured_stderr,
+                    ),
+                )
+                .into())
+            }
+        };
+    }
+    let (new_text, new_line_endings) = LineEndings::normalize(captured_stdout);
+    if line_index.endings != new_line_endings {
+        // If line endings are different, send the entire file.
+        // Diffing would not work here, as the line endings might be the only
+        // difference.
+        Ok(Some(to_proto::text_edit_vec(
+            &line_index,
+            TextEdit::replace(TextRange::up_to(TextSize::of(&*file)), new_text),
+        )))
+    } else if *file == new_text {
+        // The document is already formatted correctly -- no edits needed.
+        Ok(None)
+    } else {
+        Ok(Some(to_proto::text_edit_vec(&line_index, diff(&file, &new_text))))
+    }
+}
 #[derive(Debug, Serialize, Deserialize)]
 struct CompletionResolveData {
    position: lsp_types::TextDocumentPositionParams,
diff --git a/crates/rust-analyzer/src/main_loop.rs b/crates/rust-analyzer/src/main_loop.rs
index cb002f700..008758ea0 100644
--- a/crates/rust-analyzer/src/main_loop.rs
+++ b/crates/rust-analyzer/src/main_loop.rs
@@ -543,6 +543,7 @@ impl GlobalState {
            .on::<lsp_types::request::Rename>(handlers::handle_rename)
            .on::<lsp_types::request::References>(handlers::handle_references)
            .on::<lsp_types::request::Formatting>(handlers::handle_formatting)
+            .on::<lsp_types::request::RangeFormatting>(handlers::handle_range_formatting)
            .on::<lsp_types::request::DocumentHighlightRequest>(handlers::handle_document_highlight)
            .on::<lsp_types::request::CallHierarchyPrepare>(handlers::handle_call_hierarchy_prepare)
            .on::<lsp_types::request::CallHierarchyIncomingCalls>(
diff --git a/crates/rust-analyzer/src/reload.rs b/crates/rust-analyzer/src/reload.rs
index 7a53e4a8b..93b5ff55f 100644
--- a/crates/rust-analyzer/src/reload.rs
+++ b/crates/rust-analyzer/src/reload.rs
@@ -455,7 +455,11 @@ impl ProjectFolders {
                dirs.include.extend(root.include);
                dirs.exclude.extend(root.exclude);
                for excl in global_excludes {
-                    if dirs.include.iter().any(|incl| incl.starts_with(excl)) {
+                    if dirs
+                        .include
+                        .iter()
+                        .any(|incl| incl.starts_with(excl) || excl.starts_with(incl))
+                    {
                        dirs.exclude.push(excl.clone());
                    }
                }
diff --git a/crates/rust-analyzer/src/semantic_tokens.rs b/crates/rust-analyzer/src/semantic_tokens.rs
index 4fd576adb..db216d951 100644
--- a/crates/rust-analyzer/src/semantic_tokens.rs
+++ b/crates/rust-analyzer/src/semantic_tokens.rs
@@ -46,7 +46,7 @@ define_semantic_token_types![
    (BRACE, "brace"),
    (BRACKET, "bracket"),
    (BUILTIN_TYPE, "builtinType"),
-    (CHAR_LITERAL, "characterLiteral"),
+    (CHAR, "character"),
    (COLON, "colon"),
    (COMMA, "comma"),
    (COMPARISON, "comparison"),
@@ -92,6 +92,7 @@ define_semantic_token_modifiers![
    (MUTABLE, "mutable"),
    (CONSUMING, "consuming"),
    (ASYNC, "async"),
+    (LIBRARY, "library"),
    (UNSAFE, "unsafe"),
    (ATTRIBUTE_MODIFIER, "attribute"),
    (TRAIT_MODIFIER, "trait"),
diff --git a/crates/rust-analyzer/src/to_proto.rs b/crates/rust-analyzer/src/to_proto.rs
index 410384ae5..f5c8535a2 100644
--- a/crates/rust-analyzer/src/to_proto.rs
+++ b/crates/rust-analyzer/src/to_proto.rs
@@ -466,7 +466,7 @@ fn semantic_token_type_and_modifiers(
        HlTag::BoolLiteral => semantic_tokens::BOOLEAN,
        HlTag::BuiltinType => semantic_tokens::BUILTIN_TYPE,
        HlTag::ByteLiteral | HlTag::NumericLiteral => lsp_types::SemanticTokenType::NUMBER,
-        HlTag::CharLiteral => semantic_tokens::CHAR_LITERAL,
+        HlTag::CharLiteral => semantic_tokens::CHAR,
        HlTag::Comment => lsp_types::SemanticTokenType::COMMENT,
        HlTag::EscapeSequence => semantic_tokens::ESCAPE_SEQUENCE,
        HlTag::FormatSpecifier => semantic_tokens::FORMAT_SPECIFIER,
@@ -504,6 +504,7 @@ fn semantic_token_type_and_modifiers(
            HlMod::Mutable => semantic_tokens::MUTABLE,
            HlMod::Consuming => semantic_tokens::CONSUMING,
            HlMod::Async => semantic_tokens::ASYNC,
+            HlMod::Library => semantic_tokens::LIBRARY,
            HlMod::Unsafe => semantic_tokens::UNSAFE,
            HlMod::Callable => semantic_tokens::CALLABLE,
            HlMod::Static => lsp_types::SemanticTokenModifier::STATIC,
@@ -533,6 +534,7 @@ pub(crate) fn folding_range(
        | FoldKind::Consts
        | FoldKind::Statics
        | FoldKind::WhereClause
+        | FoldKind::ReturnType
        | FoldKind::Array => None,
    };
diff --git a/crates/syntax/src/ast/edit_in_place.rs b/crates/syntax/src/ast/edit_in_place.rs
index ca8103668..f7ee29d14 100644
--- a/crates/syntax/src/ast/edit_in_place.rs
+++ b/crates/syntax/src/ast/edit_in_place.rs
@@ -356,13 +356,17 @@ impl ast::MatchArm {
 impl ast::MatchArmList {
    pub fn add_arm(&self, arm: ast::MatchArm) {
        normalize_ws_between_braces(self.syntax());
+        let mut elements = Vec::new();
        let position = match self.arms().last() {
            Some(last_arm) => {
-                let curly = last_arm
+                let comma = last_arm
                    .syntax()
                    .siblings_with_tokens(Direction::Next)
                    .find(|it| it.kind() == T![,]);
-                Position::after(curly.unwrap_or_else(|| last_arm.syntax().clone().into()))
+                if needs_comma(&last_arm) && comma.is_none() {
+                    elements.push(make::token(SyntaxKind::COMMA).into());
+                }
+                Position::after(comma.unwrap_or_else(|| last_arm.syntax().clone().into()))
            }
            None => match self.l_curly_token() {
                Some(it) => Position::after(it),
@@ -370,11 +374,16 @@ impl ast::MatchArmList {
            },
        };
        let indent = IndentLevel::from_node(self.syntax()) + 1;
-        let elements = vec![
+        elements.push(make::tokens::whitespace(&format!("\n{}", indent)).into());
-            make::tokens::whitespace(&format!("\n{}", indent)).into(),
+        elements.push(arm.syntax().clone().into());
-            arm.syntax().clone().into(),
+        if needs_comma(&arm) {
-        ];
+            elements.push(make::token(SyntaxKind::COMMA).into());
+        }
        ted::insert_all(position, elements);
+        fn needs_comma(arm: &ast::MatchArm) -> bool {
+            arm.expr().map_or(false, |e| !e.is_block_like())
+        }
    }
 }
diff --git a/crates/syntax/src/ast/node_ext.rs b/crates/syntax/src/ast/node_ext.rs
index df8f98b5b..884fe0739 100644
--- a/crates/syntax/src/ast/node_ext.rs
+++ b/crates/syntax/src/ast/node_ext.rs
@@ -243,6 +243,13 @@ impl ast::Path {
        }
    }
+    pub fn as_single_name_ref(&self) -> Option<ast::NameRef> {
+        match self.qualifier() {
+            Some(_) => None,
+            None => self.segment()?.name_ref(),
+        }
+    }
    pub fn first_qualifier_or_self(&self) -> ast::Path {
        successors(Some(self.clone()), ast::Path::qualifier).last().unwrap()
    }
diff --git a/crates/test_utils/src/lib.rs b/crates/test_utils/src/lib.rs
index fce4fd6bf..bd017567c 100644
--- a/crates/test_utils/src/lib.rs
+++ b/crates/test_utils/src/lib.rs
@@ -96,6 +96,21 @@ pub enum RangeOrOffset {
    Offset(TextSize),
 }
+impl RangeOrOffset {
+    pub fn expect_offset(self) -> TextSize {
+        match self {
+            RangeOrOffset::Offset(it) => it,
+            RangeOrOffset::Range(_) => panic!("expected an offset but got a range instead"),
+        }
+    }
+    pub fn expect_range(self) -> TextRange {
+        match self {
+            RangeOrOffset::Range(it) => it,
+            RangeOrOffset::Offset(_) => panic!("expected a range but got an offset"),
+        }
+    }
+}
 impl From<RangeOrOffset> for TextRange {
    fn from(selection: RangeOrOffset) -> Self {
        match selection {
diff --git a/docs/dev/lsp-extensions.md b/docs/dev/lsp-extensions.md
index fbe2ce1c9..11a3dd04e 100644
--- a/docs/dev/lsp-extensions.md
+++ b/docs/dev/lsp-extensions.md
@@ -25,15 +25,21 @@ rust-analyzer supports clangd's extension for opting into UTF-8 as the coordinat
 https://clangd.llvm.org/extensions.html#utf-8-offsets
-## `initializationOptions`
+## Configuration in `initializationOptions`
+**Issue:** https://github.com/microsoft/language-server-protocol/issues/567
+The `initializationOptions` filed of the `InitializeParams` of the initialization request should contain `"rust-analyzer"` section of the configuration.
+`rust-analyzer` normally sends a `"workspace/configuration"` request with `{ "items": ["rust-analyzer"] }` payload.
+However, the server can't do this during initialization.
+At the same time some essential configuration parameters are needed early on, before servicing requests.
+For this reason, we ask that `initializationOptions` contains the configuration, as if the server did make a `"workspace/configuration"` request.
-For `initializationOptions`, `rust-analyzer` expects `"rust-analyzer"` section of the configuration.
-That is, `rust-analyzer` usually sends `"workspace/configuration"` request with `{ "items": ["rust-analyzer"] }` payload.
-`initializationOptions` should contain the same data that would be in the first item of the result.
 If a language client does not know about `rust-analyzer`'s configuration options it can get sensible defaults by doing any of the following:
 * Not sending `initializationOptions`
- * Send `"initializationOptions": null`
+ * Sending `"initializationOptions": null`
- * Send `"initializationOptions": {}`
+ * Sending `"initializationOptions": {}`
 ## Snippet `TextEdit`
diff --git a/docs/user/generated_config.adoc b/docs/user/generated_config.adoc
index c02bab7cc..4a5782a57 100644
--- a/docs/user/generated_config.adoc
+++ b/docs/user/generated_config.adoc
@@ -161,18 +161,18 @@ This should be the reverse mapping of what is passed to `rustc` as `--remap-path
 [[rust-analyzer.diagnostics.warningsAsHint]]rust-analyzer.diagnostics.warningsAsHint (default: `[]`)::
 +
 --
-List of warnings that should be displayed with info severity.
+List of warnings that should be displayed with hint severity.
-The warnings will be indicated by a blue squiggly underline in code
+The warnings will be indicated by faded text or three dots in code
-and a blue icon in the `Problems Panel`.
+and will not show up in the `Problems Panel`.
 --
 [[rust-analyzer.diagnostics.warningsAsInfo]]rust-analyzer.diagnostics.warningsAsInfo (default: `[]`)::
 +
 --
-List of warnings that should be displayed with hint severity.
+List of warnings that should be displayed with info severity.
-The warnings will be indicated by faded text or three dots in code
+The warnings will be indicated by a blue squiggly underline in code
-and will not show up in the `Problems Panel`.
+and a blue icon in the `Problems Panel`.
 --
 [[rust-analyzer.files.watcher]]rust-analyzer.files.watcher (default: `"client"`)::
 +
@@ -346,6 +346,13 @@ Additional arguments to `rustfmt`.
 Advanced option, fully override the command rust-analyzer uses for
 formatting.
 --
+[[rust-analyzer.rustfmt.enableRangeFormatting]]rust-analyzer.rustfmt.enableRangeFormatting (default: `false`)::
+
+--
+Enables the use of rustfmt's unstable range formatting command for the
+`textDocument/rangeFormatting` request. The rustfmt option is unstable and only
+available on a nightly build.
+--
 [[rust-analyzer.workspace.symbol.search.scope]]rust-analyzer.workspace.symbol.search.scope (default: `"workspace"`)::
 +
 --
diff --git a/docs/user/manual.adoc b/docs/user/manual.adoc
index ad367511b..1f95df56e 100644
--- a/docs/user/manual.adoc
+++ b/docs/user/manual.adoc
@@ -139,18 +139,18 @@ $ cargo xtask install --server
 === rust-analyzer Language Server Binary
 Other editors generally require the `rust-analyzer` binary to be in `$PATH`.
-You can download the pre-built binary from the https://github.com/rust-analyzer/rust-analyzer/releases[releases] page.
+You can download pre-built binaries from the https://github.com/rust-analyzer/rust-analyzer/releases[releases] page.
-Typically, you then need to rename the binary for your platform, e.g. `rust-analyzer-mac` if you're on Mac OS, to `rust-analyzer` and make it executable in addition to moving it into a directory in your `$PATH`.
+You will need to uncompress and rename the binary for your platform, e.g. from `rust-analyzer-aarch64-apple-darwin.gz` on Mac OS to `rust-analyzer`, make it executable, then move it into a directory in your `$PATH`.
-On Linux to install the `rust-analyzer` binary into `~/.local/bin`, this commands could be used
+On Linux to install the `rust-analyzer` binary into `~/.local/bin`, these commands should work:
 [source,bash]
 ----
-$ curl -L https://github.com/rust-analyzer/rust-analyzer/releases/latest/download/rust-analyzer-linux -o ~/.local/bin/rust-analyzer
+$ curl -L https://github.com/rust-analyzer/rust-analyzer/releases/latest/download/rust-analyzer-x86_64-unknown-linux-gnu.gz | gunzip -c - > ~/.local/bin/rust-analyzer
 $ chmod +x ~/.local/bin/rust-analyzer
 ----
-Ensure `~/.local/bin` is listed in the `$PATH` variable.
+Make sure that `~/.local/bin` is listed in the `$PATH` variable and use the appropriate URL if you're not on a `x86-64` system.
 Alternatively, you can install it from source using the command below.
 You'll need the latest stable version of the Rust toolchain.
diff --git a/editors/code/package.json b/editors/code/package.json
index 17d9281ff..5b80cc1f9 100644
--- a/editors/code/package.json
+++ b/editors/code/package.json
@@ -597,7 +597,7 @@
                    "type": "object"
                },
                "rust-analyzer.diagnostics.warningsAsHint": {
-                    "markdownDescription": "List of warnings that should be displayed with info severity.\n\nThe warnings will be indicated by a blue squiggly underline in code\nand a blue icon in the `Problems Panel`.",
+                    "markdownDescription": "List of warnings that should be displayed with hint severity.\n\nThe warnings will be indicated by faded text or three dots in code\nand will not show up in the `Problems Panel`.",
                    "default": [],
                    "type": "array",
                    "items": {
@@ -605,7 +605,7 @@
                    }
                },
                "rust-analyzer.diagnostics.warningsAsInfo": {
-                    "markdownDescription": "List of warnings that should be displayed with hint severity.\n\nThe warnings will be indicated by faded text or three dots in code\nand will not show up in the `Problems Panel`.",
+                    "markdownDescription": "List of warnings that should be displayed with info severity.\n\nThe warnings will be indicated by a blue squiggly underline in code\nand a blue icon in the `Problems Panel`.",
                    "default": [],
                    "type": "array",
                    "items": {
@@ -795,6 +795,11 @@
                        "type": "string"
                    }
                },
+                "rust-analyzer.rustfmt.enableRangeFormatting": {
+                    "markdownDescription": "Enables the use of rustfmt's unstable range formatting command for the\n`textDocument/rangeFormatting` request. The rustfmt option is unstable and only\navailable on a nightly build.",
+                    "default": false,
+                    "type": "boolean"
+                },
                "rust-analyzer.workspace.symbol.search.scope": {
                    "markdownDescription": "Workspace symbol search scope.",
                    "default": "workspace",
diff --git a/editors/code/src/client.ts b/editors/code/src/client.ts
index 69dbe2535..f13ae07e1 100644
--- a/editors/code/src/client.ts
+++ b/editors/code/src/client.ts
@@ -32,14 +32,9 @@ export function createClient(serverPath: string, workspace: Workspace, extraEnv:
    const newEnv = Object.assign({}, process.env);
    Object.assign(newEnv, extraEnv);
-    let cwd = undefined;
-    if (workspace.kind === "Workspace Folder") {
-        cwd = workspace.folder.fsPath;
-    };
    const run: lc.Executable = {
        command: serverPath,
-        options: { cwd, env: newEnv },
+        options: { env: newEnv },
    };
    const serverOptions: lc.ServerOptions = {
        run,
diff --git a/editors/code/src/ctx.ts b/editors/code/src/ctx.ts
index 22c5f62a1..cf67dd8cf 100644
--- a/editors/code/src/ctx.ts
+++ b/editors/code/src/ctx.ts
@@ -10,7 +10,6 @@ import { ServerStatusParams } from './lsp_ext';
 export type Workspace =
    {
        kind: 'Workspace Folder';
-        folder: vscode.Uri;
    }
    | {
        kind: 'Detached Files';
diff --git a/editors/code/src/main.ts b/editors/code/src/main.ts
index b735186fe..d26273246 100644
--- a/editors/code/src/main.ts
+++ b/editors/code/src/main.ts
@@ -45,8 +45,7 @@ async function tryActivate(context: vscode.ExtensionContext) {
        throw new Error(message);
    });
-    const workspaceFolder = vscode.workspace.workspaceFolders?.[0];
+    if (vscode.workspace.workspaceFolders?.length === 0) {
-    if (workspaceFolder === undefined) {
        const rustDocuments = vscode.workspace.textDocuments.filter(document => isRustDocument(document));
        if (rustDocuments.length > 0) {
            ctx = await Ctx.create(config, context, serverPath, { kind: 'Detached Files', files: rustDocuments });
@@ -58,8 +57,8 @@ async function tryActivate(context: vscode.ExtensionContext) {
        // registers its `onDidChangeDocument` handler before us.
        //
        // This a horribly, horribly wrong way to deal with this problem.
-        ctx = await Ctx.create(config, context, serverPath, { kind: "Workspace Folder", folder: workspaceFolder.uri });
+        ctx = await Ctx.create(config, context, serverPath, { kind: "Workspace Folder" });
-        ctx.pushCleanup(activateTaskProvider(workspaceFolder, ctx.config));
+        ctx.pushCleanup(activateTaskProvider(ctx.config));
    }
    await initCommonContext(context, ctx);
diff --git a/editors/code/src/run.ts b/editors/code/src/run.ts
index 138e3f686..d0be84068 100644
--- a/editors/code/src/run.ts
+++ b/editors/code/src/run.ts
@@ -142,7 +142,11 @@ export async function createTask(runnable: ra.Runnable, config: Config): Promise
    // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
    const target = vscode.workspace.workspaceFolders![0]; // safe, see main activate()
    const cargoTask = await tasks.buildCargoTask(target, definition, runnable.label, args, config.cargoRunner, true);
    cargoTask.presentationOptions.clear = true;
+    // Sadly, this doesn't prevent focus stealing if the terminal is currently
+    // hidden, and will become revealed due to task exucution.
+    cargoTask.presentationOptions.focus = false;
    return cargoTask;
 }
diff --git a/editors/code/src/snippets.ts b/editors/code/src/snippets.ts
index 58f7aa128..a409e5296 100644
--- a/editors/code/src/snippets.ts
+++ b/editors/code/src/snippets.ts
@@ -52,7 +52,7 @@ export async function applySnippetTextEdits(editor: vscode.TextEditor, edits: vs
            } else {
                builder.replace(indel.range, indel.newText);
            }
-            lineDelta = countLines(indel.newText) - (indel.range.end.line - indel.range.start.line);
+            lineDelta += countLines(indel.newText) - (indel.range.end.line - indel.range.start.line);
        }
    });
    if (selections.length > 0) editor.selections = selections;
diff --git a/editors/code/src/tasks.ts b/editors/code/src/tasks.ts
index a3ff15102..694ee1e41 100644
--- a/editors/code/src/tasks.ts
+++ b/editors/code/src/tasks.ts
@@ -17,11 +17,9 @@ export interface CargoTaskDefinition extends vscode.TaskDefinition {
 }
 class CargoTaskProvider implements vscode.TaskProvider {
-    private readonly target: vscode.WorkspaceFolder;
    private readonly config: Config;
-    constructor(target: vscode.WorkspaceFolder, config: Config) {
+    constructor(config: Config) {
-        this.target = target;
        this.config = config;
    }
@@ -40,10 +38,12 @@ class CargoTaskProvider implements vscode.TaskProvider {
        ];
        const tasks: vscode.Task[] = [];
-        for (const def of defs) {
+        for (const workspaceTarget of vscode.workspace.workspaceFolders || []) {
-            const vscodeTask = await buildCargoTask(this.target, { type: TASK_TYPE, command: def.command }, `cargo ${def.command}`, [def.command], this.config.cargoRunner);
+            for (const def of defs) {
-            vscodeTask.group = def.group;
+                const vscodeTask = await buildCargoTask(workspaceTarget, { type: TASK_TYPE, command: def.command }, `cargo ${def.command}`, [def.command], this.config.cargoRunner);
-            tasks.push(vscodeTask);
+                vscodeTask.group = def.group;
+                tasks.push(vscodeTask);
+            }
        }
        return tasks;
@@ -58,14 +58,19 @@ class CargoTaskProvider implements vscode.TaskProvider {
        if (definition.type === TASK_TYPE && definition.command) {
            const args = [definition.command].concat(definition.args ?? []);
+            if (isWorkspaceFolder(task.scope)) {
-            return await buildCargoTask(this.target, definition, task.name, args, this.config.cargoRunner);
+                return await buildCargoTask(task.scope, definition, task.name, args, this.config.cargoRunner);
+            }
        }
        return undefined;
    }
 }
+function isWorkspaceFolder(scope?: any): scope is vscode.WorkspaceFolder {
+    return (scope as vscode.WorkspaceFolder).name !== undefined;
+}
 export async function buildCargoTask(
    target: vscode.WorkspaceFolder,
    definition: CargoTaskDefinition,
@@ -119,7 +124,7 @@ export async function buildCargoTask(
    );
 }
-export function activateTaskProvider(target: vscode.WorkspaceFolder, config: Config): vscode.Disposable {
+export function activateTaskProvider(config: Config): vscode.Disposable {
-    const provider = new CargoTaskProvider(target, config);
+    const provider = new CargoTaskProvider(config);
    return vscode.tasks.registerTaskProvider(TASK_TYPE, provider);
 }
diff --git a/xtask/src/dist.rs b/xtask/src/dist.rs
index 7ac9ae5b8..3a67294c5 100644
--- a/xtask/src/dist.rs
+++ b/xtask/src/dist.rs
@@ -67,7 +67,11 @@ fn dist_client(version: &str, release_tag: &str) -> Result<()> {
 fn dist_server(release_channel: &str) -> Result<()> {
    let _e = pushenv("RUST_ANALYZER_CHANNEL", release_channel);
    let _e = pushenv("CARGO_PROFILE_RELEASE_LTO", "thin");
-    let _e = pushenv("CARGO_PROFILE_RELEASE_DEBUG", "1");
+    // Uncomment to enable debug info for releases. Note that:
+    //   * debug info is split on windows and macs, so it does nothing for those platforms,
+    //   * on Linux, this blows up the binary size from 8MB to 43MB, which is unreasonable.
+    // let _e = pushenv("CARGO_PROFILE_RELEASE_DEBUG", "1");
    let target = get_target();
    if target.contains("-linux-gnu") || target.contains("-linux-musl") {
diff --git a/xtask/src/tidy.rs b/xtask/src/tidy.rs
index 82b33a7a0..6f687a788 100644
--- a/xtask/src/tidy.rs
+++ b/xtask/src/tidy.rs
@@ -275,6 +275,7 @@ fn check_todo(path: &Path, text: &str) {
        // Some of our assists generate `todo!()`.
        "handlers/add_turbo_fish.rs",
        "handlers/generate_function.rs",
+        "handlers/fill_match_arms.rs",
        // To support generating `todo!()` in assists, we have `expr_todo()` in
        // `ast::make`.
        "ast/make.rs",