64 files changed, 1499 insertions, 908 deletions
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/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..993772aac 100644
--- a/crates/hir/src/display.rs
+++ b/crates/hir/src/display.rs
@@ -13,29 +13,28 @@ 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 +67,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 +87,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,7 +234,7 @@ 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<_>>();
        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 97f162315..19901ed33 100644
--- a/crates/hir/src/lib.rs
+++ b/crates/hir/src/lib.rs
@@ -55,11 +55,10 @@ use hir_ty::{
    autoderef, could_unify,
    method_resolution::{self, TyFingerprint},
    primitive::UintTy,
-    to_assoc_type_id,
    traits::{FnTrait, Solution, SolutionVariables},
    AliasEq, AliasTy, BoundVar, CallableDefId, CallableSig, Canonical, CanonicalVarKinds, Cast,
-    DebruijnIndex, InEnvironment, Interner, ProjectionTy, QuantifiedWhereClause, Scalar,
+    DebruijnIndex, InEnvironment, Interner, QuantifiedWhereClause, Scalar, Substitution,
-    Substitution, TraitEnvironment, Ty, TyDefId, TyKind, TyVariableKind, WhereClause,
+    TraitEnvironment, Ty, TyBuilder, TyDefId, TyKind, TyVariableKind, WhereClause,
 };
 use itertools::Itertools;
 use rustc_hash::FxHashSet;
@@ -515,7 +514,7 @@ 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);
        Type::new(db, self.parent.module(db).id.krate(), var_id, ty)
    }
@@ -832,7 +831,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 })
@@ -864,7 +863,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) {
@@ -878,7 +877,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.
@@ -957,7 +956,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,
@@ -1011,7 +1010,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()
    }
 }
@@ -1101,7 +1100,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 {
@@ -1129,7 +1128,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")
    }
@@ -1502,7 +1501,7 @@ 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));
        Some(Type::new_with_resolver_inner(db, krate, &resolver, ty))
    }
@@ -1615,7 +1614,7 @@ impl Impl {
    // FIXME: the return type is wrong. This should be a hir version of
    // `TraitRef` (ie, resolved `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 self_ty(self, db: &dyn HirDatabase) -> Type {
@@ -1703,30 +1702,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,
        }
@@ -1785,13 +1783,10 @@ 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)),
@@ -1804,11 +1799,10 @@ 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();
@@ -1816,10 +1810,7 @@ impl Type {
            InEnvironment::new(
                self.env.env.clone(),
                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),
                }
@@ -1829,9 +1820,11 @@ impl Type {
        );
        match db.trait_solve(self.krate, goal)? {
-            Solution::Unique(SolutionVariables(subst)) => {
+            Solution::Unique(SolutionVariables(subst)) => subst
-                subst.value.first().map(|ty| self.derived(ty.clone()))
+                .value
-            }
+                .interned(&Interner)
+                .first()
+                .map(|ty| self.derived(ty.assert_ty_ref(&Interner).clone())),
            Solution::Ambig(_) => None,
        }
    }
@@ -1853,15 +1846,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,
        };
@@ -1874,14 +1867,14 @@ 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::Adt(_, substs)
@@ -1889,7 +1882,9 @@ impl Type {
                | 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)
@@ -1910,7 +1905,7 @@ impl Type {
    }
    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(),
@@ -1927,8 +1922,11 @@ impl Type {
    }
    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()
        }
@@ -1973,8 +1971,9 @@ impl Type {
            .strip_references()
            .substs()
            .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>(
@@ -2080,7 +2079,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);
            }
        }
@@ -2096,7 +2095,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);
                        }
                    }
@@ -2107,7 +2111,7 @@ 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(..) => {
                    cb(type_.derived(ty.clone()));
                }
diff --git a/crates/hir_def/Cargo.toml b/crates/hir_def/Cargo.toml
index 475d337f3..60adb655c 100644
--- a/crates/hir_def/Cargo.toml
+++ b/crates/hir_def/Cargo.toml
@@ -10,7 +10,9 @@ edition = "2018"
 doctest = false
 [dependencies]
+bitflags = "1.2.1"
 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..442c5fb5b 100644
--- a/crates/hir_def/src/attr.rs
+++ b/crates/hir_def/src/attr.rs
@@ -18,6 +18,7 @@ use tt::Subtree;
 use crate::{
    db::DefDatabase,
+    intern::Interned,
    item_tree::{ItemTreeId, ItemTreeNode},
    nameres::ModuleSource,
    path::{ModPath, PathKind},
@@ -98,7 +99,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<_>>();
@@ -510,7 +511,7 @@ impl AttrSourceMap {
 #[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 +525,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 +533,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
        };
diff --git a/crates/hir_def/src/body.rs b/crates/hir_def/src/body.rs
index 1080d9c2c..96b959967 100644
--- a/crates/hir_def/src/body.rs
+++ b/crates/hir_def/src/body.rs
@@ -226,7 +226,7 @@ pub struct Body {
    /// The `ExprId` of the actual body expression.
    pub body_expr: ExprId,
    /// Block expressions in this body that may contain inner items.
-    pub block_scopes: Vec<BlockId>,
+    block_scopes: Vec<BlockId>,
    _c: Count<Self>,
 }
@@ -302,7 +302,8 @@ impl Body {
            }
        };
        let expander = Expander::new(db, file_id, module);
-        let (body, source_map) = Body::new(db, expander, params, body);
+        let (mut body, source_map) = Body::new(db, expander, params, body);
+        body.shrink_to_fit();
        (Arc::new(body), Arc::new(source_map))
    }
@@ -310,6 +311,16 @@ impl Body {
        db.body_with_source_map(def).0
    }
+    /// Returns an iterator over all block expressions in this body that define inner items.
+    pub fn blocks<'a>(
+        &'a self,
+        db: &'a dyn DefDatabase,
+    ) -> impl Iterator<Item = (BlockId, Arc<DefMap>)> + '_ {
+        self.block_scopes
+            .iter()
+            .map(move |block| (*block, db.block_def_map(*block).expect("block ID without DefMap")))
+    }
    fn new(
        db: &dyn DefDatabase,
        expander: Expander,
@@ -318,6 +329,15 @@ impl Body {
    ) -> (Body, BodySourceMap) {
        lower::lower(db, expander, params, body)
    }
+    fn shrink_to_fit(&mut self) {
+        let Self { _c: _, body_expr: _, block_scopes, exprs, labels, params, pats } = self;
+        block_scopes.shrink_to_fit();
+        exprs.shrink_to_fit();
+        labels.shrink_to_fit();
+        params.shrink_to_fit();
+        pats.shrink_to_fit();
+    }
 }
 impl Index<ExprId> for Body {
diff --git a/crates/hir_def/src/body/lower.rs b/crates/hir_def/src/body/lower.rs
index 229e81dd4..63e89a1f4 100644
--- a/crates/hir_def/src/body/lower.rs
+++ b/crates/hir_def/src/body/lower.rs
@@ -673,12 +673,14 @@ impl ExprCollector<'_> {
        let block_loc =
            BlockLoc { ast_id, module: self.expander.def_map.module_id(self.expander.module) };
        let block_id = self.db.intern_block(block_loc);
-        self.body.block_scopes.push(block_id);
-        let opt_def_map = self.db.block_def_map(block_id);
+        let (module, def_map) = match self.db.block_def_map(block_id) {
-        let has_def_map = opt_def_map.is_some();
+            Some(def_map) => {
-        let def_map = opt_def_map.unwrap_or_else(|| self.expander.def_map.clone());
+                self.body.block_scopes.push(block_id);
-        let module = if has_def_map { def_map.root() } else { self.expander.module };
+                (def_map.root(), def_map)
+            }
+            None => (self.expander.module, self.expander.def_map.clone()),
+        };
        let prev_def_map = mem::replace(&mut self.expander.def_map, def_map);
        let prev_local_module = mem::replace(&mut self.expander.module, module);
        let prev_statements = std::mem::take(&mut self.statements_in_scope);
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 214bcc648..b409fb45c 100644
--- a/crates/hir_def/src/data.rs
+++ b/crates/hir_def/src/data.rs
@@ -9,7 +9,8 @@ use crate::{
    attr::Attrs,
    body::Expander,
    db::DefDatabase,
-    item_tree::{AssocItem, FunctionQualifier, ItemTreeId, ModItem, Param},
+    intern::Interned,
+    item_tree::{AssocItem, FnFlags, ItemTreeId, ModItem, Param},
    type_ref::{TraitRef, TypeBound, TypeRef},
    visibility::RawVisibility,
    AssocContainerId, AssocItemId, ConstId, ConstLoc, FunctionId, FunctionLoc, HasModule, ImplId,
@@ -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 |= 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.contains(FnFlags::HAS_BODY)
+    }
+    /// 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.contains(FnFlags::HAS_SELF_PARAM)
+    }
+    pub fn is_default(&self) -> bool {
+        self.flags.contains(FnFlags::IS_DEFAULT)
+    }
+    pub fn is_const(&self) -> bool {
+        self.flags.contains(FnFlags::IS_CONST)
+    }
+    pub fn is_async(&self) -> bool {
+        self.flags.contains(FnFlags::IS_ASYNC)
+    }
+    pub fn is_unsafe(&self) -> bool {
+        self.flags.contains(FnFlags::IS_UNSAFE)
+    }
+    pub fn is_in_extern_block(&self) -> bool {
+        self.flags.contains(FnFlags::IS_IN_EXTERN_BLOCK)
+    }
+    pub fn is_varargs(&self) -> bool {
+        self.flags.contains(FnFlags::IS_VARARGS)
+    }
 }
 #[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<TraitRef>,
+    pub target_trait: Option<Interned<TraitRef>>,
-    pub self_ty: 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 self_ty = item_tree[impl_def.self_ty].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);
@@ -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/intern.rs b/crates/hir_def/src/intern.rs
new file mode 100644
index 000000000..d163f633f
--- /dev/null
+++ b/crates/hir_def/src/intern.rs
@@ -0,0 +1,197 @@
+//! 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},
+    ops::Deref,
+    sync::Arc,
+};
+use dashmap::{lock::RwLockWriteGuard, DashMap, SharedValue};
+use once_cell::sync::OnceCell;
+use rustc_hash::FxHasher;
+type InternMap<T> = DashMap<Arc<T>, (), BuildHasherDefault<FxHasher>>;
+type Guard<T> =
+    RwLockWriteGuard<'static, HashMap<Arc<T>, SharedValue<()>, BuildHasherDefault<FxHasher>>>;
+#[derive(Hash)]
+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> 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>;
+}
+macro_rules! impl_internable {
+    ( $($t:path),+ $(,)? ) => { $(
+        impl Internable for $t {
+            fn storage() -> &'static InternStorage<Self> {
+                static STORAGE: InternStorage<$t> = InternStorage::new();
+                &STORAGE
+            }
+        }
+    )+ };
+}
+impl_internable!(crate::type_ref::TypeRef, crate::type_ref::TraitRef, crate::path::ModPath, str);
diff --git a/crates/hir_def/src/item_scope.rs b/crates/hir_def/src/item_scope.rs
index f3ebe7c72..a8ee5eeac 100644
--- a/crates/hir_def/src/item_scope.rs
+++ b/crates/hir_def/src/item_scope.rs
@@ -285,6 +285,28 @@ 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_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_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 5449bbf5d..c6d700977 100644
--- a/crates/hir_def/src/item_tree.rs
+++ b/crates/hir_def/src/item_tree.rs
@@ -24,12 +24,13 @@ 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, TraitRef, TypeBound, TypeRef},
    visibility::RawVisibility,
@@ -146,8 +147,6 @@ impl ItemTree {
                macro_defs,
                vis,
                generics,
-                type_refs,
-                trait_refs,
                inner_items,
            } = &mut **data;
@@ -172,9 +171,6 @@ impl ItemTree {
            vis.arena.shrink_to_fit();
            generics.arena.shrink_to_fit();
-            type_refs.arena.shrink_to_fit();
-            type_refs.map.shrink_to_fit();
-            trait_refs.map.shrink_to_fit();
            inner_items.shrink_to_fit();
        }
@@ -271,58 +267,6 @@ static EMPTY_GENERICS: GenericParams = GenericParams {
    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())]
-    }
-}
-/// `TraitRef` interner.
-#[derive(Default, Debug, Eq, PartialEq)]
-struct TraitRefStorage {
-    arena: Arena<Arc<TraitRef>>,
-    map: FxHashMap<Arc<TraitRef>, Idx<Arc<TraitRef>>>,
-}
-impl TraitRefStorage {
-    // Note: We lie about the `Idx<TraitRef>` to hide the interner details.
-    fn intern(&mut self, ty: TraitRef) -> Idx<TraitRef> {
-        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<TraitRef>) -> &TraitRef {
-        &self.arena[Idx::from_raw(id.into_raw())]
-    }
-}
 #[derive(Default, Debug, Eq, PartialEq)]
 struct ItemTreeData {
    imports: Arena<Import>,
@@ -346,8 +290,6 @@ struct ItemTreeData {
    vis: ItemVisibilities,
    generics: GenericParamsStorage,
-    type_refs: TypeRefStorage,
-    trait_refs: TraitRefStorage,
    inner_items: FxHashMap<FileAstId<ast::BlockExpr>, SmallVec<[ModItem; 1]>>,
 }
@@ -577,22 +519,6 @@ impl Index<GenericParamsId> for ItemTree {
    }
 }
-impl Index<Idx<TypeRef>> for ItemTree {
-    type Output = TypeRef;
-    fn index(&self, id: Idx<TypeRef>) -> &Self::Output {
-        self.data().type_refs.lookup(id)
-    }
-}
-impl Index<Idx<TraitRef>> for ItemTree {
-    type Output = TraitRef;
-    fn index(&self, id: Idx<TraitRef>) -> &Self::Output {
-        self.data().trait_refs.lookup(id)
-    }
-}
 impl<N: ItemTreeNode> Index<FileItemTreeId<N>> for ItemTree {
    type Output = N;
    fn index(&self, id: FileItemTreeId<N>) -> &N {
@@ -603,7 +529,7 @@ impl<N: ItemTreeNode> Index<FileItemTreeId<N>> for ItemTree {
 /// A desugared `use` import.
 #[derive(Debug, Clone, Eq, PartialEq)]
 pub struct Import {
-    pub path: ModPath,
+    pub path: Interned<ModPath>,
    pub alias: Option<ImportAlias>,
    pub visibility: RawVisibilityId,
    pub is_glob: bool,
@@ -630,30 +556,33 @@ pub struct Function {
    pub name: Name,
    pub visibility: RawVisibilityId,
    pub generic_params: GenericParamsId,
-    pub has_self_param: bool,
+    pub abi: Option<Interned<str>>,
-    pub has_body: bool,
-    pub qualifier: FunctionQualifier,
-    /// Whether the function is located in an `extern` block (*not* whether it is an
-    /// `extern "abi" fn`).
-    pub is_in_extern_block: bool,
    pub params: IdRange<Param>,
-    pub ret_type: Idx<TypeRef>,
+    pub ret_type: Interned<TypeRef>,
    pub ast_id: FileAstId<ast::Fn>,
+    pub(crate) flags: FnFlags,
 }
 #[derive(Debug, Clone, Eq, PartialEq)]
 pub enum Param {
-    Normal(Idx<TypeRef>),
+    Normal(Interned<TypeRef>),
    Varargs,
 }
-#[derive(Debug, Clone, PartialEq, Eq)]
+bitflags::bitflags! {
-pub struct FunctionQualifier {
+    /// NOTE: Shared with `FunctionData`
-    pub is_default: bool,
+    pub(crate) struct FnFlags: u8 {
-    pub is_const: bool,
+        const HAS_SELF_PARAM = 1 << 0;
-    pub is_async: bool,
+        const HAS_BODY = 1 << 1;
-    pub is_unsafe: bool,
+        const IS_DEFAULT = 1 << 2;
-    pub abi: Option<SmolStr>,
+        const IS_CONST = 1 << 3;
+        const IS_ASYNC = 1 << 4;
+        const IS_UNSAFE = 1 << 5;
+        /// Whether the function is located in an `extern` block (*not* whether it is an
+        /// `extern "abi" fn`).
+        const IS_IN_EXTERN_BLOCK = 1 << 6;
+        const IS_VARARGS = 1 << 7;
+    }
 }
 #[derive(Debug, Clone, Eq, PartialEq)]
@@ -699,7 +628,7 @@ pub struct Const {
    /// const _: () = ();
    pub name: Option<Name>,
    pub visibility: RawVisibilityId,
-    pub type_ref: Idx<TypeRef>,
+    pub type_ref: Interned<TypeRef>,
    pub ast_id: FileAstId<ast::Const>,
 }
@@ -710,7 +639,7 @@ pub struct Static {
    pub mutable: bool,
    /// Whether the static is in an `extern` block.
    pub is_extern: bool,
-    pub type_ref: Idx<TypeRef>,
+    pub type_ref: Interned<TypeRef>,
    pub ast_id: FileAstId<ast::Static>,
 }
@@ -729,8 +658,8 @@ pub struct Trait {
 #[derive(Debug, Clone, Eq, PartialEq)]
 pub struct Impl {
    pub generic_params: GenericParamsId,
-    pub target_trait: Option<Idx<TraitRef>>,
+    pub target_trait: Option<Interned<TraitRef>>,
-    pub self_ty: Idx<TypeRef>,
+    pub self_ty: Interned<TypeRef>,
    pub is_negative: bool,
    pub items: Box<[AssocItem]>,
    pub ast_id: FileAstId<ast::Impl>,
@@ -743,7 +672,7 @@ pub struct TypeAlias {
    /// Bounds on the type alias itself. Only valid in trait declarations, eg. `type Assoc: Copy;`.
    pub bounds: Box<[TypeBound]>,
    pub generic_params: GenericParamsId,
-    pub type_ref: Option<Idx<TypeRef>>,
+    pub type_ref: Option<Interned<TypeRef>>,
    pub is_extern: bool,
    pub ast_id: FileAstId<ast::TypeAlias>,
 }
@@ -768,7 +697,7 @@ pub enum ModKind {
 #[derive(Debug, Clone, Eq, PartialEq)]
 pub struct MacroCall {
    /// Path to the called macro.
-    pub path: ModPath,
+    pub path: Interned<ModPath>,
    pub ast_id: FileAstId<ast::MacroCall>,
 }
@@ -933,6 +862,6 @@ pub enum Fields {
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Field {
    pub name: Name,
-    pub type_ref: Idx<TypeRef>,
+    pub type_ref: Interned<TypeRef>,
    pub visibility: RawVisibilityId,
 }
diff --git a/crates/hir_def/src/item_tree/lower.rs b/crates/hir_def/src/item_tree/lower.rs
index 124dcc866..39e8403b0 100644
--- a/crates/hir_def/src/item_tree/lower.rs
+++ b/crates/hir_def/src/item_tree/lower.rs
@@ -362,7 +362,7 @@ impl Ctx {
                        }
                    }
                };
-                let ty = self.data().type_refs.intern(self_type);
+                let ty = Interned::new(self_type);
                let idx = self.data().params.alloc(Param::Normal(ty));
                self.add_attrs(idx.into(), RawAttrs::new(&self_param, &self.hygiene));
                has_self_param = true;
@@ -372,7 +372,7 @@ impl Ctx {
                    Some(_) => self.data().params.alloc(Param::Varargs),
                    None => {
                        let type_ref = TypeRef::from_ast_opt(&self.body_ctx, param.ty());
-                        let ty = self.data().type_refs.intern(type_ref);
+                        let ty = Interned::new(type_ref);
                        self.data().params.alloc(Param::Normal(ty))
                    }
                };
@@ -395,41 +395,51 @@ impl Ctx {
            ret_type
        };
-        let ret_type = self.data().type_refs.intern(ret_type);
+        let abi = func.abi().map(|abi| {
+            // FIXME: Abi::abi() -> Option<SyntaxToken>?
-        let has_body = func.body().is_some();
+            match abi.syntax().last_token() {
+                Some(tok) if tok.kind() == SyntaxKind::STRING => {
+                    // FIXME: Better way to unescape?
+                    Interned::new_str(tok.text().trim_matches('"'))
+                }
+                _ => {
+                    // `extern` default to be `extern "C"`.
+                    Interned::new_str("C")
+                }
+            }
+        });
        let ast_id = self.source_ast_id_map.ast_id(func);
-        let qualifier = FunctionQualifier {
-            is_default: func.default_token().is_some(),
+        let mut flags = FnFlags::empty();
-            is_const: func.const_token().is_some(),
+        if func.body().is_some() {
-            is_async: func.async_token().is_some(),
+            flags |= FnFlags::HAS_BODY;
-            is_unsafe: func.unsafe_token().is_some(),
+        }
-            abi: func.abi().map(|abi| {
+        if has_self_param {
-                // FIXME: Abi::abi() -> Option<SyntaxToken>?
+            flags |= FnFlags::HAS_SELF_PARAM;
-                match abi.syntax().last_token() {
+        }
-                    Some(tok) if tok.kind() == SyntaxKind::STRING => {
+        if func.default_token().is_some() {
-                        // FIXME: Better way to unescape?
+            flags |= FnFlags::IS_DEFAULT;
-                        tok.text().trim_matches('"').into()
+        }
-                    }
+        if func.const_token().is_some() {
-                    _ => {
+            flags |= FnFlags::IS_CONST;
-                        // `extern` default to be `extern "C"`.
+        }
-                        "C".into()
+        if func.async_token().is_some() {
-                    }
+            flags |= FnFlags::IS_ASYNC;
-                }
+        }
-            }),
+        if func.unsafe_token().is_some() {
-        };
+            flags |= FnFlags::IS_UNSAFE;
+        }
        let mut res = Function {
            name,
            visibility,
            generic_params: GenericParamsId::EMPTY,
-            has_self_param,
+            abi,
-            has_body,
-            qualifier,
-            is_in_extern_block: false,
            params,
-            ret_type,
+            ret_type: Interned::new(ret_type),
            ast_id,
+            flags,
        };
        res.generic_params = self.lower_generic_params(GenericsOwner::Function(&res), func);
@@ -579,7 +589,7 @@ impl Ctx {
            &self.hygiene,
            |path, _use_tree, is_glob, alias| {
                imports.push(id(tree.imports.alloc(Import {
-                    path,
+                    path: Interned::new(path),
                    alias,
                    visibility,
                    is_glob,
@@ -608,7 +618,7 @@ impl Ctx {
    }
    fn lower_macro_call(&mut self, m: &ast::MacroCall) -> Option<FileItemTreeId<MacroCall>> {
-        let path = ModPath::from_src(m.path()?, &self.hygiene)?;
+        let path = Interned::new(ModPath::from_src(m.path()?, &self.hygiene)?);
        let ast_id = self.source_ast_id_map.ast_id(m);
        let res = MacroCall { path, ast_id };
        Some(id(self.data().macro_calls.alloc(res)))
@@ -642,8 +652,10 @@ impl Ctx {
                        ast::ExternItem::Fn(ast) => {
                            let func_id = self.lower_function(&ast)?;
                            let func = &mut self.data().functions[func_id.index];
-                            func.qualifier.is_unsafe = is_intrinsic_fn_unsafe(&func.name);
+                            if is_intrinsic_fn_unsafe(&func.name) {
-                            func.is_in_extern_block = true;
+                                func.flags |= FnFlags::IS_UNSAFE;
+                            }
+                            func.flags |= FnFlags::IS_IN_EXTERN_BLOCK;
                            func_id.into()
                        }
                        ast::ExternItem::Static(ast) => {
@@ -694,8 +706,7 @@ impl Ctx {
                generics.fill(&self.body_ctx, sm, node);
                // lower `impl Trait` in arguments
                for id in func.params.clone() {
-                    if let Param::Normal(ty) = self.data().params[id] {
+                    if let Param::Normal(ty) = &self.data().params[id] {
-                        let ty = self.data().type_refs.lookup(ty);
                        generics.fill_implicit_impl_trait_args(ty);
                    }
                }
@@ -749,20 +760,20 @@ impl Ctx {
        self.data().vis.alloc(vis)
    }
-    fn lower_trait_ref(&mut self, trait_ref: &ast::Type) -> Option<Idx<TraitRef>> {
+    fn lower_trait_ref(&mut self, trait_ref: &ast::Type) -> Option<Interned<TraitRef>> {
        let trait_ref = TraitRef::from_ast(&self.body_ctx, trait_ref.clone())?;
-        Some(self.data().trait_refs.intern(trait_ref))
+        Some(Interned::new(trait_ref))
    }
-    fn lower_type_ref(&mut self, type_ref: &ast::Type) -> Idx<TypeRef> {
+    fn lower_type_ref(&mut self, type_ref: &ast::Type) -> Interned<TypeRef> {
        let tyref = TypeRef::from_ast(&self.body_ctx, type_ref.clone());
-        self.data().type_refs.intern(tyref)
+        Interned::new(tyref)
    }
-    fn lower_type_ref_opt(&mut self, type_ref: Option<ast::Type>) -> Idx<TypeRef> {
+    fn lower_type_ref_opt(&mut self, type_ref: Option<ast::Type>) -> Interned<TypeRef> {
        match type_ref.map(|ty| self.lower_type_ref(&ty)) {
            Some(it) => it,
-            None => self.data().type_refs.intern(TypeRef::Error),
+            None => Interned::new(TypeRef::Error),
        }
    }
diff --git a/crates/hir_def/src/lib.rs b/crates/hir_def/src/lib.rs
index c9e07de86..f408e510a 100644
--- a/crates/hir_def/src/lib.rs
+++ b/crates/hir_def/src/lib.rs
@@ -49,6 +49,7 @@ pub mod import_map;
 #[cfg(test)]
 mod test_db;
+mod intern;
 use std::{
    hash::{Hash, Hasher},
diff --git a/crates/hir_def/src/nameres.rs b/crates/hir_def/src/nameres.rs
index 9e8e4e9ec..7dd68219f 100644
--- a/crates/hir_def/src/nameres.rs
+++ b/crates/hir_def/src/nameres.rs
@@ -409,6 +409,31 @@ impl DefMap {
            }
        }
    }
+    fn shrink_to_fit(&mut self) {
+        // Exhaustive match to require handling new fields.
+        let Self {
+            _c: _,
+            exported_proc_macros,
+            extern_prelude,
+            diagnostics,
+            modules,
+            block: _,
+            edition: _,
+            krate: _,
+            prelude: _,
+            root: _,
+        } = self;
+        extern_prelude.shrink_to_fit();
+        exported_proc_macros.shrink_to_fit();
+        diagnostics.shrink_to_fit();
+        modules.shrink_to_fit();
+        for (_, module) in modules.iter_mut() {
+            module.children.shrink_to_fit();
+            module.scope.shrink_to_fit();
+        }
+    }
 }
 impl ModuleData {
diff --git a/crates/hir_def/src/nameres/collector.rs b/crates/hir_def/src/nameres/collector.rs
index d58135ec9..4ddc791ce 100644
--- a/crates/hir_def/src/nameres/collector.rs
+++ b/crates/hir_def/src/nameres/collector.rs
@@ -23,6 +23,7 @@ use crate::{
    attr::Attrs,
    db::DefDatabase,
    derive_macro_as_call_id,
+    intern::Interned,
    item_scope::{ImportType, PerNsGlobImports},
    item_tree::{
        self, FileItemTreeId, ItemTree, ItemTreeId, MacroCall, MacroDef, MacroRules, Mod, ModItem,
@@ -54,20 +55,22 @@ pub(super) fn collect_defs(
 ) -> DefMap {
    let crate_graph = db.crate_graph();
-    // populate external prelude
+    if block.is_none() {
-    for dep in &crate_graph[def_map.krate].dependencies {
+        // populate external prelude
-        log::debug!("crate dep {:?} -> {:?}", dep.name, dep.crate_id);
+        for dep in &crate_graph[def_map.krate].dependencies {
-        let dep_def_map = db.crate_def_map(dep.crate_id);
+            log::debug!("crate dep {:?} -> {:?}", dep.name, dep.crate_id);
-        def_map
+            let dep_def_map = db.crate_def_map(dep.crate_id);
-            .extern_prelude
+            def_map
-            .insert(dep.as_name(), dep_def_map.module_id(dep_def_map.root).into());
+                .extern_prelude
+                .insert(dep.as_name(), dep_def_map.module_id(dep_def_map.root).into());
-        // look for the prelude
-        // If the dependency defines a prelude, we overwrite an already defined
+            // look for the prelude
-        // prelude. This is necessary to import the "std" prelude if a crate
+            // If the dependency defines a prelude, we overwrite an already defined
-        // depends on both "core" and "std".
+            // prelude. This is necessary to import the "std" prelude if a crate
-        if dep_def_map.prelude.is_some() {
+            // depends on both "core" and "std".
-            def_map.prelude = dep_def_map.prelude;
+            if dep_def_map.prelude.is_some() {
+                def_map.prelude = dep_def_map.prelude;
+            }
        }
    }
@@ -106,7 +109,9 @@ pub(super) fn collect_defs(
        }
    }
    collector.collect();
-    collector.finish()
+    let mut def_map = collector.finish();
+    def_map.shrink_to_fit();
+    def_map
 }
 #[derive(Copy, Clone, Debug, Eq, PartialEq)]
@@ -137,7 +142,7 @@ enum ImportSource {
 #[derive(Clone, Debug, Eq, PartialEq)]
 struct Import {
-    path: ModPath,
+    path: Interned<ModPath>,
    alias: Option<ImportAlias>,
    visibility: RawVisibility,
    is_glob: bool,
@@ -179,7 +184,10 @@ impl Import {
        let attrs = &tree.attrs(db, krate, ModItem::from(id.value).into());
        let visibility = &tree[it.visibility];
        Self {
-            path: ModPath::from_segments(PathKind::Plain, iter::once(it.name.clone())),
+            path: Interned::new(ModPath::from_segments(
+                PathKind::Plain,
+                iter::once(it.name.clone()),
+            )),
            alias: it.alias.clone(),
            visibility: visibility.clone(),
            is_glob: false,
@@ -1400,8 +1408,18 @@ impl ModCollector<'_, '_> {
        // Case 1: builtin macros
        if attrs.by_key("rustc_builtin_macro").exists() {
+            // `#[rustc_builtin_macro = "builtin_name"]` overrides the `macro_rules!` name.
+            let name;
+            let name = match attrs.by_key("rustc_builtin_macro").string_value() {
+                Some(it) => {
+                    // FIXME: a hacky way to create a Name from string.
+                    name = tt::Ident { text: it.clone(), id: tt::TokenId::unspecified() }.as_name();
+                    &name
+                }
+                None => &mac.name,
+            };
            let krate = self.def_collector.def_map.krate;
-            if let Some(macro_id) = find_builtin_macro(&mac.name, krate, ast_id) {
+            if let Some(macro_id) = find_builtin_macro(name, krate, ast_id) {
                self.def_collector.define_macro_rules(
                    self.module_id,
                    mac.name.clone(),
@@ -1464,7 +1482,7 @@ impl ModCollector<'_, '_> {
    }
    fn collect_macro_call(&mut self, mac: &MacroCall) {
-        let mut ast_id = AstIdWithPath::new(self.file_id, mac.ast_id, mac.path.clone());
+        let mut ast_id = AstIdWithPath::new(self.file_id, mac.ast_id, (*mac.path).clone());
        // Case 1: try to resolve in legacy scope and expand macro_rules
        let mut error = None;
diff --git a/crates/hir_def/src/nameres/tests/diagnostics.rs b/crates/hir_def/src/nameres/tests/diagnostics.rs
index a89061c2e..fefdadb22 100644
--- a/crates/hir_def/src/nameres/tests/diagnostics.rs
+++ b/crates/hir_def/src/nameres/tests/diagnostics.rs
@@ -7,6 +7,11 @@ fn check_diagnostics(ra_fixture: &str) {
    db.check_diagnostics();
 }
+fn check_no_diagnostics(ra_fixture: &str) {
+    let db: TestDB = TestDB::with_files(ra_fixture);
+    db.check_no_diagnostics();
+}
 #[test]
 fn unresolved_import() {
    check_diagnostics(
@@ -202,6 +207,21 @@ fn builtin_macro_fails_expansion() {
 }
 #[test]
+fn include_macro_should_allow_empty_content() {
+    check_no_diagnostics(
+        r#"
+        //- /lib.rs
+          #[rustc_builtin_macro]
+          macro_rules! include { () => {} }
+          include!("bar.rs");
+        //- /bar.rs
+          // empty
+        "#,
+    );
+}
+#[test]
 fn good_out_dir_diagnostic() {
    check_diagnostics(
        r#"
diff --git a/crates/hir_def/src/path.rs b/crates/hir_def/src/path.rs
index 8c923bb7b..a3e83e2cf 100644
--- a/crates/hir_def/src/path.rs
+++ b/crates/hir_def/src/path.rs
@@ -7,7 +7,7 @@ use std::{
    sync::Arc,
 };
-use crate::{body::LowerCtx, type_ref::LifetimeRef};
+use crate::{body::LowerCtx, intern::Interned, type_ref::LifetimeRef};
 use base_db::CrateId;
 use hir_expand::{
    hygiene::Hygiene,
@@ -48,7 +48,7 @@ pub enum ImportAlias {
 impl ModPath {
    pub fn from_src(path: ast::Path, hygiene: &Hygiene) -> Option<ModPath> {
-        lower::lower_path(path, hygiene).map(|it| it.mod_path)
+        lower::lower_path(path, hygiene).map(|it| (*it.mod_path).clone())
    }
    pub fn from_segments(kind: PathKind, segments: impl IntoIterator<Item = Name>) -> ModPath {
@@ -123,7 +123,7 @@ pub struct Path {
    /// Type based path like `<T>::foo`.
    /// Note that paths like `<Type as Trait>::foo` are desugard to `Trait::<Self=Type>::foo`.
    type_anchor: Option<Box<TypeRef>>,
-    mod_path: ModPath,
+    mod_path: Interned<ModPath>,
    /// Invariant: the same len as `self.mod_path.segments`
    generic_args: Vec<Option<Arc<GenericArgs>>>,
 }
@@ -176,7 +176,7 @@ impl Path {
        path: ModPath,
        generic_args: Vec<Option<Arc<GenericArgs>>>,
    ) -> Path {
-        Path { type_anchor: None, mod_path: path, generic_args }
+        Path { type_anchor: None, mod_path: Interned::new(path), generic_args }
    }
    pub fn kind(&self) -> &PathKind {
@@ -204,10 +204,10 @@ impl Path {
        }
        let res = Path {
            type_anchor: self.type_anchor.clone(),
-            mod_path: ModPath::from_segments(
+            mod_path: Interned::new(ModPath::from_segments(
                self.mod_path.kind.clone(),
                self.mod_path.segments[..self.mod_path.segments.len() - 1].iter().cloned(),
-            ),
+            )),
            generic_args: self.generic_args[..self.generic_args.len() - 1].to_vec(),
        };
        Some(res)
@@ -283,7 +283,7 @@ impl From<Name> for Path {
    fn from(name: Name) -> Path {
        Path {
            type_anchor: None,
-            mod_path: ModPath::from_segments(PathKind::Plain, iter::once(name)),
+            mod_path: Interned::new(ModPath::from_segments(PathKind::Plain, iter::once(name))),
            generic_args: vec![None],
        }
    }
diff --git a/crates/hir_def/src/path/lower.rs b/crates/hir_def/src/path/lower.rs
index 4de951fd3..28f6244da 100644
--- a/crates/hir_def/src/path/lower.rs
+++ b/crates/hir_def/src/path/lower.rs
@@ -2,6 +2,7 @@
 mod lower_use;
+use crate::intern::Interned;
 use std::sync::Arc;
 use either::Either;
@@ -74,10 +75,11 @@ pub(super) fn lower_path(mut path: ast::Path, hygiene: &Hygiene) -> Option<Path>
                    // <T as Trait<A>>::Foo desugars to Trait<Self=T, A>::Foo
                    Some(trait_ref) => {
                        let path = Path::from_src(trait_ref.path()?, hygiene)?;
+                        let mod_path = (*path.mod_path).clone();
                        let num_segments = path.mod_path.segments.len();
-                        kind = path.mod_path.kind;
+                        kind = mod_path.kind;
-                        let mut prefix_segments = path.mod_path.segments;
+                        let mut prefix_segments = mod_path.segments;
                        prefix_segments.reverse();
                        segments.extend(prefix_segments);
@@ -140,7 +142,7 @@ pub(super) fn lower_path(mut path: ast::Path, hygiene: &Hygiene) -> Option<Path>
        }
    }
-    let mod_path = ModPath::from_segments(kind, segments);
+    let mod_path = Interned::new(ModPath::from_segments(kind, segments));
    return Some(Path { type_anchor, mod_path, generic_args });
    fn qualifier(path: &ast::Path) -> Option<ast::Path> {
diff --git a/crates/hir_def/src/test_db.rs b/crates/hir_def/src/test_db.rs
index 10977761c..dd36106f8 100644
--- a/crates/hir_def/src/test_db.rs
+++ b/crates/hir_def/src/test_db.rs
@@ -265,4 +265,17 @@ impl TestDB {
        assert_eq!(annotations, actual);
    }
+    pub(crate) fn check_no_diagnostics(&self) {
+        let db: &TestDB = self;
+        let annotations = db.extract_annotations();
+        assert!(annotations.is_empty());
+        let mut has_diagnostics = false;
+        db.diagnostics(|_| {
+            has_diagnostics = true;
+        });
+        assert!(!has_diagnostics);
+    }
 }
diff --git a/crates/hir_expand/src/builtin_macro.rs b/crates/hir_expand/src/builtin_macro.rs
index 4d52904b9..75ec4196b 100644
--- a/crates/hir_expand/src/builtin_macro.rs
+++ b/crates/hir_expand/src/builtin_macro.rs
@@ -1,10 +1,10 @@
 //! Builtin macro
 use crate::{
    db::AstDatabase, name, quote, AstId, CrateId, EagerMacroId, LazyMacroId, MacroCallId,
-    MacroDefId, MacroDefKind, TextSize,
+    MacroCallLoc, MacroDefId, MacroDefKind, TextSize,
 };
-use base_db::{AnchoredPath, FileId};
+use base_db::{AnchoredPath, Edition, FileId};
 use cfg::CfgExpr;
 use either::Either;
 use mbe::{parse_exprs_with_sep, parse_to_token_tree, ExpandResult};
@@ -111,6 +111,8 @@ register_builtin! {
    (llvm_asm, LlvmAsm) => asm_expand,
    (asm, Asm) => asm_expand,
    (cfg, Cfg) => cfg_expand,
+    (core_panic, CorePanic) => panic_expand,
+    (std_panic, StdPanic) => panic_expand,
    EAGER:
    (compile_error, CompileError) => compile_error_expand,
@@ -284,6 +286,25 @@ fn cfg_expand(
    ExpandResult::ok(expanded)
 }
+fn panic_expand(
+    db: &dyn AstDatabase,
+    id: LazyMacroId,
+    tt: &tt::Subtree,
+) -> ExpandResult<tt::Subtree> {
+    let loc: MacroCallLoc = db.lookup_intern_macro(id);
+    // Expand to a macro call `$crate::panic::panic_{edition}`
+    let krate = tt::Ident { text: "$crate".into(), id: tt::TokenId::unspecified() };
+    let mut call = if db.crate_graph()[loc.krate].edition == Edition::Edition2021 {
+        quote!(#krate::panic::panic_2021!)
+    } else {
+        quote!(#krate::panic::panic_2015!)
+    };
+    // Pass the original arguments
+    call.token_trees.push(tt::TokenTree::Subtree(tt.clone()));
+    ExpandResult::ok(call)
+}
 fn unquote_str(lit: &tt::Literal) -> Option<String> {
    let lit = ast::make::tokens::literal(&lit.to_string());
    let token = ast::String::cast(lit)?;
@@ -563,7 +584,7 @@ mod tests {
                };
                let args = macro_call.token_tree().unwrap();
-                let parsed_args = mbe::ast_to_token_tree(&args).unwrap().0;
+                let parsed_args = mbe::ast_to_token_tree(&args).0;
                let call_id = AstId::new(file_id.into(), ast_id_map.ast_id(&macro_call));
                let arg_id = db.intern_eager_expansion({
diff --git a/crates/hir_expand/src/db.rs b/crates/hir_expand/src/db.rs
index c0ab70b60..10fe60821 100644
--- a/crates/hir_expand/src/db.rs
+++ b/crates/hir_expand/src/db.rs
@@ -119,7 +119,7 @@ pub fn expand_hypothetical(
    token_to_map: syntax::SyntaxToken,
 ) -> Option<(SyntaxNode, syntax::SyntaxToken)> {
    let macro_file = MacroFile { macro_call_id: actual_macro_call };
-    let (tt, tmap_1) = mbe::syntax_node_to_token_tree(hypothetical_args.syntax()).unwrap();
+    let (tt, tmap_1) = mbe::syntax_node_to_token_tree(hypothetical_args.syntax());
    let range =
        token_to_map.text_range().checked_sub(hypothetical_args.syntax().text_range().start())?;
    let token_id = tmap_1.token_by_range(range)?;
@@ -143,10 +143,7 @@ fn macro_def(db: &dyn AstDatabase, id: MacroDefId) -> Option<Arc<(TokenExpander,
        MacroDefKind::Declarative(ast_id) => match ast_id.to_node(db) {
            syntax::ast::Macro::MacroRules(macro_rules) => {
                let arg = macro_rules.token_tree()?;
-                let (tt, tmap) = mbe::ast_to_token_tree(&arg).or_else(|| {
+                let (tt, tmap) = mbe::ast_to_token_tree(&arg);
-                    log::warn!("fail on macro_rules to token tree: {:#?}", arg);
-                    None
-                })?;
                let rules = match MacroRules::parse(&tt) {
                    Ok(it) => it,
                    Err(err) => {
@@ -159,10 +156,7 @@ fn macro_def(db: &dyn AstDatabase, id: MacroDefId) -> Option<Arc<(TokenExpander,
            }
            syntax::ast::Macro::MacroDef(macro_def) => {
                let arg = macro_def.body()?;
-                let (tt, tmap) = mbe::ast_to_token_tree(&arg).or_else(|| {
+                let (tt, tmap) = mbe::ast_to_token_tree(&arg);
-                    log::warn!("fail on macro_def to token tree: {:#?}", arg);
-                    None
-                })?;
                let rules = match MacroDef::parse(&tt) {
                    Ok(it) => it,
                    Err(err) => {
@@ -202,7 +196,7 @@ fn macro_arg_text(db: &dyn AstDatabase, id: MacroCallId) -> Option<GreenNode> {
 fn macro_arg(db: &dyn AstDatabase, id: MacroCallId) -> Option<Arc<(tt::Subtree, mbe::TokenMap)>> {
    let arg = db.macro_arg_text(id)?;
-    let (tt, tmap) = mbe::syntax_node_to_token_tree(&SyntaxNode::new_root(arg))?;
+    let (tt, tmap) = mbe::syntax_node_to_token_tree(&SyntaxNode::new_root(arg));
    Some(Arc::new((tt, tmap)))
 }
diff --git a/crates/hir_expand/src/eager.rs b/crates/hir_expand/src/eager.rs
index 9eedc8461..9705526fa 100644
--- a/crates/hir_expand/src/eager.rs
+++ b/crates/hir_expand/src/eager.rs
@@ -106,7 +106,7 @@ pub fn expand_eager_macro(
    mut diagnostic_sink: &mut dyn FnMut(mbe::ExpandError),
 ) -> Result<EagerMacroId, ErrorEmitted> {
    let parsed_args = diagnostic_sink.option_with(
-        || Some(mbe::ast_to_token_tree(&macro_call.value.token_tree()?)?.0),
+        || Some(mbe::ast_to_token_tree(&macro_call.value.token_tree()?).0),
        || err("malformed macro invocation"),
    )?;
@@ -161,7 +161,7 @@ pub fn expand_eager_macro(
 }
 fn to_subtree(node: &SyntaxNode) -> Option<tt::Subtree> {
-    let mut subtree = mbe::syntax_node_to_token_tree(node)?.0;
+    let mut subtree = mbe::syntax_node_to_token_tree(node).0;
    subtree.delimiter = None;
    Some(subtree)
 }
diff --git a/crates/hir_expand/src/name.rs b/crates/hir_expand/src/name.rs
index 203ebbe85..a0f8766b0 100644
--- a/crates/hir_expand/src/name.rs
+++ b/crates/hir_expand/src/name.rs
@@ -208,6 +208,8 @@ pub mod known {
        line,
        module_path,
        assert,
+        core_panic,
+        std_panic,
        stringify,
        concat,
        include,
diff --git a/crates/hir_expand/src/quote.rs b/crates/hir_expand/src/quote.rs
index 08bc5aa49..c82487ef0 100644
--- a/crates/hir_expand/src/quote.rs
+++ b/crates/hir_expand/src/quote.rs
@@ -104,6 +104,7 @@ macro_rules! __quote {
    ( . ) => {$crate::__quote!(@PUNCT '.')};
    ( < ) => {$crate::__quote!(@PUNCT '<')};
    ( > ) => {$crate::__quote!(@PUNCT '>')};
+    ( ! ) => {$crate::__quote!(@PUNCT '!')};
    ( $first:tt $($tail:tt)+ ) => {
        {
diff --git a/crates/hir_ty/src/autoderef.rs b/crates/hir_ty/src/autoderef.rs
index dc5fc759a..70c56cc45 100644
--- a/crates/hir_ty/src/autoderef.rs
+++ b/crates/hir_ty/src/autoderef.rs
@@ -13,11 +13,9 @@ use log::{info, warn};
 use crate::{
    db::HirDatabase,
-    to_assoc_type_id, to_chalk_trait_id,
    traits::{InEnvironment, Solution},
-    utils::generics,
+    AliasEq, AliasTy, BoundVar, Canonical, CanonicalVarKinds, DebruijnIndex, Interner, Ty,
-    AliasEq, AliasTy, BoundVar, Canonical, CanonicalVarKinds, DebruijnIndex, Interner,
+    TyBuilder, TyKind,
-    ProjectionTy, Substitution, TraitRef, Ty, TyKind,
 };
 const AUTODEREF_RECURSION_LIMIT: usize = 10;
@@ -57,21 +55,20 @@ fn deref_by_trait(
    };
    let target = db.trait_data(deref_trait).associated_type_by_name(&name![Target])?;
-    let generic_params = generics(db.upcast(), target.into());
+    let projection = {
-    if generic_params.len() != 1 {
+        let b = TyBuilder::assoc_type_projection(db, target);
-        // the Target type + Deref trait should only have one generic parameter,
+        if b.remaining() != 1 {
-        // namely Deref's Self type
+            // the Target type + Deref trait should only have one generic parameter,
-        return None;
+            // namely Deref's Self type
-    }
+            return None;
+        }
+        b.push(ty.goal.value.clone()).build()
+    };
    // FIXME make the Canonical / bound var handling nicer
-    let parameters =
-        Substitution::build_for_generics(&generic_params).push(ty.goal.value.clone()).build();
    // Check that the type implements Deref at all
-    let trait_ref =
+    let trait_ref = projection.trait_ref(db);
-        TraitRef { trait_id: to_chalk_trait_id(deref_trait), substitution: parameters.clone() };
    let implements_goal = Canonical {
        binders: ty.goal.binders.clone(),
        value: InEnvironment {
@@ -84,11 +81,8 @@ fn deref_by_trait(
    }
    // Now do the assoc type projection
-    let projection = AliasEq {
+    let alias_eq = AliasEq {
-        alias: AliasTy::Projection(ProjectionTy {
+        alias: AliasTy::Projection(projection),
-            associated_ty_id: to_assoc_type_id(target),
-            substitution: parameters,
-        }),
        ty: TyKind::BoundVar(BoundVar::new(
            DebruijnIndex::INNERMOST,
            ty.goal.binders.len(&Interner),
@@ -96,9 +90,7 @@ fn deref_by_trait(
        .intern(&Interner),
    };
-    let obligation = projection.cast(&Interner);
+    let in_env = InEnvironment { goal: alias_eq.cast(&Interner), environment: ty.environment };
-    let in_env = InEnvironment { goal: obligation, environment: ty.environment };
    let canonical = Canonical {
        value: in_env,
@@ -131,7 +123,7 @@ fn deref_by_trait(
            // new variables in that case
            for i in 1..vars.0.binders.len(&Interner) {
-                if vars.0.value[i - 1].interned(&Interner)
+                if vars.0.value.at(&Interner, i - 1).assert_ty_ref(&Interner).kind(&Interner)
                    != &TyKind::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, i - 1))
                {
                    warn!("complex solution for derefing {:?}: {:?}, ignoring", ty.goal, solution);
@@ -139,7 +131,12 @@ fn deref_by_trait(
                }
            }
            Some(Canonical {
-                value: vars.0.value[vars.0.value.len() - 1].clone(),
+                value: vars
+                    .0
+                    .value
+                    .at(&Interner, vars.0.value.len(&Interner) - 1)
+                    .assert_ty_ref(&Interner)
+                    .clone(),
                binders: vars.0.binders.clone(),
            })
        }
diff --git a/crates/hir_ty/src/builder.rs b/crates/hir_ty/src/builder.rs
new file mode 100644
index 000000000..4a9a8058f
--- /dev/null
+++ b/crates/hir_ty/src/builder.rs
@@ -0,0 +1,219 @@
+//! `TyBuilder`, a helper for building instances of `Ty` and related types.
+use std::iter;
+use chalk_ir::{
+    cast::{Cast, CastTo, Caster},
+    interner::HasInterner,
+    AdtId, BoundVar, DebruijnIndex, Safety, Scalar,
+};
+use hir_def::{builtin_type::BuiltinType, GenericDefId, TraitId, TypeAliasId};
+use smallvec::SmallVec;
+use crate::{
+    db::HirDatabase, primitive, to_assoc_type_id, to_chalk_trait_id, utils::generics, Binders,
+    CallableSig, FnPointer, FnSig, GenericArg, Interner, ProjectionTy, Substitution, TraitRef, Ty,
+    TyDefId, TyKind, TypeWalk, ValueTyDefId,
+};
+/// This is a builder for `Ty` or anything that needs a `Substitution`.
+pub struct TyBuilder<D> {
+    /// The `data` field is used to keep track of what we're building (e.g. an
+    /// ADT, a `TraitRef`, ...).
+    data: D,
+    vec: SmallVec<[GenericArg; 2]>,
+    param_count: usize,
+}
+impl<D> TyBuilder<D> {
+    fn new(data: D, param_count: usize) -> TyBuilder<D> {
+        TyBuilder { data, param_count, vec: SmallVec::with_capacity(param_count) }
+    }
+    fn build_internal(self) -> (D, Substitution) {
+        assert_eq!(self.vec.len(), self.param_count);
+        // FIXME: would be good to have a way to construct a chalk_ir::Substitution from the interned form
+        let subst = Substitution(self.vec);
+        (self.data, subst)
+    }
+    pub fn push(mut self, arg: impl CastTo<GenericArg>) -> Self {
+        self.vec.push(arg.cast(&Interner));
+        self
+    }
+    pub fn remaining(&self) -> usize {
+        self.param_count - self.vec.len()
+    }
+    pub fn fill_with_bound_vars(self, debruijn: DebruijnIndex, starting_from: usize) -> Self {
+        self.fill(
+            (starting_from..)
+                .map(|idx| TyKind::BoundVar(BoundVar::new(debruijn, idx)).intern(&Interner)),
+        )
+    }
+    pub fn fill_with_unknown(self) -> Self {
+        self.fill(iter::repeat(TyKind::Unknown.intern(&Interner)))
+    }
+    pub fn fill(mut self, filler: impl Iterator<Item = impl CastTo<GenericArg>>) -> Self {
+        self.vec.extend(filler.take(self.remaining()).casted(&Interner));
+        assert_eq!(self.remaining(), 0);
+        self
+    }
+    pub fn use_parent_substs(mut self, parent_substs: &Substitution) -> Self {
+        assert!(self.vec.is_empty());
+        assert!(parent_substs.len(&Interner) <= self.param_count);
+        self.vec.extend(parent_substs.iter(&Interner).cloned());
+        self
+    }
+}
+impl TyBuilder<()> {
+    pub fn unit() -> Ty {
+        TyKind::Tuple(0, Substitution::empty(&Interner)).intern(&Interner)
+    }
+    pub fn fn_ptr(sig: CallableSig) -> Ty {
+        TyKind::Function(FnPointer {
+            num_args: sig.params().len(),
+            sig: FnSig { abi: (), safety: Safety::Safe, variadic: sig.is_varargs },
+            substs: Substitution::from_iter(&Interner, sig.params_and_return.iter().cloned()),
+        })
+        .intern(&Interner)
+    }
+    pub fn builtin(builtin: BuiltinType) -> Ty {
+        match builtin {
+            BuiltinType::Char => TyKind::Scalar(Scalar::Char).intern(&Interner),
+            BuiltinType::Bool => TyKind::Scalar(Scalar::Bool).intern(&Interner),
+            BuiltinType::Str => TyKind::Str.intern(&Interner),
+            BuiltinType::Int(t) => {
+                TyKind::Scalar(Scalar::Int(primitive::int_ty_from_builtin(t))).intern(&Interner)
+            }
+            BuiltinType::Uint(t) => {
+                TyKind::Scalar(Scalar::Uint(primitive::uint_ty_from_builtin(t))).intern(&Interner)
+            }
+            BuiltinType::Float(t) => {
+                TyKind::Scalar(Scalar::Float(primitive::float_ty_from_builtin(t))).intern(&Interner)
+            }
+        }
+    }
+    pub fn type_params_subst(db: &dyn HirDatabase, def: impl Into<GenericDefId>) -> Substitution {
+        let params = generics(db.upcast(), def.into());
+        params.type_params_subst(db)
+    }
+    pub fn subst_for_def(db: &dyn HirDatabase, def: impl Into<GenericDefId>) -> TyBuilder<()> {
+        let def = def.into();
+        let params = generics(db.upcast(), def);
+        let param_count = params.len();
+        TyBuilder::new((), param_count)
+    }
+    pub fn build(self) -> Substitution {
+        let ((), subst) = self.build_internal();
+        subst
+    }
+}
+impl TyBuilder<hir_def::AdtId> {
+    pub fn adt(db: &dyn HirDatabase, adt: hir_def::AdtId) -> TyBuilder<hir_def::AdtId> {
+        let generics = generics(db.upcast(), adt.into());
+        let param_count = generics.len();
+        TyBuilder::new(adt, param_count)
+    }
+    pub fn fill_with_defaults(
+        mut self,
+        db: &dyn HirDatabase,
+        mut fallback: impl FnMut() -> Ty,
+    ) -> Self {
+        let defaults = db.generic_defaults(self.data.into());
+        for default_ty in defaults.iter().skip(self.vec.len()) {
+            if default_ty.skip_binders().is_unknown() {
+                self.vec.push(fallback().cast(&Interner));
+            } else {
+                // each default can depend on the previous parameters
+                let subst_so_far = Substitution(self.vec.clone());
+                self.vec.push(default_ty.clone().subst(&subst_so_far).cast(&Interner));
+            }
+        }
+        self
+    }
+    pub fn build(self) -> Ty {
+        let (adt, subst) = self.build_internal();
+        TyKind::Adt(AdtId(adt), subst).intern(&Interner)
+    }
+}
+pub struct Tuple(usize);
+impl TyBuilder<Tuple> {
+    pub fn tuple(size: usize) -> TyBuilder<Tuple> {
+        TyBuilder::new(Tuple(size), size)
+    }
+    pub fn build(self) -> Ty {
+        let (Tuple(size), subst) = self.build_internal();
+        TyKind::Tuple(size, subst).intern(&Interner)
+    }
+}
+impl TyBuilder<TraitId> {
+    pub fn trait_ref(db: &dyn HirDatabase, trait_id: TraitId) -> TyBuilder<TraitId> {
+        let generics = generics(db.upcast(), trait_id.into());
+        let param_count = generics.len();
+        TyBuilder::new(trait_id, param_count)
+    }
+    pub fn build(self) -> TraitRef {
+        let (trait_id, substitution) = self.build_internal();
+        TraitRef { trait_id: to_chalk_trait_id(trait_id), substitution }
+    }
+}
+impl TyBuilder<TypeAliasId> {
+    pub fn assoc_type_projection(
+        db: &dyn HirDatabase,
+        type_alias: TypeAliasId,
+    ) -> TyBuilder<TypeAliasId> {
+        let generics = generics(db.upcast(), type_alias.into());
+        let param_count = generics.len();
+        TyBuilder::new(type_alias, param_count)
+    }
+    pub fn build(self) -> ProjectionTy {
+        let (type_alias, substitution) = self.build_internal();
+        ProjectionTy { associated_ty_id: to_assoc_type_id(type_alias), substitution }
+    }
+}
+impl<T: TypeWalk + HasInterner<Interner = Interner>> TyBuilder<Binders<T>> {
+    fn subst_binders(b: Binders<T>) -> Self {
+        let param_count = b.num_binders;
+        TyBuilder::new(b, param_count)
+    }
+    pub fn build(self) -> T {
+        let (b, subst) = self.build_internal();
+        b.subst(&subst)
+    }
+}
+impl TyBuilder<Binders<Ty>> {
+    pub fn def_ty(db: &dyn HirDatabase, def: TyDefId) -> TyBuilder<Binders<Ty>> {
+        TyBuilder::subst_binders(db.ty(def.into()))
+    }
+    pub fn impl_self_ty(db: &dyn HirDatabase, def: hir_def::ImplId) -> TyBuilder<Binders<Ty>> {
+        TyBuilder::subst_binders(db.impl_self_ty(def))
+    }
+    pub fn value_ty(db: &dyn HirDatabase, def: ValueTyDefId) -> TyBuilder<Binders<Ty>> {
+        TyBuilder::subst_binders(db.value_ty(def))
+    }
+}
diff --git a/crates/hir_ty/src/chalk_cast.rs b/crates/hir_ty/src/chalk_cast.rs
index bf884ae15..df6492113 100644
--- a/crates/hir_ty/src/chalk_cast.rs
+++ b/crates/hir_ty/src/chalk_cast.rs
@@ -5,7 +5,7 @@ use chalk_ir::{
    interner::HasInterner,
 };
-use crate::{AliasEq, DomainGoal, Interner, TraitRef, WhereClause};
+use crate::{AliasEq, DomainGoal, GenericArg, GenericArgData, Interner, TraitRef, Ty, WhereClause};
 macro_rules! has_interner {
    ($t:ty) => {
@@ -17,6 +17,8 @@ macro_rules! has_interner {
 has_interner!(WhereClause);
 has_interner!(DomainGoal);
+has_interner!(GenericArg);
+has_interner!(Ty);
 impl CastTo<WhereClause> for TraitRef {
    fn cast_to(self, _interner: &Interner) -> WhereClause {
@@ -36,6 +38,12 @@ impl CastTo<DomainGoal> for WhereClause {
    }
 }
+impl CastTo<GenericArg> for Ty {
+    fn cast_to(self, interner: &Interner) -> GenericArg {
+        GenericArg::new(interner, GenericArgData::Ty(self))
+    }
+}
 macro_rules! transitive_impl {
    ($a:ty, $b:ty, $c:ty) => {
        impl CastTo<$c> for $a {
@@ -51,3 +59,15 @@ macro_rules! transitive_impl {
 transitive_impl!(TraitRef, WhereClause, DomainGoal);
 transitive_impl!(AliasEq, WhereClause, DomainGoal);
+macro_rules! reflexive_impl {
+    ($a:ty) => {
+        impl CastTo<$a> for $a {
+            fn cast_to(self, _interner: &Interner) -> $a {
+                self
+            }
+        }
+    };
+}
+reflexive_impl!(GenericArg);
diff --git a/crates/hir_ty/src/chalk_ext.rs b/crates/hir_ty/src/chalk_ext.rs
new file mode 100644
index 000000000..b7463366b
--- /dev/null
+++ b/crates/hir_ty/src/chalk_ext.rs
@@ -0,0 +1,13 @@
+//! Various extensions traits for Chalk types.
+use crate::{Interner, Ty, TyKind};
+pub trait TyExt {
+    fn is_unit(&self) -> bool;
+}
+impl TyExt for Ty {
+    fn is_unit(&self) -> bool {
+        matches!(self.kind(&Interner), TyKind::Tuple(0, _))
+    }
+}
diff --git a/crates/hir_ty/src/diagnostics/decl_check.rs b/crates/hir_ty/src/diagnostics/decl_check.rs
index 33a0f4d7d..1c9f9ede7 100644
--- a/crates/hir_ty/src/diagnostics/decl_check.rs
+++ b/crates/hir_ty/src/diagnostics/decl_check.rs
@@ -91,7 +91,7 @@ impl<'a, 'b> DeclValidator<'a, 'b> {
    fn validate_func(&mut self, func: FunctionId) {
        let data = self.db.function_data(func);
-        if data.is_in_extern_block {
+        if data.is_in_extern_block() {
            cov_mark::hit!(extern_func_incorrect_case_ignored);
            return;
        }
@@ -99,8 +99,7 @@ impl<'a, 'b> DeclValidator<'a, 'b> {
        let body = self.db.body(func.into());
        // Recursively validate inner scope items, such as static variables and constants.
-        let db = self.db;
+        for (_, block_def_map) in body.blocks(self.db.upcast()) {
-        for block_def_map in body.block_scopes.iter().filter_map(|block| db.block_def_map(*block)) {
            for (_, module) in block_def_map.modules() {
                for def_id in module.scope.declarations() {
                    let mut validator = DeclValidator::new(self.db, self.krate, self.sink);
diff --git a/crates/hir_ty/src/diagnostics/expr.rs b/crates/hir_ty/src/diagnostics/expr.rs
index 3909ad354..8169b759f 100644
--- a/crates/hir_ty/src/diagnostics/expr.rs
+++ b/crates/hir_ty/src/diagnostics/expr.rs
@@ -15,7 +15,7 @@ use crate::{
        MissingPatFields, RemoveThisSemicolon,
    },
    utils::variant_data,
-    AdtId, InferenceResult, Interner, Ty, TyKind,
+    AdtId, InferenceResult, Interner, TyExt, TyKind,
 };
 pub(crate) use hir_def::{
@@ -378,7 +378,7 @@ impl<'a, 'b> ExprValidator<'a, 'b> {
            _ => return,
        };
-        let (params, required) = match mismatch.expected.interned(&Interner) {
+        let (params, required) = match mismatch.expected.kind(&Interner) {
            TyKind::Adt(AdtId(hir_def::AdtId::EnumId(enum_id)), ref parameters)
                if *enum_id == core_result_enum =>
            {
@@ -392,7 +392,9 @@ impl<'a, 'b> ExprValidator<'a, 'b> {
            _ => return,
        };
-        if params.len() > 0 && params[0] == mismatch.actual {
+        if params.len(&Interner) > 0
+            && params.at(&Interner, 0).ty(&Interner) == Some(&mismatch.actual)
+        {
            let (_, source_map) = db.body_with_source_map(self.owner);
            if let Ok(source_ptr) = source_map.expr_syntax(id) {
@@ -421,7 +423,7 @@ impl<'a, 'b> ExprValidator<'a, 'b> {
            None => return,
        };
-        if mismatch.actual != Ty::unit() || mismatch.expected != *possible_tail_ty {
+        if !mismatch.actual.is_unit() || mismatch.expected != *possible_tail_ty {
            return;
        }
diff --git a/crates/hir_ty/src/diagnostics/match_check.rs b/crates/hir_ty/src/diagnostics/match_check.rs
index 9cb472b51..34291578a 100644
--- a/crates/hir_ty/src/diagnostics/match_check.rs
+++ b/crates/hir_ty/src/diagnostics/match_check.rs
@@ -626,7 +626,7 @@ pub(super) fn is_useful(
    // - enum with no variants
    // - `!` type
    // In those cases, no match arm is useful.
-    match cx.infer[cx.match_expr].strip_references().interned(&Interner) {
+    match cx.infer[cx.match_expr].strip_references().kind(&Interner) {
        TyKind::Adt(AdtId(hir_def::AdtId::EnumId(enum_id)), ..) => {
            if cx.db.enum_data(*enum_id).variants.is_empty() {
                return Ok(Usefulness::NotUseful);
@@ -792,7 +792,10 @@ fn pat_constructor(cx: &MatchCheckCtx, pat: PatIdOrWild) -> MatchCheckResult<Opt
        Pat::Tuple { .. } => {
            let pat_id = pat.as_id().expect("we already know this pattern is not a wild");
            Some(Constructor::Tuple {
-                arity: cx.infer.type_of_pat[pat_id].as_tuple().ok_or(MatchCheckErr::Unknown)?.len(),
+                arity: cx.infer.type_of_pat[pat_id]
+                    .as_tuple()
+                    .ok_or(MatchCheckErr::Unknown)?
+                    .len(&Interner),
            })
        }
        Pat::Lit(lit_expr) => match cx.body.exprs[lit_expr] {
diff --git a/crates/hir_ty/src/diagnostics/unsafe_check.rs b/crates/hir_ty/src/diagnostics/unsafe_check.rs
index 1f49a4909..b5efe9df5 100644
--- a/crates/hir_ty/src/diagnostics/unsafe_check.rs
+++ b/crates/hir_ty/src/diagnostics/unsafe_check.rs
@@ -32,7 +32,7 @@ impl<'a, 'b> UnsafeValidator<'a, 'b> {
        let def = self.owner;
        let unsafe_expressions = unsafe_expressions(db, self.infer.as_ref(), def);
        let is_unsafe = match self.owner {
-            DefWithBodyId::FunctionId(it) => db.function_data(it).qualifier.is_unsafe,
+            DefWithBodyId::FunctionId(it) => db.function_data(it).is_unsafe(),
            DefWithBodyId::StaticId(_) | DefWithBodyId::ConstId(_) => false,
        };
        if is_unsafe
@@ -86,7 +86,7 @@ fn walk_unsafe(
    match expr {
        &Expr::Call { callee, .. } => {
            if let Some(func) = infer[callee].as_fn_def(db) {
-                if db.function_data(func).qualifier.is_unsafe {
+                if db.function_data(func).is_unsafe() {
                    unsafe_exprs.push(UnsafeExpr { expr: current, inside_unsafe_block });
                }
            }
@@ -103,14 +103,14 @@ fn walk_unsafe(
        Expr::MethodCall { .. } => {
            if infer
                .method_resolution(current)
-                .map(|func| db.function_data(func).qualifier.is_unsafe)
+                .map(|func| db.function_data(func).is_unsafe())
                .unwrap_or(false)
            {
                unsafe_exprs.push(UnsafeExpr { expr: current, inside_unsafe_block });
            }
        }
        Expr::UnaryOp { expr, op: UnaryOp::Deref } => {
-            if let TyKind::Raw(..) = &infer[*expr].interned(&Interner) {
+            if let TyKind::Raw(..) = &infer[*expr].kind(&Interner) {
                unsafe_exprs.push(UnsafeExpr { expr: current, inside_unsafe_block });
            }
        }
diff --git a/crates/hir_ty/src/display.rs b/crates/hir_ty/src/display.rs
index 51480304b..385bd9405 100644
--- a/crates/hir_ty/src/display.rs
+++ b/crates/hir_ty/src/display.rs
@@ -8,7 +8,7 @@ use hir_def::{
    find_path,
    generics::TypeParamProvenance,
    item_scope::ItemInNs,
-    path::{GenericArg, Path, PathKind},
+    path::{Path, PathKind},
    type_ref::{TypeBound, TypeRef},
    visibility::Visibility,
    AssocContainerId, Lookup, ModuleId, TraitId,
@@ -18,8 +18,8 @@ use hir_expand::name::Name;
 use crate::{
    db::HirDatabase, from_assoc_type_id, from_foreign_def_id, from_placeholder_idx, primitive,
    to_assoc_type_id, traits::chalk::from_chalk, utils::generics, AdtId, AliasEq, AliasTy,
-    CallableDefId, CallableSig, DomainGoal, ImplTraitId, Interner, Lifetime, OpaqueTy,
+    CallableDefId, CallableSig, DomainGoal, GenericArg, ImplTraitId, Interner, Lifetime, OpaqueTy,
-    ProjectionTy, QuantifiedWhereClause, Scalar, Substitution, TraitRef, Ty, TyKind, WhereClause,
+    ProjectionTy, QuantifiedWhereClause, Scalar, TraitRef, Ty, TyExt, TyKind, WhereClause,
 };
 pub struct HirFormatter<'a> {
@@ -251,16 +251,16 @@ impl HirDisplay for ProjectionTy {
        }
        let trait_ = f.db.trait_data(self.trait_(f.db));
-        let first_parameter = self.substitution[0].into_displayable(
+        let first_parameter = self.self_type_parameter().into_displayable(
            f.db,
            f.max_size,
            f.omit_verbose_types,
            f.display_target,
        );
        write!(f, "<{} as {}", first_parameter, trait_.name)?;
-        if self.substitution.len() > 1 {
+        if self.substitution.len(&Interner) > 1 {
            write!(f, "<")?;
-            f.write_joined(&self.substitution[1..], ", ")?;
+            f.write_joined(&self.substitution.interned(&Interner)[1..], ", ")?;
            write!(f, ">")?;
        }
        write!(f, ">::{}", f.db.type_alias_data(from_assoc_type_id(self.associated_ty_id)).name)?;
@@ -274,7 +274,15 @@ impl HirDisplay for OpaqueTy {
            return write!(f, "{}", TYPE_HINT_TRUNCATION);
        }
-        self.substitution[0].hir_fmt(f)
+        self.substitution.at(&Interner, 0).hir_fmt(f)
+    }
+}
+impl HirDisplay for GenericArg {
+    fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
+        match self.interned() {
+            crate::GenericArgData::Ty(ty) => ty.hir_fmt(f),
+        }
    }
 }
@@ -284,7 +292,7 @@ impl HirDisplay for Ty {
            return write!(f, "{}", TYPE_HINT_TRUNCATION);
        }
-        match self.interned(&Interner) {
+        match self.kind(&Interner) {
            TyKind::Never => write!(f, "!")?,
            TyKind::Str => write!(f, "str")?,
            TyKind::Scalar(Scalar::Bool) => write!(f, "bool")?,
@@ -306,7 +314,7 @@ impl HirDisplay for Ty {
                let ty_display =
                    t.into_displayable(f.db, f.max_size, f.omit_verbose_types, f.display_target);
-                if matches!(self.interned(&Interner), TyKind::Raw(..)) {
+                if matches!(self.kind(&Interner), TyKind::Raw(..)) {
                    write!(
                        f,
                        "*{}",
@@ -328,7 +336,7 @@ impl HirDisplay for Ty {
                // FIXME: all this just to decide whether to use parentheses...
                let datas;
-                let predicates: Vec<_> = match t.interned(&Interner) {
+                let predicates: Vec<_> = match t.kind(&Interner) {
                    TyKind::Dyn(dyn_ty) if dyn_ty.bounds.skip_binders().interned().len() > 1 => {
                        dyn_ty.bounds.skip_binders().interned().iter().cloned().collect()
                    }
@@ -373,9 +381,9 @@ impl HirDisplay for Ty {
                }
            }
            TyKind::Tuple(_, substs) => {
-                if substs.len() == 1 {
+                if substs.len(&Interner) == 1 {
                    write!(f, "(")?;
-                    substs[0].hir_fmt(f)?;
+                    substs.at(&Interner, 0).hir_fmt(f)?;
                    write!(f, ",)")?;
                } else {
                    write!(f, "(")?;
@@ -399,7 +407,7 @@ impl HirDisplay for Ty {
                        write!(f, "{}", f.db.enum_data(e.parent).variants[e.local_id].name)?
                    }
                };
-                if parameters.len() > 0 {
+                if parameters.len(&Interner) > 0 {
                    let generics = generics(f.db.upcast(), def.into());
                    let (parent_params, self_param, type_params, _impl_trait_params) =
                        generics.provenance_split();
@@ -415,7 +423,7 @@ impl HirDisplay for Ty {
                f.write_joined(sig.params(), ", ")?;
                write!(f, ")")?;
                let ret = sig.ret();
-                if *ret != Ty::unit() {
+                if !ret.is_unit() {
                    let ret_display = ret.into_displayable(
                        f.db,
                        f.max_size,
@@ -451,7 +459,7 @@ impl HirDisplay for Ty {
                    }
                }
-                if parameters.len() > 0 {
+                if parameters.len(&Interner) > 0 {
                    let parameters_to_write = if f.display_target.is_source_code()
                        || f.omit_verbose_types()
                    {
@@ -463,9 +471,11 @@ impl HirDisplay for Ty {
                            None => parameters.0.as_ref(),
                            Some(default_parameters) => {
                                let mut default_from = 0;
-                                for (i, parameter) in parameters.iter().enumerate() {
+                                for (i, parameter) in parameters.iter(&Interner).enumerate() {
-                                    match (parameter.interned(&Interner), default_parameters.get(i))
+                                    match (
-                                    {
+                                        parameter.assert_ty_ref(&Interner).kind(&Interner),
+                                        default_parameters.get(i),
+                                    ) {
                                        (&TyKind::Unknown, _) | (_, None) => {
                                            default_from = i + 1;
                                        }
@@ -473,7 +483,8 @@ impl HirDisplay for Ty {
                                            let actual_default = default_parameter
                                                .clone()
                                                .subst(&parameters.prefix(i));
-                                            if parameter != &actual_default {
+                                            if parameter.assert_ty_ref(&Interner) != &actual_default
+                                            {
                                                default_from = i + 1;
                                            }
                                        }
@@ -504,7 +515,7 @@ impl HirDisplay for Ty {
                // Use placeholder associated types when the target is test (https://rust-lang.github.io/chalk/book/clauses/type_equality.html#placeholder-associated-types)
                if f.display_target.is_test() {
                    write!(f, "{}::{}", trait_.name, type_alias_data.name)?;
-                    if parameters.len() > 0 {
+                    if parameters.len(&Interner) > 0 {
                        write!(f, "<")?;
                        f.write_joined(&*parameters.0, ", ")?;
                        write!(f, ">")?;
@@ -537,7 +548,7 @@ impl HirDisplay for Ty {
                    }
                    ImplTraitId::AsyncBlockTypeImplTrait(..) => {
                        write!(f, "impl Future<Output = ")?;
-                        parameters[0].hir_fmt(f)?;
+                        parameters.at(&Interner, 0).hir_fmt(f)?;
                        write!(f, ">")?;
                    }
                }
@@ -548,7 +559,7 @@ impl HirDisplay for Ty {
                        DisplaySourceCodeError::Closure,
                    ));
                }
-                let sig = substs[0].callable_sig(f.db);
+                let sig = substs.at(&Interner, 0).assert_ty_ref(&Interner).callable_sig(f.db);
                if let Some(sig) = sig {
                    if sig.params().is_empty() {
                        write!(f, "||")?;
@@ -580,7 +591,7 @@ impl HirDisplay for Ty {
                        write!(f, "{}", param_data.name.clone().unwrap_or_else(Name::missing))?
                    }
                    TypeParamProvenance::ArgumentImplTrait => {
-                        let substs = Substitution::type_params_for_generics(f.db, &generics);
+                        let substs = generics.type_params_subst(f.db);
                        let bounds = f
                            .db
                            .generic_predicates(id.parent)
@@ -652,7 +663,7 @@ impl HirDisplay for CallableSig {
        }
        write!(f, ")")?;
        let ret = self.ret();
-        if *ret != Ty::unit() {
+        if !ret.is_unit() {
            let ret_display =
                ret.into_displayable(f.db, f.max_size, f.omit_verbose_types, f.display_target);
            write!(f, " -> {}", ret_display)?;
@@ -718,7 +729,9 @@ fn write_bounds_like_dyn_trait(
                write!(f, "{}", f.db.trait_data(trait_).name)?;
                if let [_, params @ ..] = &*trait_ref.substitution.0 {
                    if is_fn_trait {
-                        if let Some(args) = params.first().and_then(|it| it.as_tuple()) {
+                        if let Some(args) =
+                            params.first().and_then(|it| it.assert_ty_ref(&Interner).as_tuple())
+                        {
                            write!(f, "(")?;
                            f.write_joined(&*args.0, ", ")?;
                            write!(f, ")")?;
@@ -767,16 +780,16 @@ impl TraitRef {
            return write!(f, "{}", TYPE_HINT_TRUNCATION);
        }
-        self.substitution[0].hir_fmt(f)?;
+        self.self_type_parameter().hir_fmt(f)?;
        if use_as {
            write!(f, " as ")?;
        } else {
            write!(f, ": ")?;
        }
        write!(f, "{}", f.db.trait_data(self.hir_trait_id()).name)?;
-        if self.substitution.len() > 1 {
+        if self.substitution.len(&Interner) > 1 {
            write!(f, "<")?;
-            f.write_joined(&self.substitution[1..], ", ")?;
+            f.write_joined(&self.substitution.interned(&Interner)[1..], ", ")?;
            write!(f, ">")?;
        }
        Ok(())
@@ -1016,11 +1029,11 @@ impl HirDisplay for Path {
    }
 }
-impl HirDisplay for GenericArg {
+impl HirDisplay for hir_def::path::GenericArg {
    fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
        match self {
-            GenericArg::Type(ty) => ty.hir_fmt(f),
+            hir_def::path::GenericArg::Type(ty) => ty.hir_fmt(f),
-            GenericArg::Lifetime(lifetime) => write!(f, "{}", lifetime.name),
+            hir_def::path::GenericArg::Lifetime(lifetime) => write!(f, "{}", lifetime.name),
        }
    }
 }
diff --git a/crates/hir_ty/src/infer.rs b/crates/hir_ty/src/infer.rs
index 497a1beb7..1b1d4458c 100644
--- a/crates/hir_ty/src/infer.rs
+++ b/crates/hir_ty/src/infer.rs
@@ -38,11 +38,11 @@ use syntax::SmolStr;
 use super::{
    traits::{DomainGoal, Guidance, Solution},
-    InEnvironment, ProjectionTy, Substitution, TraitEnvironment, TraitRef, Ty, TypeWalk,
+    InEnvironment, ProjectionTy, TraitEnvironment, TraitRef, Ty, TypeWalk,
 };
 use crate::{
    db::HirDatabase, infer::diagnostics::InferenceDiagnostic, lower::ImplTraitLoweringMode,
-    to_assoc_type_id, to_chalk_trait_id, AliasEq, AliasTy, Interner, TyKind,
+    to_assoc_type_id, AliasEq, AliasTy, Interner, TyBuilder, TyKind,
 };
 // This lint has a false positive here. See the link below for details.
@@ -325,7 +325,7 @@ impl<'a> InferenceContext<'a> {
    /// Replaces Ty::Unknown by a new type var, so we can maybe still infer it.
    fn insert_type_vars_shallow(&mut self, ty: Ty) -> Ty {
-        match ty.interned(&Interner) {
+        match ty.kind(&Interner) {
            TyKind::Unknown => self.table.new_type_var(),
            _ => ty,
        }
@@ -340,6 +340,8 @@ impl<'a> InferenceContext<'a> {
            // no change
            return;
        }
+        let _span = profile::span("resolve_obligations_as_possible");
        self.last_obligations_check = Some(self.table.revision);
        let obligations = mem::replace(&mut self.obligations, Vec::new());
        for obligation in obligations {
@@ -407,16 +409,14 @@ impl<'a> InferenceContext<'a> {
                    _ => panic!("resolve_associated_type called with non-associated type"),