259 files changed, 6376 insertions, 6100 deletions
diff --git a/Cargo.lock b/Cargo.lock
index 505263c64..e47b87964 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -245,9 +245,9 @@ dependencies = [
 [[package]]
 name = "cov-mark"
-version = "1.1.0"
+version = "2.0.0-pre.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9ffa3d3e0138386cd4361f63537765cac7ee40698028844635a54495a92f67f3"
+checksum = "0d48d8f76bd9331f19fe2aaf3821a9f9fb32c3963e1e3d6ce82a8c09cef7444a"
 [[package]]
 name = "crc32fast"
@@ -482,6 +482,7 @@ dependencies = [
 "hir_ty",
 "itertools",
 "log",
+ "once_cell",
 "profile",
 "rustc-hash",
 "smallvec",
@@ -765,9 +766,9 @@ checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
 [[package]]
 name = "libc"
-version = "0.2.95"
+version = "0.2.97"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "789da6d93f1b866ffe175afc5322a4d76c038605a1c3319bb57b06967ca98a36"
+checksum = "12b8adadd720df158f4d70dfe7ccc6adb0472d7c55ca83445f6a5ab3e36f8fb6"
 [[package]]
 name = "libloading"
@@ -1158,6 +1159,15 @@ dependencies = [
 [[package]]
 name = "proc_macro_test"
 version = "0.0.0"
+dependencies = [
+ "cargo_metadata",
+ "proc_macro_test_impl",
+ "toolchain",
+]
+[[package]]
+name = "proc_macro_test_impl"
+version = "0.0.0"
 [[package]]
 name = "profile"
@@ -1170,6 +1180,7 @@ dependencies = [
 "once_cell",
 "perf-event",
 "tikv-jemalloc-ctl",
+ "winapi",
 ]
 [[package]]
@@ -1792,9 +1803,9 @@ checksum = "56dee185309b50d1f11bfedef0fe6d036842e3fb77413abef29f8f8d1c5d4c1c"
 [[package]]
 name = "ungrammar"
-version = "1.13.0"
+version = "1.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "76760314176cc2b94047af2f921b92c39f11a34dc05c43a3c2b0fc91cb22959f"
+checksum = "50ef6d7335c77ec3e4a7c4be74c2b9e4642569e94a4004c836f8cca71fede3a7"
 [[package]]
 name = "unicase"
diff --git a/Cargo.toml b/Cargo.toml
index 32ba3923b..4d6908fa9 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,7 @@
 [workspace]
 resolver = "2"
 members = ["xtask/", "lib/*", "crates/*"]
+exclude = ["crates/proc_macro_test/imp"]
 [profile.dev]
 # Disabling debug info speeds up builds a bunch,
diff --git a/crates/base_db/src/fixture.rs b/crates/base_db/src/fixture.rs
index 69ceba735..da4afb5eb 100644
--- a/crates/base_db/src/fixture.rs
+++ b/crates/base_db/src/fixture.rs
@@ -190,7 +190,7 @@ impl From<Fixture> for FileMeta {
            edition: f
                .edition
                .as_ref()
-                .map_or(Edition::Edition2018, |v| Edition::from_str(&v).unwrap()),
+                .map_or(Edition::Edition2018, |v| Edition::from_str(v).unwrap()),
            env: f.env.into_iter().collect(),
            introduce_new_source_root: f.introduce_new_source_root,
        }
diff --git a/crates/base_db/src/lib.rs b/crates/base_db/src/lib.rs
index 62bf2a4b2..d26f8f180 100644
--- a/crates/base_db/src/lib.rs
+++ b/crates/base_db/src/lib.rs
@@ -42,7 +42,7 @@ pub struct FilePosition {
    pub offset: TextSize,
 }
-#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
 pub struct FileRange {
    pub file_id: FileId,
    pub range: TextRange,
@@ -120,6 +120,7 @@ impl<T: SourceDatabaseExt> FileLoader for FileLoaderDelegate<&'_ T> {
    }
    fn relevant_crates(&self, file_id: FileId) -> Arc<FxHashSet<CrateId>> {
+        let _p = profile::span("relevant_crates");
        let source_root = self.0.file_source_root(file_id);
        self.0.source_root_crates(source_root)
    }
diff --git a/crates/hir/Cargo.toml b/crates/hir/Cargo.toml
index 560b15238..7c148fd40 100644
--- a/crates/hir/Cargo.toml
+++ b/crates/hir/Cargo.toml
@@ -16,6 +16,7 @@ either = "1.5.3"
 arrayvec = "0.7"
 itertools = "0.10.0"
 smallvec = "1.4.0"
+once_cell = "1"
 stdx = { path = "../stdx", version = "0.0.0" }
 syntax = { path = "../syntax", version = "0.0.0" }
diff --git a/crates/hir/src/diagnostics.rs b/crates/hir/src/diagnostics.rs
index 2cdbd172a..b4c505898 100644
--- a/crates/hir/src/diagnostics.rs
+++ b/crates/hir/src/diagnostics.rs
@@ -3,251 +3,152 @@
 //!
 //! This probably isn't the best way to do this -- ideally, diagnistics should
 //! be expressed in terms of hir types themselves.
-use std::any::Any;
+use cfg::{CfgExpr, CfgOptions};
+use either::Either;
-use cfg::{CfgExpr, CfgOptions, DnfExpr};
 use hir_def::path::ModPath;
-use hir_expand::{HirFileId, InFile};
+use hir_expand::{name::Name, HirFileId, InFile};
-use stdx::format_to;
 use syntax::{ast, AstPtr, SyntaxNodePtr, TextRange};
-pub use hir_ty::{
+macro_rules! diagnostics {
-    diagnostics::{
+    ($($diag:ident,)*) => {
-        IncorrectCase, MismatchedArgCount, MissingFields, MissingMatchArms,
+        pub enum AnyDiagnostic {$(
-        MissingOkOrSomeInTailExpr, NoSuchField, RemoveThisSemicolon,
+            $diag(Box<$diag>),
-        ReplaceFilterMapNextWithFindMap,
+        )*}
-    },
-    diagnostics_sink::{Diagnostic, DiagnosticCode, DiagnosticSink, DiagnosticSinkBuilder},
+        $(
-};
+            impl From<$diag> for AnyDiagnostic {
+                fn from(d: $diag) -> AnyDiagnostic {
-// Diagnostic: unresolved-module
+                    AnyDiagnostic::$diag(Box::new(d))
-//
+                }
-// This diagnostic is triggered if rust-analyzer is unable to discover referred module.
+            }
+        )*
+    };
+}
+diagnostics![
+    BreakOutsideOfLoop,
+    InactiveCode,
+    IncorrectCase,
+    MacroError,
+    MismatchedArgCount,
+    MissingFields,
+    MissingMatchArms,
+    MissingOkOrSomeInTailExpr,
+    MissingUnsafe,
+    NoSuchField,
+    RemoveThisSemicolon,
+    ReplaceFilterMapNextWithFindMap,
+    UnimplementedBuiltinMacro,
+    UnresolvedExternCrate,
+    UnresolvedImport,
+    UnresolvedMacroCall,
+    UnresolvedModule,
+    UnresolvedProcMacro,
+];
 #[derive(Debug)]
 pub struct UnresolvedModule {
-    pub file: HirFileId,
+    pub decl: InFile<AstPtr<ast::Module>>,
-    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 decl: InFile<AstPtr<ast::ExternCrate>>,
-    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 decl: InFile<AstPtr<ast::UseTree>>,
-    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 macro_call: InFile<AstPtr<ast::MacroCall>>,
-    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: InFile<SyntaxNodePtr>,
-    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: InFile<SyntaxNodePtr>,
-    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 {
+#[derive(Debug, Clone, Eq, PartialEq)]
-    fn code(&self) -> DiagnosticCode {
+pub struct MacroError {
-        DiagnosticCode("unresolved-proc-macro")
+    pub node: InFile<SyntaxNodePtr>,
-    }
+    pub message: String,
+}
-    fn message(&self) -> String {
+#[derive(Debug)]
-        match &self.macro_name {
+pub struct UnimplementedBuiltinMacro {
-            Some(name) => format!("proc macro `{}` not expanded", name),
+    pub node: InFile<SyntaxNodePtr>,
-            None => "proc macro not expanded".to_string(),
+}
-        }
-    }
-    fn display_source(&self) -> InFile<SyntaxNodePtr> {
+#[derive(Debug)]
-        InFile::new(self.file, self.node.clone())
+pub struct NoSuchField {
-    }
+    pub field: InFile<AstPtr<ast::RecordExprField>>,
+}
-    fn as_any(&self) -> &(dyn Any + Send + 'static) {
+#[derive(Debug)]
-        self
+pub struct BreakOutsideOfLoop {
-    }
+    pub expr: InFile<AstPtr<ast::Expr>>,
 }
-// Diagnostic: macro-error
+#[derive(Debug)]
-//
+pub struct MissingUnsafe {
-// This diagnostic is shown for macro expansion errors.
+    pub expr: InFile<AstPtr<ast::Expr>>,
-#[derive(Debug, Clone, Eq, PartialEq)]
-pub struct MacroError {
-    pub file: HirFileId,
-    pub node: SyntaxNodePtr,
-    pub message: String,
 }
-impl Diagnostic for MacroError {
+#[derive(Debug)]
-    fn code(&self) -> DiagnosticCode {
+pub struct MissingFields {
-        DiagnosticCode("macro-error")
+    pub file: HirFileId,
-    }
+    pub field_list_parent: Either<AstPtr<ast::RecordExpr>, AstPtr<ast::RecordPat>>,
-    fn message(&self) -> String {
+    pub field_list_parent_path: Option<AstPtr<ast::Path>>,
-        self.message.clone()
+    pub missed_fields: Vec<Name>,
-    }
-    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
-    }
 }
 #[derive(Debug)]
-pub struct UnimplementedBuiltinMacro {
+pub struct ReplaceFilterMapNextWithFindMap {
    pub file: HirFileId,
-    pub node: SyntaxNodePtr,
+    /// This expression is the whole method chain up to and including `.filter_map(..).next()`.
+    pub next_expr: AstPtr<ast::Expr>,
 }
-impl Diagnostic for UnimplementedBuiltinMacro {
+#[derive(Debug)]
-    fn code(&self) -> DiagnosticCode {
+pub struct MismatchedArgCount {
-        DiagnosticCode("unimplemented-builtin-macro")
+    pub call_expr: InFile<AstPtr<ast::Expr>>,
-    }
+    pub expected: usize,
+    pub found: usize,
+}
-    fn message(&self) -> String {
+#[derive(Debug)]
-        "unimplemented built-in macro".to_string()
+pub struct RemoveThisSemicolon {
-    }
+    pub expr: InFile<AstPtr<ast::Expr>>,
+}
-    fn display_source(&self) -> InFile<SyntaxNodePtr> {
+#[derive(Debug)]
-        InFile::new(self.file, self.node.clone())
+pub struct MissingOkOrSomeInTailExpr {
-    }
+    pub expr: InFile<AstPtr<ast::Expr>>,
+    // `Some` or `Ok` depending on whether the return type is Result or Option
+    pub required: String,
+}
-    fn as_any(&self) -> &(dyn Any + Send + 'static) {
+#[derive(Debug)]
-        self
+pub struct MissingMatchArms {
-    }
+    pub file: HirFileId,
+    pub match_expr: AstPtr<ast::Expr>,
+    pub arms: AstPtr<ast::MatchArmList>,
 }
+pub use hir_ty::diagnostics::IncorrectCase;
diff --git a/crates/hir/src/lib.rs b/crates/hir/src/lib.rs
index 2ec568b26..5bc0b2338 100644
--- a/crates/hir/src/lib.rs
+++ b/crates/hir/src/lib.rs
@@ -35,14 +35,10 @@ use std::{iter, sync::Arc};
 use arrayvec::ArrayVec;
 use base_db::{CrateDisplayName, CrateId, Edition, FileId};
-use diagnostics::{
-    InactiveCode, MacroError, UnimplementedBuiltinMacro, UnresolvedExternCrate, UnresolvedImport,
-    UnresolvedMacroCall, UnresolvedModule, UnresolvedProcMacro,
-};
 use either::Either;
 use hir_def::{
    adt::{ReprKind, VariantData},
-    body::BodyDiagnostic,
+    body::{BodyDiagnostic, SyntheticSyntax},
    expr::{BindingAnnotation, LabelId, Pat, PatId},
    item_tree::ItemTreeNode,
    lang_item::LangItemTarget,
@@ -60,8 +56,8 @@ use hir_ty::{
    autoderef,
    consteval::ConstExt,
    could_unify,
-    diagnostics_sink::DiagnosticSink,
+    diagnostics::BodyValidationDiagnostic,
-    method_resolution::{self, def_crates, TyFingerprint},
+    method_resolution::{self, TyFingerprint},
    primitive::UintTy,
    subst_prefix,
    traits::FnTrait,
@@ -72,6 +68,7 @@ use hir_ty::{
 };
 use itertools::Itertools;
 use nameres::diagnostics::DefDiagnosticKind;
+use once_cell::unsync::Lazy;
 use rustc_hash::FxHashSet;
 use stdx::{format_to, impl_from};
 use syntax::{
@@ -84,6 +81,13 @@ use crate::db::{DefDatabase, HirDatabase};
 pub use crate::{
    attrs::{HasAttrs, Namespace},
+    diagnostics::{
+        AnyDiagnostic, BreakOutsideOfLoop, InactiveCode, IncorrectCase, MacroError,
+        MismatchedArgCount, MissingFields, MissingMatchArms, MissingOkOrSomeInTailExpr,
+        MissingUnsafe, NoSuchField, RemoveThisSemicolon, ReplaceFilterMapNextWithFindMap,
+        UnimplementedBuiltinMacro, UnresolvedExternCrate, UnresolvedImport, UnresolvedMacroCall,
+        UnresolvedModule, UnresolvedProcMacro,
+    },
    has_source::HasSource,
    semantics::{PathResolution, Semantics, SemanticsScope},
 };
@@ -191,6 +195,7 @@ impl Crate {
        db: &dyn DefDatabase,
        query: import_map::Query,
    ) -> impl Iterator<Item = Either<ModuleDef, MacroDef>> {
+        let _p = profile::span("query_external_importables");
        import_map::search_dependencies(db, self.into(), query).into_iter().map(|item| match item {
            ItemInNs::Types(mod_id) | ItemInNs::Values(mod_id) => Either::Left(mod_id.into()),
            ItemInNs::Macros(mac_id) => Either::Right(mac_id.into()),
@@ -331,7 +336,7 @@ impl ModuleDef {
        }
    }
-    pub fn diagnostics(self, db: &dyn HirDatabase, sink: &mut DiagnosticSink) {
+    pub fn diagnostics(self, db: &dyn HirDatabase) -> Vec<AnyDiagnostic> {
        let id = match self {
            ModuleDef::Adt(it) => match it {
                Adt::Struct(it) => it.id.into(),
@@ -344,15 +349,19 @@ impl ModuleDef {
            ModuleDef::Module(it) => it.id.into(),
            ModuleDef::Const(it) => it.id.into(),
            ModuleDef::Static(it) => it.id.into(),
-            _ => return,
+            _ => return Vec::new(),
        };
        let module = match self.module(db) {
            Some(it) => it,
-            None => return,
+            None => return Vec::new(),
        };
-        hir_ty::diagnostics::validate_module_item(db, module.id.krate(), id, sink)
+        let mut acc = Vec::new();
+        for diag in hir_ty::diagnostics::validate_module_item(db, module.id.krate(), id) {
+            acc.push(diag.into())
+        }
+        acc
    }
 }
@@ -441,10 +450,10 @@ impl Module {
    }
    pub fn visibility_of(self, db: &dyn HirDatabase, def: &ModuleDef) -> Option<Visibility> {
-        self.id.def_map(db.upcast())[self.id.local_id].scope.visibility_of(def.clone().into())
+        self.id.def_map(db.upcast())[self.id.local_id].scope.visibility_of((*def).into())
    }
-    pub fn diagnostics(self, db: &dyn HirDatabase, sink: &mut DiagnosticSink) {
+    pub fn diagnostics(self, db: &dyn HirDatabase, acc: &mut Vec<AnyDiagnostic>) {
        let _p = profile::span("Module::diagnostics").detail(|| {
            format!("{:?}", self.name(db).map_or("<unknown>".into(), |name| name.to_string()))
        });
@@ -457,18 +466,22 @@ impl Module {
            match &diag.kind {
                DefDiagnosticKind::UnresolvedModule { ast: declaration, candidate } => {
                    let decl = declaration.to_node(db.upcast());
-                    sink.push(UnresolvedModule {
+                    acc.push(
-                        file: declaration.file_id,
+                        UnresolvedModule {
-                        decl: AstPtr::new(&decl),
+                            decl: InFile::new(declaration.file_id, AstPtr::new(&decl)),
-                        candidate: candidate.clone(),
+                            candidate: candidate.clone(),
-                    })
+                        }
+                        .into(),
+                    )
                }
                DefDiagnosticKind::UnresolvedExternCrate { ast } => {
                    let item = ast.to_node(db.upcast());
-                    sink.push(UnresolvedExternCrate {
+                    acc.push(
-                        file: ast.file_id,
+                        UnresolvedExternCrate {
-                        item: AstPtr::new(&item),
+                            decl: InFile::new(ast.file_id, AstPtr::new(&item)),
-                    });
+                        }
+                        .into(),
+                    );
                }
                DefDiagnosticKind::UnresolvedImport { id, index } => {
@@ -477,25 +490,30 @@ impl Module {
                    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) });
+                    acc.push(
+                        UnresolvedImport { decl: InFile::new(file_id, AstPtr::new(&use_tree)) }
+                            .into(),
+                    );
                }
                DefDiagnosticKind::UnconfiguredCode { ast, cfg, opts } => {
                    let item = ast.to_node(db.upcast());
-                    sink.push(InactiveCode {
+                    acc.push(
-                        file: ast.file_id,
+                        InactiveCode {
-                        node: AstPtr::new(&item).into(),
+                            node: ast.with_value(AstPtr::new(&item).into()),
-                        cfg: cfg.clone(),
+                            cfg: cfg.clone(),
-                        opts: opts.clone(),
+                            opts: opts.clone(),
-                    });
+                        }
+                        .into(),
+                    );
                }
                DefDiagnosticKind::UnresolvedProcMacro { ast } => {
                    let mut precise_location = None;
-                    let (file, ast, name) = match ast {
+                    let (node, 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)
+                            (ast_id.with_value(SyntaxNodePtr::from(AstPtr::new(&node))), None)
                        }
                        MacroCallKind::Derive { ast_id, derive_name, .. } => {
                            let node = ast_id.to_node(db.upcast());
@@ -528,8 +546,7 @@ impl Module {
                            }
                            (
-                                ast_id.file_id,
+                                ast_id.with_value(SyntaxNodePtr::from(AstPtr::new(&node))),
-                                SyntaxNodePtr::from(AstPtr::new(&node)),
                                Some(derive_name.clone()),
                            )
                        }
@@ -540,73 +557,73 @@ impl Module {
                                    || panic!("cannot find attribute #{}", invoc_attr_index),
                                );
                            (
-                                ast_id.file_id,
+                                ast_id.with_value(SyntaxNodePtr::from(AstPtr::new(&attr))),
-                                SyntaxNodePtr::from(AstPtr::new(&attr)),
                                Some(attr_name.clone()),
                            )
                        }
                    };
-                    sink.push(UnresolvedProcMacro {
+                    acc.push(
-                        file,
+                        UnresolvedProcMacro { node, precise_location, macro_name: name }.into(),
-                        node: ast,
+                    );
-                        precise_location,
-                        macro_name: name,
-                    });
                }
                DefDiagnosticKind::UnresolvedMacroCall { ast, path } => {
                    let node = ast.to_node(db.upcast());
-                    sink.push(UnresolvedMacroCall {
+                    acc.push(
-                        file: ast.file_id,
+                        UnresolvedMacroCall {
-                        node: AstPtr::new(&node),
+                            macro_call: InFile::new(ast.file_id, AstPtr::new(&node)),
-                        path: path.clone(),
+                            path: path.clone(),
-                    });
+                        }
+                        .into(),
+                    );
                }
                DefDiagnosticKind::MacroError { ast, message } => {
-                    let (file, ast) = match ast {
+                    let node = match ast {
                        MacroCallKind::FnLike { ast_id, .. } => {
                            let node = ast_id.to_node(db.upcast());
-                            (ast_id.file_id, SyntaxNodePtr::from(AstPtr::new(&node)))
+                            ast_id.with_value(SyntaxNodePtr::from(AstPtr::new(&node)))
                        }
                        MacroCallKind::Derive { ast_id, .. }
                        | MacroCallKind::Attr { ast_id, .. } => {
                            // FIXME: point to the attribute instead, this creates very large diagnostics
                            let node = ast_id.to_node(db.upcast());
-                            (ast_id.file_id, SyntaxNodePtr::from(AstPtr::new(&node)))
+                            ast_id.with_value(SyntaxNodePtr::from(AstPtr::new(&node)))
                        }
                    };
-                    sink.push(MacroError { file, node: ast, message: message.clone() });
+                    acc.push(MacroError { node, message: message.clone() }.into());
                }
                DefDiagnosticKind::UnimplementedBuiltinMacro { ast } => {
                    let node = ast.to_node(db.upcast());
                    // Must have a name, otherwise we wouldn't emit it.
                    let name = node.name().expect("unimplemented builtin macro with no name");
-                    let ptr = SyntaxNodePtr::from(AstPtr::new(&name));
+                    acc.push(
-                    sink.push(UnimplementedBuiltinMacro { file: ast.file_id, node: ptr });
+                        UnimplementedBuiltinMacro {
+                            node: ast.with_value(SyntaxNodePtr::from(AstPtr::new(&name))),
+                        }
+                        .into(),
+                    );
                }
            }
        }
        for decl in self.declarations(db) {
            match decl {
-                crate::ModuleDef::Function(f) => f.diagnostics(db, sink),
+                ModuleDef::Function(f) => f.diagnostics(db, acc),
-                crate::ModuleDef::Module(m) => {
+                ModuleDef::Module(m) => {
                    // Only add diagnostics from inline modules
                    if def_map[m.id.local_id].origin.is_inline() {
-                        m.diagnostics(db, sink)
+                        m.diagnostics(db, acc)
                    }
                }
-                _ => {
+                _ => acc.extend(decl.diagnostics(db)),
-                    decl.diagnostics(db, sink);
-                }
            }
        }
        for impl_def in self.impl_defs(db) {
            for item in impl_def.items(db) {
                if let AssocItem::Function(f) = item {
-                    f.diagnostics(db, sink);
+                    f.diagnostics(db, acc);
                }
            }
        }
@@ -1008,41 +1025,191 @@ impl Function {
        db.function_data(self.id).is_async()
    }
-    pub fn diagnostics(self, db: &dyn HirDatabase, sink: &mut DiagnosticSink) {
+    pub fn diagnostics(self, db: &dyn HirDatabase, acc: &mut Vec<AnyDiagnostic>) {
        let krate = self.module(db).id.krate();
        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 {
+                BodyDiagnostic::InactiveCode { node, cfg, opts } => acc.push(
-                    file: node.file_id,
+                    InactiveCode { node: node.clone(), cfg: cfg.clone(), opts: opts.clone() }
-                    node: node.value.clone(),
+                        .into(),
-                    cfg: cfg.clone(),
+                ),
-                    opts: opts.clone(),
+                BodyDiagnostic::MacroError { node, message } => acc.push(
-                }),
+                    MacroError {
-                BodyDiagnostic::MacroError { node, message } => sink.push(MacroError {
+                        node: node.clone().map(|it| it.into()),
-                    file: node.file_id,
+                        message: message.to_string(),
-                    node: node.value.clone().into(),
+                    }
-                    message: message.to_string(),
+                    .into(),
-                }),
+                ),
-                BodyDiagnostic::UnresolvedProcMacro { node } => sink.push(UnresolvedProcMacro {
+                BodyDiagnostic::UnresolvedProcMacro { node } => acc.push(
-                    file: node.file_id,
+                    UnresolvedProcMacro {
-                    node: node.value.clone().into(),
+                        node: node.clone().map(|it| it.into()),
-                    precise_location: None,
+                        precise_location: None,
-                    macro_name: None,
+                        macro_name: None,
-                }),
+                    }
-                BodyDiagnostic::UnresolvedMacroCall { node, path } => {
+                    .into(),
-                    sink.push(UnresolvedMacroCall {
+                ),
-                        file: node.file_id,
+                BodyDiagnostic::UnresolvedMacroCall { node, path } => acc.push(
-                        node: node.value.clone(),
+                    UnresolvedMacroCall { macro_call: node.clone(), path: path.clone() }.into(),
-                        path: path.clone(),
+                ),
-                    })
+            }
+        }
+        let infer = db.infer(self.id.into());
+        let source_map = Lazy::new(|| db.body_with_source_map(self.id.into()).1);
+        for d in &infer.diagnostics {
+            match d {
+                hir_ty::InferenceDiagnostic::NoSuchField { expr } => {
+                    let field = source_map.field_syntax(*expr);
+                    acc.push(NoSuchField { field }.into())
+                }
+                hir_ty::InferenceDiagnostic::BreakOutsideOfLoop { expr } => {
+                    let expr = source_map
+                        .expr_syntax(*expr)
+                        .expect("break outside of loop in synthetic syntax");
+                    acc.push(BreakOutsideOfLoop { expr }.into())
+                }
+            }
+        }
+        for expr in hir_ty::diagnostics::missing_unsafe(db, self.id.into()) {
+            match source_map.expr_syntax(expr) {
+                Ok(expr) => acc.push(MissingUnsafe { expr }.into()),
+                Err(SyntheticSyntax) => {
+                    // FIXME: Here and eslwhere in this file, the `expr` was
+                    // desugared, report or assert that this doesn't happen.
+                }
+            }
+        }
+        for diagnostic in BodyValidationDiagnostic::collect(db, self.id.into()) {
+            match diagnostic {
+                BodyValidationDiagnostic::RecordMissingFields {
+                    record,
+                    variant,
+                    missed_fields,
+                } => {
+                    let variant_data = variant.variant_data(db.upcast());
+                    let missed_fields = missed_fields
+                        .into_iter()
+                        .map(|idx| variant_data.fields()[idx].name.clone())
+                        .collect();
+                    match record {
+                        Either::Left(record_expr) => match source_map.expr_syntax(record_expr) {
+                            Ok(source_ptr) => {
+                                let root = source_ptr.file_syntax(db.upcast());
+                                if let ast::Expr::RecordExpr(record_expr) =
+                                    &source_ptr.value.to_node(&root)
+                                {
+                                    if let Some(_) = record_expr.record_expr_field_list() {
+                                        acc.push(
+                                            MissingFields {
+                                                file: source_ptr.file_id,
+                                                field_list_parent: Either::Left(AstPtr::new(
+                                                    record_expr,
+                                                )),
+                                                field_list_parent_path: record_expr
+                                                    .path()
+                                                    .map(|path| AstPtr::new(&path)),
+                                                missed_fields,
+                                            }
+                                            .into(),
+                                        )
+                                    }
+                                }
+                            }
+                            Err(SyntheticSyntax) => (),
+                        },
+                        Either::Right(record_pat) => match source_map.pat_syntax(record_pat) {
+                            Ok(source_ptr) => {
+                                if let Some(expr) = source_ptr.value.as_ref().left() {
+                                    let root = source_ptr.file_syntax(db.upcast());
+                                    if let ast::Pat::RecordPat(record_pat) = expr.to_node(&root) {
+                                        if let Some(_) = record_pat.record_pat_field_list() {
+                                            acc.push(
+                                                MissingFields {
+                                                    file: source_ptr.file_id,
+                                                    field_list_parent: Either::Right(AstPtr::new(
+                                                        &record_pat,
+                                                    )),
+                                                    field_list_parent_path: record_pat
+                                                        .path()
+                                                        .map(|path| AstPtr::new(&path)),
+                                                    missed_fields,
+                                                }
+                                                .into(),
+                                            )
+                                        }
+                                    }
+                                }
+                            }
+                            Err(SyntheticSyntax) => (),
+                        },
+                    }
+                }
+                BodyValidationDiagnostic::ReplaceFilterMapNextWithFindMap { method_call_expr } => {
+                    if let Ok(next_source_ptr) = source_map.expr_syntax(method_call_expr) {
+                        acc.push(
+                            ReplaceFilterMapNextWithFindMap {
+                                file: next_source_ptr.file_id,
+                                next_expr: next_source_ptr.value,
+                            }
+                            .into(),
+                        );
+                    }
+                }
+                BodyValidationDiagnostic::MismatchedArgCount { call_expr, expected, found } => {
+                    match source_map.expr_syntax(call_expr) {
+                        Ok(source_ptr) => acc.push(
+                            MismatchedArgCount { call_expr: source_ptr, expected, found }.into(),
+                        ),
+                        Err(SyntheticSyntax) => (),
+                    }
+                }
+                BodyValidationDiagnostic::RemoveThisSemicolon { expr } => {
+                    match source_map.expr_syntax(expr) {
+                        Ok(expr) => acc.push(RemoveThisSemicolon { expr }.into()),
+                        Err(SyntheticSyntax) => (),
+                    }
+                }
+                BodyValidationDiagnostic::MissingOkOrSomeInTailExpr { expr, required } => {
+                    match source_map.expr_syntax(expr) {
+                        Ok(expr) => acc.push(MissingOkOrSomeInTailExpr { expr, required }.into()),
+                        Err(SyntheticSyntax) => (),
+                    }
+                }
+                BodyValidationDiagnostic::MissingMatchArms { match_expr } => {
+                    match source_map.expr_syntax(match_expr) {
+                        Ok(source_ptr) => {
+                            let root = source_ptr.file_syntax(db.upcast());
+                            if let ast::Expr::MatchExpr(match_expr) =
+                                &source_ptr.value.to_node(&root)
+                            {
+                                if let (Some(match_expr), Some(arms)) =
+                                    (match_expr.expr(), match_expr.match_arm_list())
+                                {
+                                    acc.push(
+                                        MissingMatchArms {
+                                            file: source_ptr.file_id,
+                                            match_expr: AstPtr::new(&match_expr),
+                                            arms: AstPtr::new(&arms),
+                                        }
+                                        .into(),
+                                    )
+                                }
+                            }
+                        }
+                        Err(SyntheticSyntax) => (),
+                    }
                }
            }
        }
-        hir_ty::diagnostics::validate_module_item(db, krate, self.id.into(), sink);
+        for diag in hir_ty::diagnostics::validate_module_item(db, krate, self.id.into()) {
-        hir_ty::diagnostics::validate_body(db, self.id.into(), sink);
+            acc.push(diag.into())
+        }
    }
    /// Whether this function declaration has a definition.
@@ -1450,6 +1617,20 @@ impl AssocItem {
            _ => None,
        }
    }
+    pub fn containing_trait_impl(self, db: &dyn HirDatabase) -> Option<Trait> {
+        match self.container(db) {
+            AssocItemContainer::Impl(i) => i.trait_(db),
+            _ => None,
+        }
+    }
+    pub fn containing_trait_or_trait_impl(self, db: &dyn HirDatabase) -> Option<Trait> {
+        match self.container(db) {
+            AssocItemContainer::Trait(t) => Some(t),
+            AssocItemContainer::Impl(i) => i.trait_(db),
+        }
+    }
 }
 impl HasVisibility for AssocItem {
@@ -1747,7 +1928,7 @@ impl Impl {
    }
    pub fn all_for_type(db: &dyn HirDatabase, Type { krate, ty, .. }: Type) -> Vec<Impl> {
-        let def_crates = match def_crates(db, &ty, krate) {
+        let def_crates = match method_resolution::def_crates(db, &ty, krate) {
            Some(def_crates) => def_crates,
            None => return Vec::new(),
        };
@@ -2153,7 +2334,7 @@ impl Type {
        krate: Crate,
        mut callback: impl FnMut(AssocItem) -> Option<T>,
    ) -> Option<T> {
-        for krate in def_crates(db, &self.ty, krate.id)? {
+        for krate in method_resolution::def_crates(db, &self.ty, krate.id)? {
            let impls = db.inherent_impls_in_crate(krate);
            for impl_def in impls.for_self_ty(&self.ty) {
@@ -2185,6 +2366,7 @@ impl Type {
        name: Option<&Name>,
        mut callback: impl FnMut(&Ty, Function) -> Option<T>,
    ) -> Option<T> {
+        let _p = profile::span("iterate_method_candidates");
        // There should be no inference vars in types passed here
        // FIXME check that?
        // FIXME replace Unknown by bound vars here
@@ -2218,6 +2400,7 @@ impl Type {
        name: Option<&Name>,
        mut callback: impl FnMut(&Ty, AssocItem) -> Option<T>,
    ) -> Option<T> {
+        let _p = profile::span("iterate_path_candidates");
        let canonical = hir_ty::replace_errors_with_variables(&self.ty);
        let env = self.env.clone();
@@ -2255,6 +2438,7 @@ impl Type {
        &'a self,
        db: &'a dyn HirDatabase,
    ) -> impl Iterator<Item = Trait> + 'a {
+        let _p = profile::span("applicable_inherent_traits");
        self.autoderef(db)
            .filter_map(|derefed_type| derefed_type.ty.dyn_trait())
            .flat_map(move |dyn_trait_id| hir_ty::all_super_traits(db.upcast(), dyn_trait_id))
@@ -2327,13 +2511,13 @@ impl Type {
            match ty.kind(&Interner) {
                TyKind::Adt(_, substs) => {
                    cb(type_.derived(ty.clone()));
-                    walk_substs(db, type_, &substs, cb);
+                    walk_substs(db, type_, substs, cb);
                }
                TyKind::AssociatedType(_, substs) => {
                    if let Some(_) = ty.associated_type_parent_trait(db) {
                        cb(type_.derived(ty.clone()));
                    }
-                    walk_substs(db, type_, &substs, cb);
+                    walk_substs(db, type_, substs, cb);
                }
                TyKind::OpaqueType(_, subst) => {
                    if let Some(bounds) = ty.impl_trait_bounds(db) {
@@ -2373,7 +2557,7 @@ impl Type {
                TyKind::FnDef(_, substs)
                | TyKind::Tuple(_, substs)
                | TyKind::Closure(.., substs) => {
-                    walk_substs(db, type_, &substs, cb);
+                    walk_substs(db, type_, substs, cb);
                }
                TyKind::Function(hir_ty::FnPointer { substitution, .. }) => {
                    walk_substs(db, type_, &substitution.0, cb);
diff --git a/crates/hir/src/semantics.rs b/crates/hir/src/semantics.rs
index d522d5245..613266e07 100644
--- a/crates/hir/src/semantics.rs
+++ b/crates/hir/src/semantics.rs
@@ -192,7 +192,7 @@ impl<'db, DB: HirDatabase> Semantics<'db, DB> {
        node: &SyntaxNode,
        offset: TextSize,
    ) -> Option<N> {
-        if let Some(it) = find_node_at_offset(&node, offset) {
+        if let Some(it) = find_node_at_offset(node, offset) {
            return Some(it);
        }
@@ -744,7 +744,7 @@ impl<'db> SemanticsImpl<'db> {
                    return None;
                }
-                let func = self.resolve_method_call(&method_call_expr).map(Function::from)?;
+                let func = self.resolve_method_call(method_call_expr).map(Function::from)?;
                let res = match func.self_param(self.db)?.access(self.db) {
                    Access::Shared | Access::Exclusive => true,
                    Access::Owned => false,
diff --git a/crates/hir/src/source_analyzer.rs b/crates/hir/src/source_analyzer.rs
index 37a050415..c9744d81d 100644
--- a/crates/hir/src/source_analyzer.rs
+++ b/crates/hir/src/source_analyzer.rs
@@ -222,7 +222,7 @@ impl SourceAnalyzer {
            Pat::Path(path) => path,
            _ => return None,
        };
-        let res = resolve_hir_path(db, &self.resolver, &path)?;
+        let res = resolve_hir_path(db, &self.resolver, path)?;
        match res {
            PathResolution::Def(def) => Some(def),
            _ => None,
@@ -329,7 +329,7 @@ impl SourceAnalyzer {
        let (variant, missing_fields, _exhaustive) =
            record_literal_missing_fields(db, infer, expr_id, &body[expr_id])?;
-        let res = self.missing_fields(db, krate, &substs, variant, missing_fields);
+        let res = self.missing_fields(db, krate, substs, variant, missing_fields);
        Some(res)
    }
@@ -347,7 +347,7 @@ impl SourceAnalyzer {
        let (variant, missing_fields, _exhaustive) =
            record_pattern_missing_fields(db, infer, pat_id, &body[pat_id])?;
-        let res = self.missing_fields(db, krate, &substs, variant, missing_fields);
+        let res = self.missing_fields(db, krate, substs, variant, missing_fields);
        Some(res)
    }
diff --git a/crates/hir_def/Cargo.toml b/crates/hir_def/Cargo.toml
index 43324d8d9..bb86f6a73 100644
--- a/crates/hir_def/Cargo.toml
+++ b/crates/hir_def/Cargo.toml
@@ -10,7 +10,7 @@ edition = "2018"
 doctest = false
 [dependencies]
-cov-mark = { version = "1.1", features = ["thread-local"] }
+cov-mark = "2.0.0-pre.1"
 dashmap = { version = "4.0.2", features = ["raw-api"] }
 log = "0.4.8"
 once_cell = "1.3.1"
diff --git a/crates/hir_def/src/attr.rs b/crates/hir_def/src/attr.rs
index 3886b6c04..d07adb084 100644
--- a/crates/hir_def/src/attr.rs
+++ b/crates/hir_def/src/attr.rs
@@ -106,7 +106,9 @@ impl RawAttrs {
    ) -> Self {
        let entries = collect_attrs(owner)
            .flat_map(|(id, attr)| match attr {
-                Either::Left(attr) => Attr::from_src(db, attr, hygiene, id),
+                Either::Left(attr) => {
+                    attr.meta().and_then(|meta| Attr::from_src(db, meta, hygiene, id))
+                }
                Either::Right(comment) => comment.doc_comment().map(|doc| Attr {
                    id,
                    input: Some(Interned::new(AttrInput::Literal(SmolStr::new(doc)))),
@@ -172,10 +174,9 @@ impl RawAttrs {
                let index = attr.id;
                let attrs = parts.filter(|a| !a.is_empty()).filter_map(|attr| {
                    let tree = Subtree { delimiter: None, token_trees: attr.to_vec() };
-                    let attr = ast::Attr::parse(&format!("#[{}]", tree)).ok()?;
                    // FIXME hygiene
                    let hygiene = Hygiene::new_unhygienic();
-                    Attr::from_src(db, attr, &hygiene, index)
+                    Attr::from_tt(db, &tree, &hygiene, index)
                });
                let cfg_options = &crate_graph[krate].cfg_options;
@@ -582,13 +583,13 @@ impl AttrSourceMap {
                .get(id.ast_index as usize)
                .unwrap_or_else(|| panic!("cannot find doc comment at index {:?}", id))
                .clone()
-                .map(|attr| Either::Right(attr))
+                .map(Either::Right)
        } else {
            self.attrs
                .get(id.ast_index as usize)
                .unwrap_or_else(|| panic!("cannot find `Attr` at index {:?}", id))
                .clone()
-                .map(|attr| Either::Left(attr))
+                .map(Either::Left)
        }
    }
 }
@@ -605,7 +606,7 @@ pub struct DocsRangeMap {
 impl DocsRangeMap {
    pub fn map(&self, range: TextRange) -> Option<InFile<TextRange>> {
        let found = self.mapping.binary_search_by(|(probe, ..)| probe.ordering(range)).ok()?;
-        let (line_docs_range, idx, original_line_src_range) = self.mapping[found].clone();
+        let (line_docs_range, idx, original_line_src_range) = self.mapping[found];
        if !line_docs_range.contains_range(range) {
            return None;
        }
@@ -664,7 +665,7 @@ impl fmt::Display for AttrInput {
 impl Attr {
    fn from_src(
        db: &dyn DefDatabase,
-        ast: ast::Attr,
+        ast: ast::Meta,
        hygiene: &Hygiene,
        id: AttrId,
    ) -> Option<Attr> {
@@ -683,6 +684,19 @@ impl Attr {
        Some(Attr { id, path, input })
    }
+    fn from_tt(
+        db: &dyn DefDatabase,
+        tt: &tt::Subtree,
+        hygiene: &Hygiene,
+        id: AttrId,
+    ) -> Option<Attr> {
+        let (parse, _) =
+            mbe::token_tree_to_syntax_node(tt, hir_expand::FragmentKind::MetaItem).ok()?;
+        let ast = ast::Meta::cast(parse.syntax_node())?;
+        Self::from_src(db, ast, hygiene, id)
+    }
    /// Parses this attribute as a `#[derive]`, returns an iterator that yields all contained paths
    /// to derive macros.
    ///
diff --git a/crates/hir_def/src/body/lower.rs b/crates/hir_def/src/body/lower.rs
index da1fdac33..bed4c4994 100644
--- a/crates/hir_def/src/body/lower.rs
+++ b/crates/hir_def/src/body/lower.rs
@@ -1000,18 +1000,18 @@ impl From<ast::LiteralKind> for Literal {
            // FIXME: these should have actual values filled in, but unsure on perf impact
            LiteralKind::IntNumber(lit) => {
                if let builtin @ Some(_) = lit.suffix().and_then(BuiltinFloat::from_suffix) {
-                    return Literal::Float(Default::default(), builtin);
+                    Literal::Float(Default::default(), builtin)
                } else if let builtin @ Some(_) =
-                    lit.suffix().and_then(|it| BuiltinInt::from_suffix(&it))
+                    lit.suffix().and_then(|it| BuiltinInt::from_suffix(it))
                {
                    Literal::Int(lit.value().unwrap_or(0) as i128, builtin)
                } else {
-                    let builtin = lit.suffix().and_then(|it| BuiltinUint::from_suffix(&it));
+                    let builtin = lit.suffix().and_then(|it| BuiltinUint::from_suffix(it));
                    Literal::Uint(lit.value().unwrap_or(0), builtin)
                }
            }
            LiteralKind::FloatNumber(lit) => {
-                let ty = lit.suffix().and_then(|it| BuiltinFloat::from_suffix(&it));
+                let ty = lit.suffix().and_then(|it| BuiltinFloat::from_suffix(it));
                Literal::Float(Default::default(), ty)
            }
            LiteralKind::ByteString(bs) => {
diff --git a/crates/hir_def/src/body/scope.rs b/crates/hir_def/src/body/scope.rs
index 6764de3a7..58a1fc81c 100644
--- a/crates/hir_def/src/body/scope.rs
+++ b/crates/hir_def/src/body/scope.rs
@@ -198,7 +198,7 @@ fn compute_expr_scopes(expr: ExprId, body: &Body, scopes: &mut ExprScopes, scope
        }
        Expr::Lambda { args, body: body_expr, .. } => {
            let scope = scopes.new_scope(scope);
-            scopes.add_params_bindings(body, scope, &args);
+            scopes.add_params_bindings(body, scope, args);
            compute_expr_scopes(*body_expr, body, scopes, scope);
        }
        Expr::Match { expr, arms } => {
diff --git a/crates/hir_def/src/body/tests.rs b/crates/hir_def/src/body/tests.rs
index d4fae05a6..27d837d47 100644
--- a/crates/hir_def/src/body/tests.rs
+++ b/crates/hir_def/src/body/tests.rs
@@ -3,7 +3,7 @@ mod block;
 use base_db::{fixture::WithFixture, SourceDatabase};
 use expect_test::Expect;
-use crate::{test_db::TestDB, ModuleDefId};
+use crate::ModuleDefId;
 use super::*;
@@ -28,11 +28,6 @@ fn lower(ra_fixture: &str) -> Arc<Body> {
    db.body(fn_def.unwrap().into())
 }
-fn check_diagnostics(ra_fixture: &str) {
-    let db: TestDB = TestDB::with_files(ra_fixture);
-    db.check_diagnostics();
-}
 fn block_def_map_at(ra_fixture: &str) -> String {
    let (db, position) = crate::test_db::TestDB::with_position(ra_fixture);
@@ -57,7 +52,7 @@ fn check_at(ra_fixture: &str, expect: Expect) {
 fn your_stack_belongs_to_me() {
    cov_mark::check!(your_stack_belongs_to_me);
    lower(
-        "
+        r#"
 macro_rules! n_nuple {
    ($e:tt) => ();
    ($($rest:tt)*) => {{
@@ -65,7 +60,7 @@ macro_rules! n_nuple {
    }};
 }
 fn main() { n_nuple!(1,2,3); }
-",
+"#,
    );
 }
@@ -73,7 +68,7 @@ fn main() { n_nuple!(1,2,3); }
 fn macro_resolve() {
    // Regression test for a path resolution bug introduced with inner item handling.
    lower(
-        r"
+        r#"
 macro_rules! vec {
    () => { () };
    ($elem:expr; $n:expr) => { () };
@@ -84,140 +79,6 @@ mod m {
        let _ = vec![FileSet::default(); self.len()];
    }
 }
-      ",
+"#,
-    );
-}
-#[test]
-fn cfg_diagnostics() {
-    check_diagnostics(
-        r"
-fn f() {
-    // The three g̶e̶n̶d̶e̶r̶s̶ statements:
-    #[cfg(a)] fn f() {}  // Item statement
-  //^^^^^^^^^^^^^^^^^^^ InactiveCode
-    #[cfg(a)] {}         // Expression statement
-  //^^^^^^^^^^^^ InactiveCode
-    #[cfg(a)] let x = 0; // let statement
-  //^^^^^^^^^^^^^^^^^^^^ InactiveCode
-    abc(#[cfg(a)] 0);
-      //^^^^^^^^^^^ InactiveCode
-    let x = Struct {
-        #[cfg(a)] f: 0,
-      //^^^^^^^^^^^^^^ InactiveCode
-    };
-    match () {
-        () => (),
-        #[cfg(a)] () => (),
-      //^^^^^^^^^^^^^^^^^^ InactiveCode
-    }
-    #[cfg(a)] 0          // Trailing expression of block
-  //^^^^^^^^^^^ InactiveCode
-}
-    ",
-    );
-}
-#[test]
-fn macro_diag_builtin() {
-    check_diagnostics(
-        r#"
-#[rustc_builtin_macro]
-macro_rules! env {}
-#[rustc_builtin_macro]
-macro_rules! include {}
-#[rustc_builtin_macro]
-macro_rules! compile_error {}
-#[rustc_builtin_macro]
-macro_rules! format_args {
-    () => {}
-}
-fn f() {
-    // Test a handful of built-in (eager) macros:
-    include!(invalid);
-  //^^^^^^^^^^^^^^^^^ could not convert tokens
-    include!("does not exist");
-  //^^^^^^^^^^^^^^^^^^^^^^^^^^ failed to load file `does not exist`
-    env!(invalid);
-  //^^^^^^^^^^^^^ could not convert tokens
-    env!("OUT_DIR");
-  //^^^^^^^^^^^^^^^ `OUT_DIR` not set, enable "run build scripts" to fix
-    compile_error!("compile_error works");
-  //^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ compile_error works
-    // Lazy:
-    format_args!();
-  //^^^^^^^^^^^^^^ no rule matches input tokens
-}
-        "#,
-    );
-}
-#[test]
-fn macro_rules_diag() {
-    check_diagnostics(
-        r#"
-macro_rules! m {
-    () => {};
-}
-fn f() {
-    m!();
-    m!(hi);
-  //^^^^^^ leftover tokens
-}
-      "#,
    );
 }
-#[test]
-fn unresolved_macro_diag() {
-    check_diagnostics(
-        r#"
-fn f() {
-    m!();
-  //^^^^ UnresolvedMacroCall
-}
-      "#,
-    );
-}
-#[test]
-fn dollar_crate_in_builtin_macro() {
-    check_diagnostics(
-        r#"
-#[macro_export]
-#[rustc_builtin_macro]
-macro_rules! format_args {}
-#[macro_export]
-macro_rules! arg {
-    () => {}
-}
-#[macro_export]
-macro_rules! outer {
-    () => {
-        $crate::format_args!( "", $crate::arg!(1) )
-    };
-}
-fn f() {
-    outer!();
-  //^^^^^^^^ leftover tokens
-}
-        "#,
-    )
-}
diff --git a/crates/hir_def/src/body/tests/block.rs b/crates/hir_def/src/body/tests/block.rs
index bc3d0f138..15c10d053 100644
--- a/crates/hir_def/src/body/tests/block.rs
+++ b/crates/hir_def/src/body/tests/block.rs
@@ -163,14 +163,14 @@ fn legacy_macro_items() {
    // correctly.
    check_at(
        r#"
-macro_rules! hit {
+macro_rules! mark {
    () => {
        struct Hit {}
    }
 }
 fn f() {
-    hit!();
+    mark!();
    $0
 }
 "#,
@@ -193,20 +193,20 @@ use core::cov_mark;
 fn f() {
    fn nested() {
-        cov_mark::hit!(Hit);
+        cov_mark::mark!(Hit);
        $0
    }
 }
 //- /core.rs crate:core
 pub mod cov_mark {
    #[macro_export]
-    macro_rules! _hit {
+    macro_rules! _mark {
        ($name:ident) => {
            struct $name {}
        }
    }
-    pub use crate::_hit as hit;
+    pub use crate::_mark as mark;
 }
 "#,
        expect![[r#"
diff --git a/crates/hir_def/src/generics.rs b/crates/hir_def/src/generics.rs
index 44d22b918..6933f6e3c 100644
--- a/crates/hir_def/src/generics.rs
+++ b/crates/hir_def/src/generics.rs
@@ -280,7 +280,7 @@ impl GenericParams {
            sm.type_params.insert(param_id, Either::Right(type_param.clone()));
            let type_ref = TypeRef::Path(name.into());
-            self.fill_bounds(&lower_ctx, &type_param, Either::Left(type_ref));
+            self.fill_bounds(lower_ctx, &type_param, Either::Left(type_ref));
        }
        for lifetime_param in params.lifetime_params() {
            let name =
@@ -289,7 +289,7 @@ impl GenericParams {
            let param_id = self.lifetimes.alloc(param);
            sm.lifetime_params.insert(param_id, lifetime_param.clone());
            let lifetime_ref = LifetimeRef::new_name(name);
-            self.fill_bounds(&lower_ctx, &lifetime_param, Either::Right(lifetime_ref));
+            self.fill_bounds(lower_ctx, &lifetime_param, Either::Right(lifetime_ref));
        }
        for const_param in params.const_params() {
            let name = const_param.name().map_or_else(Name::missing, |it| it.as_name());
diff --git a/crates/hir_def/src/import_map.rs b/crates/hir_def/src/import_map.rs
index 960cabb5f..404e3e153 100644
--- a/crates/hir_def/src/import_map.rs
+++ b/crates/hir_def/src/import_map.rs
@@ -1,6 +1,6 @@
 //! A map of all publicly exported items in a crate.
-use std::{cmp::Ordering, fmt, hash::BuildHasherDefault, sync::Arc};
+use std::{fmt, hash::BuildHasherDefault, sync::Arc};
 use base_db::CrateId;
 use fst::{self, Streamer};
@@ -69,81 +69,11 @@ pub struct ImportMap {
 impl ImportMap {
    pub fn import_map_query(db: &dyn DefDatabase, krate: CrateId) -> Arc<Self> {
        let _p = profile::span("import_map_query");
-        let def_map = db.crate_def_map(krate);
-        let mut import_map = Self::default();
-        // We look only into modules that are public(ly reexported), starting with the crate root.
-        let empty = ImportPath { segments: vec![] };
-        let root = def_map.module_id(def_map.root());
-        let mut worklist = vec![(root, empty)];
-        while let Some((module, mod_path)) = worklist.pop() {
-            let ext_def_map;
-            let mod_data = if module.krate == krate {
-                &def_map[module.local_id]
-            } else {
-                // The crate might reexport a module defined in another crate.
-                ext_def_map = module.def_map(db);
-                &ext_def_map[module.local_id]
-            };
-            let visible_items = mod_data.scope.entries().filter_map(|(name, per_ns)| {
-                let per_ns = per_ns.filter_visibility(|vis| vis == Visibility::Public);
-                if per_ns.is_none() {
-                    None
-                } else {
-                    Some((name, per_ns))
-                }
-            });
-            for (name, per_ns) in visible_items {
-                let mk_path = || {
-                    let mut path = mod_path.clone();
-                    path.segments.push(name.clone());
-                    path
-                };
-                for item in per_ns.iter_items() {
-                    let path = mk_path();
-                    let path_len = path.len();
-                    let import_info =
-                        ImportInfo { path, container: module, is_trait_assoc_item: false };
-                    if let Some(ModuleDefId::TraitId(tr)) = item.as_module_def_id() {
-                        import_map.collect_trait_assoc_items(
-                            db,
-                            tr,
-                            matches!(item, ItemInNs::Types(_)),
-                            &import_info,
-                        );
-                    }
-                    match import_map.map.entry(item) {
+        let mut import_map = collect_import_map(db, krate);
-                        Entry::Vacant(entry) => {
-                            entry.insert(import_info);
-                        }
-                        Entry::Occupied(mut entry) => {
-                            // If the new path is shorter, prefer that one.
-                            if path_len < entry.get().path.len() {
-                                *entry.get_mut() = import_info;
-                            } else {
-                                continue;
-                            }
-                        }
-                    }
-                    // If we've just added a path to a module, descend into it. We might traverse
-                    // modules multiple times, but only if the new path to it is shorter than the
-                    // first (else we `continue` above).
-                    if let Some(ModuleDefId::ModuleId(mod_id)) = item.as_module_def_id() {
-                        worklist.push((mod_id, mk_path()));
-                    }
-                }
-            }
-        }
        let mut importables = import_map.map.iter().collect::<Vec<_>>();
+        importables.sort_by_cached_key(|(_, import_info)| fst_path(&import_info.path));
-        importables.sort_by(cmp);
        // Build the FST, taking care not to insert duplicate values.
@@ -151,13 +81,13 @@ impl ImportMap {
        let mut last_batch_start = 0;
        for idx in 0..importables.len() {
-            if let Some(next_item) = importables.get(idx + 1) {
+            let key = fst_path(&importables[last_batch_start].1.path);
-                if cmp(&importables[last_batch_start], next_item) == Ordering::Equal {
+            if let Some((_, next_import_info)) = importables.get(idx + 1) {
+                if key == fst_path(&next_import_info.path) {
                    continue;
                }
            }
-            let key = fst_path(&importables[last_batch_start].1.path);
            builder.insert(key, last_batch_start as u64).unwrap();
            last_batch_start = idx + 1;
@@ -185,6 +115,7 @@ impl ImportMap {
        is_type_in_ns: bool,
        original_import_info: &ImportInfo,
    ) {
+        let _p = profile::span("collect_trait_assoc_items");
        for (assoc_item_name, item) in &db.trait_data(tr).items {
            let module_def_id = match item {
                AssocItemId::FunctionId(f) => ModuleDefId::from(*f),
@@ -210,6 +141,84 @@ impl ImportMap {
    }
 }
+fn collect_import_map(db: &dyn DefDatabase, krate: CrateId) -> ImportMap {
+    let _p = profile::span("collect_import_map");
+    let def_map = db.crate_def_map(krate);
+    let mut import_map = ImportMap::default();
+    // We look only into modules that are public(ly reexported), starting with the crate root.
+    let empty = ImportPath { segments: vec![] };
+    let root = def_map.module_id(def_map.root());
+    let mut worklist = vec![(root, empty)];
+    while let Some((module, mod_path)) = worklist.pop() {
+        let ext_def_map;
+        let mod_data = if module.krate == krate {
+            &def_map[module.local_id]
+        } else {
+            // The crate might reexport a module defined in another crate.
+            ext_def_map = module.def_map(db);
+            &ext_def_map[module.local_id]
+        };
+        let visible_items = mod_data.scope.entries().filter_map(|(name, per_ns)| {
+            let per_ns = per_ns.filter_visibility(|vis| vis == Visibility::Public);
+            if per_ns.is_none() {
+                None
+            } else {
+                Some((name, per_ns))
+            }
+        });
+        for (name, per_ns) in visible_items {
+            let mk_path = || {
+                let mut path = mod_path.clone();
+                path.segments.push(name.clone());
+                path
+            };
+            for item in per_ns.iter_items() {
+                let path = mk_path();
+                let path_len = path.len();
+                let import_info =
+                    ImportInfo { path, container: module, is_trait_assoc_item: false };
+                if let Some(ModuleDefId::TraitId(tr)) = item.as_module_def_id() {
+                    import_map.collect_trait_assoc_items(
+                        db,
+                        tr,
+                        matches!(item, ItemInNs::Types(_)),
+                        &import_info,
+                    );
+                }
+                match import_map.map.entry(item) {
+                    Entry::Vacant(entry) => {
+                        entry.insert(import_info);
+                    }
+                    Entry::Occupied(mut entry) => {
+                        // If the new path is shorter, prefer that one.
+                        if path_len < entry.get().path.len() {
+                            *entry.get_mut() = import_info;
+                        } else {
+                            continue;
+                        }
+                    }
+                }
+                // If we've just added a path to a module, descend into it. We might traverse
+                // modules multiple times, but only if the new path to it is shorter than the
+                // first (else we `continue` above).
+                if let Some(ModuleDefId::ModuleId(mod_id)) = item.as_module_def_id() {
+                    worklist.push((mod_id, mk_path()));
+                }
+            }
+        }
+    }
+    import_map
+}
 impl PartialEq for ImportMap {
    fn eq(&self, other: &Self) -> bool {
        // `fst` and `importables` are built from `map`, so we don't need to compare them.
@@ -240,17 +249,12 @@ impl fmt::Debug for ImportMap {
 }
 fn fst_path(path: &ImportPath) -> String {
+    let _p = profile::span("fst_path");
    let mut s = path.to_string();
    s.make_ascii_lowercase();
    s
 }
-fn cmp((_, lhs): &(&ItemInNs, &ImportInfo), (_, rhs): &(&ItemInNs, &ImportInfo)) -> Ordering {
-    let lhs_str = fst_path(&lhs.path);
-    let rhs_str = fst_path(&rhs.path);
-    lhs_str.cmp(&rhs_str)
-}
 #[derive(Debug, Eq, PartialEq, Hash)]
 pub enum ImportKind {
    Module,
@@ -338,6 +342,7 @@ impl Query {
    }
    fn import_matches(&self, import: &ImportInfo, enforce_lowercase: bool) -> bool {
+        let _p = profile::span("import_map::Query::import_matches");
        if import.is_trait_assoc_item {
            if self.exclude_import_kinds.contains(&ImportKind::AssociatedItem) {
                return false;
diff --git a/crates/hir_def/src/item_scope.rs b/crates/hir_def/src/item_scope.rs
index 0f74f050d..08407ebfa 100644
--- a/crates/hir_def/src/item_scope.rs
+++ b/crates/hir_def/src/item_scope.rs
@@ -59,7 +59,7 @@ pub struct ItemScope {
 pub(crate) static BUILTIN_SCOPE: Lazy<FxHashMap<Name, PerNs>> = Lazy::new(|| {
    BuiltinType::ALL
        .iter()
-        .map(|(name, ty)| (name.clone(), PerNs::types(ty.clone().into(), Visibility::Public)))
+        .map(|(name, ty)| (name.clone(), PerNs::types((*ty).into(), Visibility::Public)))
        .collect()
 });
diff --git a/crates/hir_def/src/item_tree/lower.rs b/crates/hir_def/src/item_tree/lower.rs
index cfda7cb32..3f90bda74 100644
--- a/crates/hir_def/src/item_tree/lower.rs
+++ b/crates/hir_def/src/item_tree/lower.rs
@@ -823,7 +823,7 @@ fn is_intrinsic_fn_unsafe(name: &Name) -> bool {
        known::type_name,
        known::variant_count,
    ]
-    .contains(&name)
+    .contains(name)
 }
 fn lower_abi(abi: ast::Abi) -> Interned<str> {
@@ -855,7 +855,7 @@ impl UseTreeLowering<'_> {
                // 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) {
+                    match ModPath::from_src(self.db, path, self.hygiene) {
                        Some(it) => Some(it),
                        None => return None, // FIXME: report errors somewhere
                    }
@@ -874,7 +874,7 @@ impl UseTreeLowering<'_> {
        } 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)?),
+                Some(path) => Some(ModPath::from_src(self.db, path, self.hygiene)?),
                None => None,
            };
            let alias = tree.rename().map(|a| {
diff --git a/crates/hir_def/src/item_tree/pretty.rs b/crates/hir_def/src/item_tree/pretty.rs
index cc9944a22..b1e1b70d0 100644
--- a/crates/hir_def/src/item_tree/pretty.rs
+++ b/crates/hir_def/src/item_tree/pretty.rs
@@ -426,7 +426,7 @@ impl<'a> Printer<'a> {
                        w!(self, " {{");
                        self.indented(|this| {
                            for item in &**items {
-                                this.print_mod_item((*item).into());
+                                this.print_mod_item(*item);
                            }
                        });
                        wln!(self, "}}");
diff --git a/crates/hir_def/src/lang_item.rs b/crates/hir_def/src/lang_item.rs
index 9e90f745c..3a45cbfa1 100644
--- a/crates/hir_def/src/lang_item.rs
+++ b/crates/hir_def/src/lang_item.rs
@@ -141,6 +141,7 @@ impl LangItems {
    ) where
        T: Into<AttrDefId> + Copy,
    {
+        let _p = profile::span("collect_lang_item");
        if let Some(lang_item_name) = lang_attr(db, item) {
            self.items.entry(lang_item_name).or_insert_with(|| constructor(item));
        }
diff --git a/crates/hir_def/src/lib.rs b/crates/hir_def/src/lib.rs
index 987485acc..bb174aec8 100644
--- a/crates/hir_def/src/lib.rs
+++ b/crates/hir_def/src/lib.rs
@@ -112,6 +112,10 @@ impl ModuleId {
        self.def_map(db).containing_module(self.local_id)
    }
+    pub fn containing_block(&self) -> Option<BlockId> {
+        self.block
+    }
    /// Returns `true` if this module represents a block expression.
    ///
    /// Returns `false` if this module is a submodule *inside* a block expression
@@ -581,6 +585,18 @@ impl HasModule for GenericDefId {
    }
 }
+impl HasModule for TypeAliasId {
+    fn module(&self, db: &dyn db::DefDatabase) -> ModuleId {
+        self.lookup(db).module(db)
+    }
+}
+impl HasModule for TraitId {
+    fn module(&self, db: &dyn db::DefDatabase) -> ModuleId {
+        self.lookup(db).container
+    }
+}
 impl HasModule for StaticLoc {
    fn module(&self, _db: &dyn db::DefDatabase) -> ModuleId {
        self.container
@@ -731,13 +747,11 @@ fn macro_call_as_call_id(
        )
        .map(MacroCallId::from)
    } else {
-        Ok(def
+        Ok(def.as_lazy_macro(
-            .as_lazy_macro(
+            db.upcast(),
-                db.upcast(),
+            krate,
-                krate,
+            MacroCallKind::FnLike { ast_id: call.ast_id, fragment },
-                MacroCallKind::FnLike { ast_id: call.ast_id, fragment },
+        ))
-            )
-            .into())
    };
    Ok(res)
 }
@@ -756,17 +770,15 @@ fn derive_macro_as_call_id(
        .segments()
        .last()
        .ok_or_else(|| UnresolvedMacro { path: item_attr.path.clone() })?;
-    let res = def
+    let res = def.as_lazy_macro(
-        .as_lazy_macro(
+        db.upcast(),
-            db.upcast(),
+        krate,
-            krate,
+        MacroCallKind::Derive {
-            MacroCallKind::Derive {
+            ast_id: item_attr.ast_id,
-                ast_id: item_attr.ast_id,
+            derive_name: last_segment.to_string(),
-                derive_name: last_segment.to_string(),
+            derive_attr_index: derive_attr.ast_index,
-                derive_attr_index: derive_attr.ast_index,
+        },
-            },
+    );
-        )
-        .into();
    Ok(res)
 }
@@ -794,17 +806,15 @@ fn attr_macro_as_call_id(
    // The parentheses are always disposed here.
    arg.delimiter = None;
-    let res = def
+    let res = def.as_lazy_macro(
-        .as_lazy_macro(
+        db.upcast(),
-            db.upcast(),
+        krate,
-            krate,
+        MacroCallKind::Attr {
-            MacroCallKind::Attr {
+            ast_id: item_attr.ast_id,
-                ast_id: item_attr.ast_id,
+            attr_name: last_segment.to_string(),
-                attr_name: last_segment.to_string(),
+            attr_args: arg,
-                attr_args: arg,
+            invoc_attr_index: macro_attr.id.ast_index,
-                invoc_attr_index: macro_attr.id.ast_index,
+        },
-            },
+    );
-        )
-        .into();
    Ok(res)
 }
diff --git a/crates/hir_def/src/nameres/collector.rs b/crates/hir_def/src/nameres/collector.rs
index 93f30f23d..6fab58f15 100644
--- a/crates/hir_def/src/nameres/collector.rs
+++ b/crates/hir_def/src/nameres/collector.rs
@@ -500,7 +500,7 @@ impl DefCollector<'_> {
            let (per_ns, _) = self.def_map.resolve_path(
                self.db,
                self.def_map.root,
-                &path,
+                path,
                BuiltinShadowMode::Other,
            );
@@ -722,7 +722,7 @@ impl DefCollector<'_> {
        if import.is_extern_crate {
            let res = self.def_map.resolve_name_in_extern_prelude(
                self.db,
-                &import
+                import
                    .path
                    .as_ident()
                    .expect("extern crate should have been desugared to one-element path"),
@@ -1351,7 +1351,7 @@ impl ModCollector<'_, '_> {
                    let imports = Import::from_use(
                        self.def_collector.db,
                        krate,
-                        &self.item_tree,
+                        self.item_tree,
                        ItemTreeId::new(self.file_id, import_id),
                    );
                    self.def_collector.unresolved_imports.extend(imports.into_iter().map(
@@ -1368,7 +1368,7 @@ impl ModCollector<'_, '_> {
                        import: Import::from_extern_crate(
                            self.def_collector.db,
                            krate,
-                            &self.item_tree,
+                            self.item_tree,
                            ItemTreeId::new(self.file_id, import_id),
                        ),
                        status: PartialResolvedImport::Unresolved,
@@ -1889,7 +1889,7 @@ impl ModCollector<'_, '_> {
                    self.def_collector.def_map.with_ancestor_maps(
                        self.def_collector.db,
                        self.module_id,
-                        &mut |map, module| map[module].scope.get_legacy_macro(&name),
+                        &mut |map, module| map[module].scope.get_legacy_macro(name),
                    )
                })
            },
@@ -1993,7 +1993,7 @@ mod tests {
    }
    fn do_resolve(code: &str) -> DefMap {
-        let (db, _file_id) = TestDB::with_single_file(&code);
+        let (db, _file_id) = TestDB::with_single_file(code);
        let krate = db.test_crate();
        let edition = db.crate_graph()[krate].edition;
diff --git a/crates/hir_def/src/nameres/path_resolution.rs b/crates/hir_def/src/nameres/path_resolution.rs
index c984148c3..629bc7952 100644
--- a/crates/hir_def/src/nameres/path_resolution.rs
+++ b/crates/hir_def/src/nameres/path_resolution.rs
@@ -93,7 +93,7 @@ impl DefMap {
        let mut vis = match visibility {
            RawVisibility::Module(path) => {
                let (result, remaining) =
-                    self.resolve_path(db, original_module, &path, BuiltinShadowMode::Module);
+                    self.resolve_path(db, original_module, path, BuiltinShadowMode::Module);
                if remaining.is_some() {
                    return None;
                }
@@ -205,7 +205,7 @@ impl DefMap {
                    None => return ResolvePathResult::empty(ReachedFixedPoint::Yes),
                };
                log::debug!("resolving {:?} in crate root (+ extern prelude)", segment);
-                self.resolve_name_in_crate_root_or_extern_prelude(db, &segment)
+                self.resolve_name_in_crate_root_or_extern_prelude(db, segment)
            }
            PathKind::Plain => {
                let (_, segment) = match segments.next() {
@@ -222,7 +222,7 @@ impl DefMap {
                    if path.segments().len() == 1 { shadow } else { BuiltinShadowMode::Module };
                log::debug!("resolving {:?} in module", segment);
-                self.resolve_name_in_module(db, original_module, &segment, prefer_module)
+                self.resolve_name_in_module(db, original_module, segment, prefer_module)
            }
            PathKind::Super(lvl) => {
                let mut module = original_module;
@@ -269,7 +269,7 @@ impl DefMap {
                    Some((_, segment)) => segment,
                    None => return ResolvePathResult::empty(ReachedFixedPoint::Yes),
                };
-                if let Some(def) = self.extern_prelude.get(&segment) {
+                if let Some(def) = self.extern_prelude.get(segment) {
                    log::debug!("absolute path {:?} resolved to crate {:?}", path, def);
                    PerNs::types(*def, Visibility::Public)
                } else {
@@ -319,13 +319,13 @@ impl DefMap {
                    };
                    // Since it is a qualified path here, it should not contains legacy macros
-                    module_data.scope.get(&segment)
+                    module_data.scope.get(segment)
                }
                ModuleDefId::AdtId(AdtId::EnumId(e)) => {
                    // enum variant
                    cov_mark::hit!(can_import_enum_variant);
                    let enum_data = db.enum_data(e);
-                    match enum_data.variant(&segment) {
+                    match enum_data.variant(segment) {
                        Some(local_id) => {
                            let variant = EnumVariantId { parent: e, local_id };
                            match &*enum_data.variants[local_id].variant_data {
diff --git a/crates/hir_def/src/nameres/tests.rs b/crates/hir_def/src/nameres/tests.rs
index 58c01354a..cf43f2a96 100644
--- a/crates/hir_def/src/nameres/tests.rs
+++ b/crates/hir_def/src/nameres/tests.rs
@@ -2,7 +2,6 @@ mod globs;
 mod incremental;
 mod macros;
 mod mod_resolution;
-mod diagnostics;
 mod primitives;
 use std::sync::Arc;
diff --git a/crates/hir_def/src/nameres/tests/diagnostics.rs b/crates/hir_def/src/nameres/tests/diagnostics.rs
deleted file mode 100644
index ec6670952..000000000
--- a/crates/hir_def/src/nameres/tests/diagnostics.rs
+++ /dev/null
@@ -1,229 +0,0 @@
-use base_db::fixture::WithFixture;
-use crate::test_db::TestDB;
-fn check_diagnostics(ra_fixture: &str) {
-    let db: TestDB = TestDB::with_files(ra_fixture);
-    db.check_diagnostics();
-}
-fn check_no_diagnostics(ra_fixture: &str) {
-    let db: TestDB = TestDB::with_files(ra_fixture);
-    db.check_no_diagnostics();
-}
-#[test]
-fn unresolved_import() {
-    check_diagnostics(
-        r"
-        use does_exist;
-        use does_not_exist;
-      //^^^^^^^^^^^^^^^^^^^ UnresolvedImport
-        mod does_exist {}
-        ",
-    );
-}
-#[test]
-fn unresolved_extern_crate() {
-    check_diagnostics(
-        r"
-        //- /main.rs crate:main deps:core
-        extern crate core;
-          extern crate doesnotexist;
-        //^^^^^^^^^^^^^^^^^^^^^^^^^^ UnresolvedExternCrate
-        //- /lib.rs crate:core
-        ",
-    );
-}
-#[test]
-fn extern_crate_self_as() {
-    cov_mark::check!(extern_crate_self_as);
-    check_diagnostics(
-        r"
-        //- /lib.rs
-          extern crate doesnotexist;
-        //^^^^^^^^^^^^^^^^^^^^^^^^^^ UnresolvedExternCrate
-        // Should not error.
-        extern crate self as foo;
-        struct Foo;
-        use foo::Foo as Bar;
-        ",
-    );
-}
-#[test]
-fn dedup_unresolved_import_from_unresolved_crate() {
-    check_diagnostics(
-        r"
-        //- /main.rs crate:main
-        mod a {
-            extern crate doesnotexist;
-          //^^^^^^^^^^^^^^^^^^^^^^^^^^ UnresolvedExternCrate
-            // Should not error, since we already errored for the missing crate.
-            use doesnotexist::{self, bla, *};
-            use crate::doesnotexist;
-          //^^^^^^^^^^^^^^^^^^^^^^^^ UnresolvedImport
-        }
-        mod m {
-            use super::doesnotexist;
-          //^^^^^^^^^^^^^^^^^^^^^^^^ UnresolvedImport
-        }
-        ",
-    );
-}
-#[test]
-fn unresolved_module() {
-    check_diagnostics(
-        r"
-        //- /lib.rs
-        mod foo;
-          mod bar;
-        //^^^^^^^^ UnresolvedModule
-        mod baz {}
-        //- /foo.rs
-        ",
-    );
-}
-#[test]
-fn inactive_item() {
-    // Additional tests in `cfg` crate. This only tests disabled cfgs.
-    check_diagnostics(
-        r#"
-        //- /lib.rs
-          #[cfg(no)] pub fn f() {}
-        //^^^^^^^^^^^^^^^^^^^^^^^^ UnconfiguredCode
-          #[cfg(no)] #[cfg(no2)] mod m;
-        //^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ UnconfiguredCode
-          #[cfg(all(not(a), b))] enum E {}
-        //^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ UnconfiguredCode
-          #[cfg(feature = "std")] use std;
-        //^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ UnconfiguredCode
-        "#,
-    );
-}
-/// Tests that `cfg` attributes behind `cfg_attr` is handled properly.
-#[test]
-fn inactive_via_cfg_attr() {
-    cov_mark::check!(cfg_attr_active);
-    check_diagnostics(
-        r#"
-        //- /lib.rs
-          #[cfg_attr(not(never), cfg(no))] fn f() {}
-        //^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 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() {}
-        //^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ UnconfiguredCode
-        "#,
-    );
-}
-#[test]
-fn unresolved_legacy_scope_macro() {
-    check_diagnostics(
-        r#"
-        //- /lib.rs
-          macro_rules! m { () => {} }
-          m!();
-          m2!();
-        //^^^^^^ UnresolvedMacroCall
-        "#,
-    );
-}
-#[test]
-fn unresolved_module_scope_macro() {
-    check_diagnostics(
-        r#"
-        //- /lib.rs
-          mod mac {
-            #[macro_export]
-            macro_rules! m { () => {} }
-          }
-          self::m!();
-          self::m2!();
-        //^^^^^^^^^^^^ UnresolvedMacroCall
-        "#,
-    );
-}
-#[test]
-fn builtin_macro_fails_expansion() {
-    check_diagnostics(
-        r#"
-        //- /lib.rs
-          #[rustc_builtin_macro]
-          macro_rules! include { () => {} }
-          include!("doesntexist");
-        //^^^^^^^^^^^^^^^^^^^^^^^^ failed to load file `doesntexist`
-        "#,
-    );
-}
-#[test]
-fn include_macro_should_allow_empty_content() {
-    check_no_diagnostics(
-        r#"
-        //- /lib.rs
-          #[rustc_builtin_macro]
-          macro_rules! include { () => {} }
-          include!("bar.rs");
-        //- /bar.rs
-          // empty
-        "#,
-    );
-}
-#[test]
-fn good_out_dir_diagnostic() {
-    check_diagnostics(
-        r#"
-        #[rustc_builtin_macro]
-        macro_rules! include { () => {} }
-        #[rustc_builtin_macro]
-        macro_rules! env { () => {} }
-        #[rustc_builtin_macro]
-        macro_rules! concat { () => {} }
-        include!(concat!(env!("OUT_DIR"), "/out.rs"));
-      //^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `OUT_DIR` not set, enable "run build scripts" to fix
-        "#,
-    );
-}
-#[test]
-fn register_attr_and_tool() {
-    cov_mark::check!(register_attr);
-    cov_mark::check!(register_tool);
-    check_no_diagnostics(
-        r#"
-#![register_tool(tool)]
-#![register_attr(attr)]
-#[tool::path]
-#[attr]
-struct S;
-        "#,
-    );
-    // NB: we don't currently emit diagnostics here
-}
diff --git a/crates/hir_def/src/path/lower.rs b/crates/hir_def/src/path/lower.rs
index f6220aa92..27345d07c 100644
--- a/crates/hir_def/src/path/lower.rs
+++ b/crates/hir_def/src/path/lower.rs
@@ -208,13 +208,13 @@ fn lower_generic_args_from_fn_path(
    let params = params?;
    let mut param_types = Vec::new();
    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);
    }
    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());
+        let type_ref = TypeRef::from_ast_opt(ctx, ret_type.ty());
        bindings.push(AssociatedTypeBinding {
            name: name![Output],
            type_ref: Some(type_ref),
diff --git a/crates/hir_def/src/per_ns.rs b/crates/hir_def/src/per_ns.rs
index a594afce6..a9f13cb82 100644
--- a/crates/hir_def/src/per_ns.rs
+++ b/crates/hir_def/src/per_ns.rs
@@ -62,6 +62,7 @@ impl PerNs {
    }
    pub fn filter_visibility(self, mut f: impl FnMut(Visibility) -> bool) -> PerNs {
+        let _p = profile::span("PerNs::filter_visibility");
        PerNs {
            types: self.types.filter(|(_, v)| f(*v)),
            values: self.values.filter(|(_, v)| f(*v)),
@@ -86,6 +87,7 @@ impl PerNs {
    }
    pub fn iter_items(self) -> impl Iterator<Item = ItemInNs> {
+        let _p = profile::span("PerNs::iter_items");
        self.types
            .map(|it| ItemInNs::Types(it.0))
            .into_iter()
diff --git a/crates/hir_def/src/resolver.rs b/crates/hir_def/src/resolver.rs
index fb8a6f260..d4681fa3e 100644
--- a/crates/hir_def/src/resolver.rs
+++ b/crates/hir_def/src/resolver.rs
@@ -133,7 +133,7 @@ impl Resolver {
            Some(it) => it,
            None => return PerNs::none(),
        };
-        let (module_res, segment_index) = item_map.resolve_path(db, module, &path, shadow);
+        let (module_res, segment_index) = item_map.resolve_path(db, module, path, shadow);
        if segment_index.is_some() {
            return PerNs::none();
        }
@@ -150,7 +150,7 @@ impl Resolver {
        path: &ModPath,
    ) -> Option<TraitId> {
        let (item_map, module) = self.module_scope()?;
-        let (module_res, ..) = item_map.resolve_path(db, module, &path, BuiltinShadowMode::Module);
+        let (module_res, ..) = item_map.resolve_path(db, module, path, BuiltinShadowMode::Module);
        match module_res.take_types()? {
            ModuleDefId::TraitId(it) => Some(it),
            _ => None,
@@ -325,7 +325,7 @@ impl Resolver {
        path: &ModPath,
    ) -> Option<MacroDefId> {
        let (item_map, module) = self.module_scope()?;
-        item_map.resolve_path(db, module, &path, BuiltinShadowMode::Other).0.take_macros()
+        item_map.resolve_path(db, module, path, BuiltinShadowMode::Other).0.take_macros()
    }
    pub fn process_all_names(&self, db: &dyn DefDatabase, f: &mut dyn FnMut(Name, ScopeDef)) {
@@ -561,7 +561,7 @@ impl ModuleItemMap {
        path: &ModPath,
    ) -> Option<ResolveValueResult> {
        let (module_def, idx) =
-            self.def_map.resolve_path_locally(db, self.module_id, &path, BuiltinShadowMode::Other);
+            self.def_map.resolve_path_locally(db, self.module_id, path, BuiltinShadowMode::Other);
        match idx {
            None => {
                let value = to_value_ns(module_def)?;
@@ -591,7 +591,7 @@ impl ModuleItemMap {
        path: &ModPath,
    ) -> Option<(TypeNs, Option<usize>)> {
        let (module_def, idx) =
-            self.def_map.resolve_path_locally(db, self.module_id, &path, BuiltinShadowMode::Other);
+            self.def_map.resolve_path_locally(db, self.module_id, path, BuiltinShadowMode::Other);
        let res = to_type_ns(module_def)?;
        Some((res, idx))
    }
diff --git a/crates/hir_def/src/test_db.rs b/crates/hir_def/src/test_db.rs
index b20b066e2..2635b556e 100644
--- a/crates/hir_def/src/test_db.rs
+++ b/crates/hir_def/src/test_db.rs
@@ -6,19 +6,16 @@ use std::{
 };
 use base_db::{
-    salsa, CrateId, FileId, FileLoader, FileLoaderDelegate, FilePosition, FileRange, Upcast,
+    salsa, AnchoredPath, CrateId, FileId, FileLoader, FileLoaderDelegate, FilePosition,
+    SourceDatabase, Upcast,
 };
-use base_db::{AnchoredPath, SourceDatabase};
 use hir_expand::{db::AstDatabase, InFile};
-use rustc_hash::FxHashMap;
 use rustc_hash::FxHashSet;
-use syntax::{algo, ast, AstNode, SyntaxNode, SyntaxNodePtr, TextRange, TextSize};
+use syntax::{algo, ast, AstNode};
-use test_utils::extract_annotations;
 use crate::{
-    body::BodyDiagnostic,
    db::DefDatabase,
-    nameres::{diagnostics::DefDiagnosticKind, DefMap, ModuleSource},
+    nameres::{DefMap, ModuleSource},
    src::HasSource,
    LocalModuleId, Lookup, ModuleDefId, ModuleId,
 };
@@ -245,145 +242,4 @@ impl TestDB {
            })
            .collect()
    }
-    pub(crate) fn extract_annotations(&self) -> FxHashMap<FileId, Vec<(TextRange, String)>> {
-        let mut files = Vec::new();
-        let crate_graph = self.crate_graph();
-        for krate in crate_graph.iter() {
-            let crate_def_map = self.crate_def_map(krate);
-            for (module_id, _) in crate_def_map.modules() {
-                let file_id = crate_def_map[module_id].origin.file_id();
-                files.extend(file_id)
-            }
-        }
-        assert!(!files.is_empty());
-        files
-            .into_iter()
-            .filter_map(|file_id| {
-                let text = self.file_text(file_id);
-                let annotations = extract_annotations(&text);
-                if annotations.is_empty() {
-                    return None;
-                }
-                Some((file_id, annotations))
-            })
-            .collect()
-    }
-    pub(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);
-            for diag in crate_def_map.diagnostics() {
-                let (node, message): (InFile<SyntaxNode>, &str) = match &diag.kind {
-                    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())
-                    }
-                    DefDiagnosticKind::UnimplementedBuiltinMacro { ast } => {
-                        let node = ast.to_node(self.upcast());
-                        (
-                            InFile::new(ast.file_id, node.syntax().clone()),
-                            "UnimplementedBuiltinMacro",
-                        )
-                    }
-                };
-                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;
-                        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())
-                        }
-                    }
-                }
-            }
-        }
-    }
-    pub(crate) fn check_diagnostics(&self) {
-        let db: &TestDB = self;
-        let annotations = db.extract_annotations();
-        assert!(!annotations.is_empty());
-        let mut actual: FxHashMap<FileId, Vec<(TextRange, String)>> = FxHashMap::default();
-        db.diagnostics(&mut |frange, message| {
-            actual.entry(frange.file_id).or_default().push((frange.range, message));
-        });
-        for (file_id, diags) in actual.iter_mut() {
-            diags.sort_by_key(|it| it.0.start());
-            let text = db.file_text(*file_id);
-            // For multiline spans, place them on line start
-            for (range, content) in diags {
-                if text[*range].contains('\n') {
-                    *range = TextRange::new(range.start(), range.start() + TextSize::from(1));
-                    *content = format!("... {}", content);
-                }
-            }
-        }
-        assert_eq!(annotations, actual);
-    }
-    pub(crate) fn check_no_diagnostics(&self) {
-        let db: &TestDB = self;
-        let annotations = db.extract_annotations();
-        assert!(annotations.is_empty());
-        let mut has_diagnostics = false;
-        db.diagnostics(&mut |_, _| {
-            has_diagnostics = true;
-        });
-        assert!(!has_diagnostics);
-    }
 }
diff --git a/crates/hir_def/src/type_ref.rs b/crates/hir_def/src/type_ref.rs
index cbde6b940..ffe499973 100644
--- a/crates/hir_def/src/type_ref.rs
+++ b/crates/hir_def/src/type_ref.rs
@@ -128,7 +128,7 @@ impl TypeRef {
    /// Converts an `ast::TypeRef` to a `hir::TypeRef`.
    pub fn from_ast(ctx: &LowerCtx, node: ast::Type) -> Self {
        match node {
-            ast::Type::ParenType(inner) => TypeRef::from_ast_opt(&ctx, inner.ty()),
+            ast::Type::ParenType(inner) => TypeRef::from_ast_opt(ctx, inner.ty()),
            ast::Type::TupleType(inner) => {
                TypeRef::Tuple(inner.fields().map(|it| TypeRef::from_ast(ctx, it)).collect())
            }
@@ -142,7 +142,7 @@ impl TypeRef {
                    .unwrap_or(TypeRef::Error)
            }
            ast::Type::PtrType(inner) => {
-                let inner_ty = TypeRef::from_ast_opt(&ctx, inner.ty());
+                let inner_ty = TypeRef::from_ast_opt(ctx, inner.ty());
                let mutability = Mutability::from_mutable(inner.mut_token().is_some());
                TypeRef::RawPtr(Box::new(inner_ty), mutability)
            }
@@ -156,13 +156,13 @@ impl TypeRef {
                    .map(ConstScalar::usize_from_literal_expr)
                    .unwrap_or(ConstScalar::Unknown);
-                TypeRef::Array(Box::new(TypeRef::from_ast_opt(&ctx, inner.ty())), len)
+                TypeRef::Array(Box::new(TypeRef::from_ast_opt(ctx, inner.ty())), len)
            }
            ast::Type::SliceType(inner) => {
-                TypeRef::Slice(Box::new(TypeRef::from_ast_opt(&ctx, inner.ty())))
+                TypeRef::Slice(Box::new(TypeRef::from_ast_opt(ctx, inner.ty())))
            }
            ast::Type::RefType(inner) => {
-                let inner_ty = TypeRef::from_ast_opt(&ctx, inner.ty());
+                let inner_ty = TypeRef::from_ast_opt(ctx, inner.ty());
                let lifetime = inner.lifetime().map(|lt| LifetimeRef::new(&lt));
                let mutability = Mutability::from_mutable(inner.mut_token().is_some());
                TypeRef::Reference(Box::new(inner_ty), lifetime, mutability)
@@ -180,7 +180,7 @@ impl TypeRef {
                        is_varargs = param.dotdotdot_token().is_some();
                    }
-                    pl.params().map(|p| p.ty()).map(|it| TypeRef::from_ast_opt(&ctx, it)).collect()
+                    pl.params().map(|p| p.ty()).map(|it| TypeRef::from_ast_opt(ctx, it)).collect()
                } else {
                    Vec::new()
                };
@@ -188,7 +188,7 @@ impl TypeRef {
                TypeRef::Fn(params, is_varargs)
            }
            // for types are close enough for our purposes to the inner type for now...
-            ast::Type::ForType(inner) => TypeRef::from_ast_opt(&ctx, inner.ty()),
+            ast::Type::ForType(inner) => TypeRef::from_ast_opt(ctx, inner.ty()),
            ast::Type::ImplTraitType(inner) => {
                TypeRef::ImplTrait(type_bounds_from_ast(ctx, inner.type_bound_list()))
            }
@@ -229,7 +229,7 @@ impl TypeRef {
                TypeRef::RawPtr(type_ref, _)
                | TypeRef::Reference(type_ref, ..)
                | TypeRef::Array(type_ref, _)
-                | TypeRef::Slice(type_ref) => go(&type_ref, f),
+                | TypeRef::Slice(type_ref) => go(type_ref, f),
                TypeRef::ImplTrait(bounds) | TypeRef::DynTrait(bounds) => {
                    for bound in bounds {
                        match bound.as_ref() {
diff --git a/crates/hir_expand/src/builtin_derive.rs b/crates/hir_expand/src/builtin_derive.rs
index fe9497b50..4610f6f91 100644
--- a/crates/hir_expand/src/builtin_derive.rs
+++ b/crates/hir_expand/src/builtin_derive.rs
@@ -325,7 +325,7 @@ $0
            },
        };
-        let id: MacroCallId = db.intern_macro(loc).into();
+        let id: MacroCallId = db.intern_macro(loc);
        let parsed = db.parse_or_expand(id.as_file()).unwrap();
        // FIXME text() for syntax nodes parsed from token tree looks weird
diff --git a/crates/hir_expand/src/builtin_macro.rs b/crates/hir_expand/src/builtin_macro.rs
index 0b310ba2f..f24d1d919 100644
--- a/crates/hir_expand/src/builtin_macro.rs
+++ b/crates/hir_expand/src/builtin_macro.rs
@@ -354,7 +354,7 @@ fn concat_expand(
                // concat works with string and char literals, so remove any quotes.
                // It also works with integer, float and boolean literals, so just use the rest
                // as-is.
-                let component = unquote_str(&it).unwrap_or_else(|| it.text.to_string());
+                let component = unquote_str(it).unwrap_or_else(|| it.text.to_string());
                text.push_str(&component);
            }
            // handle boolean literals
@@ -417,7 +417,7 @@ fn parse_string(tt: &tt::Subtree) -> Result<String, mbe::ExpandError> {
    tt.token_trees
        .get(0)
        .and_then(|tt| match tt {
-            tt::TokenTree::Leaf(tt::Leaf::Literal(it)) => unquote_str(&it),
+            tt::TokenTree::Leaf(tt::Leaf::Literal(it)) => unquote_str(it),
            _ => None,
        })
        .ok_or_else(|| mbe::ExpandError::ConversionError)
@@ -430,7 +430,7 @@ fn include_expand(
 ) -> ExpandResult<Option<ExpandedEager>> {
    let res = (|| {
        let path = parse_string(tt)?;
-        let file_id = relative_file(db, arg_id.into(), &path, false)?;
+        let file_id = relative_file(db, arg_id, &path, false)?;
        let subtree = parse_to_token_tree(&db.file_text(file_id))
            .ok_or_else(|| mbe::ExpandError::ConversionError)?
@@ -480,7 +480,7 @@ fn include_str_expand(
    // it's unusual to `include_str!` a Rust file), but we can return an empty string.
    // Ideally, we'd be able to offer a precise expansion if the user asks for macro
    // expansion.
-    let file_id = match relative_file(db, arg_id.into(), &path, true) {
+    let file_id = match relative_file(db, arg_id, &path, true) {
        Ok(file_id) => file_id,
        Err(_) => {
            return ExpandResult::ok(Some(ExpandedEager::new(quote!(""))));
@@ -561,7 +561,7 @@ mod tests {
    use syntax::ast::NameOwner;
    fn expand_builtin_macro(ra_fixture: &str) -> String {
-        let (db, file_id) = TestDB::with_single_file(&ra_fixture);
+        let (db, file_id) = TestDB::with_single_file(ra_fixture);
        let parsed = db.parse(file_id);
        let mut macro_rules: Vec<_> =
            parsed.syntax_node().descendants().filter_map(ast::MacroRules::cast).collect();
@@ -598,7 +598,7 @@ mod tests {
                    },
                };
-                let id: MacroCallId = db.intern_macro(loc).into();
+                let id: MacroCallId = db.intern_macro(loc);
                id.as_file()
            }
            Either::Right(expander) => {
@@ -635,7 +635,7 @@ mod tests {
                    kind: MacroCallKind::FnLike { ast_id: call_id, fragment },
                };
-                let id: MacroCallId = db.intern_macro(loc).into();
+                let id: MacroCallId = db.intern_macro(loc);
                id.as_file()
            }
        };
diff --git a/crates/hir_expand/src/db.rs b/crates/hir_expand/src/db.rs
index 45e6e446a..66f44202b 100644
--- a/crates/hir_expand/src/db.rs
+++ b/crates/hir_expand/src/db.rs
@@ -57,7 +57,7 @@ impl TokenExpander {
                // We store the result in salsa db to prevent non-deterministic behavior in
                // some proc-macro implementation
                // See #4315 for details
-                db.expand_proc_macro(id.into()).into()
+                db.expand_proc_macro(id).into()
            }
        }
    }
@@ -241,7 +241,7 @@ fn parse_macro_expansion(
                }
            };
            if is_self_replicating(&node, &call_node.value) {
-                return ExpandResult::only_err(err);
+                ExpandResult::only_err(err)
            } else {
                ExpandResult { value: Some((parse, Arc::new(rev_token_map))), err: Some(err) }
            }
diff --git a/crates/hir_expand/src/eager.rs b/crates/hir_expand/src/eager.rs
index c25ce7634..584ddcf9f 100644
--- a/crates/hir_expand/src/eager.rs
+++ b/crates/hir_expand/src/eager.rs
@@ -128,7 +128,7 @@ pub fn expand_eager_macro(
        }),
        kind: MacroCallKind::FnLike { ast_id: call_id, fragment: FragmentKind::Expr },
    });
-    let arg_file_id: MacroCallId = arg_id.into();
+    let arg_file_id: MacroCallId = arg_id;
    let parsed_args =
        diagnostic_sink.result(mbe::token_tree_to_syntax_node(&parsed_args, FragmentKind::Expr))?.0;
@@ -177,13 +177,11 @@ fn lazy_expand(
    let ast_id = db.ast_id_map(macro_call.file_id).ast_id(&macro_call.value);
    let fragment = crate::to_fragment_kind(&macro_call.value);
-    let id: MacroCallId = def
+    let id: MacroCallId = def.as_lazy_macro(
-        .as_lazy_macro(
+        db,
-            db,
+        krate,
-            krate,