206 files changed, 9717 insertions, 6391 deletions
diff --git a/crates/base_db/src/fixture.rs b/crates/base_db/src/fixture.rs
index 8d4641355..0132565e4 100644
--- a/crates/base_db/src/fixture.rs
+++ b/crates/base_db/src/fixture.rs
@@ -1,62 +1,4 @@
-//! Fixtures are strings containing rust source code with optional metadata.
+//! A set of high-level utility fixture methods to use in tests.
-//! A fixture without metadata is parsed into a single source file.
-//! Use this to test functionality local to one file.
-//!
-//! Simple Example:
-//! ```
-//! r#"
-//! fn main() {
-//!     println!("Hello World")
-//! }
-//! "#
-//! ```
-//!
-//! Metadata can be added to a fixture after a `//-` comment.
-//! The basic form is specifying filenames,
-//! which is also how to define multiple files in a single test fixture
-//!
-//! Example using two files in the same crate:
-//! ```
-//! "
-//! //- /main.rs
-//! mod foo;
-//! fn main() {
-//!     foo::bar();
-//! }
-//!
-//! //- /foo.rs
-//! pub fn bar() {}
-//! "
-//! ```
-//!
-//! Example using two crates with one file each, with one crate depending on the other:
-//! ```
-//! r#"
-//! //- /main.rs crate:a deps:b
-//! fn main() {
-//!     b::foo();
-//! }
-//! //- /lib.rs crate:b
-//! pub fn b() {
-//!     println!("Hello World")
-//! }
-//! "#
-//! ```
-//!
-//! Metadata allows specifying all settings and variables
-//! that are available in a real rust project:
-//! - crate names via `crate:cratename`
-//! - dependencies via `deps:dep1,dep2`
-//! - configuration settings via `cfg:dbg=false,opt_level=2`
-//! - environment variables via `env:PATH=/bin,RUST_LOG=debug`
-//!
-//! Example using all available metadata:
-//! ```
-//! "
-//! //- /lib.rs crate:foo deps:bar,baz cfg:foo=a,bar=b env:OUTDIR=path/to,OTHER=foo
-//! fn insert_source_code_here() {}
-//! "
-//! ```
 use std::{mem, str::FromStr, sync::Arc};
 use cfg::CfgOptions;
@@ -93,7 +35,7 @@ pub trait WithFixture: Default + SourceDatabaseExt + 'static {
    fn with_position(ra_fixture: &str) -> (Self, FilePosition) {
        let (db, file_id, range_or_offset) = Self::with_range_or_offset(ra_fixture);
        let offset = match range_or_offset {
-            RangeOrOffset::Range(_) => panic!(),
+            RangeOrOffset::Range(_) => panic!("Expected a cursor position, got a range instead"),
            RangeOrOffset::Offset(it) => it,
        };
        (db, FilePosition { file_id, offset })
@@ -103,7 +45,7 @@ pub trait WithFixture: Default + SourceDatabaseExt + 'static {
        let (db, file_id, range_or_offset) = Self::with_range_or_offset(ra_fixture);
        let range = match range_or_offset {
            RangeOrOffset::Range(it) => it,
-            RangeOrOffset::Offset(_) => panic!(),
+            RangeOrOffset::Offset(_) => panic!("Expected a cursor range, got a position instead"),
        };
        (db, FileRange { file_id, range })
    }
@@ -112,7 +54,9 @@ pub trait WithFixture: Default + SourceDatabaseExt + 'static {
        let fixture = ChangeFixture::parse(ra_fixture);
        let mut db = Self::default();
        fixture.change.apply(&mut db);
-        let (file_id, range_or_offset) = fixture.file_position.unwrap();
+        let (file_id, range_or_offset) = fixture
+            .file_position
+            .expect("Could not find file position in fixture. Did you forget to add an `$0`?");
        (db, file_id, range_or_offset)
    }
diff --git a/crates/base_db/src/lib.rs b/crates/base_db/src/lib.rs
index 5f77a0b1f..980a0ed98 100644
--- a/crates/base_db/src/lib.rs
+++ b/crates/base_db/src/lib.rs
@@ -59,6 +59,8 @@ pub trait CheckCanceled {
        Self: Sized + panic::RefUnwindSafe,
        F: FnOnce(&Self) -> T + panic::UnwindSafe,
    {
+        // Uncomment to debug missing cancellations.
+        // let _span = profile::heartbeat_span();
        panic::catch_unwind(|| f(self)).map_err(|err| match err.downcast::<Canceled>() {
            Ok(canceled) => *canceled,
            Err(payload) => panic::resume_unwind(payload),
@@ -68,6 +70,7 @@ pub trait CheckCanceled {
 impl<T: salsa::Database> CheckCanceled for T {
    fn check_canceled(&self) {
+        // profile::heartbeat();
        if self.salsa_runtime().is_current_revision_canceled() {
            Canceled::throw()
        }
diff --git a/crates/cfg/src/tests.rs b/crates/cfg/src/tests.rs
index bd0f9ec48..d8736c893 100644
--- a/crates/cfg/src/tests.rs
+++ b/crates/cfg/src/tests.rs
@@ -8,7 +8,7 @@ fn assert_parse_result(input: &str, expected: CfgExpr) {
    let (tt, _) = {
        let source_file = ast::SourceFile::parse(input).ok().unwrap();
        let tt = source_file.syntax().descendants().find_map(ast::TokenTree::cast).unwrap();
-        ast_to_token_tree(&tt).unwrap()
+        ast_to_token_tree(&tt)
    };
    let cfg = CfgExpr::parse(&tt);
    assert_eq!(cfg, expected);
@@ -18,7 +18,7 @@ fn check_dnf(input: &str, expect: Expect) {
    let (tt, _) = {
        let source_file = ast::SourceFile::parse(input).ok().unwrap();
        let tt = source_file.syntax().descendants().find_map(ast::TokenTree::cast).unwrap();
-        ast_to_token_tree(&tt).unwrap()
+        ast_to_token_tree(&tt)
    };
    let cfg = CfgExpr::parse(&tt);
    let actual = format!("#![cfg({})]", DnfExpr::new(cfg));
@@ -29,7 +29,7 @@ fn check_why_inactive(input: &str, opts: &CfgOptions, expect: Expect) {
    let (tt, _) = {
        let source_file = ast::SourceFile::parse(input).ok().unwrap();
        let tt = source_file.syntax().descendants().find_map(ast::TokenTree::cast).unwrap();
-        ast_to_token_tree(&tt).unwrap()
+        ast_to_token_tree(&tt)
    };
    let cfg = CfgExpr::parse(&tt);
    let dnf = DnfExpr::new(cfg);
@@ -42,7 +42,7 @@ fn check_enable_hints(input: &str, opts: &CfgOptions, expected_hints: &[&str]) {
    let (tt, _) = {
        let source_file = ast::SourceFile::parse(input).ok().unwrap();
        let tt = source_file.syntax().descendants().find_map(ast::TokenTree::cast).unwrap();
-        ast_to_token_tree(&tt).unwrap()
+        ast_to_token_tree(&tt)
    };
    let cfg = CfgExpr::parse(&tt);
    let dnf = DnfExpr::new(cfg);
diff --git a/crates/hir/Cargo.toml b/crates/hir/Cargo.toml
index 2ef5bcbc9..9e329656f 100644
--- a/crates/hir/Cargo.toml
+++ b/crates/hir/Cargo.toml
@@ -13,7 +13,7 @@ doctest = false
 log = "0.4.8"
 rustc-hash = "1.1.0"
 either = "1.5.3"
-arrayvec = "0.6"
+arrayvec = "0.7"
 itertools = "0.10.0"
 smallvec = "1.4.0"
diff --git a/crates/hir/src/db.rs b/crates/hir/src/db.rs
index 1902a8d16..df5758342 100644
--- a/crates/hir/src/db.rs
+++ b/crates/hir/src/db.rs
@@ -1,14 +1,6 @@
 //! FIXME: write short doc here
-pub use hir_def::db::{
+pub use hir_def::db::*;
-    AttrsQuery, BlockDefMapQuery, BodyQuery, BodyWithSourceMapQuery, ConstDataQuery,
-    CrateDefMapQueryQuery, CrateLangItemsQuery, DefDatabase, DefDatabaseStorage, EnumDataQuery,
-    ExprScopesQuery, FileItemTreeQuery, FunctionDataQuery, GenericParamsQuery, ImplDataQuery,
-    ImportMapQuery, InternConstQuery, InternDatabase, InternDatabaseStorage, InternEnumQuery,
-    InternFunctionQuery, InternImplQuery, InternStaticQuery, InternStructQuery, InternTraitQuery,
-    InternTypeAliasQuery, InternUnionQuery, LangItemQuery, StaticDataQuery, StructDataQuery,
-    TraitDataQuery, TypeAliasDataQuery, UnionDataQuery,
-};
 pub use hir_expand::db::{
    AstDatabase, AstDatabaseStorage, AstIdMapQuery, HygieneFrameQuery, InternEagerExpansionQuery,
    InternMacroQuery, MacroArgTextQuery, MacroDefQuery, MacroExpandQuery, ParseMacroExpansionQuery,
diff --git a/crates/hir/src/display.rs b/crates/hir/src/display.rs
index 97a78ca25..01a4d205f 100644
--- a/crates/hir/src/display.rs
+++ b/crates/hir/src/display.rs
@@ -9,33 +9,33 @@ use hir_ty::display::{
    write_bounds_like_dyn_trait_with_prefix, write_visibility, HirDisplay, HirDisplayError,
    HirFormatter,
 };
+use hir_ty::Interner;
 use syntax::ast::{self, NameOwner};
 use crate::{
    Adt, Const, ConstParam, Enum, Field, Function, GenericParam, HasVisibility, LifetimeParam,
-    Module, Static, Struct, Substitution, Trait, Type, TypeAlias, TypeParam, Union, Variant,
+    Module, Static, Struct, Trait, TyBuilder, Type, TypeAlias, TypeParam, Union, Variant,
 };
 impl HirDisplay for Function {
    fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
        let data = f.db.function_data(self.id);
        write_visibility(self.module(f.db).id, self.visibility(f.db), f)?;
-        let qual = &data.qualifier;
+        if data.is_default() {
-        if qual.is_default {
            write!(f, "default ")?;
        }
-        if qual.is_const {
+        if data.is_const() {
            write!(f, "const ")?;
        }
-        if qual.is_async {
+        if data.is_async() {
            write!(f, "async ")?;
        }
-        if qual.is_unsafe {
+        if data.is_unsafe() {
            write!(f, "unsafe ")?;
        }
-        if let Some(abi) = &qual.abi {
+        if let Some(abi) = &data.abi {
            // FIXME: String escape?
-            write!(f, "extern \"{}\" ", abi)?;
+            write!(f, "extern \"{}\" ", &**abi)?;
        }
        write!(f, "fn {}", data.name)?;
@@ -68,7 +68,7 @@ impl HirDisplay for Function {
                write!(f, ", ")?;
            } else {
                first = false;
-                if data.has_self_param {
+                if data.has_self_param() {
                    write_self_param(type_ref, f)?;
                    continue;
                }
@@ -88,10 +88,10 @@ impl HirDisplay for Function {
        // `FunctionData::ret_type` will be `::core::future::Future<Output = ...>` for async fns.
        // Use ugly pattern match to strip the Future trait.
        // Better way?
-        let ret_type = if !qual.is_async {
+        let ret_type = if !data.is_async() {
            &data.ret_type
        } else {
-            match &data.ret_type {
+            match &*data.ret_type {
                TypeRef::ImplTrait(bounds) => match &bounds[0] {
                    TypeBound::Path(path) => {
                        path.segments().iter().last().unwrap().args_and_bindings.unwrap().bindings
@@ -235,8 +235,9 @@ impl HirDisplay for TypeParam {
    fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
        write!(f, "{}", self.name(f.db))?;
        let bounds = f.db.generic_predicates_for_param(self.id);
-        let substs = Substitution::type_params(f.db, self.id.parent);
+        let substs = TyBuilder::type_params_subst(f.db, self.id.parent);
-        let predicates = bounds.iter().cloned().map(|b| b.subst(&substs)).collect::<Vec<_>>();
+        let predicates =
+            bounds.iter().cloned().map(|b| b.substitute(&Interner, &substs)).collect::<Vec<_>>();
        if !(predicates.is_empty() || f.omit_verbose_types()) {
            write_bounds_like_dyn_trait_with_prefix(":", &predicates, f)?;
        }
diff --git a/crates/hir/src/lib.rs b/crates/hir/src/lib.rs
index 4ee08ef21..0acfa582a 100644
--- a/crates/hir/src/lib.rs
+++ b/crates/hir/src/lib.rs
@@ -44,6 +44,7 @@ use hir_def::{
    per_ns::PerNs,
    resolver::{HasResolver, Resolver},
    src::HasSource as _,
+    type_ref::TraitRef,
    AdtId, AssocContainerId, AssocItemId, AssocItemLoc, AttrDefId, ConstId, ConstParamId,
    DefWithBodyId, EnumId, FunctionId, GenericDefId, HasModule, ImplId, LifetimeParamId,
    LocalEnumVariantId, LocalFieldId, Lookup, ModuleId, StaticId, StructId, TraitId, TypeAliasId,
@@ -52,13 +53,14 @@ use hir_def::{
 use hir_expand::{diagnostics::DiagnosticSink, name::name, MacroDefKind};
 use hir_ty::{
    autoderef, could_unify,
-    method_resolution::{self, TyFingerprint},
+    method_resolution::{self, def_crates, TyFingerprint},
    primitive::UintTy,
-    to_assoc_type_id,
+    subst_prefix,
-    traits::{FnTrait, Solution, SolutionVariables},
+    traits::FnTrait,
    AliasEq, AliasTy, BoundVar, CallableDefId, CallableSig, Canonical, CanonicalVarKinds, Cast,
-    DebruijnIndex, InEnvironment, Interner, ProjectionTy, QuantifiedWhereClause, Scalar,
+    DebruijnIndex, InEnvironment, Interner, QuantifiedWhereClause, Scalar, Solution, Substitution,
-    Substitution, TraitEnvironment, Ty, TyDefId, TyKind, TyVariableKind, WhereClause,
+    TraitEnvironment, TraitRefExt, Ty, TyBuilder, TyDefId, TyExt, TyKind, TyVariableKind,
+    WhereClause,
 };
 use itertools::Itertools;
 use rustc_hash::FxHashSet;
@@ -514,8 +516,8 @@ impl Field {
            VariantDef::Union(it) => it.id.into(),
            VariantDef::Variant(it) => it.parent.id.into(),
        };
-        let substs = Substitution::type_params(db, generic_def_id);
+        let substs = TyBuilder::type_params_subst(db, generic_def_id);
-        let ty = db.field_types(var_id)[self.id].clone().subst(&substs);
+        let ty = db.field_types(var_id)[self.id].clone().substitute(&Interner, &substs);
        Type::new(db, self.parent.module(db).id.krate(), var_id, ty)
    }
@@ -701,7 +703,7 @@ impl_from!(Struct, Union, Enum for Adt);
 impl Adt {
    pub fn has_non_default_type_params(self, db: &dyn HirDatabase) -> bool {
        let subst = db.generic_defaults(self.into());
-        subst.iter().any(|ty| ty.value.is_unknown())
+        subst.iter().any(|ty| ty.skip_binders().is_unknown())
    }
    /// Turns this ADT into a type. Any type parameters of the ADT will be
@@ -831,7 +833,7 @@ impl Function {
    }
    pub fn self_param(self, db: &dyn HirDatabase) -> Option<SelfParam> {
-        if !db.function_data(self.id).has_self_param {
+        if !db.function_data(self.id).has_self_param() {
            return None;
        }
        Some(SelfParam { func: self.id })
@@ -863,7 +865,7 @@ impl Function {
    }
    pub fn is_unsafe(self, db: &dyn HirDatabase) -> bool {
-        db.function_data(self.id).qualifier.is_unsafe
+        db.function_data(self.id).is_unsafe()
    }
    pub fn diagnostics(self, db: &dyn HirDatabase, sink: &mut DiagnosticSink) {
@@ -877,7 +879,7 @@ impl Function {
    ///
    /// This is false in the case of required (not provided) trait methods.
    pub fn has_body(self, db: &dyn HirDatabase) -> bool {
-        db.function_data(self.id).has_body
+        db.function_data(self.id).has_body()
    }
    /// A textual representation of the HIR of this function for debugging purposes.
@@ -956,7 +958,7 @@ impl SelfParam {
        func_data
            .params
            .first()
-            .map(|param| match *param {
+            .map(|param| match &**param {
                TypeRef::Reference(.., mutability) => match mutability {
                    hir_def::type_ref::Mutability::Shared => Access::Shared,
                    hir_def::type_ref::Mutability::Mut => Access::Exclusive,
@@ -1010,7 +1012,7 @@ impl Const {
    }
    pub fn type_ref(self, db: &dyn HirDatabase) -> TypeRef {
-        db.const_data(self.id).type_ref.clone()
+        db.const_data(self.id).type_ref.as_ref().clone()
    }
 }
@@ -1088,7 +1090,7 @@ pub struct TypeAlias {
 impl TypeAlias {
    pub fn has_non_default_type_params(self, db: &dyn HirDatabase) -> bool {
        let subst = db.generic_defaults(self.id.into());
-        subst.iter().any(|ty| ty.value.is_unknown())
+        subst.iter().any(|ty| ty.skip_binders().is_unknown())
    }
    pub fn module(self, db: &dyn HirDatabase) -> Module {
@@ -1100,7 +1102,7 @@ impl TypeAlias {
    }
    pub fn type_ref(self, db: &dyn HirDatabase) -> Option<TypeRef> {
-        db.type_alias_data(self.id).type_ref.clone()
+        db.type_alias_data(self.id).type_ref.as_deref().cloned()
    }
    pub fn ty(self, db: &dyn HirDatabase) -> Type {
@@ -1128,7 +1130,7 @@ pub struct BuiltinType {
 impl BuiltinType {
    pub fn ty(self, db: &dyn HirDatabase, module: Module) -> Type {
        let resolver = module.id.resolver(db.upcast());
-        Type::new_with_resolver(db, &resolver, Ty::builtin(self.inner))
+        Type::new_with_resolver(db, &resolver, TyBuilder::builtin(self.inner))
            .expect("crate not present in resolver")
    }
@@ -1501,8 +1503,8 @@ impl TypeParam {
        let resolver = self.id.parent.resolver(db.upcast());
        let krate = self.id.parent.module(db.upcast()).krate();
        let ty = params.get(local_idx)?.clone();
-        let subst = Substitution::type_params(db, self.id.parent);
+        let subst = TyBuilder::type_params_subst(db, self.id.parent);
-        let ty = ty.subst(&subst.prefix(local_idx));
+        let ty = ty.substitute(&Interner, &subst_prefix(&subst, local_idx));
        Some(Type::new_with_resolver_inner(db, krate, &resolver, ty))
    }
 }
@@ -1567,22 +1569,35 @@ impl Impl {
    }
    pub fn all_for_type(db: &dyn HirDatabase, Type { krate, ty, .. }: Type) -> Vec<Impl> {
-        let def_crates = match ty.def_crates(db, krate) {
+        let def_crates = match def_crates(db, &ty, krate) {
            Some(def_crates) => def_crates,
            None => return Vec::new(),
        };
        let filter = |impl_def: &Impl| {
-            let target_ty = impl_def.target_ty(db);
+            let self_ty = impl_def.self_ty(db);
-            let rref = target_ty.remove_ref();
+            let rref = self_ty.remove_ref();
-            ty.equals_ctor(rref.as_ref().map_or(&target_ty.ty, |it| &it.ty))
+            ty.equals_ctor(rref.as_ref().map_or(&self_ty.ty, |it| &it.ty))
+        };
+        let fp = TyFingerprint::for_inherent_impl(&ty);
+        let fp = if let Some(fp) = fp {
+            fp
+        } else {
+            return Vec::new();
        };
        let mut all = Vec::new();
        def_crates.iter().for_each(|&id| {
-            all.extend(db.inherent_impls_in_crate(id).all_impls().map(Self::from).filter(filter))
+            all.extend(
+                db.inherent_impls_in_crate(id)
+                    .for_self_ty(&ty)
+                    .into_iter()
+                    .cloned()
+                    .map(Self::from)
+                    .filter(filter),
+            )
        });
-        let fp = TyFingerprint::for_impl(&ty);
        for id in def_crates
            .iter()
            .flat_map(|&id| Crate { id }.transitive_reverse_dependencies(db))
@@ -1590,13 +1605,12 @@ impl Impl {
            .chain(def_crates.iter().copied())
            .unique()
        {
-            match fp {
+            all.extend(
-                Some(fp) => all.extend(
+                db.trait_impls_in_crate(id)
-                    db.trait_impls_in_crate(id).for_self_ty(fp).map(Self::from).filter(filter),
+                    .for_self_ty_without_blanket_impls(fp)
-                ),
+                    .map(Self::from)
-                None => all
+                    .filter(filter),
-                    .extend(db.trait_impls_in_crate(id).all_impls().map(Self::from).filter(filter)),
+            );
-            }
        }
        all
    }
@@ -1613,16 +1627,16 @@ impl Impl {
    // FIXME: the return type is wrong. This should be a hir version of
    // `TraitRef` (ie, resolved `TypeRef`).
-    pub fn target_trait(self, db: &dyn HirDatabase) -> Option<TypeRef> {
+    pub fn trait_(self, db: &dyn HirDatabase) -> Option<TraitRef> {
-        db.impl_data(self.id).target_trait.clone()
+        db.impl_data(self.id).target_trait.as_deref().cloned()
    }
-    pub fn target_ty(self, db: &dyn HirDatabase) -> Type {
+    pub fn self_ty(self, db: &dyn HirDatabase) -> Type {
        let impl_data = db.impl_data(self.id);
        let resolver = self.id.resolver(db.upcast());
        let krate = self.id.lookup(db.upcast()).container.krate();
        let ctx = hir_ty::TyLoweringContext::new(db, &resolver);
-        let ty = ctx.lower_ty(&impl_data.target_type);
+        let ty = ctx.lower_ty(&impl_data.self_ty);
        Type::new_with_resolver_inner(db, krate, &resolver, ty)
    }
@@ -1702,30 +1716,29 @@ impl Type {
    fn from_def(
        db: &dyn HirDatabase,
        krate: CrateId,
-        def: impl HasResolver + Into<TyDefId> + Into<GenericDefId>,
+        def: impl HasResolver + Into<TyDefId>,
    ) -> Type {
-        let substs = Substitution::build_for_def(db, def).fill_with_unknown().build();
+        let ty = TyBuilder::def_ty(db, def.into()).fill_with_unknown().build();
-        let ty = db.ty(def.into()).subst(&substs);
        Type::new(db, krate, def, ty)
    }
    pub fn is_unit(&self) -> bool {
-        matches!(self.ty.interned(&Interner), TyKind::Tuple(0, ..))
+        matches!(self.ty.kind(&Interner), TyKind::Tuple(0, ..))
    }
    pub fn is_bool(&self) -> bool {
-        matches!(self.ty.interned(&Interner), TyKind::Scalar(Scalar::Bool))
+        matches!(self.ty.kind(&Interner), TyKind::Scalar(Scalar::Bool))
    }
    pub fn is_mutable_reference(&self) -> bool {
-        matches!(self.ty.interned(&Interner), TyKind::Ref(hir_ty::Mutability::Mut, ..))
+        matches!(self.ty.kind(&Interner), TyKind::Ref(hir_ty::Mutability::Mut, ..))
    }
    pub fn is_usize(&self) -> bool {
-        matches!(self.ty.interned(&Interner), TyKind::Scalar(Scalar::Uint(UintTy::Usize)))
+        matches!(self.ty.kind(&Interner), TyKind::Scalar(Scalar::Uint(UintTy::Usize)))
    }
    pub fn remove_ref(&self) -> Option<Type> {
-        match &self.ty.interned(&Interner) {
+        match &self.ty.kind(&Interner) {
            TyKind::Ref(.., ty) => Some(self.derived(ty.clone())),
            _ => None,
        }
@@ -1784,16 +1797,13 @@ impl Type {
    }
    pub fn impls_trait(&self, db: &dyn HirDatabase, trait_: Trait, args: &[Type]) -> bool {
-        let trait_ref = hir_ty::TraitRef {
+        let trait_ref = TyBuilder::trait_ref(db, trait_.id)
-            trait_id: hir_ty::to_chalk_trait_id(trait_.id),
+            .push(self.ty.clone())
-            substitution: Substitution::build_for_def(db, trait_.id)
+            .fill(args.iter().map(|t| t.ty.clone()))
-                .push(self.ty.clone())
+            .build();
-                .fill(args.iter().map(|t| t.ty.clone()))
-                .build(),
-        };
        let goal = Canonical {
-            value: hir_ty::InEnvironment::new(self.env.env.clone(), trait_ref.cast(&Interner)),
+            value: hir_ty::InEnvironment::new(&self.env.env, trait_ref.cast(&Interner)),
            binders: CanonicalVarKinds::empty(&Interner),
        };
@@ -1803,22 +1813,18 @@ impl Type {
    pub fn normalize_trait_assoc_type(
        &self,
        db: &dyn HirDatabase,
-        trait_: Trait,
        args: &[Type],
        alias: TypeAlias,
    ) -> Option<Type> {
-        let subst = Substitution::build_for_def(db, trait_.id)
+        let projection = TyBuilder::assoc_type_projection(db, alias.id)
            .push(self.ty.clone())
            .fill(args.iter().map(|t| t.ty.clone()))
            .build();
-        let goal = Canonical::new(
+        let goal = hir_ty::make_canonical(
            InEnvironment::new(
-                self.env.env.clone(),
+                &self.env.env,
                AliasEq {
-                    alias: AliasTy::Projection(ProjectionTy {
+                    alias: AliasTy::Projection(projection),
-                        associated_ty_id: to_assoc_type_id(alias.id),
-                        substitution: subst,
-                    }),
                    ty: TyKind::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, 0))
                        .intern(&Interner),
                }
@@ -1828,9 +1834,12 @@ impl Type {
        );
        match db.trait_solve(self.krate, goal)? {
-            Solution::Unique(SolutionVariables(subst)) => {
+            Solution::Unique(s) => s
-                subst.value.first().map(|ty| self.derived(ty.clone()))
+                .value
-            }
+                .subst
+                .as_slice(&Interner)
+                .first()
+                .map(|ty| self.derived(ty.assert_ty_ref(&Interner).clone())),
            Solution::Ambig(_) => None,
        }
    }
@@ -1852,15 +1861,15 @@ impl Type {
    }
    pub fn is_closure(&self) -> bool {
-        matches!(&self.ty.interned(&Interner), TyKind::Closure { .. })
+        matches!(&self.ty.kind(&Interner), TyKind::Closure { .. })
    }
    pub fn is_fn(&self) -> bool {
-        matches!(&self.ty.interned(&Interner), TyKind::FnDef(..) | TyKind::Function { .. })
+        matches!(&self.ty.kind(&Interner), TyKind::FnDef(..) | TyKind::Function { .. })
    }
    pub fn is_packed(&self, db: &dyn HirDatabase) -> bool {
-        let adt_id = match self.ty.interned(&Interner) {
+        let adt_id = match self.ty.kind(&Interner) {
            &TyKind::Adt(hir_ty::AdtId(adt_id), ..) => adt_id,
            _ => return false,
        };
@@ -1873,27 +1882,30 @@ impl Type {
    }
    pub fn is_raw_ptr(&self) -> bool {
-        matches!(&self.ty.interned(&Interner), TyKind::Raw(..))
+        matches!(&self.ty.kind(&Interner), TyKind::Raw(..))
    }
    pub fn contains_unknown(&self) -> bool {
        return go(&self.ty);
        fn go(ty: &Ty) -> bool {
-            match ty.interned(&Interner) {
+            match ty.kind(&Interner) {
-                TyKind::Unknown => true,
+                TyKind::Error => true,
                TyKind::Adt(_, substs)
                | TyKind::AssociatedType(_, substs)
                | TyKind::Tuple(_, substs)
                | TyKind::OpaqueType(_, substs)
                | TyKind::FnDef(_, substs)
-                | TyKind::Closure(_, substs) => substs.iter().any(go),
+                | TyKind::Closure(_, substs) => {
+                    substs.iter(&Interner).filter_map(|a| a.ty(&Interner)).any(go)
-                TyKind::Array(ty) | TyKind::Slice(ty) | TyKind::Raw(_, ty) | TyKind::Ref(_, ty) => {
-                    go(ty)
                }
+                TyKind::Array(ty, _)
+                | TyKind::Slice(ty)
+                | TyKind::Raw(_, ty)
+                | TyKind::Ref(_, _, ty) => go(ty),
                TyKind::Scalar(_)
                | TyKind::Str
                | TyKind::Never
@@ -1903,13 +1915,15 @@ impl Type {
                | TyKind::Dyn(_)
                | TyKind::Function(_)
                | TyKind::Alias(_)
-                | TyKind::ForeignType(_) => false,
+                | TyKind::Foreign(_)
+                | TyKind::Generator(..)
+                | TyKind::GeneratorWitness(..) => false,
            }
        }
    }
    pub fn fields(&self, db: &dyn HirDatabase) -> Vec<(Field, Type)> {
-        let (variant_id, substs) = match self.ty.interned(&Interner) {
+        let (variant_id, substs) = match self.ty.kind(&Interner) {
            &TyKind::Adt(hir_ty::AdtId(AdtId::StructId(s)), ref substs) => (s.into(), substs),
            &TyKind::Adt(hir_ty::AdtId(AdtId::UnionId(u)), ref substs) => (u.into(), substs),
            _ => return Vec::new(),
@@ -1919,15 +1933,18 @@ impl Type {
            .iter()
            .map(|(local_id, ty)| {
                let def = Field { parent: variant_id.into(), id: local_id };
-                let ty = ty.clone().subst(substs);
+                let ty = ty.clone().substitute(&Interner, substs);
                (def, self.derived(ty))
            })
            .collect()
    }
    pub fn tuple_fields(&self, _db: &dyn HirDatabase) -> Vec<Type> {
-        if let TyKind::Tuple(_, substs) = &self.ty.interned(&Interner) {
+        if let TyKind::Tuple(_, substs) = &self.ty.kind(&Interner) {
-            substs.iter().map(|ty| self.derived(ty.clone())).collect()
+            substs
+                .iter(&Interner)
+                .map(|ty| self.derived(ty.assert_ty_ref(&Interner).clone()))
+                .collect()
        } else {
            Vec::new()
        }
@@ -1953,7 +1970,7 @@ impl Type {
        krate: Crate,
        mut callback: impl FnMut(AssocItem) -> Option<T>,
    ) -> Option<T> {
-        for krate in self.ty.def_crates(db, krate.id)? {
+        for krate in 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) {
@@ -1970,10 +1987,11 @@ impl Type {
    pub fn type_parameters(&self) -> impl Iterator<Item = Type> + '_ {
        self.ty
            .strip_references()
-            .substs()
+            .as_adt()
            .into_iter()
-            .flat_map(|substs| substs.iter())
+            .flat_map(|(_, substs)| substs.iter(&Interner))
-            .map(move |ty| self.derived(ty.clone()))
+            .filter_map(|arg| arg.ty(&Interner).cloned())
+            .map(move |ty| self.derived(ty))
    }
    pub fn iterate_method_candidates<T>(
@@ -2048,6 +2066,18 @@ impl Type {
        self.ty.dyn_trait().map(Into::into)
    }
+    /// If a type can be represented as `dyn Trait`, returns all traits accessible via this type,
+    /// or an empty iterator otherwise.
+    pub fn applicable_inherent_traits<'a>(
+        &'a self,
+        db: &'a dyn HirDatabase,
+    ) -> impl Iterator<Item = Trait> + 'a {
+        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))
+            .map(Trait::from)
+    }
    pub fn as_impl_traits(&self, db: &dyn HirDatabase) -> Option<Vec<Trait>> {
        self.ty.impl_trait_bounds(db).map(|it| {
            it.into_iter()
@@ -2079,7 +2109,7 @@ impl Type {
            substs: &Substitution,
            cb: &mut impl FnMut(Type),
        ) {
-            for ty in substs.iter() {
+            for ty in substs.iter(&Interner).filter_map(|a| a.ty(&Interner)) {
                walk_type(db, &type_.derived(ty.clone()), cb);
            }
        }
@@ -2095,7 +2125,12 @@ impl Type {
                    WhereClause::Implemented(trait_ref) => {
                        cb(type_.clone());
                        // skip the self type. it's likely the type we just got the bounds from
-                        for ty in trait_ref.substitution.iter().skip(1) {
+                        for ty in trait_ref
+                            .substitution
+                            .iter(&Interner)
+                            .skip(1)
+                            .filter_map(|a| a.ty(&Interner))
+                        {
                            walk_type(db, &type_.derived(ty.clone()), cb);
                        }
                    }
@@ -2106,19 +2141,23 @@ impl Type {
        fn walk_type(db: &dyn HirDatabase, type_: &Type, cb: &mut impl FnMut(Type)) {
            let ty = type_.ty.strip_references();
-            match ty.interned(&Interner) {
+            match ty.kind(&Interner) {
-                TyKind::Adt(..) => {
+                TyKind::Adt(_, substs) => {
                    cb(type_.derived(ty.clone()));
+                    walk_substs(db, type_, &substs, cb);
                }
-                TyKind::AssociatedType(..) => {
+                TyKind::AssociatedType(_, substs) => {
                    if let Some(_) = ty.associated_type_parent_trait(db) {
                        cb(type_.derived(ty.clone()));
                    }
+                    walk_substs(db, type_, &substs, cb);
                }
-                TyKind::OpaqueType(..) => {
+                TyKind::OpaqueType(_, subst) => {
                    if let Some(bounds) = ty.impl_trait_bounds(db) {
                        walk_bounds(db, &type_.derived(ty.clone()), &bounds, cb);
                    }
+                    walk_substs(db, type_, subst, cb);
                }
                TyKind::Alias(AliasTy::Opaque(opaque_ty)) => {
                    if let Some(bounds) = ty.impl_trait_bounds(db) {
@@ -2141,15 +2180,24 @@ impl Type {
                    );
                }
-                TyKind::Ref(_, ty) | TyKind::Raw(_, ty) | TyKind::Array(ty) | TyKind::Slice(ty) => {
+                TyKind::Ref(_, _, ty)
+                | TyKind::Raw(_, ty)
+                | TyKind::Array(ty, _)
+                | TyKind::Slice(ty) => {
                    walk_type(db, &type_.derived(ty.clone()), cb);
                }
+                TyKind::FnDef(_, substs)
+                | TyKind::Tuple(_, substs)
+                | TyKind::Closure(.., substs) => {
+                    walk_substs(db, type_, &substs, cb);
+                }
+                TyKind::Function(hir_ty::FnPointer { substitution, .. }) => {
+                    walk_substs(db, type_, &substitution.0, cb);
+                }
                _ => {}
            }
-            if let Some(substs) = ty.substs() {
-                walk_substs(db, type_, &substs, cb);
-            }
        }
        walk_type(db, self, &mut cb);
diff --git a/crates/hir/src/semantics.rs b/crates/hir/src/semantics.rs
index d3caeef4e..7955bf0b5 100644
--- a/crates/hir/src/semantics.rs
+++ b/crates/hir/src/semantics.rs
@@ -76,9 +76,11 @@ impl PathResolution {
    pub fn assoc_type_shorthand_candidates<R>(
        &self,
        db: &dyn HirDatabase,
-        mut cb: impl FnMut(TypeAlias) -> Option<R>,
+        mut cb: impl FnMut(&Name, TypeAlias) -> Option<R>,
    ) -> Option<R> {
-        associated_type_shorthand_candidates(db, self.in_type_ns()?, |_, _, id| cb(id.into()))
+        associated_type_shorthand_candidates(db, self.in_type_ns()?, |name, _, id| {
+            cb(name, id.into())
+        })
    }
 }
@@ -492,9 +494,9 @@ impl<'db> SemanticsImpl<'db> {
    fn resolve_method_call_as_callable(&self, call: &ast::MethodCallExpr) -> Option<Callable> {
        // FIXME: this erases Substs
        let func = self.resolve_method_call(call)?;
-        let ty = self.db.value_ty(func.into());
+        let (ty, _) = self.db.value_ty(func.into()).into_value_and_skipped_binders();
        let resolver = self.analyze(call.syntax()).resolver;
-        let ty = Type::new_with_resolver(self.db, &resolver, ty.value)?;
+        let ty = Type::new_with_resolver(self.db, &resolver, ty)?;
        let mut res = ty.as_callable(self.db)?;
        res.is_bound_method = true;
        Some(res)
diff --git a/crates/hir/src/source_analyzer.rs b/crates/hir/src/source_analyzer.rs
index 37d162b32..847d2537d 100644
--- a/crates/hir/src/source_analyzer.rs
+++ b/crates/hir/src/source_analyzer.rs
@@ -20,7 +20,7 @@ use hir_def::{
 use hir_expand::{hygiene::Hygiene, name::AsName, HirFileId, InFile};
 use hir_ty::{
    diagnostics::{record_literal_missing_fields, record_pattern_missing_fields},
-    InferenceResult, Substitution,
+    InferenceResult, Interner, Substitution, TyExt, TyLoweringContext,
 };
 use syntax::{
    ast::{self, AstNode},
@@ -161,14 +161,15 @@ impl SourceAnalyzer {
        db: &dyn HirDatabase,
        field: &ast::RecordExprField,
    ) -> Option<(Field, Option<Local>)> {
-        let expr_id =
+        let record_expr = ast::RecordExpr::cast(field.syntax().parent().and_then(|p| p.parent())?)?;
-            self.body_source_map.as_ref()?.node_field(InFile::new(self.file_id, field))?;
+        let expr = ast::Expr::from(record_expr);
+        let expr_id = self.body_source_map.as_ref()?.node_expr(InFile::new(self.file_id, &expr))?;
+        let local_name = field.field_name()?.as_name();
        let local = if field.name_ref().is_some() {
            None
        } else {
-            let local_name = field.field_name()?.as_name();
+            let path = ModPath::from_segments(PathKind::Plain, once(local_name.clone()));
-            let path = ModPath::from_segments(PathKind::Plain, once(local_name));
            match self.resolver.resolve_path_in_value_ns_fully(db.upcast(), &path) {
                Some(ValueNs::LocalBinding(pat_id)) => {
                    Some(Local { pat_id, parent: self.resolver.body_owner()? })
@@ -176,18 +177,24 @@ impl SourceAnalyzer {
                _ => None,
            }
        };
-        let struct_field = self.infer.as_ref()?.record_field_resolution(expr_id)?;
+        let variant = self.infer.as_ref()?.variant_resolution_for_expr(expr_id)?;
-        Some((struct_field.into(), local))
+        let variant_data = variant.variant_data(db.upcast());
+        let field = FieldId { parent: variant, local_id: variant_data.field(&local_name)? };
+        Some((field.into(), local))
    }
    pub(crate) fn resolve_record_pat_field(
        &self,
-        _db: &dyn HirDatabase,
+        db: &dyn HirDatabase,
        field: &ast::RecordPatField,
    ) -> Option<Field> {
-        let pat_id = self.pat_id(&field.pat()?)?;
+        let field_name = field.field_name()?.as_name();
-        let struct_field = self.infer.as_ref()?.record_pat_field_resolution(pat_id)?;
+        let record_pat = ast::RecordPat::cast(field.syntax().parent().and_then(|p| p.parent())?)?;
-        Some(struct_field.into())
+        let pat_id = self.pat_id(&record_pat.into())?;
+        let variant = self.infer.as_ref()?.variant_resolution_for_pat(pat_id)?;
+        let variant_data = variant.variant_data(db.upcast());
+        let field = FieldId { parent: variant, local_id: variant_data.field(&field_name)? };
+        Some(field.into())
    }
    pub(crate) fn resolve_macro_call(
@@ -299,7 +306,7 @@ impl SourceAnalyzer {
        let infer = self.infer.as_ref()?;
        let expr_id = self.expr_id(db, &literal.clone().into())?;
-        let substs = infer.type_of_expr[expr_id].substs()?;
+        let substs = infer.type_of_expr[expr_id].as_adt()?.1;
        let (variant, missing_fields, _exhaustive) =
            record_literal_missing_fields(db, infer, expr_id, &body[expr_id])?;
@@ -317,7 +324,7 @@ impl SourceAnalyzer {
        let infer = self.infer.as_ref()?;
        let pat_id = self.pat_id(&pattern.clone().into())?;
-        let substs = infer.type_of_pat[pat_id].substs()?;
+        let substs = infer.type_of_pat[pat_id].as_adt()?.1;
        let (variant, missing_fields, _exhaustive) =
            record_pattern_missing_fields(db, infer, pat_id, &body[pat_id])?;
@@ -339,7 +346,7 @@ impl SourceAnalyzer {
            .into_iter()
            .map(|local_id| {
                let field = FieldId { parent: variant, local_id };
-                let ty = field_types[local_id].clone().subst(substs);
+                let ty = field_types[local_id].clone().substitute(&Interner, substs);
                (field.into(), Type::new_with_resolver_inner(db, krate, &self.resolver, ty))
            })
            .collect()
@@ -466,7 +473,21 @@ fn resolve_hir_path_(
    prefer_value_ns: bool,
 ) -> Option<PathResolution> {
    let types = || {
-        resolver.resolve_path_in_type_ns_fully(db.upcast(), path.mod_path()).map(|ty| match ty {
+        let (ty, unresolved) = match path.type_anchor() {
+            Some(type_ref) => {
+                let (_, res) = TyLoweringContext::new(db, resolver).lower_ty_ext(type_ref);
+                res.map(|ty_ns| (ty_ns, path.segments().first()))
+            }
+            None => {
+                let (ty, remaining) =
+                    resolver.resolve_path_in_type_ns(db.upcast(), path.mod_path())?;
+                match remaining {
+                    Some(remaining) if remaining > 1 => None,
+                    _ => Some((ty, path.segments().get(1))),
+                }
+            }
+        }?;
+        let res = match ty {
            TypeNs::SelfType(it) => PathResolution::SelfType(it.into()),
            TypeNs::GenericParam(id) => PathResolution::TypeParam(TypeParam { id }),
            TypeNs::AdtSelfType(it) | TypeNs::AdtId(it) => {
@@ -476,7 +497,17 @@ fn resolve_hir_path_(
            TypeNs::TypeAliasId(it) => PathResolution::Def(TypeAlias::from(it).into()),
            TypeNs::BuiltinType(it) => PathResolution::Def(BuiltinType::from(it).into()),
            TypeNs::TraitId(it) => PathResolution::Def(Trait::from(it).into()),
-        })
+        };
+        match unresolved {
+            Some(unresolved) => res
+                .assoc_type_shorthand_candidates(db, |name, alias| {
+                    (name == unresolved.name).then(|| alias)
+                })
+                .map(TypeAlias::from)
+                .map(Into::into)
+                .map(PathResolution::Def),
+            None => Some(res),
+        }
    };
    let body_owner = resolver.body_owner();
diff --git a/crates/hir_def/Cargo.toml b/crates/hir_def/Cargo.toml
index 475d337f3..43324d8d9 100644
--- a/crates/hir_def/Cargo.toml
+++ b/crates/hir_def/Cargo.toml
@@ -11,6 +11,7 @@ doctest = false
 [dependencies]
 cov-mark = { version = "1.1", features = ["thread-local"] }
+dashmap = { version = "4.0.2", features = ["raw-api"] }
 log = "0.4.8"
 once_cell = "1.3.1"
 rustc-hash = "1.1.0"
diff --git a/crates/hir_def/src/adt.rs b/crates/hir_def/src/adt.rs
index 58e35353b..402fb1d8d 100644
--- a/crates/hir_def/src/adt.rs
+++ b/crates/hir_def/src/adt.rs
@@ -15,6 +15,7 @@ use tt::{Delimiter, DelimiterKind, Leaf, Subtree, TokenTree};
 use crate::{
    body::{CfgExpander, LowerCtx},
    db::DefDatabase,
+    intern::Interned,
    item_tree::{AttrOwner, Field, Fields, ItemTree, ModItem, RawVisibilityId},
    src::HasChildSource,
    src::HasSource,
@@ -58,7 +59,7 @@ pub enum VariantData {
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct FieldData {
    pub name: Name,
-    pub type_ref: TypeRef,
+    pub type_ref: Interned<TypeRef>,
    pub visibility: RawVisibility,
 }
@@ -292,7 +293,7 @@ fn lower_struct(
                    || Either::Left(fd.clone()),
                    || FieldData {
                        name: Name::new_tuple_field(i),
-                        type_ref: TypeRef::from_ast_opt(&ctx, fd.ty()),
+                        type_ref: Interned::new(TypeRef::from_ast_opt(&ctx, fd.ty())),
                        visibility: RawVisibility::from_ast(db, ast.with_value(fd.visibility())),
                    },
                );
@@ -309,7 +310,7 @@ fn lower_struct(
                    || Either::Right(fd.clone()),
                    || FieldData {
                        name: fd.name().map(|n| n.as_name()).unwrap_or_else(Name::missing),
-                        type_ref: TypeRef::from_ast_opt(&ctx, fd.ty()),
+                        type_ref: Interned::new(TypeRef::from_ast_opt(&ctx, fd.ty())),
                        visibility: RawVisibility::from_ast(db, ast.with_value(fd.visibility())),
                    },
                );
@@ -358,7 +359,7 @@ fn lower_field(
 ) -> FieldData {
    FieldData {
        name: field.name.clone(),
-        type_ref: item_tree[field.type_ref].clone(),
+        type_ref: field.type_ref.clone(),
        visibility: item_tree[override_visibility.unwrap_or(field.visibility)].clone(),
    }
 }
diff --git a/crates/hir_def/src/attr.rs b/crates/hir_def/src/attr.rs
index 52a2bce9b..786fad6e1 100644
--- a/crates/hir_def/src/attr.rs
+++ b/crates/hir_def/src/attr.rs
@@ -1,23 +1,28 @@
 //! A higher level attributes based on TokenTree, with also some shortcuts.
-use std::{ops, sync::Arc};
+use std::{
+    convert::{TryFrom, TryInto},
+    ops,
+    sync::Arc,
+};
 use base_db::CrateId;
 use cfg::{CfgExpr, CfgOptions};
 use either::Either;
-use hir_expand::{hygiene::Hygiene, name::AsName, AstId, InFile};
+use hir_expand::{hygiene::Hygiene, name::AsName, AstId, AttrId, InFile};
 use itertools::Itertools;
 use la_arena::ArenaMap;
 use mbe::ast_to_token_tree;
 use smallvec::{smallvec, SmallVec};
 use syntax::{
    ast::{self, AstNode, AttrsOwner},
-    match_ast, AstToken, SmolStr, SyntaxNode,
+    match_ast, AstPtr, AstToken, SmolStr, SyntaxNode, TextRange, TextSize,
 };
 use tt::Subtree;
 use crate::{
    db::DefDatabase,
+    intern::Interned,
    item_tree::{ItemTreeId, ItemTreeNode},
    nameres::ModuleSource,
    path::{ModPath, PathKind},
@@ -93,13 +98,16 @@ impl RawAttrs {
    pub(crate) fn new(owner: &dyn ast::AttrsOwner, hygiene: &Hygiene) -> Self {
        let entries = collect_attrs(owner)
            .enumerate()
-            .flat_map(|(i, attr)| match attr {
+            .flat_map(|(i, attr)| {
-                Either::Left(attr) => Attr::from_src(attr, hygiene, i as u32),
+                let index = AttrId(i as u32);
-                Either::Right(comment) => comment.doc_comment().map(|doc| Attr {
+                match attr {
-                    index: i as u32,
+                    Either::Left(attr) => Attr::from_src(attr, hygiene, index),
-                    input: Some(AttrInput::Literal(SmolStr::new(doc))),
+                    Either::Right(comment) => comment.doc_comment().map(|doc| Attr {
-                    path: ModPath::from(hir_expand::name!(doc)),
+                        id: index,
-                }),
+                        input: Some(AttrInput::Literal(SmolStr::new(doc))),
+                        path: Interned::new(ModPath::from(hir_expand::name!(doc))),
+                    }),
+                }
            })
            .collect::<Arc<_>>();
@@ -156,7 +164,7 @@ impl RawAttrs {
                let cfg = parts.next().unwrap();
                let cfg = Subtree { delimiter: subtree.delimiter, token_trees: cfg.to_vec() };
                let cfg = CfgExpr::parse(&cfg);
-                let index = attr.index;
+                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()?;
@@ -210,12 +218,11 @@ impl Attrs {
        let mut res = ArenaMap::default();
        for (id, fld) in src.value.iter() {
-            let attrs = match fld {
+            let owner: &dyn AttrsOwner = match fld {
-                Either::Left(_tuple) => Attrs::default(),
+                Either::Left(tuple) => tuple,
-                Either::Right(record) => {
+                Either::Right(record) => record,
-                    RawAttrs::from_attrs_owner(db, src.with_value(record)).filter(db, krate)
-                }
            };
+            let attrs = RawAttrs::from_attrs_owner(db, src.with_value(owner)).filter(db, krate);
            res.insert(id, attrs);
        }
@@ -399,10 +406,14 @@ impl AttrsWithOwner {
                return AttrSourceMap { attrs };
            }
            AttrDefId::FieldId(id) => {
-                id.parent.child_source(db).map(|source| match &source[id.local_id] {
+                let map = db.fields_attrs_source_map(id.parent);
-                    Either::Left(field) => ast::AttrsOwnerNode::new(field.clone()),
+                let file_id = id.parent.file_id(db);
-                    Either::Right(field) => ast::AttrsOwnerNode::new(field.clone()),
+                let root = db.parse_or_expand(file_id).unwrap();
-                })
+                let owner = match &map[id.local_id] {
+                    Either::Left(it) => ast::AttrsOwnerNode::new(it.to_node(&root)),
+                    Either::Right(it) => ast::AttrsOwnerNode::new(it.to_node(&root)),
+                };
+                InFile::new(file_id, owner)
            }
            AttrDefId::AdtId(adt) => match adt {
                AdtId::StructId(id) => id.lookup(db).source(db).map(ast::AttrsOwnerNode::new),
@@ -410,10 +421,12 @@ impl AttrsWithOwner {
                AdtId::EnumId(id) => id.lookup(db).source(db).map(ast::AttrsOwnerNode::new),
            },
            AttrDefId::FunctionId(id) => id.lookup(db).source(db).map(ast::AttrsOwnerNode::new),
-            AttrDefId::EnumVariantId(id) => id
+            AttrDefId::EnumVariantId(id) => {
-                .parent
+                let map = db.variants_attrs_source_map(id.parent);
-                .child_source(db)
+                let file_id = id.parent.lookup(db).id.file_id();
-                .map(|source| ast::AttrsOwnerNode::new(source[id.local_id].clone())),
+                let root = db.parse_or_expand(file_id).unwrap();
+                InFile::new(file_id, ast::AttrsOwnerNode::new(map[id.local_id].to_node(&root)))
+            }
            AttrDefId::StaticId(id) => id.lookup(db).source(db).map(ast::AttrsOwnerNode::new),
            AttrDefId::ConstId(id) => id.lookup(db).source(db).map(ast::AttrsOwnerNode::new),
            AttrDefId::TraitId(id) => id.lookup(db).source(db).map(ast::AttrsOwnerNode::new),
@@ -451,6 +464,55 @@ impl AttrsWithOwner {
                .collect(),
        }
    }
+    pub fn docs_with_rangemap(
+        &self,
+        db: &dyn DefDatabase,
+    ) -> Option<(Documentation, DocsRangeMap)> {
+        // FIXME: code duplication in `docs` above
+        let docs = self.by_key("doc").attrs().flat_map(|attr| match attr.input.as_ref()? {
+            AttrInput::Literal(s) => Some((s, attr.id)),
+            AttrInput::TokenTree(_) => None,
+        });
+        let indent = docs
+            .clone()
+            .flat_map(|(s, _)| s.lines())
+            .filter(|line| !line.chars().all(|c| c.is_whitespace()))
+            .map(|line| line.chars().take_while(|c| c.is_whitespace()).count())
+            .min()
+            .unwrap_or(0);
+        let mut buf = String::new();
+        let mut mapping = Vec::new();
+        for (doc, idx) in docs {
+            // str::lines doesn't yield anything for the empty string
+            if !doc.is_empty() {
+                for line in doc.split('\n') {
+                    let line = line.trim_end();
+                    let line_len = line.len();
+                    let (offset, line) = match line.char_indices().nth(indent) {
+                        Some((offset, _)) => (offset, &line[offset..]),
+                        None => (0, line),
+                    };
+                    let buf_offset = buf.len();
+                    buf.push_str(line);
+                    mapping.push((
+                        TextRange::new(buf_offset.try_into().ok()?, buf.len().try_into().ok()?),
+                        idx,
+                        TextRange::new(offset.try_into().ok()?, line_len.try_into().ok()?),
+                    ));
+                    buf.push('\n');
+                }
+            } else {
+                buf.push('\n');
+            }
+        }
+        buf.pop();
+        if buf.is_empty() {
+            None
+        } else {
+            Some((Documentation(buf), DocsRangeMap { mapping, source: self.source_map(db).attrs }))
+        }
+    }
 }
 fn inner_attributes(
@@ -501,16 +563,54 @@ impl AttrSourceMap {
    /// the attribute represented by `Attr`.
    pub fn source_of(&self, attr: &Attr) -> InFile<&Either<ast::Attr, ast::Comment>> {
        self.attrs
-            .get(attr.index as usize)
+            .get(attr.id.0 as usize)
-            .unwrap_or_else(|| panic!("cannot find `Attr` at index {}", attr.index))
+            .unwrap_or_else(|| panic!("cannot find `Attr` at index {:?}", attr.id))
            .as_ref()
    }
 }
+/// A struct to map text ranges from [`Documentation`] back to TextRanges in the syntax tree.
+pub struct DocsRangeMap {
+    source: Vec<InFile<Either<ast::Attr, ast::Comment>>>,
+    // (docstring-line-range, attr_index, attr-string-range)
+    // a mapping from the text range of a line of the [`Documentation`] to the attribute index and
+    // the original (untrimmed) syntax doc line
+    mapping: Vec<(TextRange, AttrId, TextRange)>,
+}
+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();
+        if !line_docs_range.contains_range(range) {
+            return None;
+        }
+        let relative_range = range - line_docs_range.start();
+        let &InFile { file_id, value: ref source } = &self.source[idx.0 as usize];
+        match source {
+            Either::Left(_) => None, // FIXME, figure out a nice way to handle doc attributes here
+            // as well as for whats done in syntax highlight doc injection
+            Either::Right(comment) => {
+                let text_range = comment.syntax().text_range();
+                let range = TextRange::at(
+                    text_range.start()
+                        + TextSize::try_from(comment.prefix().len()).ok()?
+                        + original_line_src_range.start()
+                        + relative_range.start(),
+                    text_range.len().min(range.len()),
+                );
+                Some(InFile { file_id, value: range })
+            }
+        }
+    }
+}
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Attr {
-    index: u32,
+    pub(crate) id: AttrId,
-    pub(crate) path: ModPath,
+    pub(crate) path: Interned<ModPath>,
    pub(crate) input: Option<AttrInput>,
 }
@@ -523,8 +623,8 @@ pub enum AttrInput {
 }
 impl Attr {
-    fn from_src(ast: ast::Attr, hygiene: &Hygiene, index: u32) -> Option<Attr> {
+    fn from_src(ast: ast::Attr, hygiene: &Hygiene, id: AttrId) -> Option<Attr> {
-        let path = ModPath::from_src(ast.path()?, hygiene)?;
+        let path = Interned::new(ModPath::from_src(ast.path()?, hygiene)?);
        let input = if let Some(ast::Expr::Literal(lit)) = ast.expr() {
            let value = match lit.kind() {
                ast::LiteralKind::String(string) => string.value()?.into(),
@@ -532,11 +632,11 @@ impl Attr {
            };
            Some(AttrInput::Literal(value))
        } else if let Some(tt) = ast.token_tree() {
-            Some(AttrInput::TokenTree(ast_to_token_tree(&tt)?.0))
+            Some(AttrInput::TokenTree(ast_to_token_tree(&tt).0))
        } else {
            None
        };
-        Some(Attr { index, path, input })
+        Some(Attr { id, path, input })
    }
    /// Parses this attribute as a `#[derive]`, returns an iterator that yields all contained paths
@@ -651,7 +751,38 @@ fn collect_attrs(
        .chain(inner_docs.into_iter().flatten())
        .map(|docs_text| (docs_text.syntax().text_range().start(), Either::Right(docs_text)));
    // sort here by syntax node offset because the source can have doc attributes and doc strings be interleaved
-    let attrs: Vec<_> = docs.chain(attrs).sorted_by_key(|&(offset, _)| offset).collect();
+    docs.chain(attrs).sorted_by_key(|&(offset, _)| offset).map(|(_, attr)| attr)
+}
+pub(crate) fn variants_attrs_source_map(
+    db: &dyn DefDatabase,
+    def: EnumId,
+) -> Arc<ArenaMap<LocalEnumVariantId, AstPtr<ast::Variant>>> {
+    let mut res = ArenaMap::default();
+    let child_source = def.child_source(db);
+    for (idx, variant) in child_source.value.iter() {
+        res.insert(idx, AstPtr::new(variant));
+    }
+    Arc::new(res)
+}
+pub(crate) fn fields_attrs_source_map(
+    db: &dyn DefDatabase,
+    def: VariantId,
+) -> Arc<ArenaMap<LocalFieldId, Either<AstPtr<ast::TupleField>, AstPtr<ast::RecordField>>>> {
+    let mut res = ArenaMap::default();
+    let child_source = def.child_source(db);
+    for (idx, variant) in child_source.value.iter() {
+        res.insert(
+            idx,
+            variant
+                .as_ref()
+                .either(|l| Either::Left(AstPtr::new(l)), |r| Either::Right(AstPtr::new(r))),
+        );
+    }
-    attrs.into_iter().map(|(_, attr)| attr)
+    Arc::new(res)
 }
diff --git a/crates/hir_def/src/body.rs b/crates/hir_def/src/body.rs
index 1080d9c2c..96b959967 100644
--- a/crates/hir_def/src/body.rs
+++ b/crates/hir_def/src/body.rs
@@ -226,7 +226,7 @@ pub struct Body {
    /// The `ExprId` of the actual body expression.
    pub body_expr: ExprId,
    /// Block expressions in this body that may contain inner items.
-    pub block_scopes: Vec<BlockId>,
+    block_scopes: Vec<BlockId>,
    _c: Count<Self>,
 }
@@ -302,7 +302,8 @@ impl Body {
            }
        };
        let expander = Expander::new(db, file_id, module);
-        let (body, source_map) = Body::new(db, expander, params, body);
+        let (mut body, source_map) = Body::new(db, expander, params, body);
+        body.shrink_to_fit();
        (Arc::new(body), Arc::new(source_map))
    }
@@ -310,6 +311,16 @@ impl Body {
        db.body_with_source_map(def).0
    }
+    /// Returns an iterator over all block expressions in this body that define inner items.
+    pub fn blocks<'a>(
+        &'a self,
+        db: &'a dyn DefDatabase,
+    ) -> impl Iterator<Item = (BlockId, Arc<DefMap>)> + '_ {
+        self.block_scopes
+            .iter()
+            .map(move |block| (*block, db.block_def_map(*block).expect("block ID without DefMap")))
+    }
    fn new(
        db: &dyn DefDatabase,
        expander: Expander,
@@ -318,6 +329,15 @@ impl Body {
    ) -> (Body, BodySourceMap) {
        lower::lower(db, expander, params, body)
    }
+    fn shrink_to_fit(&mut self) {
+        let Self { _c: _, body_expr: _, block_scopes, exprs, labels, params, pats } = self;
+        block_scopes.shrink_to_fit();
+        exprs.shrink_to_fit();
+        labels.shrink_to_fit();
+        params.shrink_to_fit();
+        pats.shrink_to_fit();
+    }
 }
 impl Index<ExprId> for Body {
diff --git a/crates/hir_def/src/body/lower.rs b/crates/hir_def/src/body/lower.rs
index 229e81dd4..c0b0b7841 100644
--- a/crates/hir_def/src/body/lower.rs
+++ b/crates/hir_def/src/body/lower.rs
@@ -30,6 +30,7 @@ use crate::{
        LabelId, Literal, LogicOp, MatchArm, Ordering, Pat, PatId, RecordFieldPat, RecordLitField,
        Statement,
    },
+    intern::Interned,
    item_scope::BuiltinShadowMode,
    path::{GenericArgs, Path},
    type_ref::{Mutability, Rawness, TypeRef},
@@ -322,8 +323,10 @@ impl ExprCollector<'_> {
                    Vec::new()
                };
                let method_name = e.name_ref().map(|nr| nr.as_name()).unwrap_or_else(Name::missing);
-                let generic_args =
+                let generic_args = e
-                    e.generic_arg_list().and_then(|it| GenericArgs::from_ast(&self.ctx(), it));
+                    .generic_arg_list()
+                    .and_then(|it| GenericArgs::from_ast(&self.ctx(), it))
+                    .map(Box::new);
                self.alloc_expr(
                    Expr::MethodCall { receiver, method_name, args, generic_args },
                    syntax_ptr,
@@ -385,7 +388,7 @@ impl ExprCollector<'_> {
                self.alloc_expr(Expr::Yield { expr }, syntax_ptr)
            }
            ast::Expr::RecordExpr(e) => {
-                let path = e.path().and_then(|path| self.expander.parse_path(path));
+                let path = e.path().and_then(|path| self.expander.parse_path(path)).map(Box::new);
                let record_lit = if let Some(nfl) = e.record_expr_field_list() {
                    let fields = nfl
                        .fields()
@@ -430,7 +433,7 @@ impl ExprCollector<'_> {
            }
            ast::Expr::CastExpr(e) => {
                let expr = self.collect_expr_opt(e.expr());
-                let type_ref = TypeRef::from_ast_opt(&self.ctx(), e.ty());
+                let type_ref = Interned::new(TypeRef::from_ast_opt(&self.ctx(), e.ty()));
                self.alloc_expr(Expr::Cast { expr, type_ref }, syntax_ptr)
            }
            ast::Expr::RefExpr(e) => {
@@ -464,13 +467,16 @@ impl ExprCollector<'_> {
                if let Some(pl) = e.param_list() {
                    for param in pl.params() {
                        let pat = self.collect_pat_opt(param.pat());
-                        let type_ref = param.ty().map(|it| TypeRef::from_ast(&self.ctx(), it));
+                        let type_ref =
+                            param.ty().map(|it| Interned::new(TypeRef::from_ast(&self.ctx(), it)));
                        args.push(pat);
                        arg_types.push(type_ref);
                    }
                }
-                let ret_type =
+                let ret_type = e
-                    e.ret_type().and_then(|r| r.ty()).map(|it| TypeRef::from_ast(&self.ctx(), it));
+                    .ret_type()
+                    .and_then(|r| r.ty())
+                    .map(|it| Interned::new(TypeRef::from_ast(&self.ctx(), it)));
                let body = self.collect_expr_opt(e.body());
                self.alloc_expr(Expr::Lambda { args, arg_types, ret_type, body }, syntax_ptr)
            }
@@ -525,8 +531,9 @@ impl ExprCollector<'_> {
                }
            }
            ast::Expr::MacroCall(e) => {
+                let macro_ptr = AstPtr::new(&e);
                let mut ids = vec![];
-                self.collect_macro_call(e, syntax_ptr.clone(), true, |this, expansion| {
+                self.collect_macro_call(e, macro_ptr, true, |this, expansion| {
                    ids.push(match expansion {
                        Some(it) => this.collect_expr(it),
                        None => this.alloc_expr(Expr::Missing, syntax_ptr.clone()),
@@ -549,7 +556,7 @@ impl ExprCollector<'_> {
    fn collect_macro_call<F: FnMut(&mut Self, Option<T>), T: ast::AstNode>(
        &mut self,
        e: ast::MacroCall,
-        syntax_ptr: AstPtr<ast::Expr>,
+        syntax_ptr: AstPtr<ast::MacroCall>,
        is_error_recoverable: bool,
        mut collector: F,
    ) {
@@ -561,9 +568,13 @@ impl ExprCollector<'_> {
        let res = match res {
            Ok(res) => res,
-            Err(UnresolvedMacro) => {
+            Err(UnresolvedMacro { path }) => {
                self.source_map.diagnostics.push(BodyDiagnostic::UnresolvedMacroCall(
-                    UnresolvedMacroCall { file: outer_file, node: syntax_ptr.cast().unwrap() },
+                    UnresolvedMacroCall {
+                        file: outer_file,
+                        node: syntax_ptr.cast().unwrap(),
+                        path,
+                    },
                ));
                collector(self, None);
                return;
@@ -625,7 +636,8 @@ impl ExprCollector<'_> {
                    return;
                }
                let pat = self.collect_pat_opt(stmt.pat());
-                let type_ref = stmt.ty().map(|it| TypeRef::from_ast(&self.ctx(), it));
+                let type_ref =
+                    stmt.ty().map(|it| Interned::new(TypeRef::from_ast(&self.ctx(), it)));
                let initializer = stmt.initializer().map(|e| self.collect_expr(e));
                self.statements_in_scope.push(Statement::Let { pat, type_ref, initializer });
            }
@@ -636,10 +648,14 @@ impl ExprCollector<'_> {
                // Note that macro could be expended to multiple statements
                if let Some(ast::Expr::MacroCall(m)) = stmt.expr() {
+                    let macro_ptr = AstPtr::new(&m);
                    let syntax_ptr = AstPtr::new(&stmt.expr().unwrap());
-                    self.collect_macro_call(m, syntax_ptr.clone(), false, |this, expansion| {
+                    self.collect_macro_call(
-                        match expansion {
+                        m,
+                        macro_ptr,
+                        false,
+                        |this, expansion| match expansion {
                            Some(expansion) => {
                                let statements: ast::MacroStmts = expansion;
@@ -653,8 +669,8 @@ impl ExprCollector<'_> {
                                let expr = this.alloc_expr(Expr::Missing, syntax_ptr.clone());
                                this.statements_in_scope.push(Statement::Expr(expr));
                            }
-                        }
+                        },
-                    });
+                    );
                } else {
                    let expr = self.collect_expr_opt(stmt.expr());
                    self.statements_in_scope.push(Statement::Expr(expr));
@@ -673,12 +689,14 @@ impl ExprCollector<'_> {
        let block_loc =
            BlockLoc { ast_id, module: self.expander.def_map.module_id(self.expander.module) };
        let block_id = self.db.intern_block(block_loc);
-        self.body.block_scopes.push(block_id);
-        let opt_def_map = self.db.block_def_map(block_id);
+        let (module, def_map) = match self.db.block_def_map(block_id) {
-        let has_def_map = opt_def_map.is_some();
+            Some(def_map) => {
-        let def_map = opt_def_map.unwrap_or_else(|| self.expander.def_map.clone());
+                self.body.block_scopes.push(block_id);
-        let module = if has_def_map { def_map.root() } else { self.expander.module };
+                (def_map.root(), def_map)
+            }
+            None => (self.expander.module, self.expander.def_map.clone()),
+        };
        let prev_def_map = mem::replace(&mut self.expander.def_map, def_map);
        let prev_local_module = mem::replace(&mut self.expander.module, module);
        let prev_statements = std::mem::take(&mut self.statements_in_scope);
@@ -753,7 +771,7 @@ impl ExprCollector<'_> {
                }
            }
            ast::Pat::TupleStructPat(p) => {
-                let path = p.path().and_then(|path| self.expander.parse_path(path));
+                let path = p.path().and_then(|path| self.expander.parse_path(path)).map(Box::new);
                let (args, ellipsis) = self.collect_tuple_pat(p.fields());
                Pat::TupleStruct { path, args, ellipsis }
            }
@@ -763,7 +781,7 @@ impl ExprCollector<'_> {
                Pat::Ref { pat, mutability }
            }
            ast::Pat::PathPat(p) => {
-                let path = p.path().and_then(|path| self.expander.parse_path(path));
+                let path = p.path().and_then(|path| self.expander.parse_path(path)).map(Box::new);
                path.map(Pat::Path).unwrap_or(Pat::Missing)
            }
            ast::Pat::OrPat(p) => {
@@ -777,7 +795,7 @@ impl ExprCollector<'_> {
            }
            ast::Pat::WildcardPat(_) => Pat::Wild,
            ast::Pat::RecordPat(p) => {
-                let path = p.path().and_then(|path| self.expander.parse_path(path));
+                let path = p.path().and_then(|path| self.expander.parse_path(path)).map(Box::new);
                let args: Vec<_> = p
                    .record_pat_field_list()
                    .expect("every struct should have a field list")
@@ -839,8 +857,23 @@ impl ExprCollector<'_> {
                    Pat::Missing
                }
            }
+            ast::Pat::MacroPat(mac) => match mac.macro_call() {
+                Some(call) => {
+                    let macro_ptr = AstPtr::new(&call);
+                    let mut pat = None;
+                    self.collect_macro_call(call, macro_ptr, true, |this, expanded_pat| {
+                        pat = Some(this.collect_pat_opt(expanded_pat));
+                    });
+                    match pat {
+                        Some(pat) => return pat,
+                        None => Pat::Missing,
+                    }
+                }
+                None => Pat::Missing,
+            },
            // FIXME: implement
-            ast::Pat::RangePat(_) | ast::Pat::MacroPat(_) => Pat::Missing,
+            ast::Pat::RangePat(_) => Pat::Missing,
        };
        let ptr = AstPtr::new(&pat);
        self.alloc_pat(pattern, Either::Left(ptr))
diff --git a/crates/hir_def/src/body/tests.rs b/crates/hir_def/src/body/tests.rs
index faa133297..63f5fe88d 100644
--- a/crates/hir_def/src/body/tests.rs
+++ b/crates/hir_def/src/body/tests.rs
@@ -143,7 +143,7 @@ fn f() {
  //^^^^^^^^^^^^^ could not convert tokens
    env!("OUT_DIR");
-  //^^^^^^^^^^^^^^^ `OUT_DIR` not set, enable "load out dirs from check" to fix
+  //^^^^^^^^^^^^^^^ `OUT_DIR` not set, enable "run build scripts" to fix
    compile_error!("compile_error works");
  //^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ compile_error works
@@ -180,7 +180,7 @@ fn unresolved_macro_diag() {
        r#"
 fn f() {
    m!();
-  //^^^^ unresolved macro call
+  //^^^^ unresolved macro `m!`
 }
      "#,
    );
diff --git a/crates/hir_def/src/child_by_source.rs b/crates/hir_def/src/child_by_source.rs
index 2a331dcaf..f2e809ca9 100644
--- a/crates/hir_def/src/child_by_source.rs
+++ b/crates/hir_def/src/child_by_source.rs
@@ -80,6 +80,10 @@ impl ChildBySource for ModuleId {
 impl ChildBySource for ItemScope {
    fn child_by_source_to(&self, db: &dyn DefDatabase, res: &mut DynMap) {
        self.declarations().for_each(|item| add_module_def(db, res, item));
+        self.unnamed_consts().for_each(|konst| {
+            let src = konst.lookup(db).source(db);
+            res[keys::CONST].insert(src, konst);
+        });
        self.impls().for_each(|imp| add_impl(db, res, imp));
        fn add_module_def(db: &dyn DefDatabase, map: &mut DynMap, item: ModuleDefId) {
@@ -160,7 +164,7 @@ impl ChildBySource for EnumId {
 impl ChildBySource for DefWithBodyId {
    fn child_by_source_to(&self, db: &dyn DefDatabase, res: &mut DynMap) {
        let body = db.body(*self);
-        for def_map in body.block_scopes.iter().filter_map(|block| db.block_def_map(*block)) {
+        for (_, def_map) in body.blocks(db) {
            // All block expressions are merged into the same map, because they logically all add
            // inner items to the containing `DefWithBodyId`.
            def_map[def_map.root()].scope.child_by_source_to(db, res);
diff --git a/crates/hir_def/src/data.rs b/crates/hir_def/src/data.rs
index 0be868ba2..135a6698e 100644
--- a/crates/hir_def/src/data.rs
+++ b/crates/hir_def/src/data.rs
@@ -9,8 +9,9 @@ use crate::{
    attr::Attrs,
    body::Expander,
    db::DefDatabase,
-    item_tree::{AssocItem, FunctionQualifier, ItemTreeId, ModItem, Param},
+    intern::Interned,
-    type_ref::{TypeBound, TypeRef},
+    item_tree::{AssocItem, FnFlags, ItemTreeId, ModItem, Param},
+    type_ref::{TraitRef, TypeBound, TypeRef},
    visibility::RawVisibility,
    AssocContainerId, AssocItemId, ConstId, ConstLoc, FunctionId, FunctionLoc, HasModule, ImplId,
    Intern, Lookup, ModuleId, StaticId, TraitId, TypeAliasId, TypeAliasLoc,
@@ -19,17 +20,12 @@ use crate::{
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct FunctionData {
    pub name: Name,
-    pub params: Vec<TypeRef>,
+    pub params: Vec<Interned<TypeRef>>,
-    pub ret_type: TypeRef,
+    pub ret_type: Interned<TypeRef>,
    pub attrs: Attrs,
-    /// True if the first param is `self`. This is relevant to decide whether this
-    /// can be called as a method.
-    pub has_self_param: bool,
-    pub has_body: bool,
-    pub qualifier: FunctionQualifier,
-    pub is_in_extern_block: bool,
-    pub is_varargs: bool,
    pub visibility: RawVisibility,
+    pub abi: Option<Interned<str>>,
+    flags: FnFlags,
 }
 impl FunctionData {
@@ -52,31 +48,67 @@ impl FunctionData {
            .next_back()
            .map_or(false, |param| matches!(item_tree[param], Param::Varargs));
+        let mut flags = func.flags;
+        if is_varargs {
+            flags.bits |= FnFlags::IS_VARARGS;
+        }
        Arc::new(FunctionData {
            name: func.name.clone(),
            params: enabled_params
                .clone()
                .filter_map(|id| match &item_tree[id] {
-                    Param::Normal(ty) => Some(item_tree[*ty].clone()),
+                    Param::Normal(ty) => Some(ty.clone()),
                    Param::Varargs => None,
                })
                .collect(),
-            ret_type: item_tree[func.ret_type].clone(),
+            ret_type: func.ret_type.clone(),
            attrs: item_tree.attrs(db, krate, ModItem::from(loc.id.value).into()),
-            has_self_param: func.has_self_param,
-            has_body: func.has_body,
-            qualifier: func.qualifier.clone(),
-            is_in_extern_block: func.is_in_extern_block,
-            is_varargs,
            visibility: item_tree[func.visibility].clone(),
+            abi: func.abi.clone(),
+            flags,
        })
    }
+    pub fn has_body(&self) -> bool {
+        self.flags.bits & FnFlags::HAS_BODY != 0
+    }
+    /// True if the first param is `self`. This is relevant to decide whether this
+    /// can be called as a method.
+    pub fn has_self_param(&self) -> bool {
+        self.flags.bits & FnFlags::HAS_SELF_PARAM != 0
+    }
+    pub fn is_default(&self) -> bool {
+        self.flags.bits & FnFlags::IS_DEFAULT != 0
+    }
+    pub fn is_const(&self) -> bool {
+        self.flags.bits & FnFlags::IS_CONST != 0
+    }
+    pub fn is_async(&self) -> bool {
+        self.flags.bits & FnFlags::IS_ASYNC != 0
+    }
+    pub fn is_unsafe(&self) -> bool {
+        self.flags.bits & FnFlags::IS_UNSAFE != 0
+    }
+    pub fn is_in_extern_block(&self) -> bool {
+        self.flags.bits & FnFlags::IS_IN_EXTERN_BLOCK != 0
+    }
+    pub fn is_varargs(&self) -> bool {
+        self.flags.bits & FnFlags::IS_VARARGS != 0
+    }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct TypeAliasData {
    pub name: Name,
-    pub type_ref: Option<TypeRef>,
+    pub type_ref: Option<Interned<TypeRef>>,
    pub visibility: RawVisibility,
    pub is_extern: bool,
    /// Bounds restricting the type alias itself (eg. `type Ty: Bound;` in a trait or impl).
@@ -94,7 +126,7 @@ impl TypeAliasData {
        Arc::new(TypeAliasData {
            name: typ.name.clone(),
-            type_ref: typ.type_ref.map(|id| item_tree[id].clone()),
+            type_ref: typ.type_ref.clone(),
            visibility: item_tree[typ.visibility].clone(),
            is_extern: typ.is_extern,
            bounds: typ.bounds.to_vec(),
@@ -156,8 +188,8 @@ impl TraitData {
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct ImplData {
-    pub target_trait: Option<TypeRef>,
+    pub target_trait: Option<Interned<TraitRef>>,
-    pub target_type: TypeRef,
+    pub self_ty: Interned<TypeRef>,
    pub items: Vec<AssocItemId>,
    pub is_negative: bool,
 }
@@ -169,8 +201,8 @@ impl ImplData {
        let item_tree = impl_loc.id.item_tree(db);
        let impl_def = &item_tree[impl_loc.id.value];
-        let target_trait = impl_def.target_trait.map(|id| item_tree[id].clone());
+        let target_trait = impl_def.target_trait.clone();
-        let target_type = item_tree[impl_def.target_type].clone();
+        let self_ty = impl_def.self_ty.clone();
        let is_negative = impl_def.is_negative;
        let module_id = impl_loc.container;
        let container = AssocContainerId::ImplId(id);
@@ -187,7 +219,7 @@ impl ImplData {
        );
        let items = items.into_iter().map(|(_, item)| item).collect();
-        Arc::new(ImplData { target_trait, target_type, items, is_negative })
+        Arc::new(ImplData { target_trait, self_ty, items, is_negative })
    }
 }
@@ -195,7 +227,7 @@ impl ImplData {
 pub struct ConstData {
    /// const _: () = ();
    pub name: Option<Name>,
-    pub type_ref: TypeRef,
+    pub type_ref: Interned<TypeRef>,
    pub visibility: RawVisibility,
 }
@@ -207,7 +239,7 @@ impl ConstData {
        Arc::new(ConstData {
            name: konst.name.clone(),
-            type_ref: item_tree[konst.type_ref].clone(),
+            type_ref: konst.type_ref.clone(),
            visibility: item_tree[konst.visibility].clone(),
        })
    }
@@ -216,7 +248,7 @@ impl ConstData {
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct StaticData {
    pub name: Option<Name>,
-    pub type_ref: TypeRef,
+    pub type_ref: Interned<TypeRef>,
    pub visibility: RawVisibility,
    pub mutable: bool,
    pub is_extern: bool,
@@ -230,7 +262,7 @@ impl StaticData {
        Arc::new(StaticData {
            name: Some(statik.name.clone()),
-            type_ref: item_tree[statik.type_ref].clone(),
+            type_ref: statik.type_ref.clone(),
            visibility: item_tree[statik.visibility].clone(),
            mutable: statik.mutable,
            is_extern: statik.is_extern,
diff --git a/crates/hir_def/src/db.rs b/crates/hir_def/src/db.rs
index 068b2ee38..7eadc8e0d 100644
--- a/crates/hir_def/src/db.rs
+++ b/crates/hir_def/src/db.rs
@@ -2,9 +2,10 @@
 use std::sync::Arc;
 use base_db::{salsa, CrateId, SourceDatabase, Upcast};
+use either::Either;
 use hir_expand::{db::AstDatabase, HirFileId};
 use la_arena::ArenaMap;
-use syntax::SmolStr;
+use syntax::{ast, AstPtr, SmolStr};
 use crate::{
    adt::{EnumData, StructData},
@@ -13,6 +14,7 @@ use crate::{
    data::{ConstData, FunctionData, ImplData, StaticData, TraitData, TypeAliasData},
    generics::GenericParams,
    import_map::ImportMap,
+    intern::Interned,
    item_tree::ItemTree,
    lang_item::{LangItemTarget, LangItems},
    nameres::DefMap,
@@ -113,7 +115,7 @@ pub trait DefDatabase: InternDatabase + AstDatabase + Upcast<dyn AstDatabase> {
    fn expr_scopes(&self, def: DefWithBodyId) -> Arc<ExprScopes>;
    #[salsa::invoke(GenericParams::generic_params_query)]
-    fn generic_params(&self, def: GenericDefId) -> Arc<GenericParams>;
+    fn generic_params(&self, def: GenericDefId) -> Interned<GenericParams>;
    #[salsa::invoke(Attrs::variants_attrs_query)]
    fn variants_attrs(&self, def: EnumId) -> Arc<ArenaMap<LocalEnumVariantId, Attrs>>;
@@ -121,6 +123,18 @@ pub trait DefDatabase: InternDatabase + AstDatabase + Upcast<dyn AstDatabase> {
    #[salsa::invoke(Attrs::fields_attrs_query)]
    fn fields_attrs(&self, def: VariantId) -> Arc<ArenaMap<LocalFieldId, Attrs>>;
+    #[salsa::invoke(crate::attr::variants_attrs_source_map)]
+    fn variants_attrs_source_map(
+        &self,
+        def: EnumId,
+    ) -> Arc<ArenaMap<LocalEnumVariantId, AstPtr<ast::Variant>>>;
+    #[salsa::invoke(crate::attr::fields_attrs_source_map)]
+    fn fields_attrs_source_map(
+        &self,
+        def: VariantId,
+    ) -> Arc<ArenaMap<LocalFieldId, Either<AstPtr<ast::TupleField>, AstPtr<ast::RecordField>>>>;
    #[salsa::invoke(AttrsWithOwner::attrs_query)]
    fn attrs(&self, def: AttrDefId) -> AttrsWithOwner;
diff --git a/crates/hir_def/src/diagnostics.rs b/crates/hir_def/src/diagnostics.rs
index 97abf8653..a71ae2668 100644
--- a/crates/hir_def/src/diagnostics.rs
+++ b/crates/hir_def/src/diagnostics.rs
@@ -8,7 +8,7 @@ use hir_expand::diagnostics::{Diagnostic, DiagnosticCode, DiagnosticSink};
 use hir_expand::{HirFileId, InFile};
 use syntax::{ast, AstPtr, SyntaxNodePtr, TextRange};
-use crate::{db::DefDatabase, DefWithBodyId};
+use crate::{db::DefDatabase, path::ModPath, DefWithBodyId};
 pub fn validate_body(db: &dyn DefDatabase, owner: DefWithBodyId, sink: &mut DiagnosticSink<'_>) {
    let source_map = db.body_with_source_map(owner).1;
@@ -103,6 +103,7 @@ impl Diagnostic for UnresolvedImport {
 pub struct UnresolvedMacroCall {
    pub file: HirFileId,
    pub node: AstPtr<ast::MacroCall>,
+    pub path: ModPath,
 }
 impl Diagnostic for UnresolvedMacroCall {
@@ -110,7 +111,7 @@ impl Diagnostic for UnresolvedMacroCall {
        DiagnosticCode("unresolved-macro-call")
    }
    fn message(&self) -> String {
-        "unresolved macro call".to_string()
+        format!("unresolved macro `{}!`", self.path)
    }
    fn display_source(&self) -> InFile<SyntaxNodePtr> {
        InFile::new(self.file, self.node.clone().into())
diff --git a/crates/hir_def/src/expr.rs b/crates/hir_def/src/expr.rs
index 6c7376fad..b4ad984bd 100644
--- a/crates/hir_def/src/expr.rs
+++ b/crates/hir_def/src/expr.rs
@@ -18,6 +18,7 @@ use syntax::ast::RangeOp;
 use crate::{
    builtin_type::{BuiltinFloat, BuiltinInt, BuiltinUint},
+    intern::Interned,
    path::{GenericArgs, Path},
    type_ref::{Mutability, Rawness, TypeRef},
    BlockId,
@@ -86,7 +87,7 @@ pub enum Expr {
        receiver: ExprId,
        method_name: Name,
        args: Vec<ExprId>,
-        generic_args: Option<GenericArgs>,
+        generic_args: Option<Box<GenericArgs>>,
    },
    Match {
        expr: ExprId,
@@ -106,7 +107,7 @@ pub enum Expr {
        expr: Option<ExprId>,
    },
    RecordLit {
-        path: Option<Path>,
+        path: Option<Box<Path>>,
        fields: Vec<RecordLitField>,
        spread: Option<ExprId>,
    },
@@ -131,7 +132,7 @@ pub enum Expr {
    },
    Cast {
        expr: ExprId,
-        type_ref: TypeRef,
+        type_ref: Interned<TypeRef>,
    },
    Ref {
        expr: ExprId,
@@ -161,8 +162,8 @@ pub enum Expr {
    },
    Lambda {
        args: Vec<PatId>,
-        arg_types: Vec<Option<TypeRef>>,
+        arg_types: Vec<Option<Interned<TypeRef>>>,
-        ret_type: Option<TypeRef>,
+        ret_type: Option<Interned<TypeRef>>,
        body: ExprId,
    },
    Tuple {
@@ -240,7 +241,7 @@ pub struct RecordLitField {
 #[derive(Debug, Clone, Eq, PartialEq)]
 pub enum Statement {
-    Let { pat: PatId, type_ref: Option<TypeRef>, initializer: Option<ExprId> },
+    Let { pat: PatId, type_ref: Option<Interned<TypeRef>>, initializer: Option<ExprId> },
    Expr(ExprId),
 }
@@ -412,13 +413,13 @@ pub enum Pat {
    Wild,
    Tuple { args: Vec<PatId>, ellipsis: Option<usize> },
    Or(Vec<PatId>),
-    Record { path: Option<Path>, args: Vec<RecordFieldPat>, ellipsis: bool },
+    Record { path: Option<Box<Path>>, args: Vec<RecordFieldPat>, ellipsis: bool },
    Range { start: ExprId, end: ExprId },
    Slice { prefix: Vec<PatId>, slice: Option<PatId>, suffix: Vec<PatId> },
-    Path(Path),
+    Path(Box<Path>),
    Lit(ExprId),
    Bind { mode: BindingAnnotation, name: Name, subpat: Option<PatId> },
-    TupleStruct { path: Option<Path>, args: Vec<PatId>, ellipsis: Option<usize> },
+    TupleStruct { path: Option<Box<Path>>, args: Vec<PatId>, ellipsis: Option<usize> },
    Ref { pat: PatId, mutability: Mutability },
    Box { inner: PatId },
    ConstBlock(ExprId),
diff --git a/crates/hir_def/src/find_path.rs b/crates/hir_def/src/find_path.rs
index 109d3552f..2c4bbe585 100644
--- a/crates/hir_def/src/find_path.rs
+++ b/crates/hir_def/src/find_path.rs
@@ -425,106 +425,142 @@ mod tests {
    #[test]
    fn same_module() {
-        let code = r#"
+        check_found_path(
-            //- /main.rs
+            r#"
-            struct S;
+struct S;
-            $0
+$0
-        "#;
+        "#,
-        check_found_path(code, "S", "S", "crate::S", "self::S");
+            "S",
+            "S",
+            "crate::S",
+            "self::S",
+        );
    }
    #[test]
    fn enum_variant() {
-        let code = r#"
+        check_found_path(
-            //- /main.rs
+            r#"
-            enum E { A }
+enum E { A }
-            $0
+$0
-        "#;
+        "#,
-        check_found_path(code, "E::A", "E::A", "E::A", "E::A");
+            "E::A",
+            "E::A",
+            "E::A",
+            "E::A",
+        );
    }
    #[test]
    fn sub_module() {
-        let code = r#"
+        check_found_path(
-            //- /main.rs
+            r#"
-            mod foo {
+mod foo {
-                pub struct S;
+    pub struct S;
-            }
+}
-            $0
+$0
-        "#;
+        "#,
-        check_found_path(code, "foo::S", "foo::S", "crate::foo::S", "self::foo::S");
+            "foo::S",
+            "foo::S",
+            "crate::foo::S",
+            "self::foo::S",
+        );
    }
    #[test]
    fn super_module() {
-        let code = r#"
+        check_found_path(
-            //- /main.rs
+            r#"
-            mod foo;
+//- /main.rs
-            //- /foo.rs
+mod foo;
-            mod bar;
+//- /foo.rs
-            struct S;
+mod bar;
-            //- /foo/bar.rs
+struct S;
-            $0
+//- /foo/bar.rs
-        "#;
+$0
-        check_found_path(code, "super::S", "super::S", "crate::foo::S", "super::S");
+        "#,
+            "super::S",
+            "super::S",
+            "crate::foo::S",
+            "super::S",
+        );
    }
    #[test]
    fn self_module() {
-        let code = r#"
+        check_found_path(
-            //- /main.rs
+            r#"
-            mod foo;
+//- /main.rs
-            //- /foo.rs
+mod foo;
-            $0
+//- /foo.rs
-        "#;
+$0
-        check_found_path(code, "self", "self", "crate::foo", "self");
+        "#,
+            "self",
+            "self",
+            "crate::foo",
+            "self",
+        );
    }
    #[test]
    fn crate_root() {
-        let code = r#"
+        check_found_path(
-            //- /main.rs
+            r#"
-            mod foo;
+//- /main.rs
-            //- /foo.rs
+mod foo;
-            $0
+//- /foo.rs
-        "#;
+$0
-        check_found_path(code, "crate", "crate", "crate", "crate");
+        "#,
+            "crate",
+            "crate",
+            "crate",
+            "crate",
+        );
    }
    #[test]
    fn same_crate() {
-        let code = r#"
+        check_found_path(
-            //- /main.rs
+            r#"
-            mod foo;
+//- /main.rs
-            struct S;
+mod foo;
-            //- /foo.rs
+struct S;
-            $0
+//- /foo.rs
-        "#;
+$0
-        check_found_path(code, "crate::S", "crate::S", "crate::S", "crate::S");
+        "#,
+            "crate::S",
+            "crate::S",
+            "crate::S",
+            "crate::S",
+        );
    }
    #[test]
    fn different_crate() {
-        let code = r#"
+        check_found_path(
-            //- /main.rs crate:main deps:std
+            r#"
-            $0
+//- /main.rs crate:main deps:std
-            //- /std.rs crate:std
+$0
-            pub struct S;
+//- /std.rs crate:std
-        "#;
+pub struct S;
-        check_found_path(code, "std::S", "std::S", "std::S", "std::S");
+        "#,
+            "std::S",
+            "std::S",
+            "std::S",
+            "std::S",
+        );
    }
    #[test]
    fn different_crate_renamed() {
-        let code = r#"
-            //- /main.rs crate:main deps:std
-            extern crate std as std_renamed;
-            $0
-            //- /std.rs crate:std
-            pub struct S;
-        "#;
        check_found_path(
-            code,
+            r#"
+//- /main.rs crate:main deps:std
+extern crate std as std_renamed;
+$0
+//- /std.rs crate:std
+pub struct S;
+        "#,
            "std_renamed::S",
            "std_renamed::S",
            "std_renamed::S",
@@ -537,41 +573,38 @@ mod tests {
        cov_mark::check!(partially_imported);
        // Tests that short paths are used even for external items, when parts of the path are
        // already in scope.
-        let code = r#"
+        check_found_path(
-            //- /main.rs crate:main deps:syntax
+            r#"
+//- /main.rs crate:main deps:syntax
-            use syntax::ast;
+use syntax::ast;
-            $0
+$0
-            //- /lib.rs crate:syntax
+//- /lib.rs crate:syntax
-            pub mod ast {
+pub mod ast {
-                pub enum ModuleItem {
+    pub enum ModuleItem {
-                    A, B, C,
+        A, B, C,
-                }
+    }
-            }
+}
-        "#;
+        "#,
-        check_found_path(
-            code,
            "ast::ModuleItem",
            "syntax::ast::ModuleItem",
            "syntax::ast::ModuleItem",
            "syntax::ast::ModuleItem",
        );
-        let code = r#"
-            //- /main.rs crate:main deps:syntax
-            $0
-            //- /lib.rs crate:syntax
-            pub mod ast {
-                pub enum ModuleItem {
-                    A, B, C,
-                }
-            }
-        "#;
        check_found_path(
-            code,
+            r#"
+//- /main.rs crate:main deps:syntax
+$0
+//- /lib.rs crate:syntax
+pub mod ast {
+    pub enum ModuleItem {
+        A, B, C,
+    }
+}
+        "#,
            "syntax::ast::ModuleItem",
            "syntax::ast::ModuleItem",
            "syntax::ast::ModuleItem",
@@ -581,68 +614,86 @@ mod tests {
    #[test]
    fn same_crate_reexport() {
-        let code = r#"
+        check_found_path(
-            //- /main.rs
+            r#"
-            mod bar {
+mod bar {
-                mod foo { pub(super) struct S; }
+    mod foo { pub(super) struct S; }
-                pub(crate) use foo::*;
+    pub(crate) use foo::*;
-            }
+}
-            $0
+$0
-        "#;
+        "#,
-        check_found_path(code, "bar::S", "bar::S", "crate::bar::S", "self::bar::S");
+            "bar::S",
+            "bar::S",
+            "crate::bar::S",
+            "self::bar::S",
+        );
    }
    #[test]
    fn same_crate_reexport_rename() {
-        let code = r#"
+        check_found_path(
-            //- /main.rs
+            r#"
-            mod bar {
+mod bar {
-                mod foo { pub(super) struct S; }
+    mod foo { pub(super) struct S; }
-                pub(crate) use foo::S as U;
+    pub(crate) use foo::S as U;
-            }
+}
-            $0
+$0
-        "#;
+        "#,
-        check_found_path(code, "bar::U", "bar::U", "crate::bar::U", "self::bar::U");
+            "bar::U",
+            "bar::U",
+            "crate::bar::U",
+            "self::bar::U",
+        );
    }
    #[test]
    fn different_crate_reexport() {
-        let code = r#"
+        check_found_path(
-            //- /main.rs crate:main deps:std
+            r#"
-            $0
+//- /main.rs crate:main deps:std
-            //- /std.rs crate:std deps:core
+$0
-            pub use core::S;
+//- /std.rs crate:std deps:core
-            //- /core.rs crate:core
+pub use core::S;
-            pub struct S;
+//- /core.rs crate:core
-        "#;
+pub struct S;
-        check_found_path(code, "std::S", "std::S", "std::S", "std::S");
+        "#,
+            "std::S",
+            "std::S",
+            "std::S",
+            "std::S",
+        );
    }
    #[test]
    fn prelude() {
-        let code = r#"
+        check_found_path(
-            //- /main.rs crate:main deps:std
+            r#"
-            $0
+//- /main.rs crate:main deps:std
-            //- /std.rs crate:std
+$0
-            pub mod prelude { pub struct S; }
+//- /std.rs crate:std
-            #[prelude_import]
+pub mod prelude { pub struct S; }
-            pub use prelude::*;
+#[prelude_import]
-        "#;
+pub use prelude::*;
-        check_found_path(code, "S", "S", "S", "S");
+        "#,
+            "S",
+            "S",
+            "S",
+            "S",
+        );
    }
    #[test]
    fn enum_variant_from_prelude() {
        let code = r#"
-            //- /main.rs crate:main deps:std
+//- /main.rs crate:main deps:std
-            $0
+$0
-            //- /std.rs crate:std
+//- /std.rs crate:std
-            pub mod prelude {
+pub mod prelude {
-                pub enum Option<T> { Some(T), None }
+    pub enum Option<T> { Some(T), None }
-                pub use Option::*;
+    pub use Option::*;
-            }
+}
-            #[prelude_import]
+#[prelude_import]
-            pub use prelude::*;
+pub use prelude::*;
        "#;
        check_found_path(code, "None", "None", "None", "None");
        check_found_path(code, "Some", "Some", "Some", "Some");
@@ -650,71 +701,85 @@ mod tests {
    #[test]
    fn shortest_path() {
-        let code = r#"
+        check_found_path(
-            //- /main.rs
+            r#"
-            pub mod foo;
+//- /main.rs
-            pub mod baz;
+pub mod foo;
-            struct S;
+pub mod baz;
-            $0
+struct S;
-            //- /foo.rs
+$0
-            pub mod bar { pub struct S; }
+//- /foo.rs
-            //- /baz.rs
+pub mod bar { pub struct S; }
-            pub use crate::foo::bar::S;
+//- /baz.rs
-        "#;
+pub use crate::foo::bar::S;
-        check_found_path(code, "baz::S", "baz::S", "crate::baz::S", "self::baz::S");
+        "#,
+            "baz::S",
+            "baz::S",
+            "crate::baz::S",
+            "self::baz::S",
+        );
    }
    #[test]
    fn discount_private_imports() {
-        let code = r#"
+        check_found_path(
-            //- /main.rs
+            r#"
-            mod foo;
+//- /main.rs
-            pub mod bar { pub struct S; }
+mod foo;
-            use bar::S;
+pub mod bar { pub struct S; }
-            //- /foo.rs
+use bar::S;
-            $0
+//- /foo.rs
-        "#;
+$0
-        // crate::S would be shorter, but using private imports seems wrong
+        "#,
-        check_found_path(code, "crate::bar::S", "crate::bar::S", "crate::bar::S", "crate::bar::S");
+            // crate::S would be shorter, but using private imports seems wrong
+            "crate::bar::S",
+            "crate::bar::S",
+            "crate::bar::S",
+            "crate::bar::S",
+        );
    }
    #[test]
    fn import_cycle() {
-        let code = r#"
+        check_found_path(
-            //- /main.rs
+            r#"
-            pub mod foo;
+//- /main.rs
-            pub mod bar;
+pub mod foo;
-            pub mod baz;
+pub mod bar;
-            //- /bar.rs
+pub mod baz;
-            $0
+//- /bar.rs
-            //- /foo.rs
+$0
-            pub use super::baz;
+//- /foo.rs
-            pub struct S;
+pub use super::baz;
-            //- /baz.rs
+pub struct S;
-            pub use super::foo;
+//- /baz.rs
-        "#;
+pub use super::foo;
-        check_found_path(code, "crate::foo::S", "crate::foo::S", "crate::foo::S", "crate::foo::S");
+        "#,
+            "crate::foo::S",
+            "crate::foo::S",
+            "crate::foo::S",
+            "crate::foo::S",
+        );
    }
    #[test]
    fn prefer_std_paths_over_alloc() {
        cov_mark::check!(prefer_std_paths);
-        let code = r#"
+        check_found_path(
-        //- /main.rs crate:main deps:alloc,std
+            r#"
-        $0
+//- /main.rs crate:main deps:alloc,std
+$0
-        //- /std.rs crate:std deps:alloc
+//- /std.rs crate:std deps:alloc
-        pub mod sync {
+pub mod sync {
-            pub use alloc::sync::Arc;
+    pub use alloc::sync::Arc;
-        }
+}
-        //- /zzz.rs crate:alloc
+//- /zzz.rs crate:alloc
-        pub mod sync {
+pub mod sync {
-            pub struct Arc;
+    pub struct Arc;
-        }
+}
-        "#;
+        "#,
-        check_found_path(
-            code,
            "std::sync::Arc",
            "std::sync::Arc",
            "std::sync::Arc",
@@ -725,26 +790,25 @@ mod tests {
    #[test]
    fn prefer_core_paths_over_std() {
        cov_mark::check!(prefer_no_std_paths);
-        let code = r#"
+        check_found_path(
-        //- /main.rs crate:main deps:core,std
+            r#"
-        #![no_std]
+//- /main.rs crate:main deps:core,std
+#![no_std]
-        $0
+$0
-        //- /std.rs crate:std deps:core
+//- /std.rs crate:std deps:core
-        pub mod fmt {
+pub mod fmt {
-            pub use core::fmt::Error;
+    pub use core::fmt::Error;
-        }
+}
-        //- /zzz.rs crate:core
+//- /zzz.rs crate:core
-        pub mod fmt {
+pub mod fmt {
-            pub struct Error;
+    pub struct Error;
-        }
+}
-        "#;
+        "#,
-        check_found_path(
-            code,
            "core::fmt::Error",
            "core::fmt::Error",
            "core::fmt::Error",
@@ -754,26 +818,25 @@ mod tests {
    #[test]
    fn prefer_alloc_paths_over_std() {
-        let code = r#"
+        check_found_path(
-        //- /main.rs crate:main deps:alloc,std
+            r#"
-        #![no_std]
+//- /main.rs crate:main deps:alloc,std
+#![no_std]
-        $0
+$0
-        //- /std.rs crate:std deps:alloc
+//- /std.rs crate:std deps:alloc
-        pub mod sync {
+pub mod sync {
-            pub use alloc::sync::Arc;
+    pub use alloc::sync::Arc;
-        }
+}
-        //- /zzz.rs crate:alloc
+//- /zzz.rs crate:alloc
-        pub mod sync {
+pub mod sync {
-            pub struct Arc;
+    pub struct Arc;
-        }
+}
-        "#;
+            "#,
-        check_found_path(
-            code,
            "alloc::sync::Arc",
            "alloc::sync::Arc",
            "alloc::sync::Arc",
@@ -783,20 +846,19 @@ mod tests {
    #[test]
    fn prefer_shorter_paths_if_not_alloc() {
-        let code = r#"
+        check_found_path(
-        //- /main.rs crate:main deps:megaalloc,std
+            r#"
-        $0
+//- /main.rs crate:main deps:megaalloc,std
+$0
-        //- /std.rs crate:std deps:megaalloc
+//- /std.rs crate:std deps:megaalloc
-        pub mod sync {
+pub mod sync {
-            pub use megaalloc::sync::Arc;
+    pub use megaalloc::sync::Arc;
-        }
+}
-        //- /zzz.rs crate:megaalloc
+//- /zzz.rs crate:megaalloc
-        pub struct Arc;
+pub struct Arc;
-        "#;
+            "#,
-        check_found_path(
-            code,
            "megaalloc::Arc",
            "megaalloc::Arc",
            "megaalloc::Arc",
@@ -807,12 +869,11 @@ mod tests {
    #[test]
    fn builtins_are_in_scope() {
        let code = r#"
-        //- /main.rs
+$0
-        $0
-        pub mod primitive {
+pub mod primitive {
-            pub use u8;
+    pub use u8;
-        }
+}
        "#;
        check_found_path(code, "u8", "u8", "u8", "u8");
        check_found_path(code, "u16", "u16", "u16", "u16");
@@ -822,10 +883,10 @@ mod tests {
    fn inner_items() {
        check_found_path(
            r#"
-            fn main() {
+fn main() {
-                struct Inner {}
+    struct Inner {}
-                $0
+    $0
-            }
+}
        "#,
            "Inner",
            "Inner",
@@ -838,12 +899,12 @@ mod tests {
    fn inner_items_from_outer_scope() {
        check_found_path(
            r#"
-            fn main() {
+fn main() {
-                struct Struct {}
+    struct Struct {}
-                {
+    {
-                    $0
+        $0
-                }
+    }
-            }
+}
        "#,
            "Struct",
            "Struct",
@@ -857,14 +918,14 @@ mod tests {
        cov_mark::check!(prefixed_in_block_expression);
        check_found_path(
            r#"
-            fn main() {
+fn main() {
-                mod module {
+    mod module {
-                    struct Struct {}
+        struct Struct {}
-                }
+    }
-                {
+    {
-                    $0
+        $0
-                }
+    }
-            }
+}
        "#,
            "module::Struct",
            "module::Struct",
@@ -877,14 +938,14 @@ mod tests {
    fn outer_items_with_inner_items_present() {