201 files changed, 7298 insertions, 4050 deletions
diff --git a/crates/base_db/src/fixture.rs b/crates/base_db/src/fixture.rs
index 8d4641355..04e2be390 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;
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 05a60e158..0afc06906 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,
@@ -51,14 +52,15 @@ use hir_def::{
 };
 use hir_expand::{diagnostics::DiagnosticSink, name::name, MacroDefKind};
 use hir_ty::{
-    autoderef,
+    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,15 +1569,15 @@ 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 mut all = Vec::new();
@@ -1613,16 +1615,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 +1704,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 +1785,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 +1801,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 +1822,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
+                .interned()
+                .first()
+                .map(|ty| self.derived(ty.assert_ty_ref(&Interner).clone())),
            Solution::Ambig(_) => None,
        }
    }
@@ -1852,15 +1849,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 +1870,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 +1903,13 @@ impl Type {
                | TyKind::Dyn(_)
                | TyKind::Function(_)
                | TyKind::Alias(_)
-                | TyKind::ForeignType(_) => false,
+                | TyKind::Foreign(_) => 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 +1919,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 +1956,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 +1973,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>(
@@ -2079,7 +2083,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 +2099,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 +2115,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,19 +2154,32 @@ 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);
    }
+    pub fn could_unify_with(&self, other: &Type) -> bool {
+        could_unify(&self.ty, &other.ty)
+    }
 }
 // FIXME: closures
diff --git a/crates/hir/src/semantics.rs b/crates/hir/src/semantics.rs
index 1198e3f0b..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())
+        })
    }
 }
@@ -445,7 +447,7 @@ impl<'db> SemanticsImpl<'db> {
                }
            };
            gpl.lifetime_params()
-                .find(|tp| tp.lifetime().as_ref().map(|lt| lt.text()) == Some(text))
+                .find(|tp| tp.lifetime().as_ref().map(|lt| lt.text()).as_ref() == Some(&text))
        })?;
        let src = self.find_file(lifetime_param.syntax().clone()).with_value(lifetime_param);
        ToDef::to_def(self, src)
@@ -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)
@@ -768,7 +770,7 @@ to_def_impls![
    (crate::TypeParam, ast::TypeParam, type_param_to_def),
    (crate::LifetimeParam, ast::LifetimeParam, lifetime_param_to_def),
    (crate::ConstParam, ast::ConstParam, const_param_to_def),
-    (crate::MacroDef, ast::MacroRules, macro_rules_to_def),
+    (crate::MacroDef, ast::Macro, macro_to_def),
    (crate::Local, ast::IdentPat, bind_pat_to_def),
    (crate::Local, ast::SelfParam, self_param_to_def),
    (crate::Label, ast::Label, label_to_def),
diff --git a/crates/hir/src/semantics/source_to_def.rs b/crates/hir/src/semantics/source_to_def.rs
index 762809fcd..9a5a2255f 100644
--- a/crates/hir/src/semantics/source_to_def.rs
+++ b/crates/hir/src/semantics/source_to_def.rs
@@ -191,10 +191,7 @@ impl SourceToDefCtx<'_, '_> {
    }
    // FIXME: use DynMap as well?
-    pub(super) fn macro_rules_to_def(
+    pub(super) fn macro_to_def(&mut self, src: InFile<ast::Macro>) -> Option<MacroDefId> {
-        &mut self,
-        src: InFile<ast::MacroRules>,
-    ) -> Option<MacroDefId> {
        let file_ast_id = self.db.ast_id_map(src.file_id).ast_id(&src.value);
        let ast_id = AstId::new(src.file_id, file_ast_id.upcast());
        let kind = MacroDefKind::Declarative(ast_id);
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..d9df7564d 100644
--- a/crates/hir_def/src/attr.rs
+++ b/crates/hir_def/src/attr.rs
@@ -1,6 +1,10 @@
 //! 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};
@@ -12,12 +16,13 @@ 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},
@@ -98,7 +103,7 @@ impl RawAttrs {
                Either::Right(comment) => comment.doc_comment().map(|doc| Attr {
                    index: i as u32,
                    input: Some(AttrInput::Literal(SmolStr::new(doc))),
-                    path: ModPath::from(hir_expand::name!(doc)),
+                    path: Interned::new(ModPath::from(hir_expand::name!(doc))),
                }),
            })
            .collect::<Arc<_>>();
@@ -210,12 +215,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 +403,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 +418,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 +461,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.index)),
+            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(
@@ -507,10 +566,48 @@ impl AttrSourceMap {
    }
 }
+/// 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, u32, 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 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) path: ModPath,
+    pub(crate) path: Interned<ModPath>,
    pub(crate) input: Option<AttrInput>,
 }
@@ -524,7 +621,7 @@ pub enum AttrInput {
 impl Attr {
    fn from_src(ast: ast::Attr, hygiene: &Hygiene, index: u32) -> 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,7 +629,7 @@ 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
        };
@@ -655,3 +752,36 @@ fn collect_attrs(
    attrs.into_iter().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))),
+        );
+    }
+    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 19f5065d1..bfb75a8a5 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},
@@ -74,6 +75,7 @@ pub(super) fn lower(
            _c: Count::new(),
        },
        expander,
+        statements_in_scope: Vec::new(),
    }
    .collect(params, body)
 }
@@ -83,6 +85,7 @@ struct ExprCollector<'a> {
    expander: Expander,
    body: Body,
    source_map: BodySourceMap,
+    statements_in_scope: Vec<Statement>,
 }
 impl ExprCollector<'_> {
@@ -320,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,
@@ -383,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()
@@ -428,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) => {
@@ -462,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)
            }
@@ -533,15 +541,13 @@ impl ExprCollector<'_> {
                ids[0]
            }
            ast::Expr::MacroStmts(e) => {
-                // FIXME:  these statements should be held by some hir containter
+                e.statements().for_each(|s| self.collect_stmt(s));
-                for stmt in e.statements() {
+                let tail = e
-                    self.collect_stmt(stmt);
+                    .expr()
-                }
+                    .map(|e| self.collect_expr(e))
-                if let Some(expr) = e.expr() {
+                    .unwrap_or_else(|| self.alloc_expr(Expr::Missing, syntax_ptr.clone()));
-                    self.collect_expr(expr)
-                } else {
+                self.alloc_expr(Expr::MacroStmts { tail }, syntax_ptr)
-                    self.alloc_expr(Expr::Missing, syntax_ptr)
-                }
            }
        })
    }
@@ -618,58 +624,55 @@ impl ExprCollector<'_> {
        }
    }
-    fn collect_stmt(&mut self, s: ast::Stmt) -> Option<Vec<Statement>> {
+    fn collect_stmt(&mut self, s: ast::Stmt) {
-        let stmt = match s {
+        match s {
            ast::Stmt::LetStmt(stmt) => {
-                self.check_cfg(&stmt)?;
+                if self.check_cfg(&stmt).is_none() {
+                    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));
-                vec![Statement::Let { pat, type_ref, initializer }]
+                self.statements_in_scope.push(Statement::Let { pat, type_ref, initializer });
            }
            ast::Stmt::ExprStmt(stmt) => {
-                self.check_cfg(&stmt)?;
+                if self.check_cfg(&stmt).is_none() {
+                    return;
+                }
                // Note that macro could be expended to multiple statements
                if let Some(ast::Expr::MacroCall(m)) = stmt.expr() {
                    let syntax_ptr = AstPtr::new(&stmt.expr().unwrap());
-                    let mut stmts = vec![];
                    self.collect_macro_call(m, syntax_ptr.clone(), false, |this, expansion| {
                        match expansion {
                            Some(expansion) => {
                                let statements: ast::MacroStmts = expansion;
-                                statements.statements().for_each(|stmt| {
+                                statements.statements().for_each(|stmt| this.collect_stmt(stmt));
-                                    if let Some(mut r) = this.collect_stmt(stmt) {
-                                        stmts.append(&mut r);
-                                    }
-                                });
                                if let Some(expr) = statements.expr() {
-                                    stmts.push(Statement::Expr(this.collect_expr(expr)));
+                                    let expr = this.collect_expr(expr);
+                                    this.statements_in_scope.push(Statement::Expr(expr));
                                }
                            }
                            None => {
-                                stmts.push(Statement::Expr(
+                                let expr = this.alloc_expr(Expr::Missing, syntax_ptr.clone());
-                                    this.alloc_expr(Expr::Missing, syntax_ptr.clone()),
+                                this.statements_in_scope.push(Statement::Expr(expr));
-                                ));
                            }
                        }
                    });
-                    stmts
                } else {
-                    vec![Statement::Expr(self.collect_expr_opt(stmt.expr()))]
+                    let expr = self.collect_expr_opt(stmt.expr());
+                    self.statements_in_scope.push(Statement::Expr(expr));
                }
            }
            ast::Stmt::Item(item) => {
-                self.check_cfg(&item)?;
+                if self.check_cfg(&item).is_none() {
+                    return;
-                return None;
+                }
            }
-        };
+        }
-        Some(stmt)
    }
    fn collect_block(&mut self, block: ast::BlockExpr) -> ExprId {
@@ -677,18 +680,22 @@ 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);
+        block.statements().for_each(|s| self.collect_stmt(s));
-        let statements =
-            block.statements().filter_map(|s| self.collect_stmt(s)).flatten().collect();
        let tail = block.tail_expr().map(|e| self.collect_expr(e));
+        let statements = std::mem::replace(&mut self.statements_in_scope, prev_statements);
        let syntax_node_ptr = AstPtr::new(&block.into());
        let expr_id = self.alloc_expr(
            Expr::Block { id: block_id, statements, tail, label: None },
@@ -755,7 +762,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 }
            }
@@ -765,7 +772,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) => {
@@ -779,7 +786,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")
diff --git a/crates/hir_def/src/body/tests.rs b/crates/hir_def/src/body/tests.rs
index faa133297..c1d3e998f 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
diff --git a/crates/hir_def/src/child_by_source.rs b/crates/hir_def/src/child_by_source.rs
index 2a331dcaf..f40a7f80d 100644
--- a/crates/hir_def/src/child_by_source.rs
+++ b/crates/hir_def/src/child_by_source.rs
@@ -160,7 +160,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/expr.rs b/crates/hir_def/src/expr.rs
index 24be93773..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 {
@@ -171,6 +172,9 @@ pub enum Expr {
    Unsafe {
        body: ExprId,
    },
+    MacroStmts {
+        tail: ExprId,
+    },
    Array(Array),
    Literal(Literal),
 }
@@ -237,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),
 }
@@ -357,6 +361,7 @@ impl Expr {
                    f(*repeat)
                }
            },
+            Expr::MacroStmts { tail } => f(*tail),
            Expr::Literal(_) => {}
        }
    }
@@ -408,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/generics.rs b/crates/hir_def/src/generics.rs
index 7c6cbff11..de5acced8 100644
--- a/crates/hir_def/src/generics.rs
+++ b/crates/hir_def/src/generics.rs
@@ -2,7 +2,6 @@
 //! structs, impls, traits, etc. This module provides a common HIR for these
 //! generic parameters. See also the `Generics` type and the `generics_of` query
 //! in rustc.
-use std::sync::Arc;
 use base_db::FileId;
 use either::Either;
@@ -18,6 +17,7 @@ use crate::{
    child_by_source::ChildBySource,
    db::DefDatabase,
    dyn_map::DynMap,
+    intern::Interned,
    keys,
    src::{HasChildSource, HasSource},
    type_ref::{LifetimeRef, TypeBound, TypeRef},
@@ -26,27 +26,27 @@ use crate::{
 };
 /// Data about a generic type parameter (to a function, struct, impl, ...).
-#[derive(Clone, PartialEq, Eq, Debug)]
+#[derive(Clone, PartialEq, Eq, Debug, Hash)]
 pub struct TypeParamData {
    pub name: Option<Name>,
-    pub default: Option<TypeRef>,
+    pub default: Option<Interned<TypeRef>>,
    pub provenance: TypeParamProvenance,
 }
 /// Data about a generic lifetime parameter (to a function, struct, impl, ...).
-#[derive(Clone, PartialEq, Eq, Debug)]
+#[derive(Clone, PartialEq, Eq, Debug, Hash)]
 pub struct LifetimeParamData {
    pub name: Name,
 }
 /// Data about a generic const parameter (to a function, struct, impl, ...).
-#[derive(Clone, PartialEq, Eq, Debug)]
+#[derive(Clone, PartialEq, Eq, Debug, Hash)]
 pub struct ConstParamData {
    pub name: Name,
-    pub ty: TypeRef,
+    pub ty: Interned<TypeRef>,
 }
-#[derive(Copy, Clone, PartialEq, Eq, Debug)]
+#[derive(Copy, Clone, PartialEq, Eq, Debug, Hash)]
 pub enum TypeParamProvenance {
    TypeParamList,
    TraitSelf,
@@ -54,7 +54,7 @@ pub enum TypeParamProvenance {
 }
 /// Data about the generic parameters of a function, struct, impl, etc.
-#[derive(Clone, PartialEq, Eq, Debug, Default)]
+#[derive(Clone, PartialEq, Eq, Debug, Default, Hash)]
 pub struct GenericParams {
    pub types: Arena<TypeParamData>,
    pub lifetimes: Arena<LifetimeParamData>,
@@ -66,16 +66,16 @@ pub struct GenericParams {
 /// where clauses like `where T: Foo + Bar` are turned into multiple of these.
 /// It might still result in multiple actual predicates though, because of
 /// associated type bindings like `Iterator<Item = u32>`.
-#[derive(Clone, PartialEq, Eq, Debug)]
+#[derive(Clone, PartialEq, Eq, Debug, Hash)]
 pub enum WherePredicate {
    TypeBound { target: WherePredicateTypeTarget, bound: TypeBound },
    Lifetime { target: LifetimeRef, bound: LifetimeRef },
    ForLifetime { lifetimes: Box<[Name]>, target: WherePredicateTypeTarget, bound: TypeBound },
 }
-#[derive(Clone, PartialEq, Eq, Debug)]
+#[derive(Clone, PartialEq, Eq, Debug, Hash)]
 pub enum WherePredicateTypeTarget {
-    TypeRef(TypeRef),
+    TypeRef(Interned<TypeRef>),
    /// For desugared where predicates that can directly refer to a type param.
    TypeParam(LocalTypeParamId),
 }
@@ -91,7 +91,7 @@ impl GenericParams {
    pub(crate) fn generic_params_query(
        db: &dyn DefDatabase,
        def: GenericDefId,
-    ) -> Arc<GenericParams> {
+    ) -> Interned<GenericParams> {
        let _p = profile::span("generic_params_query");
        let generics = match def {
@@ -99,47 +99,49 @@ impl GenericParams {
                let id = id.lookup(db).id;
                let tree = id.item_tree(db);
                let item = &tree[id.value];
-                tree[item.generic_params].clone()
+                item.generic_params.clone()
            }
            GenericDefId::AdtId(AdtId::StructId(id)) => {
                let id = id.lookup(db).id;
                let tree = id.item_tree(db);
                let item = &tree[id.value];
-                tree[item.generic_params].clone()
+                item.generic_params.clone()
            }
            GenericDefId::AdtId(AdtId::EnumId(id)) => {
                let id = id.lookup(db).id;
                let tree = id.item_tree(db);
                let item = &tree[id.value];
-                tree[item.generic_params].clone()
+                item.generic_params.clone()
            }
            GenericDefId::AdtId(AdtId::UnionId(id)) => {
                let id = id.lookup(db).id;
                let tree = id.item_tree(db);
                let item = &tree[id.value];
-                tree[item.generic_params].clone()
+                item.generic_params.clone()
            }
            GenericDefId::TraitId(id) => {
                let id = id.lookup(db).id;
                let tree = id.item_tree(db);
                let item = &tree[id.value];
-                tree[item.generic_params].clone()
+                item.generic_params.clone()
            }
            GenericDefId::TypeAliasId(id) => {
                let id = id.lookup(db).id;
                let tree = id.item_tree(db);
                let item = &tree[id.value];
-                tree[item.generic_params].clone()
+                item.generic_params.clone()
            }
            GenericDefId::ImplId(id) => {
                let id = id.lookup(db).id;
                let tree = id.item_tree(db);
                let item = &tree[id.value];
-                tree[item.generic_params].clone()
+                item.generic_params.clone()
+            }
+            GenericDefId::EnumVariantId(_) | GenericDefId::ConstId(_) => {
+                Interned::new(GenericParams::default())
            }
-            GenericDefId::EnumVariantId(_) | GenericDefId::ConstId(_) => GenericParams::default(),
        };
-        Arc::new(generics)
+        generics
    }
    fn new(db: &dyn DefDatabase, def: GenericDefId) -> (GenericParams, InFile<SourceMap>) {
@@ -217,6 +219,7 @@ impl GenericParams {
            GenericDefId::EnumVariantId(_) | GenericDefId::ConstId(_) => FileId(!0).into(),
        };
+        generics.shrink_to_fit();
        (generics, InFile::new(file_id, sm))
    }
@@ -256,7 +259,8 @@ impl GenericParams {
        for type_param in params.type_params() {
            let name = type_param.name().map_or_else(Name::missing, |it| it.as_name());
            // FIXME: Use `Path::from_src`
-            let default = type_param.default_type().map(|it| TypeRef::from_ast(lower_ctx, it));
+            let default =
+                type_param.default_type().map(|it| Interned::new(TypeRef::from_ast(lower_ctx, it)));
            let param = TypeParamData {
                name: Some(name.clone()),
                default,
@@ -280,7 +284,7 @@ impl GenericParams {
        for const_param in params.const_params() {
            let name = const_param.name().map_or_else(Name::missing, |it| it.as_name());
            let ty = const_param.ty().map_or(TypeRef::Error, |it| TypeRef::from_ast(lower_ctx, it));
-            let param = ConstParamData { name, ty };
+            let param = ConstParamData { name, ty: Interned::new(ty) };
            let param_id = self.consts.alloc(param);
            sm.const_params.insert(param_id, const_param.clone());
        }
@@ -334,11 +338,11 @@ impl GenericParams {
            (Either::Left(type_ref), bound) => match hrtb_lifetimes {
                Some(hrtb_lifetimes) => WherePredicate::ForLifetime {
                    lifetimes: hrtb_lifetimes.clone(),
-                    target: WherePredicateTypeTarget::TypeRef(type_ref),
+                    target: WherePredicateTypeTarget::TypeRef(Interned::new(type_ref)),
                    bound,
                },
                None => WherePredicate::TypeBound {
-                    target: WherePredicateTypeTarget::TypeRef(type_ref),
+                    target: WherePredicateTypeTarget::TypeRef(Interned::new(type_ref)),
                    bound,
                },
            },
@@ -369,6 +373,14 @@ impl GenericParams {
        });
    }
+    pub(crate) fn shrink_to_fit(&mut self) {
+        let Self { consts, lifetimes, types, where_predicates } = self;
+        consts.shrink_to_fit();
+        lifetimes.shrink_to_fit();
+        types.shrink_to_fit();
+        where_predicates.shrink_to_fit();
+    }
    pub fn find_type_by_name(&self, name: &Name) -> Option<LocalTypeParamId> {
        self.types
            .iter()
diff --git a/crates/hir_def/src/intern.rs b/crates/hir_def/src/intern.rs
new file mode 100644
index 000000000..abc304ef0
--- /dev/null
+++ b/crates/hir_def/src/intern.rs
@@ -0,0 +1,216 @@
+//! Global `Arc`-based object interning infrastructure.
+//!
+//! Eventually this should probably be replaced with salsa-based interning.
+use std::{
+    collections::HashMap,
+    fmt::{self, Debug},
+    hash::{BuildHasherDefault, Hash, Hasher},
+    ops::Deref,
+    sync::Arc,
+};
+use dashmap::{lock::RwLockWriteGuard, DashMap, SharedValue};
+use once_cell::sync::OnceCell;
+use rustc_hash::FxHasher;
+use crate::generics::GenericParams;
+type InternMap<T> = DashMap<Arc<T>, (), BuildHasherDefault<FxHasher>>;
+type Guard<T> =
+    RwLockWriteGuard<'static, HashMap<Arc<T>, SharedValue<()>, BuildHasherDefault<FxHasher>>>;
+pub struct Interned<T: Internable + ?Sized> {
+    arc: Arc<T>,
+}
+impl<T: Internable> Interned<T> {
+    pub fn new(obj: T) -> Self {
+        match Interned::lookup(&obj) {
+            Ok(this) => this,
+            Err(shard) => {
+                let arc = Arc::new(obj);
+                Self::alloc(arc, shard)
+            }
+        }
+    }
+}
+impl<T: Internable + ?Sized> Interned<T> {
+    fn lookup(obj: &T) -> Result<Self, Guard<T>> {
+        let storage = T::storage().get();
+        let shard_idx = storage.determine_map(obj);
+        let shard = &storage.shards()[shard_idx];
+        let shard = shard.write();
+        // Atomically,
+        // - check if `obj` is already in the map
+        //   - if so, clone its `Arc` and return it
+        //   - if not, box it up, insert it, and return a clone
+        // This needs to be atomic (locking the shard) to avoid races with other thread, which could
+        // insert the same object between us looking it up and inserting it.
+        // FIXME: avoid double lookup/hashing by using raw entry API (once stable, or when
+        // hashbrown can be plugged into dashmap)
+        match shard.get_key_value(obj) {
+            Some((arc, _)) => Ok(Self { arc: arc.clone() }),
+            None => Err(shard),
+        }
+    }
+    fn alloc(arc: Arc<T>, mut shard: Guard<T>) -> Self {
+        let arc2 = arc.clone();
+        shard.insert(arc2, SharedValue::new(()));
+        Self { arc }
+    }
+}
+impl Interned<str> {
+    pub fn new_str(s: &str) -> Self {
+        match Interned::lookup(s) {
+            Ok(this) => this,
+            Err(shard) => {
+                let arc = Arc::<str>::from(s);
+                Self::alloc(arc, shard)
+            }
+        }
+    }
+}
+impl<T: Internable + ?Sized> Drop for Interned<T> {
+    #[inline]
+    fn drop(&mut self) {
+        // When the last `Ref` is dropped, remove the object from the global map.
+        if Arc::strong_count(&self.arc) == 2 {
+            // Only `self` and the global map point to the object.
+            self.drop_slow();
+        }
+    }
+}
+impl<T: Internable + ?Sized> Interned<T> {
+    #[cold]
+    fn drop_slow(&mut self) {
+        let storage = T::storage().get();
+        let shard_idx = storage.determine_map(&self.arc);
+        let shard = &storage.shards()[shard_idx];
+        let mut shard = shard.write();
+        // FIXME: avoid double lookup
+        let (arc, _) = shard.get_key_value(&self.arc).expect("interned value removed prematurely");
+        if Arc::strong_count(arc) != 2 {
+            // Another thread has interned another copy
+            return;
+        }
+        shard.remove(&self.arc);
+        // Shrink the backing storage if the shard is less than 50% occupied.
+        if shard.len() * 2 < shard.capacity() {
+            shard.shrink_to_fit();
+        }
+    }
+}
+/// Compares interned `Ref`s using pointer equality.
+impl<T: Internable> PartialEq for Interned<T> {
+    // NOTE: No `?Sized` because `ptr_eq` doesn't work right with trait objects.
+    #[inline]
+    fn eq(&self, other: &Self) -> bool {
+        Arc::ptr_eq(&self.arc, &other.arc)
+    }
+}
+impl<T: Internable> Eq for Interned<T> {}
+impl PartialEq for Interned<str> {
+    fn eq(&self, other: &Self) -> bool {
+        Arc::ptr_eq(&self.arc, &other.arc)
+    }
+}
+impl Eq for Interned<str> {}
+impl<T: Internable + ?Sized> Hash for Interned<T> {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        // NOTE: Cast disposes vtable pointer / slice/str length.
+        state.write_usize(Arc::as_ptr(&self.arc) as *const () as usize)
+    }
+}
+impl<T: Internable + ?Sized> AsRef<T> for Interned<T> {
+    #[inline]
+    fn as_ref(&self) -> &T {
+        &self.arc
+    }
+}
+impl<T: Internable + ?Sized> Deref for Interned<T> {
+    type Target = T;
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        &self.arc
+    }
+}
+impl<T: Internable + ?Sized> Clone for Interned<T> {
+    fn clone(&self) -> Self {
+        Self { arc: self.arc.clone() }
+    }
+}
+impl<T: Debug + Internable + ?Sized> Debug for Interned<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        (*self.arc).fmt(f)
+    }
+}
+pub struct InternStorage<T: ?Sized> {
+    map: OnceCell<InternMap<T>>,
+}
+impl<T: ?Sized> InternStorage<T> {
+    pub const fn new() -> Self {
+        Self { map: OnceCell::new() }
+    }
+}
+impl<T: Internable + ?Sized> InternStorage<T> {
+    fn get(&self) -> &InternMap<T> {
+        self.map.get_or_init(DashMap::default)
+    }
+}
+pub trait Internable: Hash + Eq + 'static {
+    fn storage() -> &'static InternStorage<Self>;
+}
+/// Implements `Internable` for a given list of types, making them usable with `Interned`.
+#[macro_export]
+#[doc(hidden)]
+macro_rules! _impl_internable {
+    ( $($t:path),+ $(,)? ) => { $(
+        impl Internable for $t {
+            fn storage() -> &'static InternStorage<Self> {
+                static STORAGE: InternStorage<$t> = InternStorage::new();
+                &STORAGE
+            }
+        }
+    )+ };
+}
+pub use crate::_impl_internable as impl_internable;
+impl_internable!(
+    crate::type_ref::TypeRef,
+    crate::type_ref::TraitRef,
+    crate::path::ModPath,
+    GenericParams,
+    str,
+);
diff --git a/crates/hir_def/src/item_scope.rs b/crates/hir_def/src/item_scope.rs
index f3ebe7c72..9014468ea 100644
--- a/crates/hir_def/src/item_scope.rs
+++ b/crates/hir_def/src/item_scope.rs
@@ -11,7 +11,7 @@ use rustc_hash::{FxHashMap, FxHashSet};
 use stdx::format_to;
 use crate::{
-    db::DefDatabase, per_ns::PerNs, visibility::Visibility, AdtId, BuiltinType, ImplId,
+    db::DefDatabase, per_ns::PerNs, visibility::Visibility, AdtId, BuiltinType, ConstId, ImplId,
    LocalModuleId, MacroDefId, ModuleDefId, ModuleId, TraitId,
 };
@@ -37,6 +37,7 @@ pub struct ItemScope {
    defs: Vec<ModuleDefId>,
    impls: Vec<ImplId>,
+    unnamed_consts: Vec<ConstId>,
    /// Traits imported via `use Trait as _;`.
    unnamed_trait_imports: FxHashMap<TraitId, Visibility>,
    /// Macros visible in current module in legacy textual scope
@@ -106,6 +107,10 @@ impl ItemScope {
            .map(|(_, v)| v)
    }
+    pub fn unnamed_consts(&self) -> impl Iterator<Item = ConstId> + '_ {
+        self.unnamed_consts.iter().copied()
+    }
    /// Iterate over all module scoped macros
    pub(crate) fn macros<'a>(&'a self) -> impl Iterator<Item = (&'a Name, MacroDefId)> + 'a {
        self.entries().filter_map(|(name, def)| def.take_macros().map(|macro_| (name, macro_)))
@@ -156,6 +161,10 @@ impl ItemScope {
        self.impls.push(imp)
    }
+    pub(crate) fn define_unnamed_const(&mut self, konst: ConstId) {
+        self.unnamed_consts.push(konst);
+    }
    pub(crate) fn define_legacy_macro(&mut self, name: Name, mac: MacroDefId) {
        self.legacy_macros.insert(name, mac);
    }
@@ -285,6 +294,30 @@ impl ItemScope {
            buf.push('\n');
        }
    }
+    pub(crate) fn shrink_to_fit(&mut self) {
+        // Exhaustive match to require handling new fields.
+        let Self {
+            types,
+            values,
+            macros,
+            unresolved,
+            defs,
+            impls,
+            unnamed_consts,
+            unnamed_trait_imports,
+            legacy_macros,
+        } = self;
+        types.shrink_to_fit();
+        values.shrink_to_fit();
+        macros.shrink_to_fit();
+        unresolved.shrink_to_fit();
+        defs.shrink_to_fit();
+        impls.shrink_to_fit();
+        unnamed_consts.shrink_to_fit();
+        unnamed_trait_imports.shrink_to_fit();
+        legacy_macros.shrink_to_fit();
+    }
 }
 impl PerNs {
diff --git a/crates/hir_def/src/item_tree.rs b/crates/hir_def/src/item_tree.rs
index ae2475b4e..240662486 100644
--- a/crates/hir_def/src/item_tree.rs
+++ b/crates/hir_def/src/item_tree.rs
@@ -24,14 +24,15 @@ use la_arena::{Arena, Idx, RawIdx};
 use profile::Count;
 use rustc_hash::FxHashMap;
 use smallvec::SmallVec;
-use syntax::{ast, match_ast, SmolStr, SyntaxKind};
+use syntax::{ast, match_ast, SyntaxKind};
 use crate::{
    attr::{Attrs, RawAttrs},
    db::DefDatabase,
    generics::GenericParams,
+    intern::Interned,
    path::{path, AssociatedTypeBinding, GenericArgs, ImportAlias, ModPath, Path, PathKind},
-    type_ref::{Mutability, TypeBound, TypeRef},
+    type_ref::{Mutability, TraitRef, TypeBound, TypeRef},
    visibility::RawVisibility,
 };
@@ -57,13 +58,6 @@ impl fmt::Debug for RawVisibilityId {
    }
 }
-#[derive(Debug, Copy, Clone, Eq, PartialEq)]
-pub struct GenericParamsId(u32);
-impl GenericParamsId {
-    pub const EMPTY: Self = GenericParamsId(u32::max_value());
-}
 /// The item tree of a source file.
 #[derive(Debug, Default, Eq, PartialEq)]
 pub struct ItemTree {
@@ -110,15 +104,6 @@ impl ItemTree {
                    // still need to collect inner items.
                    ctx.lower_inner_items(e.syntax())
                },
-                ast::ExprStmt(stmt) => {
-                    // Macros can expand to stmt. We return an empty item tree in this case, but
-                    // still need to collect inner items.
-                    ctx.lower_inner_items(stmt.syntax())
-                },
-                ast::Item(item) => {
-                    // Macros can expand to stmt and other item, and we add it as top level item
-                    ctx.lower_single_item(item)
-                },
                _ => {
                    panic!("cannot create item tree from {:?} {}", syntax, syntax);
                },
@@ -154,8 +139,6 @@ impl ItemTree {
                macro_rules,
                macro_defs,
                vis,
-                generics,
-                type_refs,
                inner_items,
            } = &mut **data;
@@ -179,9 +162,6 @@ impl ItemTree {
            macro_defs.shrink_to_fit();
            vis.arena.shrink_to_fit();
-            generics.arena.shrink_to_fit();
-            type_refs.arena.shrink_to_fit();
-            type_refs.map.shrink_to_fit();
            inner_items.shrink_to_fit();
        }
@@ -253,58 +233,6 @@ static VIS_PRIV: RawVisibility = RawVisibility::Module(ModPath::from_kind(PathKi
 static VIS_PUB_CRATE: RawVisibility = RawVisibility::Module(ModPath::from_kind(PathKind::Crate));
 #[derive(Default, Debug, Eq, PartialEq)]
-struct GenericParamsStorage {
-    arena: Arena<GenericParams>,
-}
-impl GenericParamsStorage {
-    fn alloc(&mut self, params: GenericParams) -> GenericParamsId {
-        if params.types.is_empty()
-            && params.lifetimes.is_empty()
-            && params.consts.is_empty()
-            && params.where_predicates.is_empty()
-        {
-            return GenericParamsId::EMPTY;
-        }
-        GenericParamsId(self.arena.alloc(params).into_raw().into())
-    }
-}
-static EMPTY_GENERICS: GenericParams = GenericParams {
-    types: Arena::new(),
-    lifetimes: Arena::new(),
-    consts: Arena::new(),
-    where_predicates: Vec::new(),
-};
-/// `TypeRef` interner.
-#[derive(Default, Debug, Eq, PartialEq)]
-struct TypeRefStorage {
-    arena: Arena<Arc<TypeRef>>,
-    map: FxHashMap<Arc<TypeRef>, Idx<Arc<TypeRef>>>,
-}
-impl TypeRefStorage {
-    // Note: We lie about the `Idx<TypeRef>` to hide the interner details.
-    fn intern(&mut self, ty: TypeRef) -> Idx<TypeRef> {
-        if let Some(id) = self.map.get(&ty) {
-            return Idx::from_raw(id.into_raw());
-        }
-        let ty = Arc::new(ty);
-        let idx = self.arena.alloc(ty.clone());
-        self.map.insert(ty, idx);
-        Idx::from_raw(idx.into_raw())
-    }
-    fn lookup(&self, id: Idx<TypeRef>) -> &TypeRef {
-        &self.arena[Idx::from_raw(id.into_raw())]
-    }
-}
-#[derive(Default, Debug, Eq, PartialEq)]
 struct ItemTreeData {
    imports: Arena<Import>,
    extern_crates: Arena<ExternCrate>,
@@ -326,8 +254,6 @@ struct ItemTreeData {
    macro_defs: Arena<MacroDef>,
    vis: ItemVisibilities,
-    generics: GenericParamsStorage,
-    type_refs: TypeRefStorage,
    inner_items: FxHashMap<FileAstId<ast::BlockExpr>, SmallVec<[ModItem; 1]>>,
 }
@@ -546,25 +472,6 @@ impl Index<RawVisibilityId> for ItemTree {
    }
 }
-impl Index<GenericParamsId> for ItemTree {
-    type Output = GenericParams;
-    fn index(&self, index: GenericParamsId) -> &Self::Output {
-        match index {
-            GenericParamsId::EMPTY => &EMPTY_GENERICS,
-            _ => &self.data().generics.arena[Idx::from_raw(index.0.into())],
-        }
-    }
-}
-impl Index<Idx<TypeRef>> for ItemTree {
-    type Output = TypeRef;
-    fn index(&self, id: Idx<TypeRef>) -> &Self::Output {
-        self.data().type_refs.lookup(id)
-    }
-}
 impl<N: ItemTreeNode> Index<FileItemTreeId<N>> for ItemTree {
    type Output = N;
    fn index(&self, id: FileItemTreeId<N>) -&