131 files changed, 5037 insertions, 2297 deletions
diff --git a/.cargo/config b/.cargo/config
index f6b0b66bf..1447614b7 100644
--- a/.cargo/config
+++ b/.cargo/config
@@ -3,6 +3,7 @@ xtask = "run --package xtask --bin xtask --"
 install-ra = "run --package xtask --bin xtask -- install" # for backwards compat
 tq = "test -- -q"
 qt = "tq"
+lint = "clippy --all-targets -- -Aclippy::collapsible_if -Aclippy::needless_pass_by_value -Aclippy::nonminimal_bool -Aclippy::redundant_pattern_matching --cap-lints warn"
 [target.x86_64-pc-windows-msvc]
 linker = "rust-lld"
diff --git a/Cargo.lock b/Cargo.lock
index b1fef2e80..b2d009e38 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -486,6 +486,7 @@ dependencies = [
 "log",
 "profile",
 "rustc-hash",
+ "smallvec",
 "stdx",
 "syntax",
 "tt",
diff --git a/crates/cfg/src/cfg_expr.rs b/crates/cfg/src/cfg_expr.rs
index 42327f1e1..069fc01d0 100644
--- a/crates/cfg/src/cfg_expr.rs
+++ b/crates/cfg/src/cfg_expr.rs
@@ -49,7 +49,7 @@ impl fmt::Display for CfgAtom {
    }
 }
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub enum CfgExpr {
    Invalid,
    Atom(CfgAtom),
diff --git a/crates/hir/Cargo.toml b/crates/hir/Cargo.toml
index d4ea7327e..55e9c3f0c 100644
--- a/crates/hir/Cargo.toml
+++ b/crates/hir/Cargo.toml
@@ -15,6 +15,7 @@ rustc-hash = "1.1.0"
 either = "1.5.3"
 arrayvec = "0.5.1"
 itertools = "0.10.0"
+smallvec = "1.4.0"
 stdx = { path = "../stdx", version = "0.0.0" }
 syntax = { path = "../syntax", version = "0.0.0" }
diff --git a/crates/hir/src/lib.rs b/crates/hir/src/lib.rs
index 58adc8fd3..c5161dadd 100644
--- a/crates/hir/src/lib.rs
+++ b/crates/hir/src/lib.rs
@@ -51,11 +51,12 @@ use hir_expand::{diagnostics::DiagnosticSink, name::name, MacroDefKind};
 use hir_ty::{
    autoderef,
    display::{write_bounds_like_dyn_trait_with_prefix, HirDisplayError, HirFormatter},
-    method_resolution,
+    method_resolution::{self, TyFingerprint},
+    to_assoc_type_id,
    traits::{FnTrait, Solution, SolutionVariables},
    AliasTy, BoundVar, CallableDefId, CallableSig, Canonical, DebruijnIndex, GenericPredicate,
-    InEnvironment, Obligation, ProjectionPredicate, ProjectionTy, Scalar, Substs, TraitEnvironment,
+    InEnvironment, Interner, Obligation, ProjectionPredicate, ProjectionTy, Scalar, Substs, Ty,
-    Ty, TyDefId, TyVariableKind,
+    TyDefId, TyKind, TyVariableKind,
 };
 use rustc_hash::FxHashSet;
 use stdx::{format_to, impl_from};
@@ -266,8 +267,7 @@ impl ModuleDef {
    }
    pub fn canonical_path(&self, db: &dyn HirDatabase) -> Option<String> {
-        let mut segments = Vec::new();
+        let mut segments = vec![self.name(db)?.to_string()];
-        segments.push(self.name(db)?.to_string());
        for m in self.module(db)?.path_to_root(db) {
            segments.extend(m.name(db).map(|it| it.to_string()))
        }
@@ -677,7 +677,7 @@ impl_from!(Struct, Union, Enum for Adt);
 impl Adt {
    pub fn has_non_default_type_params(self, db: &dyn HirDatabase) -> bool {
        let subst = db.generic_defaults(self.into());
-        subst.iter().any(|ty| &ty.value == &Ty::Unknown)
+        subst.iter().any(|ty| ty.value.is_unknown())
    }
    /// Turns this ADT into a type. Any type parameters of the ADT will be
@@ -696,8 +696,8 @@ impl Adt {
        }
    }
-    pub fn krate(self, db: &dyn HirDatabase) -> Option<Crate> {
+    pub fn krate(self, db: &dyn HirDatabase) -> Crate {
-        Some(self.module(db).krate())
+        self.module(db).krate()
    }
    pub fn name(self, db: &dyn HirDatabase) -> Name {
@@ -802,7 +802,7 @@ impl Function {
        let krate = self.id.lookup(db.upcast()).container.module(db.upcast()).krate();
        let ret_type = &db.function_data(self.id).ret_type;
        let ctx = hir_ty::TyLoweringContext::new(db, &resolver);
-        let ty = Ty::from_hir_ext(&ctx, ret_type).0;
+        let ty = ctx.lower_ty(ret_type);
        Type::new_with_resolver_inner(db, krate, &resolver, ty)
    }
@@ -817,7 +817,7 @@ impl Function {
        let resolver = self.id.resolver(db.upcast());
        let krate = self.id.lookup(db.upcast()).container.module(db.upcast()).krate();
        let ctx = hir_ty::TyLoweringContext::new(db, &resolver);
-        let environment = TraitEnvironment::lower(db, &resolver);
+        let environment = db.trait_environment(self.id.into());
        db.function_data(self.id)
            .params
            .iter()
@@ -825,7 +825,7 @@ impl Function {
                let ty = Type {
                    krate,
                    ty: InEnvironment {
-                        value: Ty::from_hir_ext(&ctx, type_ref).0,
+                        value: ctx.lower_ty(type_ref),
                        environment: environment.clone(),
                    },
                };
@@ -1012,15 +1012,15 @@ pub struct TypeAlias {
 impl TypeAlias {
    pub fn has_non_default_type_params(self, db: &dyn HirDatabase) -> bool {
        let subst = db.generic_defaults(self.id.into());
-        subst.iter().any(|ty| &ty.value == &Ty::Unknown)
+        subst.iter().any(|ty| ty.value.is_unknown())
    }
    pub fn module(self, db: &dyn HirDatabase) -> Module {
        Module { id: self.id.lookup(db.upcast()).module(db.upcast()) }
    }
-    pub fn krate(self, db: &dyn HirDatabase) -> Option<Crate> {
+    pub fn krate(self, db: &dyn HirDatabase) -> Crate {
-        Some(self.module(db).krate())
+        self.module(db).krate()
    }
    pub fn type_ref(self, db: &dyn HirDatabase) -> Option<TypeRef> {
@@ -1384,7 +1384,7 @@ impl TypeParam {
    pub fn ty(self, db: &dyn HirDatabase) -> Type {
        let resolver = self.id.parent.resolver(db.upcast());
        let krate = self.id.parent.module(db.upcast()).krate();
-        let ty = Ty::Placeholder(self.id);
+        let ty = TyKind::Placeholder(hir_ty::to_placeholder_idx(db, self.id)).intern(&Interner);
        Type::new_with_resolver_inner(db, krate, &resolver, ty)
    }
@@ -1483,9 +1483,44 @@ impl Impl {
        inherent.all_impls().chain(trait_.all_impls()).map(Self::from).collect()
    }
-    pub fn for_trait(db: &dyn HirDatabase, krate: Crate, trait_: Trait) -> Vec<Impl> {
-        let impls = db.trait_impls_in_crate(krate.id);
+    pub fn all_for_type(db: &dyn HirDatabase, Type { krate, ty }: Type) -> Vec<Impl> {
-        impls.for_trait(trait_.id).map(Self::from).collect()
+        let def_crates = match ty.value.def_crates(db, krate) {
+            Some(def_crates) => def_crates,
+            None => return Vec::new(),
+        };
+        let filter = |impl_def: &Impl| {
+            let target_ty = impl_def.target_ty(db);
+            let rref = target_ty.remove_ref();
+            ty.value.equals_ctor(rref.as_ref().map_or(&target_ty.ty.value, |it| &it.ty.value))
+        };
+        let mut all = Vec::new();
+        def_crates.into_iter().for_each(|id| {
+            all.extend(db.inherent_impls_in_crate(id).all_impls().map(Self::from).filter(filter))
+        });
+        let fp = TyFingerprint::for_impl(&ty.value);
+        for id in db.crate_graph().iter() {
+            match fp {
+                Some(fp) => all.extend(
+                    db.trait_impls_in_crate(id).for_self_ty(fp).map(Self::from).filter(filter),
+                ),
+                None => all
+                    .extend(db.trait_impls_in_crate(id).all_impls().map(Self::from).filter(filter)),
+            }
+        }
+        all
+    }
+    pub fn all_for_trait(db: &dyn HirDatabase, trait_: Trait) -> Vec<Impl> {
+        let krate = trait_.module(db).krate();
+        let mut all = Vec::new();
+        for Crate { id } in krate.reverse_dependencies(db).into_iter().chain(Some(krate)) {
+            let impls = db.trait_impls_in_crate(id);
+            all.extend(impls.for_trait(trait_.id).map(Self::from))
+        }
+        all
    }
    // FIXME: the return type is wrong. This should be a hir version of
@@ -1499,7 +1534,7 @@ impl Impl {
        let resolver = self.id.resolver(db.upcast());
        let krate = self.id.lookup(db.upcast()).container.krate();
        let ctx = hir_ty::TyLoweringContext::new(db, &resolver);
-        let ty = Ty::from_hir(&ctx, &impl_data.target_type);
+        let ty = ctx.lower_ty(&impl_data.target_type);
        Type::new_with_resolver_inner(db, krate, &resolver, ty)
    }
@@ -1563,13 +1598,15 @@ impl Type {
        resolver: &Resolver,
        ty: Ty,
    ) -> Type {
-        let environment = TraitEnvironment::lower(db, &resolver);
+        let environment =
+            resolver.generic_def().map_or_else(Default::default, |d| db.trait_environment(d));
        Type { krate, ty: InEnvironment { value: ty, environment } }
    }
    fn new(db: &dyn HirDatabase, krate: CrateId, lexical_env: impl HasResolver, ty: Ty) -> Type {
        let resolver = lexical_env.resolver(db.upcast());
-        let environment = TraitEnvironment::lower(db, &resolver);
+        let environment =
+            resolver.generic_def().map_or_else(Default::default, |d| db.trait_environment(d));
        Type { krate, ty: InEnvironment { value: ty, environment } }
    }
@@ -1584,25 +1621,25 @@ impl Type {
    }
    pub fn is_unit(&self) -> bool {
-        matches!(self.ty.value, Ty::Tuple(0, ..))
+        matches!(self.ty.value.interned(&Interner), TyKind::Tuple(0, ..))
    }
    pub fn is_bool(&self) -> bool {
-        matches!(self.ty.value, Ty::Scalar(Scalar::Bool))
+        matches!(self.ty.value.interned(&Interner), TyKind::Scalar(Scalar::Bool))
    }
    pub fn is_mutable_reference(&self) -> bool {
-        matches!(self.ty.value, Ty::Ref(hir_ty::Mutability::Mut, ..))
+        matches!(self.ty.value.interned(&Interner), TyKind::Ref(hir_ty::Mutability::Mut, ..))
    }
    pub fn remove_ref(&self) -> Option<Type> {
-        match &self.ty.value {
+        match &self.ty.value.interned(&Interner) {
-            Ty::Ref(.., substs) => Some(self.derived(substs[0].clone())),
+            TyKind::Ref(.., ty) => Some(self.derived(ty.clone())),
            _ => None,
        }
    }
    pub fn is_unknown(&self) -> bool {
-        matches!(self.ty.value, Ty::Unknown)
+        self.ty.value.is_unknown()
    }
    /// Checks that particular type `ty` implements `std::future::Future`.
@@ -1683,8 +1720,11 @@ impl Type {
            .fill(args.iter().map(|t| t.ty.value.clone()))
            .build();
        let predicate = ProjectionPredicate {
-            projection_ty: ProjectionTy { associated_ty: alias.id, parameters: subst },
+            projection_ty: ProjectionTy {
-            ty: Ty::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, 0)),
+                associated_ty_id: to_assoc_type_id(alias.id),
+                substitution: subst,
+            },
+            ty: TyKind::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, 0)).intern(&Interner),
        };
        let goal = Canonical {
            value: InEnvironment::new(
@@ -1712,26 +1752,23 @@ impl Type {
    }
    pub fn as_callable(&self, db: &dyn HirDatabase) -> Option<Callable> {
-        let def = match self.ty.value {
+        let def = self.ty.value.callable_def(db);
-            Ty::FnDef(def, _) => Some(def),
-            _ => None,
-        };
        let sig = self.ty.value.callable_sig(db)?;
        Some(Callable { ty: self.clone(), sig, def, is_bound_method: false })
    }
    pub fn is_closure(&self) -> bool {
-        matches!(&self.ty.value, Ty::Closure { .. })
+        matches!(&self.ty.value.interned(&Interner), TyKind::Closure { .. })
    }
    pub fn is_fn(&self) -> bool {
-        matches!(&self.ty.value, Ty::FnDef(..) | Ty::Function { .. })
+        matches!(&self.ty.value.interned(&Interner), TyKind::FnDef(..) | TyKind::Function { .. })
    }
    pub fn is_packed(&self, db: &dyn HirDatabase) -> bool {
-        let adt_id = match self.ty.value {
+        let adt_id = match self.ty.value.interned(&Interner) {
-            Ty::Adt(hir_ty::AdtId(adt_id), ..) => adt_id,
+            &TyKind::Adt(hir_ty::AdtId(adt_id), ..) => adt_id,
            _ => return false,
        };
@@ -1743,24 +1780,45 @@ impl Type {
    }
    pub fn is_raw_ptr(&self) -> bool {
-        matches!(&self.ty.value, Ty::Raw(..))
+        matches!(&self.ty.value.interned(&Interner), TyKind::Raw(..))
    }
    pub fn contains_unknown(&self) -> bool {
        return go(&self.ty.value);
        fn go(ty: &Ty) -> bool {
-            match ty {
+            match ty.interned(&Interner) {
-                Ty::Unknown => true,
+                TyKind::Unknown => true,
-                _ => ty.substs().map_or(false, |substs| substs.iter().any(go)),
+                TyKind::Adt(_, substs)
+                | TyKind::AssociatedType(_, substs)
+                | TyKind::Tuple(_, substs)
+                | TyKind::OpaqueType(_, substs)
+                | TyKind::FnDef(_, substs)
+                | TyKind::Closure(_, substs) => substs.iter().any(go),
+                TyKind::Array(ty) | TyKind::Slice(ty) | TyKind::Raw(_, ty) | TyKind::Ref(_, ty) => {
+                    go(ty)
+                }
+                TyKind::Scalar(_)
+                | TyKind::Str
+                | TyKind::Never
+                | TyKind::Placeholder(_)
+                | TyKind::BoundVar(_)
+                | TyKind::InferenceVar(_, _)
+                | TyKind::Dyn(_)
+                | TyKind::Function(_)
+                | TyKind::Alias(_)
+                | TyKind::ForeignType(_) => false,
            }
        }
    }
    pub fn fields(&self, db: &dyn HirDatabase) -> Vec<(Field, Type)> {
-        let (variant_id, substs) = match self.ty.value {
+        let (variant_id, substs) = match self.ty.value.interned(&Interner) {
-            Ty::Adt(hir_ty::AdtId(AdtId::StructId(s)), ref substs) => (s.into(), substs),
+            &TyKind::Adt(hir_ty::AdtId(AdtId::StructId(s)), ref substs) => (s.into(), substs),
-            Ty::Adt(hir_ty::AdtId(AdtId::UnionId(u)), ref substs) => (u.into(), substs),
+            &TyKind::Adt(hir_ty::AdtId(AdtId::UnionId(u)), ref substs) => (u.into(), substs),
            _ => return Vec::new(),
        };
@@ -1775,7 +1833,7 @@ impl Type {
    }
    pub fn tuple_fields(&self, _db: &dyn HirDatabase) -> Vec<Type> {
-        if let Ty::Tuple(_, substs) = &self.ty.value {
+        if let TyKind::Tuple(_, substs) = &self.ty.value.interned(&Interner) {
            substs.iter().map(|ty| self.derived(ty.clone())).collect()
        } else {
            Vec::new()
@@ -1910,12 +1968,6 @@ impl Type {
        self.ty.value.associated_type_parent_trait(db).map(Into::into)
    }
-    // FIXME: provide required accessors such that it becomes implementable from outside.
-    pub fn is_equal_for_find_impls(&self, other: &Type) -> bool {
-        let rref = other.remove_ref();
-        self.ty.value.equals_ctor(rref.as_ref().map_or(&other.ty.value, |it| &it.ty.value))
-    }
    fn derived(&self, ty: Ty) -> Type {
        Type {
            krate: self.krate,
@@ -1957,36 +2009,40 @@ impl Type {
        fn walk_type(db: &dyn HirDatabase, type_: &Type, cb: &mut impl FnMut(Type)) {
            let ty = type_.ty.value.strip_references();
-            match ty {
+            match ty.interned(&Interner) {
-                Ty::Adt(..) => {
+                TyKind::Adt(..) => {
                    cb(type_.derived(ty.clone()));
                }
-                Ty::AssociatedType(..) => {
+                TyKind::AssociatedType(..) => {
                    if let Some(_) = ty.associated_type_parent_trait(db) {
                        cb(type_.derived(ty.clone()));
                    }
                }
-                Ty::OpaqueType(..) => {
+                TyKind::OpaqueType(..) => {
                    if let Some(bounds) = ty.impl_trait_bounds(db) {
                        walk_bounds(db, &type_.derived(ty.clone()), &bounds, cb);
                    }
                }
-                Ty::Alias(AliasTy::Opaque(opaque_ty)) => {
+                TyKind::Alias(AliasTy::Opaque(opaque_ty)) => {
                    if let Some(bounds) = ty.impl_trait_bounds(db) {
                        walk_bounds(db, &type_.derived(ty.clone()), &bounds, cb);
                    }
-                    walk_substs(db, type_, &opaque_ty.parameters, cb);
+                    walk_substs(db, type_, &opaque_ty.substitution, cb);
                }
-                Ty::Placeholder(_) => {
+                TyKind::Placeholder(_) => {
                    if let Some(bounds) = ty.impl_trait_bounds(db) {
                        walk_bounds(db, &type_.derived(ty.clone()), &bounds, cb);
                    }
                }
-                Ty::Dyn(bounds) => {
+                TyKind::Dyn(bounds) => {
                    walk_bounds(db, &type_.derived(ty.clone()), bounds.as_ref(), cb);
                }
+                TyKind::Ref(_, ty) | TyKind::Raw(_, ty) | TyKind::Array(ty) | TyKind::Slice(ty) => {
+                    walk_type(db, &type_.derived(ty.clone()), cb);
+                }
                _ => {}
            }
            if let Some(substs) = ty.substs() {
diff --git a/crates/hir/src/semantics.rs b/crates/hir/src/semantics.rs
index 945638cc5..519339c0c 100644
--- a/crates/hir/src/semantics.rs
+++ b/crates/hir/src/semantics.rs
@@ -259,6 +259,10 @@ impl<'db, DB: HirDatabase> Semantics<'db, DB> {
    }
    pub fn to_module_def(&self, file: FileId) -> Option<Module> {
+        self.imp.to_module_def(file).next()
+    }
+    pub fn to_module_defs(&self, file: FileId) -> impl Iterator<Item = Module> {
        self.imp.to_module_def(file)
    }
@@ -537,8 +541,8 @@ impl<'db> SemanticsImpl<'db> {
        f(&mut ctx)
    }
-    fn to_module_def(&self, file: FileId) -> Option<Module> {
+    fn to_module_def(&self, file: FileId) -> impl Iterator<Item = Module> {
-        self.with_ctx(|ctx| ctx.file_to_def(file)).map(Module::from)
+        self.with_ctx(|ctx| ctx.file_to_def(file)).into_iter().map(Module::from)
    }
    fn scope(&self, node: &SyntaxNode) -> SemanticsScope<'db> {
diff --git a/crates/hir/src/semantics/source_to_def.rs b/crates/hir/src/semantics/source_to_def.rs
index 6c612ee86..e9d820140 100644
--- a/crates/hir/src/semantics/source_to_def.rs
+++ b/crates/hir/src/semantics/source_to_def.rs
@@ -12,6 +12,7 @@ use hir_def::{
 };
 use hir_expand::{name::AsName, AstId, MacroDefKind};
 use rustc_hash::FxHashMap;
+use smallvec::SmallVec;
 use stdx::impl_from;
 use syntax::{
    ast::{self, NameOwner},
@@ -28,14 +29,19 @@ pub(super) struct SourceToDefCtx<'a, 'b> {
 }
 impl SourceToDefCtx<'_, '_> {
-    pub(super) fn file_to_def(&mut self, file: FileId) -> Option<ModuleId> {
+    pub(super) fn file_to_def(&mut self, file: FileId) -> SmallVec<[ModuleId; 1]> {
        let _p = profile::span("SourceBinder::to_module_def");
-        self.db.relevant_crates(file).iter().find_map(|&crate_id| {
+        let mut mods = SmallVec::new();
+        for &crate_id in self.db.relevant_crates(file).iter() {
            // FIXME: inner items
            let crate_def_map = self.db.crate_def_map(crate_id);
-            let local_id = crate_def_map.modules_for_file(file).next()?;
+            mods.extend(
-            Some(crate_def_map.module_id(local_id))
+                crate_def_map
-        })
+                    .modules_for_file(file)
+                    .map(|local_id| crate_def_map.module_id(local_id)),
+            )
+        }
+        mods
    }
    pub(super) fn module_to_def(&mut self, src: InFile<ast::Module>) -> Option<ModuleId> {
@@ -55,7 +61,7 @@ impl SourceToDefCtx<'_, '_> {
            Some(parent_declaration) => self.module_to_def(parent_declaration),
            None => {
                let file_id = src.file_id.original_file(self.db.upcast());
-                self.file_to_def(file_id)
+                self.file_to_def(file_id).get(0).copied()
            }
        }?;
@@ -185,7 +191,7 @@ impl SourceToDefCtx<'_, '_> {
    ) -> Option<MacroDefId> {
        let kind = MacroDefKind::Declarative;
        let file_id = src.file_id.original_file(self.db.upcast());
-        let krate = self.file_to_def(file_id)?.krate();
+        let krate = self.file_to_def(file_id).get(0).copied()?.krate();
        let file_ast_id = self.db.ast_id_map(src.file_id).ast_id(&src.value);
        let ast_id = Some(AstId::new(src.file_id, file_ast_id.upcast()));
        Some(MacroDefId { krate, ast_id, kind, local_inner: false })
@@ -245,7 +251,7 @@ impl SourceToDefCtx<'_, '_> {
            return Some(res);
        }
-        let def = self.file_to_def(src.file_id.original_file(self.db.upcast()))?;
+        let def = self.file_to_def(src.file_id.original_file(self.db.upcast())).get(0).copied()?;
        Some(def.into())
    }
diff --git a/crates/hir/src/source_analyzer.rs b/crates/hir/src/source_analyzer.rs
index d546512cb..4d59293e9 100644
--- a/crates/hir/src/source_analyzer.rs
+++ b/crates/hir/src/source_analyzer.rs
@@ -161,8 +161,9 @@ impl SourceAnalyzer {
        db: &dyn HirDatabase,
        field: &ast::RecordExprField,
    ) -> Option<(Field, Option<Local>)> {
-        let expr = field.expr()?;
+        let expr_id =
-        let expr_id = self.expr_id(db, &expr)?;
+            self.body_source_map.as_ref()?.node_field(InFile::new(self.file_id, field))?;
        let local = if field.name_ref().is_some() {
            None
        } else {
diff --git a/crates/hir_def/Cargo.toml b/crates/hir_def/Cargo.toml
index c2d99280f..475d337f3 100644
--- a/crates/hir_def/Cargo.toml
+++ b/crates/hir_def/Cargo.toml
@@ -10,7 +10,7 @@ edition = "2018"
 doctest = false
 [dependencies]
-cov-mark = "1.1"
+cov-mark = { version = "1.1", features = ["thread-local"] }
 log = "0.4.8"
 once_cell = "1.3.1"
 rustc-hash = "1.1.0"
diff --git a/crates/hir_def/src/attr.rs b/crates/hir_def/src/attr.rs
index 97cdbbb9e..7b41b148c 100644
--- a/crates/hir_def/src/attr.rs
+++ b/crates/hir_def/src/attr.rs
@@ -9,6 +9,7 @@ use hir_expand::{hygiene::Hygiene, name::AsName, AstId, InFile};
 use itertools::Itertools;
 use la_arena::ArenaMap;
 use mbe::ast_to_token_tree;
+use smallvec::{smallvec, SmallVec};
 use syntax::{
    ast::{self, AstNode, AttrsOwner},
    match_ast, AstToken, SmolStr, SyntaxNode,
@@ -134,53 +135,42 @@ impl RawAttrs {
        let crate_graph = db.crate_graph();
        let new_attrs = self
            .iter()
-            .filter_map(|attr| {
+            .flat_map(|attr| -> SmallVec<[_; 1]> {
                let attr = attr.clone();
                let is_cfg_attr =
                    attr.path.as_ident().map_or(false, |name| *name == hir_expand::name![cfg_attr]);
                if !is_cfg_attr {
-                    return Some(attr);
+                    return smallvec![attr];
                }
                let subtree = match &attr.input {
                    Some(AttrInput::TokenTree(it)) => it,
-                    _ => return Some(attr),
+                    _ => return smallvec![attr],
                };
-                // Input subtree is: `(cfg, attr)`
+                // Input subtree is: `(cfg, $(attr),+)`
-                // Split it up into a `cfg` and an `attr` subtree.
+                // Split it up into a `cfg` subtree and the `attr` subtrees.
                // FIXME: There should be a common API for this.
-                let mut saw_comma = false;
+                let mut parts = subtree.token_trees.split(
-                let (mut cfg, attr): (Vec<_>, Vec<_>) =
+                    |tt| matches!(tt, tt::TokenTree::Leaf(tt::Leaf::Punct(p)) if p.char == ','),
-                    subtree.clone().token_trees.into_iter().partition(|tree| {
+                );
-                        if saw_comma {
+                let cfg = parts.next().unwrap();
-                            return false;
+                let cfg = Subtree { delimiter: subtree.delimiter, token_trees: cfg.to_vec() };
-                        }
-                        match tree {
-                            tt::TokenTree::Leaf(tt::Leaf::Punct(p)) if p.char == ',' => {
-                                saw_comma = true;
-                            }
-                            _ => {}
-                        }
-                        true
-                    });
-                cfg.pop(); // `,` ends up in here
-                let attr = Subtree { delimiter: None, token_trees: attr };
-                let cfg = Subtree { delimiter: subtree.delimiter, token_trees: cfg };
                let cfg = CfgExpr::parse(&cfg);
+                let attrs = parts.filter(|a| !a.is_empty()).filter_map(|attr| {
+                    let tree = Subtree { delimiter: None, token_trees: attr.to_vec() };
+                    let attr = ast::Attr::parse(&format!("#[{}]", tree)).ok()?;
+                    let hygiene = Hygiene::new_unhygienic(); // FIXME
+                    Attr::from_src(attr, &hygiene)
+                });
                let cfg_options = &crate_graph[krate].cfg_options;
                if cfg_options.check(&cfg) == Some(false) {
-                    None
+                    smallvec![]
                } else {
                    cov_mark::hit!(cfg_attr_active);
-                    let attr = ast::Attr::parse(&format!("#[{}]", attr)).ok()?;
+                    attrs.collect()
-                    let hygiene = Hygiene::new_unhygienic(); // FIXME
-                    Attr::from_src(attr, &hygiene)
                }
            })
            .collect();
diff --git a/crates/hir_def/src/body.rs b/crates/hir_def/src/body.rs
index 19c4eb521..8bcc350ce 100644
--- a/crates/hir_def/src/body.rs
+++ b/crates/hir_def/src/body.rs
@@ -253,11 +253,18 @@ pub type LabelSource = InFile<LabelPtr>;
 pub struct BodySourceMap {
    expr_map: FxHashMap<ExprSource, ExprId>,
    expr_map_back: ArenaMap<ExprId, Result<ExprSource, SyntheticSyntax>>,
    pat_map: FxHashMap<PatSource, PatId>,
    pat_map_back: ArenaMap<PatId, Result<PatSource, SyntheticSyntax>>,
    label_map: FxHashMap<LabelSource, LabelId>,
    label_map_back: ArenaMap<LabelId, LabelSource>,
-    field_map: FxHashMap<(ExprId, usize), InFile<AstPtr<ast::RecordExprField>>>,
+    /// We don't create explicit nodes for record fields (`S { record_field: 92 }`).
+    /// Instead, we use id of expression (`92`) to identify the field.
+    field_map: FxHashMap<InFile<AstPtr<ast::RecordExprField>>, ExprId>,
+    field_map_back: FxHashMap<ExprId, InFile<AstPtr<ast::RecordExprField>>>,
    expansions: FxHashMap<InFile<AstPtr<ast::MacroCall>>, HirFileId>,
    /// Diagnostics accumulated during body lowering. These contain `AstPtr`s and so are stored in
@@ -337,6 +344,8 @@ impl Index<LabelId> for Body {
    }
 }
+// FIXME: Change `node_` prefix to something more reasonable.
+// Perhaps `expr_syntax` and `expr_id`?
 impl BodySourceMap {
    pub fn expr_syntax(&self, expr: ExprId) -> Result<ExprSource, SyntheticSyntax> {
        self.expr_map_back[expr].clone()
@@ -375,8 +384,12 @@ impl BodySourceMap {
        self.label_map.get(&src).cloned()
    }
-    pub fn field_syntax(&self, expr: ExprId, field: usize) -> InFile<AstPtr<ast::RecordExprField>> {
+    pub fn field_syntax(&self, expr: ExprId) -> InFile<AstPtr<ast::RecordExprField>> {
-        self.field_map[&(expr, field)].clone()
+        self.field_map_back[&expr].clone()
+    }
+    pub fn node_field(&self, node: InFile<&ast::RecordExprField>) -> Option<ExprId> {
+        let src = node.map(|it| AstPtr::new(it));
+        self.field_map.get(&src).cloned()
    }
    pub(crate) fn add_diagnostics(&self, _db: &dyn DefDatabase, sink: &mut DiagnosticSink<'_>) {
diff --git a/crates/hir_def/src/body/lower.rs b/crates/hir_def/src/body/lower.rs
index 8c8eb8007..8934ae6c9 100644
--- a/crates/hir_def/src/body/lower.rs
+++ b/crates/hir_def/src/body/lower.rs
@@ -379,23 +379,22 @@ impl ExprCollector<'_> {
            }
            ast::Expr::RecordExpr(e) => {
                let path = e.path().and_then(|path| self.expander.parse_path(path));
-                let mut field_ptrs = Vec::new();
                let record_lit = if let Some(nfl) = e.record_expr_field_list() {
                    let fields = nfl
                        .fields()
-                        .inspect(|field| field_ptrs.push(AstPtr::new(field)))
                        .filter_map(|field| {
                            self.check_cfg(&field)?;
                            let name = field.field_name()?.as_name();
-                            Some(RecordLitField {
+                            let expr = match field.expr() {
-                                name,
+                                Some(e) => self.collect_expr(e),
-                                expr: match field.expr() {
+                                None => self.missing_expr(),
-                                    Some(e) => self.collect_expr(e),
+                            };
-                                    None => self.missing_expr(),
+                            let src = self.expander.to_source(AstPtr::new(&field));
-                                },
+                            self.source_map.field_map.insert(src.clone(), expr);
-                            })
+                            self.source_map.field_map_back.insert(expr, src);
+                            Some(RecordLitField { name, expr })
                        })
                        .collect();
                    let spread = nfl.spread().map(|s| self.collect_expr(s));
@@ -404,12 +403,7 @@ impl ExprCollector<'_> {
                    Expr::RecordLit { path, fields: Vec::new(), spread: None }
                };
-                let res = self.alloc_expr(record_lit, syntax_ptr);
+                self.alloc_expr(record_lit, syntax_ptr)
-                for (i, ptr) in field_ptrs.into_iter().enumerate() {
-                    let src = self.expander.to_source(ptr);
-                    self.source_map.field_map.insert((res, i), src);
-                }
-                res
            }
            ast::Expr::FieldExpr(e) => {
                let expr = self.collect_expr_opt(e.expr());
diff --git a/crates/hir_def/src/item_tree.rs b/crates/hir_def/src/item_tree.rs
index 6bb334573..09bcb10dc 100644
--- a/crates/hir_def/src/item_tree.rs
+++ b/crates/hir_def/src/item_tree.rs
@@ -209,18 +209,6 @@ impl ItemTree {
        }
    }
-    pub fn source<S: ItemTreeNode>(&self, db: &dyn DefDatabase, of: ItemTreeId<S>) -> S::Source {
-        // This unwrap cannot fail, since it has either succeeded above, or resulted in an empty
-        // ItemTree (in which case there is no valid `FileItemTreeId` to call this method with).
-        let root =
-            db.parse_or_expand(of.file_id).expect("parse_or_expand failed on constructed ItemTree");
-        let id = self[of.value].ast_id();
-        let map = db.ast_id_map(of.file_id);
-        let ptr = map.get(id);
-        ptr.to_node(&root)
-    }
    fn data(&self) -> &ItemTreeData {
        self.data.as_ref().expect("attempted to access data of empty ItemTree")
    }
diff --git a/crates/hir_def/src/lib.rs b/crates/hir_def/src/lib.rs
index 6d11c5be4..c6655c5fb 100644
--- a/crates/hir_def/src/lib.rs
+++ b/crates/hir_def/src/lib.rs
@@ -341,6 +341,16 @@ pub enum DefWithBodyId {
 impl_from!(FunctionId, ConstId, StaticId for DefWithBodyId);
+impl DefWithBodyId {
+    pub fn as_generic_def_id(self) -> Option<GenericDefId> {
+        match self {
+            DefWithBodyId::FunctionId(f) => Some(f.into()),
+            DefWithBodyId::StaticId(_) => None,
+            DefWithBodyId::ConstId(c) => Some(c.into()),
+        }
+    }
+}
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 pub enum AssocItemId {
    FunctionId(FunctionId),
diff --git a/crates/hir_def/src/nameres/tests/diagnostics.rs b/crates/hir_def/src/nameres/tests/diagnostics.rs
index bfc1ab13f..c22ef46fd 100644
--- a/crates/hir_def/src/nameres/tests/diagnostics.rs
+++ b/crates/hir_def/src/nameres/tests/diagnostics.rs
@@ -149,6 +149,9 @@ fn inactive_via_cfg_attr() {
          #[cfg_attr(not(never), cfg(not(no)))] fn f() {}
          #[cfg_attr(never, cfg(no))] fn g() {}
+          #[cfg_attr(not(never), inline, cfg(no))] fn h() {}
+        //^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ code is inactive due to #[cfg] directives: no is disabled
        "#,
    );
 }
diff --git a/crates/hir_def/src/test_db.rs b/crates/hir_def/src/test_db.rs
index eda982c85..10977761c 100644
--- a/crates/hir_def/src/test_db.rs
+++ b/crates/hir_def/src/test_db.rs
@@ -15,7 +15,7 @@ use rustc_hash::FxHashSet;
 use syntax::{algo, ast, AstNode, TextRange, TextSize};
 use test_utils::extract_annotations;
-use crate::{db::DefDatabase, nameres::DefMap, Lookup, ModuleDefId, ModuleId};
+use crate::{db::DefDatabase, nameres::DefMap, src::HasSource, Lookup, ModuleDefId, ModuleId};
 #[salsa::database(
    base_db::SourceDatabaseExtStorage,
@@ -115,14 +115,9 @@ impl TestDB {
            if file_id != position.file_id.into() {
                continue;
            }
-            let root = self.parse_or_expand(file_id).unwrap();
-            let ast_map = self.ast_id_map(file_id);
-            let item_tree = self.item_tree(file_id);
            for decl in module.scope.declarations() {
                if let ModuleDefId::FunctionId(it) = decl {
-                    let ast =
+                    let range = it.lookup(self).source(self).value.syntax().text_range();
-                        ast_map.get(item_tree[it.lookup(self).id.value].ast_id).to_node(&root);
-                    let range = ast.syntax().text_range();
                    if !range.contains(position.offset) {
                        continue;
diff --git a/crates/hir_expand/src/builtin_derive.rs b/crates/hir_expand/src/builtin_derive.rs
index dfdb9cf59..5e908b223 100644
--- a/crates/hir_expand/src/builtin_derive.rs
+++ b/crates/hir_expand/src/builtin_derive.rs
@@ -108,7 +108,7 @@ fn parse_adt(tt: &tt::Subtree) -> Result<BasicAdtInfo, mbe::ExpandError> {
 }
 fn make_type_args(n: usize, bound: Vec<tt::TokenTree>) -> Vec<tt::TokenTree> {
-    let mut result = Vec::<tt::TokenTree>::new();
+    let mut result = Vec::<tt::TokenTree>::with_capacity(n * 2);
    result.push(
        tt::Leaf::Punct(tt::Punct {
            char: '<',
diff --git a/crates/hir_expand/src/db.rs b/crates/hir_expand/src/db.rs
index cb6e23320..9086e6c17 100644
--- a/crates/hir_expand/src/db.rs
+++ b/crates/hir_expand/src/db.rs
@@ -340,6 +340,8 @@ fn parse_macro_with_arg(
        None => return ExpandResult { value: None, err: result.err },
    };
+    log::debug!("expanded = {}", tt.as_debug_string());
    let fragment_kind = to_fragment_kind(db, macro_call_id);
    let (parse, rev_token_map) = match mbe::token_tree_to_syntax_node(&tt, fragment_kind) {
diff --git a/crates/hir_expand/src/name.rs b/crates/hir_expand/src/name.rs
index e833e032c..43de9edd6 100644
--- a/crates/hir_expand/src/name.rs
+++ b/crates/hir_expand/src/name.rs
@@ -191,6 +191,8 @@ pub mod known {
        filter_map,
        next,
        iter_mut,
+        len,
+        is_empty,
        // Builtin macros
        file,
        column,
diff --git a/crates/hir_ty/Cargo.toml b/crates/hir_ty/Cargo.toml
index b9c93f56f..0ef27cd37 100644
--- a/crates/hir_ty/Cargo.toml
+++ b/crates/hir_ty/Cargo.toml
@@ -10,7 +10,7 @@ edition = "2018"
 doctest = false
 [dependencies]
-cov-mark = "1.1"
+cov-mark = { version = "1.1", features = ["thread-local"] }
 itertools = "0.10.0"
 arrayvec = "0.5.1"
 smallvec = "1.2.0"
@@ -31,7 +31,7 @@ profile = { path = "../profile", version = "0.0.0" }
 syntax = { path = "../syntax", version = "0.0.0" }
 [dev-dependencies]
-test_utils = { path = "../test_utils"  }
+test_utils = { path = "../test_utils" }
 expect-test = "1.1"
 tracing = "0.1"
 tracing-subscriber = { version = "0.2", default-features = false, features = ["env-filter", "registry"] }
diff --git a/crates/hir_ty/src/autoderef.rs b/crates/hir_ty/src/autoderef.rs
index be1fd1f13..56c6b92d4 100644
--- a/crates/hir_ty/src/autoderef.rs
+++ b/crates/hir_ty/src/autoderef.rs
@@ -12,9 +12,10 @@ use log::{info, warn};
 use crate::{
    db::HirDatabase,
+    to_assoc_type_id,
    traits::{InEnvironment, Solution},
    utils::generics,
-    BoundVar, Canonical, DebruijnIndex, Obligation, Substs, TraitRef, Ty,
+    BoundVar, Canonical, DebruijnIndex, Interner, Obligation, Substs, TraitRef, Ty, TyKind,
 };
 const AUTODEREF_RECURSION_LIMIT: usize = 10;
@@ -81,8 +82,12 @@ fn deref_by_trait(
    // Now do the assoc type projection
    let projection = super::traits::ProjectionPredicate {
-        ty: Ty::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, ty.value.kinds.len())),
+        ty: TyKind::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, ty.value.kinds.len()))
-        projection_ty: super::ProjectionTy { associated_ty: target, parameters },
+            .intern(&Interner),
+        projection_ty: super::ProjectionTy {
+            associated_ty_id: to_assoc_type_id(target),
+            substitution: parameters,
+        },
    };
    let obligation = super::Obligation::Projection(projection);
@@ -114,8 +119,8 @@ fn deref_by_trait(
            // new variables in that case
            for i in 1..vars.0.kinds.len() {
-                if vars.0.value[i - 1]
+                if vars.0.value[i - 1].interned(&Interner)
-                    != Ty::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, i - 1))
+                    != &TyKind::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, i - 1))
                {
                    warn!("complex solution for derefing {:?}: {:?}, ignoring", ty.value, solution);
                    return None;
diff --git a/crates/hir_ty/src/db.rs b/crates/hir_ty/src/db.rs
index 06714409f..74a048672 100644
--- a/crates/hir_ty/src/db.rs
+++ b/crates/hir_ty/src/db.rs
@@ -12,7 +12,7 @@ use la_arena::ArenaMap;
 use crate::{
    method_resolution::{InherentImpls, TraitImpls},
    traits::chalk,
-    Binders, CallableDefId, GenericPredicate, InferenceResult, OpaqueTyId, PolyFnSig,
+    Binders, CallableDefId, FnDefId, GenericPredicate, ImplTraitId, InferenceResult, PolyFnSig,
    ReturnTypeImplTraits, TraitRef, Ty, TyDefId, ValueTyDefId,
 };
 use hir_expand::name::Name;
@@ -65,6 +65,9 @@ pub trait HirDatabase: DefDatabase + Upcast<dyn DefDatabase> {
    #[salsa::invoke(crate::lower::generic_predicates_query)]
    fn generic_predicates(&self, def: GenericDefId) -> Arc<[Binders<GenericPredicate>]>;
+    #[salsa::invoke(crate::lower::trait_environment_query)]
+    fn trait_environment(&self, def: GenericDefId) -> Arc<crate::TraitEnvironment>;
    #[salsa::invoke(crate::lower::generic_defaults_query)]
    fn generic_defaults(&self, def: GenericDefId) -> Arc<[Binders<Ty>]>;
@@ -81,11 +84,11 @@ pub trait HirDatabase: DefDatabase + Upcast<dyn DefDatabase> {
    #[salsa::interned]
    fn intern_callable_def(&self, callable_def: CallableDefId) -> InternedCallableDefId;
    #[salsa::interned]
-    fn intern_type_param_id(&self, param_id: TypeParamId) -> GlobalTypeParamId;
+    fn intern_type_param_id(&self, param_id: TypeParamId) -> InternedTypeParamId;
    #[salsa::interned]
-    fn intern_impl_trait_id(&self, id: OpaqueTyId) -> InternedOpaqueTyId;
+    fn intern_impl_trait_id(&self, id: ImplTraitId) -> InternedOpaqueTyId;
    #[salsa::interned]
-    fn intern_closure(&self, id: (DefWithBodyId, ExprId)) -> ClosureId;
+    fn intern_closure(&self, id: (DefWithBodyId, ExprId)) -> InternedClosureId;
    #[salsa::invoke(chalk::associated_ty_data_query)]
    fn associated_ty_data(&self, id: chalk::AssocTypeId) -> Arc<chalk::AssociatedTyDatum>;
@@ -100,10 +103,10 @@ pub trait HirDatabase: DefDatabase + Upcast<dyn DefDatabase> {
    fn impl_datum(&self, krate: CrateId, impl_id: chalk::ImplId) -> Arc<chalk::ImplDatum>;
    #[salsa::invoke(crate::traits::chalk::fn_def_datum_query)]
-    fn fn_def_datum(&self, krate: CrateId, fn_def_id: chalk::FnDefId) -> Arc<chalk::FnDefDatum>;
+    fn fn_def_datum(&self, krate: CrateId, fn_def_id: FnDefId) -> Arc<chalk::FnDefDatum>;
    #[salsa::invoke(crate::traits::chalk::fn_def_variance_query)]
-    fn fn_def_variance(&self, krate: CrateId, fn_def_id: chalk::FnDefId) -> chalk::Variances;
+    fn fn_def_variance(&self, krate: CrateId, fn_def_id: FnDefId) -> chalk::Variances;
    #[salsa::invoke(crate::traits::chalk::adt_variance_query)]
    fn adt_variance(&self, krate: CrateId, adt_id: chalk::AdtId) -> chalk::Variances;
@@ -149,16 +152,16 @@ fn hir_database_is_object_safe() {
 }
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub struct GlobalTypeParamId(salsa::InternId);
+pub struct InternedTypeParamId(salsa::InternId);
-impl_intern_key!(GlobalTypeParamId);
+impl_intern_key!(InternedTypeParamId);
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct InternedOpaqueTyId(salsa::InternId);
 impl_intern_key!(InternedOpaqueTyId);
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub struct ClosureId(salsa::InternId);
+pub struct InternedClosureId(salsa::InternId);
-impl_intern_key!(ClosureId);
+impl_intern_key!(InternedClosureId);
 /// This exists just for Chalk, because Chalk just has a single `FnDefId` where
 /// we have different IDs for struct and enum variant constructors.
diff --git a/crates/hir_ty/src/diagnostics/expr.rs b/crates/hir_ty/src/diagnostics/expr.rs
index 2751cd304..b2bfd68d4 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, Ty,
+    AdtId, InferenceResult, Interner, Ty, TyKind,
 };
 pub(crate) use hir_def::{
@@ -289,11 +289,10 @@ impl<'a, 'b> ExprValidator<'a, 'b> {
        let (body, source_map): (Arc<Body>, Arc<BodySourceMap>) =
            db.body_with_source_map(self.owner.into());
-        let match_expr_ty = match infer.type_of_expr.get(match_expr) {
+        let match_expr_ty = if infer.type_of_expr[match_expr].is_unknown() {
-            // If we can't resolve the type of the match expression
+            return;
-            // we cannot perform exhaustiveness checks.
+        } else {
-            None | Some(Ty::Unknown) => return,
+            &infer.type_of_expr[match_expr]
-            Some(ty) => ty,
        };
        let cx = MatchCheckCtx { match_expr, body, infer: infer.clone(), db };
@@ -379,14 +378,14 @@ impl<'a, 'b> ExprValidator<'a, 'b> {
            _ => return,
        };
-        let (params, required) = match mismatch.expected {
+        let (params, required) = match mismatch.expected.interned(&Interner) {
-            Ty::Adt(AdtId(hir_def::AdtId::EnumId(enum_id)), ref parameters)
+            TyKind::Adt(AdtId(hir_def::AdtId::EnumId(enum_id)), ref parameters)
-                if enum_id == core_result_enum =>
+                if *enum_id == core_result_enum =>
            {
                (parameters, "Ok".to_string())
            }
-            Ty::Adt(AdtId(hir_def::AdtId::EnumId(enum_id)), ref parameters)
+            TyKind::Adt(AdtId(hir_def::AdtId::EnumId(enum_id)), ref parameters)
-                if enum_id == core_option_enum =>
+                if *enum_id == core_option_enum =>
            {
                (parameters, "Some".to_string())
            }
diff --git a/crates/hir_ty/src/diagnostics/match_check.rs b/crates/hir_ty/src/diagnostics/match_check.rs
index 04d39c571..5a5cdcbf3 100644
--- a/crates/hir_ty/src/diagnostics/match_check.rs
+++ b/crates/hir_ty/src/diagnostics/match_check.rs
@@ -227,7 +227,7 @@ use hir_def::{
 use la_arena::Idx;
 use smallvec::{smallvec, SmallVec};
-use crate::{db::HirDatabase, AdtId, InferenceResult, Ty};
+use crate::{db::HirDatabase, AdtId, InferenceResult, Interner, TyKind};
 #[derive(Debug, Clone, Copy)]
 /// Either a pattern from the source code being analyzed, represented as
@@ -626,13 +626,13 @@ 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() {
+    match cx.infer[cx.match_expr].strip_references().interned(&Interner) {
-        Ty::Adt(AdtId(hir_def::AdtId::EnumId(enum_id)), ..) => {
+        TyKind::Adt(AdtId(hir_def::AdtId::EnumId(enum_id)), ..) => {
            if cx.db.enum_data(*enum_id).variants.is_empty() {
                return Ok(Usefulness::NotUseful);
            }
        }
-        Ty::Never => return Ok(Usefulness::NotUseful),
+        TyKind::Never => return Ok(Usefulness::NotUseful),
        _ => (),
    }
diff --git a/crates/hir_ty/src/diagnostics/unsafe_check.rs b/crates/hir_ty/src/diagnostics/unsafe_check.rs
index e77a20fea..20bb64827 100644
--- a/crates/hir_ty/src/diagnostics/unsafe_check.rs
+++ b/crates/hir_ty/src/diagnostics/unsafe_check.rs
@@ -11,7 +11,7 @@ use hir_def::{
 };
 use hir_expand::diagnostics::DiagnosticSink;
-use crate::{db::HirDatabase, diagnostics::MissingUnsafe, InferenceResult, Ty};
+use crate::{db::HirDatabase, diagnostics::MissingUnsafe, InferenceResult, Interner, TyKind};
 pub(super) struct UnsafeValidator<'a, 'b: 'a> {
    owner: DefWithBodyId,
@@ -85,7 +85,7 @@ fn walk_unsafe(
    let expr = &body.exprs[current];
    match expr {
        &Expr::Call { callee, .. } => {
-            if let Some(func) = infer[callee].as_fn_def() {
+            if let Some(func) = infer[callee].as_fn_def(db) {
                if db.function_data(func).is_unsafe {
                    unsafe_exprs.push(UnsafeExpr { expr: current, inside_unsafe_block });
                }
@@ -110,7 +110,7 @@ fn walk_unsafe(
            }
        }
        Expr::UnaryOp { expr, op: UnaryOp::Deref } => {
-            if let Ty::Raw(..) = &infer[*expr] {
+            if let TyKind::Raw(..) = &infer[*expr].interned(&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 ab51cb0a6..c1062387e 100644
--- a/crates/hir_ty/src/display.rs
+++ b/crates/hir_ty/src/display.rs
@@ -11,9 +11,10 @@ use hir_def::{
 use hir_expand::name::Name;
 use crate::{
-    db::HirDatabase, primitive, utils::generics, AdtId, AliasTy, CallableDefId, CallableSig,
+    db::HirDatabase, from_assoc_type_id, from_foreign_def_id, from_placeholder_idx, primitive,
-    GenericPredicate, Lifetime, Obligation, OpaqueTy, OpaqueTyId, ProjectionTy, Scalar, Substs,
+    to_assoc_type_id, traits::chalk::from_chalk, utils::generics, AdtId, AliasTy, CallableDefId,
-    TraitRef, Ty,
+    CallableSig, GenericPredicate, ImplTraitId, Interner, Lifetime, Obligation, OpaqueTy,
+    ProjectionTy, Scalar, Substs, TraitRef, Ty, TyKind,
 };
 pub struct HirFormatter<'a> {
@@ -244,19 +245,19 @@ impl HirDisplay for ProjectionTy {
        }
        let trait_ = f.db.trait_data(self.trait_(f.db));
-        let first_parameter = self.parameters[0].into_displayable(
+        let first_parameter = self.substitution[0].into_displayable(
            f.db,
            f.max_size,
            f.omit_verbose_types,
            f.display_target,
        );
        write!(f, "<{} as {}", first_parameter, trait_.name)?;
-        if self.parameters.len() > 1 {
+        if self.substitution.len() > 1 {
            write!(f, "<")?;
-            f.write_joined(&self.parameters[1..], ", ")?;
+            f.write_joined(&self.substitution[1..], ", ")?;
            write!(f, ">")?;
        }
-        write!(f, ">::{}", f.db.type_alias_data(self.associated_ty).name)?;
+        write!(f, ">::{}", f.db.type_alias_data(from_assoc_type_id(self.associated_ty_id)).name)?;
        Ok(())
    }
 }
@@ -267,32 +268,29 @@ impl HirDisplay for Ty {
            return write!(f, "{}", TYPE_HINT_TRUNCATION);
        }
-        match self {
+        match self.interned(&Interner) {
-            Ty::Never => write!(f, "!")?,
+            TyKind::Never => write!(f, "!")?,
-            Ty::Str => write!(f, "str")?,
+            TyKind::Str => write!(f, "str")?,
-            Ty::Scalar(Scalar::Bool) => write!(f, "bool")?,
+            TyKind::Scalar(Scalar::Bool) => write!(f, "bool")?,
-            Ty::Scalar(Scalar::Char) => write!(f, "char")?,
+            TyKind::Scalar(Scalar::Char) => write!(f, "char")?,
-            &Ty::Scalar(Scalar::Float(t)) => write!(f, "{}", primitive::float_ty_to_string(t))?,
+            &TyKind::Scalar(Scalar::Float(t)) => write!(f, "{}", primitive::float_ty_to_string(t))?,
-            &Ty::Scalar(Scalar::Int(t)) => write!(f, "{}", primitive::int_ty_to_string(t))?,
+            &TyKind::Scalar(Scalar::Int(t)) => write!(f, "{}", primitive::int_ty_to_string(t))?,
-            &Ty::Scalar(Scalar::Uint(t)) => write!(f, "{}", primitive::uint_ty_to_string(t))?,
+            &TyKind::Scalar(Scalar::Uint(t)) => write!(f, "{}", primitive::uint_ty_to_string(t))?,
-            Ty::Slice(parameters) => {
+            TyKind::Slice(t) => {
-                let t = parameters.as_single();
                write!(f, "[")?;
                t.hir_fmt(f)?;
                write!(f, "]")?;
            }
-            Ty::Array(parameters) => {
+            TyKind::Array(t) => {
-                let t = parameters.as_single();
                write!(f, "[")?;
                t.hir_fmt(f)?;
                write!(f, "; _]")?;
            }
-            Ty::Raw(m, parameters) | Ty::Ref(m, parameters) => {
+            TyKind::Raw(m, t) | TyKind::Ref(m, t) => {
-                let t = parameters.as_single();
                let ty_display =
                    t.into_displayable(f.db, f.max_size, f.omit_verbose_types, f.display_target);
-                if matches!(self, Ty::Raw(..)) {
+                if matches!(self.interned(&Interner), TyKind::Raw(..)) {
                    write!(
                        f,
                        "*{}",
@@ -312,22 +310,29 @@ impl HirDisplay for Ty {
                    )?;
                }
+                // FIXME: all this just to decide whether to use parentheses...
                let datas;
-                let predicates = match t {
+                let predicates = match t.interned(&Interner) {
-                    Ty::Dyn(predicates) if predicates.len() > 1 => {
+                    TyKind::Dyn(predicates) if predicates.len() > 1 => {
                        Cow::Borrowed(predicates.as_ref())
                    }
-                    &Ty::Alias(AliasTy::Opaque(OpaqueTy {
+                    &TyKind::Alias(AliasTy::Opaque(OpaqueTy {
-                        opaque_ty_id: OpaqueTyId::ReturnTypeImplTrait(func, idx),
+                        opaque_ty_id,
-                        ref parameters,
+                        substitution: ref parameters,
                    })) => {
-                        datas =
+                        let impl_trait_id = f.db.lookup_intern_impl_trait_id(opaque_ty_id.into());
-                            f.db.return_type_impl_traits(func).expect("impl trait id without data");
+                        if let ImplTraitId::ReturnTypeImplTrait(func, idx) = impl_trait_id {
-                        let data = (*datas)
+                            datas =
-                            .as_ref()
+                                f.db.return_type_impl_traits(func)
-                            .map(|rpit| rpit.impl_traits[idx as usize].bounds.clone());
+                                    .expect("impl trait id without data");
-                        let bounds = data.subst(parameters);
+                            let data = (*datas)
-                        Cow::Owned(bounds.value)
+                                .as_ref()
+                                .map(|rpit| rpit.impl_traits[idx as usize].bounds.clone());
+                            let bounds = data.subst(parameters);
+                            Cow::Owned(bounds.value)
+                        } else {
+                            Cow::Borrowed(&[][..])
+                        }
                    }
                    _ => Cow::Borrowed(&[][..]),
                };
@@ -347,7 +352,7 @@ impl HirDisplay for Ty {
                    write!(f, "{}", ty_display)?;
                }
            }
-            Ty::Tuple(_, substs) => {
+            TyKind::Tuple(_, substs) => {
                if substs.len() == 1 {
                    write!(f, "(")?;
                    substs[0].hir_fmt(f)?;
@@ -358,12 +363,12 @@ impl HirDisplay for Ty {
                    write!(f, ")")?;
                }
            }
-            Ty::Function(fn_ptr) => {
+            TyKind::Function(fn_ptr) => {
                let sig = CallableSig::from_fn_ptr(fn_ptr);
                sig.hir_fmt(f)?;
            }
-            Ty::FnDef(def, parameters) => {
+            TyKind::FnDef(def, parameters) => {
-                let def = *def;
+                let def = from_chalk(f.db, *def);
                let sig = f.db.callable_item_signature(def).subst(parameters);
                match def {
                    CallableDefId::FunctionId(ff) => {
@@ -401,7 +406,7 @@ impl HirDisplay for Ty {
                    write!(f, " -> {}", ret_display)?;
                }
            }
-            Ty::Adt(AdtId(def_id), parameters) => {
+            TyKind::Adt(AdtId(def_id), parameters) => {
                match f.display_target {
                    DisplayTarget::Diagnostics | DisplayTarget::Test => {
                        let name = match *def_id {
@@ -427,37 +432,39 @@ impl HirDisplay for Ty {
                }
                if parameters.len() > 0 {
-                    let parameters_to_write =
+                    let parameters_to_write = if f.display_target.is_source_code()
-                        if f.display_target.is_source_code() || f.omit_verbose_types() {
+                        || f.omit_verbose_types()
-                            match self
+                    {
-                                .as_generic_def()
+                        match self
-                                .map(|generic_def_id| f.db.generic_defaults(generic_def_id))
+                            .as_generic_def(f.db)
-                                .filter(|defaults| !defaults.is_empty())
+                            .map(|generic_def_id| f.db.generic_defaults(generic_def_id))
-                            {
+                            .filter(|defaults| !defaults.is_empty())
-                                None => parameters.0.as_ref(),
+                        {
-                                Some(default_parameters) => {
+                            None => parameters.0.as_ref(),
-                                    let mut default_from = 0;
+                            Some(default_parameters) => {
-                                    for (i, parameter) in parameters.iter().enumerate() {
+                                let mut default_from = 0;
-                                        match (parameter, default_parameters.get(i)) {
+                                for (i, parameter) in parameters.iter().enumerate() {
-                                            (&Ty::Unknown, _) | (_, None) => {
+                                    match (parameter.interned(&Interner), default_parameters.get(i))
+                                    {
+                                        (&TyKind::Unknown, _) | (_, None) => {
+                                            default_from = i + 1;
+                                        }
+                                        (_, Some(default_parameter)) => {
+                                            let actual_default = default_parameter
+                                                .clone()
+                                                .subst(&parameters.prefix(i));
+                                            if parameter != &actual_default {
                                                default_from = i + 1;
                                            }
-                                            (_, Some(default_parameter)) => {
-                                                let actual_default = default_parameter
-                                                    .clone()
-                                                    .subst(&parameters.prefix(i));
-                                                if parameter != &actual_default {
-                                                    default_from = i + 1;
-                                                }
-                                            }
                                        }
                                    }
-                                    &parameters.0[0..default_from]
                                }
+                                &parameters.0[0..default_from]
                            }
-                        } else {
+                        }
-                            parameters.0.as_ref()
+                    } else {
-                        };
+                        parameters.0.as_ref()
+                    };
                    if !parameters_to_write.is_empty() {
                        write!(f, "<")?;
                        f.write_joined(parameters_to_write, ", ")?;
@@ -465,13 +472,14 @@ impl HirDisplay for Ty {
                    }
                }
            }
-            Ty::AssociatedType(type_alias, parameters) => {
+            TyKind::AssociatedType(assoc_type_id, parameters) => {
+                let type_alias = from_assoc_type_id(*assoc_type_id);
                let trait_ = match type_alias.lookup(f.db.upcast()).container {
                    AssocContainerId::TraitId(it) => it,
                    _ => panic!("not an associated type"),
                };
                let trait_ = f.db.trait_data(trait_);
-                let type_alias_data = f.db.type_alias_data(*type_alias);
+                let type_alias_data = f.db.type_alias_data(type_alias);
                // 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() {
@@ -482,19 +490,22 @@ impl HirDisplay for Ty {
                        write!(f, ">")?;
                    }
                } else {
-                    let projection_ty =
+                    let projection_ty = ProjectionTy {
-                        ProjectionTy { associated_ty: *type_alias, parameters: parameters.clone() };
+                        associated_ty_id: to_assoc_type_id(type_alias),
+                        substitution: parameters.clone(),
+                    };
                    projection_ty.hir_fmt(f)?;
                }
            }
-            Ty::ForeignType(type_alias) => {
+            TyKind::ForeignType(type_alias) => {
-                let type_alias = f.db.type_alias_data(*type_alias);
+                let type_alias = f.db.type_alias_data(from_foreign_def_id(*type_alias));
                write!(f, "{}", type_alias.name)?;
            }
-            Ty::OpaqueType(opaque_ty_id, parameters) => {
+            TyKind::OpaqueType(opaque_ty_id, parameters) => {
-                match opaque_ty_id {
+                let impl_trait_id = f.db.lookup_intern_impl_trait_id((*opaque_ty_id).into());
-                    &OpaqueTyId::ReturnTypeImplTrait(func, idx) => {
+                match impl_trait_id {
+                    ImplTraitId::ReturnTypeImplTrait(func, idx) => {
                        let datas =
                            f.db.return_type_impl_traits(func).expect("impl trait id without data");
                        let data = (*datas)
@@ -504,14 +515,14 @@ impl HirDisplay for Ty {
                        write_bounds_like_dyn_trait_with_prefix("impl", &bounds.value, f)?;
                        // FIXME: it would maybe be good to distinguish this from the alias type (when debug printing), and to show the substitution
                    }
-                    OpaqueTyId::AsyncBlockTypeImplTrait(..) => {
+                    ImplTraitId::AsyncBlockTypeImplTrait(..) => {
                        write!(f, "impl Future<Output = ")?;
                        parameters[0].hir_fmt(f)?;
                        write!(f, ">")?;
                    }
                }
            }
-            Ty::Closure(.., substs) => {
+            TyKind::Closure(.., substs) => {
                let sig = substs[0].callable_sig(f.db);
                if let Some(sig) = sig {
                    if sig.params().is_empty() {
@@ -535,7 +546,8 @@ impl HirDisplay for Ty {
                    write!(f, "{{closure}}")?;
                }
            }
-            Ty::Placeholder(id) => {
+            TyKind::Placeholder(idx) => {
+                let id = from_placeholder_idx(f.db, *idx);
                let generics = generics(f.db.upcast(), id.parent);
                let param_data = &generics.params.types[id.local_id];
                match param_data.provenance {
@@ -543,8 +555,8 @@ impl HirDisplay for Ty {
                        write!(f, "{}", param_data.name.clone().unwrap_or_else(Name::missing))?
                    }
                    TypeParamProvenance::ArgumentImplTrait => {
-                        let bounds = f.db.generic_predicates_for_param(*id);
+                        let bounds = f.db.generic_predicates_for_param(id);
-                        let substs = Substs::type_params_for_generics(&generics);
+                        let substs = Substs::type_params_for_generics(f.db, &generics);
                        write_bounds_like_dyn_trait_with_prefix(
                            "impl",
                            &bounds.iter().map(|b| b.clone().subst(&substs)).collect::<Vec<_>>(),
@@ -553,28 +565,29 @@ impl HirDisplay for Ty {
                    }
                }
            }
-            Ty::BoundVar(idx) => write!(f, "?{}.{}", idx.debruijn.depth(), idx.index)?,
+            TyKind::BoundVar(idx) => write!(f, "?{}.{}", idx.debruijn.depth(), idx.index)?,
-            Ty::Dyn(predicates) => {
+            TyKind::Dyn(predicates) => {
                write_bounds_like_dyn_trait_with_prefix("dyn", predicates, f)?;
            }
-            Ty::Alias(AliasTy::Projection(p_ty)) => p_ty.hir_fmt(f)?,
+            TyKind::Alias(AliasTy::Projection(p_ty)) => p_ty.hir_fmt(f)?,
-            Ty::Alias(AliasTy::Opaque(opaque_ty)) => {
+            TyKind::Alias(AliasTy::Opaque(opaque_ty)) => {
-                match opaque_ty.opaque_ty_id {
+                let impl_trait_id = f.db.lookup_intern_impl_trait_id(opaque_ty.opaque_ty_id.into());
-                    OpaqueTyId::ReturnTypeImplTrait(func, idx) => {
+                match impl_trait_id {
+                    ImplTraitId::ReturnTypeImplTrait(func, idx) => {
                        let datas =
                            f.db.return_type_impl_traits(func).expect("impl trait id without data");
                        let data = (*datas)
                            .as_ref()
                            .map(|rpit| rpit.impl_traits[idx as usize].bounds.clone());
-                        let bounds = data.subst(&opaque_ty.parameters);
+                        let bounds = data.subst(&opaque_ty.substitution);
                        write_bounds_like_dyn_trait_with_prefix("impl", &bounds.value, f)?;
                    }
-                    OpaqueTyId::AsyncBlockTypeImplTrait(..) => {
+                    ImplTraitId::AsyncBlockTypeImplTrait(..) => {
                        write!(f, "{{async block}}")?;
                    }
                };
            }
-            Ty::Unknown => {
+            TyKind::Unknown => {
                if f.display_target.is_source_code() {
                    return Err(HirDisplayError::DisplaySourceCodeError(
                        DisplaySourceCodeError::UnknownType,
@@ -582,7 +595,7 @@ impl HirDisplay for Ty {
                }
                write!(f, "{{unknown}}")?;
            }
-            Ty::InferenceVar(..) => write!(f, "_")?,
+            TyKind::InferenceVar(..) => write!(f, "_")?,
        }
        Ok(())
    }
@@ -695,7 +708,9 @@ fn write_bounds_like_dyn_trait(
                    write!(f, "<")?;
                    angle_open = true;
                }
-                let type_alias = f.db.type_alias_data(projection_pred.projection_ty.associated_ty);
+                let type_alias = f.db.type_alias_data(from_assoc_type_id(
+                    projection_pred.projection_ty.associated_ty_id,
+                ));
                write!(f, "{} = ", type_alias.name)?;
                projection_pred.ty.hir_fmt(f)?;
            }
@@ -766,7 +781,10 @@ impl HirDisplay for GenericPredicate {
                write!(
                    f,
                    ">::{} = ",
-                    f.db.type_alias_data(projection_pred.projection_ty.associated_ty).name,
+                    f.db.type_alias_data(from_assoc_type_id(
+                        projection_pred.projection_ty.associated_ty_id
+                    ))
+                    .name,
                )?;
                projection_pred.ty.hir_fmt(f)?;
            }
diff --git a/crates/hir_ty/src/infer.rs b/crates/hir_ty/src/infer.rs
index 4d771a91e..9c385b845 100644
--- a/crates/hir_ty/src/infer.rs
+++ b/crates/hir_ty/src/infer.rs
@@ -41,7 +41,8 @@ use super::{
    InEnvironment, ProjectionTy, Substs, TraitEnvironment, TraitRef, Ty, TypeWalk,
 };
 use crate::{
-    db::HirDatabase, infer::diagnostics::InferenceDiagnostic, lower::ImplTraitLoweringMode, AliasTy,
+    db::HirDatabase, infer::diagnostics::InferenceDiagnostic, lower::ImplTraitLoweringMode,
+    to_assoc_type_id, AliasTy, Interner, TyKind,
 };
 pub(crate) use unify::unify;
@@ -107,6 +108,17 @@ pub struct TypeMismatch {
    pub actual: Ty,
 }
+#[derive(Clone, PartialEq, Eq, Debug)]
+struct InternedStandardTypes {
+    unknown: Ty,
+}
+impl Default for InternedStandardTypes {
+    fn default() -> Self {
+        InternedStandardTypes { unknown: TyKind::Unknown.intern(&Interner) }
+    }
+}
 /// The result of type inference: A mapping from expressions and patterns to types.
 #[derive(Clone, PartialEq, Eq, Debug, Default)]
 pub struct InferenceResult {
@@ -125,6 +137,8 @@ pub struct InferenceResult {
    pub type_of_expr: ArenaMap<ExprId, Ty>,
    pub type_of_pat: ArenaMap<PatId, Ty>,
    pub(super) type_mismatches: ArenaMap<ExprId, TypeMismatch>,
+    /// Interned Unknown to return references to.
+    standard_types: InternedStandardTypes,
 }
 impl InferenceResult {
@@ -169,7 +183,7 @@ impl Index<ExprId> for InferenceResult {
    type Output = Ty;
    fn index(&self, expr: ExprId) -> &Ty {
-        self.type_of_expr.get(expr).unwrap_or(&Ty::Unknown)
+        self.type_of_expr.get(expr).unwrap_or(&self.standard_types.unknown)
    }
 }
@@ -177,7 +191,7 @@ impl Index<PatId> for InferenceResult {
    type Output = Ty;
    fn index(&self, pat: PatId) -> &Ty {
-        self.type_of_pat.get(pat).unwrap_or(&Ty::Unknown)
+        self.type_of_pat.get(pat).unwrap_or(&self.standard_types.unknown)
    }
 }
@@ -226,8 +240,10 @@ impl<'a> InferenceContext<'a> {
            result: InferenceResult::default(),
            table: unify::InferenceTable::new(),
            obligations: Vec::default(),
-            return_ty: Ty::Unknown, // set in collect_fn_signature
+            return_ty: TyKind::Unknown.intern(&Interner), // set in collect_fn_signature
-            trait_env: TraitEnvironment::lower(db, &resolver),
+            trait_env: owner
+                .as_generic_def_id()
+                .map_or_else(Default::default, |d| db.trait_environment(d)),
            db,
            owner,
            body: db.body(owner),
@@ -237,15 +253,19 @@ impl<'a> InferenceContext<'a> {
        }
    }
+    fn err_ty(&self) -> Ty {
+        TyKind::Unknown.intern(&Interner)
+    }
    fn resolve_all(mut self) -> InferenceResult {
        // FIXME resolve obligations as well (use Guidance if necessary)
        let mut result = std::mem::take(&mut self.result);
        for ty in result.type_of_expr.values_mut() {
-            let resolved = self.table.resolve_ty_completely(mem::replace(ty, Ty::Unknown));
+            let resolved = self.table.resolve_ty_completely(ty.clone());
            *ty = resolved;
        }
        for ty in result.type_of_pat.values_mut() {
-            let resolved = self.table.resolve_ty_completely(mem::replace(ty, Ty::Unknown));
+            let resolved = self.table.resolve_ty_completely(ty.clone());
            *ty = resolved;
        }
        result
@@ -287,7 +307,7 @@ impl<'a> InferenceContext<'a> {
        // FIXME use right resolver for block
        let ctx = crate::lower::TyLoweringContext::new(self.db, &self.resolver)
            .with_impl_trait_mode(impl_trait_mode);
-        let ty = Ty::from_hir(&ctx, type_ref);
+        let ty = ctx.lower_ty(type_ref);
        let ty = self.insert_type_vars(ty);
        self.normalize_associated_types_in(ty)
    }
@@ -298,8 +318,8 @@ 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 {
+        match ty.interned(&Interner) {
-            Ty::Unknown => self.table.new_type_var(),
+            TyKind::Unknown => self.table.new_type_var(),
            _ => ty,
        }
    }
@@ -377,13 +397,16 @@ impl<'a> InferenceContext<'a> {
                let trait_ref = TraitRef { trait_, substs: substs.clone() };
                let projection = ProjectionPredicate {
                    ty: ty.clone(),
-                    projection_ty: ProjectionTy { associated_ty: res_assoc_ty, parameters: substs },
+                    projection_ty: ProjectionTy {
+                        associated_ty_id: to_assoc_type_id(res_assoc_ty),
+                        substitution: substs,
+                    },
                };
                self.obligations.push(Obligation::Trait(trait_ref));
                self.obligations.push(Obligation::Projection(projection));
                self.resolve_ty_as_possible(ty)
            }
-            None => Ty::Unknown,
+            None => self.err_ty(),
        }
    }
@@ -395,8 +418,10 @@ impl<'a> InferenceContext<'a> {
    /// to do it as well.
    fn normalize_associated_types_in(&mut self, ty: Ty) -> Ty {
        let ty = self.resolve_ty_as_possible(ty);
-        ty.fold(&mut |ty| match ty {
+        ty.fold(&mut |ty| match ty.interned(&Interner) {
-            Ty::Alias(AliasTy::Projection(proj_ty)) => self.normalize_projection_ty(proj_ty),
+            TyKind::Alias(AliasTy::Projection(proj_ty)) => {
+                self.normalize_projection_ty(proj_ty.clone())
+            }
            _ => ty,
        })
    }
@@ -412,7 +437,7 @@ impl<'a> InferenceContext<'a> {
    fn resolve_variant(&mut self, path: Option<&Path>) -> (Ty, Option<VariantId>) {
        let path = match path {
            Some(path) => path,
-            None => return (Ty::Unknown, None),
+            None => return (self.err_ty(), None),
        };
        let resolver = &self.resolver;
        let ctx = crate::lower::TyLoweringContext::new(self.db, &self.resolver);
@@ -421,30 +446,30 @@ impl<'a> InferenceContext<'a> {
        let (resolution, unresolved) =
            match resolver.resolve_path_in_type_ns(self.db.upcast(), path.mod_path()) {
                Some(it) => it,
-                None => return (Ty::Unknown, None),
+                None => return (self.err_ty(), None),
            };
        return match resolution {
            TypeNs::AdtId(AdtId::StructId(strukt)) => {
-                let substs = Ty::substs_from_path(&ctx, path, strukt.into(), true);
+                let substs = ctx.substs_from_path(path, strukt.into(), true);
                let ty = self.db.ty(strukt.into());
                let ty = self.insert_type_vars(ty.subst(&substs));
                forbid_unresolved_segments((ty, Some(strukt.into())), unresolved)
            }
            TypeNs::AdtId(AdtId::UnionId(u)) => {
-                let substs = Ty::substs_from_path(&ctx, path, u.into(), true);
+                let substs = ctx.substs_from_path(path, u.into(), true);
                let ty = self.db.ty(u.into());
                let ty = self.insert_type_vars(ty.subst(&substs));
                forbid_unresolved_segments((ty, Some(u.into())), unresolved)
            }
            TypeNs::EnumVariantId(var) => {
-                let substs = Ty::substs_from_path(&ctx, path, var.into(), true);
+                let substs = ctx.substs_from_path(path, var.into(), true);
                let ty = self.db.ty(var.parent.into());
                let ty = self.insert_type_vars(ty.subst(&substs));
                forbid_unresolved_segments((ty, Some(var.into())), unresolved)
            }
            TypeNs::SelfType(impl_id) => {
                let generics = crate::utils::generics(self.db.upcast(), impl_id.into());
-                let substs = Substs::type_params_for_generics(&generics);
+                let substs = Substs::type_params_for_generics(self.db, &generics);
                let ty = self.db.impl_self_ty(impl_id).subst(&substs);
                match unresolved {
                    None => {
@@ -462,11 +487,11 @@ impl<'a> InferenceContext<'a> {
                            }
                        }
                        // FIXME potentially resolve assoc type
-                        (Ty::Unknown, None)
+                        (self.err_ty(), None)
                    }
                    Some(_) => {
                        // FIXME diagnostic
-                        (Ty::Unknown, None)
+                        (self.err_ty(), None)
                    }
                }
            }
@@ -480,15 +505,15 @@ impl<'a> InferenceContext<'a> {
            }
            TypeNs::AdtSelfType(_) => {
                // FIXME this could happen in array size expressions, once we're checking them
-                (Ty::Unknown, None)
+                (self.err_ty(), None)
            }
            TypeNs::GenericParam(_) => {
                // FIXME potentially resolve assoc type
-                (Ty::Unknown, None)
+                (self.err_ty(), None)
            }
            TypeNs::AdtId(AdtId::EnumId(_)) | TypeNs::BuiltinType(_) | TypeNs::TraitId(_) => {
                // FIXME diagnostic
-                (Ty::Unknown, None)
+                (self.err_ty(), None)
            }
        };
@@ -500,7 +525,7 @@ impl<'a> InferenceContext<'a> {
                result
            } else {
                // FIXME diagnostic
-                (Ty::Unknown, None)
+                (TyKind::Unknown.intern(&Interner), None)
            }
        }
@@ -529,7 +554,7 @@ impl<'a> InferenceContext<'a> {
        let ctx = crate::lower::TyLoweringContext::new(self.db, &self.resolver)
            .with_impl_trait_mode(ImplTraitLoweringMode::Param);
        let param_tys =
-            data.params.iter().map(|type_ref| Ty::from_hir(&ctx, type_ref)).collect::<Vec<_>>();
+            data.params.iter().map(|type_ref| ctx.lower_ty(type_ref)).collect::<Vec<_>>();
        for (ty, pat) in param_tys.into_iter().zip(body.params.iter()) {
            let ty = self.insert_type_vars(ty);
            let ty = self.normalize_associated_types_in(ty);
@@ -711,14 +736,19 @@ impl Expectation {
    /// This expresses no expectation on the type.
    fn none() -> Self {
-        Expectation { ty: Ty::Unknown, rvalue_hint: false }
+        Expectation {
+            // FIXME
+            ty: TyKind::Unknown.intern(&Interner),
+            rvalue_hint: false,
+        }
    }
-    fn coercion_target(&self) -> &Ty {
+    fn coercion_target(&self) -> Ty {
        if self.rvalue_hint {
-            &Ty::Unknown
+            // FIXME
+            TyKind::Unknown.intern(&Interner)
        } else {
-            &self.ty
+            self.ty.clone()
        }
    }
 }
@@ -772,7 +802,7 @@ mod diagnostics {
    #[derive(Debug, PartialEq, Eq, Clone)]
    pub(super) enum InferenceDiagnostic {
-        NoSuchField { expr: ExprId, field: usize },
+        NoSuchField { expr: ExprId },
        BreakOutsideOfLoop { expr: ExprId },
    }
@@ -784,9 +814,9 @@ mod diagnostics {
            sink: &mut DiagnosticSink,
        ) {
            match self {
-                InferenceDiagnostic::NoSuchField { expr, field } => {
+                InferenceDiagnostic::NoSuchField { expr } => {
                    let (_, source_map) = db.body_with_source_map(owner);
-                    let field = source_map.field_syntax(*expr, *field);
+                    let field = source_map.field_syntax(*expr);
                    sink.push(NoSuchField { file: field.file_id, field: field.value })
                }
                InferenceDiagnostic::BreakOutsideOfLoop { expr } => {
diff --git a/crates/hir_ty/src/infer/coerce.rs b/crates/hir_ty/src/infer/coerce.rs
index 7e8846f27..137419264 100644
--- a/crates/hir_ty/src/infer/coerce.rs
+++ b/crates/hir_ty/src/infer/coerce.rs
@@ -7,7 +7,7 @@
 use chalk_ir::{Mutability, TyVariableKind};
 use hir_def::lang_item::LangItemTarget;
-use crate::{autoderef, traits::Solution, Obligation, Substs, TraitRef, Ty};
+use crate::{autoderef, traits::Solution, Interner, Obligation, Substs, TraitRef, Ty, TyKind};
 use super::{InEnvironment, InferenceContext};
@@ -33,7 +33,9 @@ impl<'a> InferenceContext<'a> {
        } else if self.coerce(ty2, ty1) {
            ty1.clone()
        } else {
-            if let (Ty::FnDef(..), Ty::FnDef(..)) = (ty1, ty2) {
+            if let (TyKind::FnDef(..), TyKind::FnDef(..)) =
+                (ty1.interned(&Interner), ty2.interned(&Interner))
+            {
                cov_mark::hit!(coerce_fn_reification);
                // Special case: two function types. Try to coerce both to
                // pointers to have a chance at getting a match. See
@@ -51,13 +53,13 @@ impl<'a> InferenceContext<'a> {
    }
    fn coerce_inner(&mut self, mut from_ty: Ty, to_ty: &Ty) -> bool {
-        match (&from_ty, to_ty) {
+        match (from_ty.interned(&Interner), to_ty.interned(&Interner)) {
            // Never type will make type variable to fallback to Never Type instead of Unknown.
-            (Ty::Never, Ty::InferenceVar(tv, TyVariableKind::General)) => {
+            (TyKind::Never, TyKind::InferenceVar(tv, TyVariableKind::General)) => {
                self.table.type_variable_table.set_diverging(*tv, true);
                return true;
            }
-            (Ty::Never, _) => return true,
+            (TyKind::Never, _) => return true,
            // Trivial cases, this should go after `never` check to
            // avoid infer result type to be never
@@ -69,33 +71,33 @@ impl<'a> InferenceContext<'a> {
        }
        // Pointer weakening and function to pointer
-        match (&mut from_ty, to_ty) {
+        match (from_ty.interned_mut(), to_ty.interned(&Interner)) {
            // `*mut T` -> `*const T`
            // `&mut T` -> `&T`
-            (Ty::Raw(m1, ..), Ty::Raw(m2 @ Mutability::Not, ..))
+            (TyKind::Raw(m1, ..), TyKind::Raw(m2 @ Mutability::Not, ..))
-            | (Ty::Ref(m1, ..), Ty::Ref(m2 @ Mutability::Not, ..)) => {
+            | (TyKind::Ref(m1, ..), TyKind::Ref(m2 @ Mutability::Not, ..)) => {
                *m1 = *m2;
            }
            // `&T` -> `*const T`
            // `&mut T` -> `*mut T`/`*const T`
-            (Ty::Ref(.., substs), &Ty::Raw(m2 @ Mutability::Not, ..))
+            (TyKind::Ref(.., substs), &TyKind::Raw(m2 @ Mutability::Not, ..))
-            | (Ty::Ref(Mutability::Mut, substs), &Ty::Raw(m2, ..)) => {
+            | (TyKind::Ref(Mutability::Mut, substs), &TyKind::Raw(m2, ..)) => {
-                from_ty = Ty::Raw(m2, substs.clone());
+                from_ty = TyKind::Raw(m2, substs.clone()).intern(&Interner);
            }
            // Illegal mutability conversion
-            (Ty::Raw(Mutability::Not, ..), Ty::Raw(Mutability::Mut, ..))
+            (TyKind::Raw(Mutability::Not, ..), TyKind::Raw(Mutability::Mut, ..))
-            | (Ty::Ref(Mutability::Not, ..), Ty::Ref(Mutability::Mut, ..)) => return false,
+            | (TyKind::Ref(Mutability::Not, ..), TyKind::Ref(Mutability::Mut, ..)) => return false,
            // `{function_type}` -> `fn()`
-            (Ty::FnDef(..), Ty::Function { .. }) => match from_ty.callable_sig(self.db) {
+            (TyKind::FnDef(..), TyKind::Function { .. }) => match from_ty.callable_sig(self.db) {
                None => return false,
                Some(sig) => {
                    from_ty = Ty::fn_ptr(sig);
                }
            },
-            (Ty::Closure(.., substs), Ty::Function { .. }) => {
+            (TyKind::Closure(.., substs), TyKind::Function { .. }) => {
                from_ty = substs[0].clone();
            }
@@ -107,9 +109,9 @@ impl<'a> InferenceContext<'a> {
        }
        // Auto Deref if cannot coerce
-        match (&from_ty, to_ty) {
+        match (from_ty.interned(&Interner), to_ty.interned(&Interner)) {
            // FIXME: DerefMut
-            (Ty::Ref(_, st1), Ty::Ref(_, st2)) => self.unify_autoderef_behind_ref(&st1[0], &st2[0]),
+            (TyKind::Ref(_, st1), TyKind::Ref(_, st2)) => self.unify_autoderef_behind_ref(st1, st2),
            // Otherwise, normal unify
            _ => self.unify(&from_ty, to_ty),
@@ -174,11 +176,7 @@ impl<'a> InferenceContext<'a> {
            // Stop when constructor matches.
            if from_ty.equals_ctor(&to_ty) {
                // It will not recurse to `coerce`.
-                return match (from_ty.substs(), to_ty.substs()) {
+                return self.table.unify(&from_ty, &to_ty);
-                    (Some(st1), Some(st2)) => self.table.unify_substs(st1, st2, 0),
-                    (None, None) => true,
-                    _ => false,
-                };
            } else if self.table.unify_inner_trivial(&derefed_ty, &to_ty, 0) {
                return true;
            }
diff --git a/crates/hir_ty/src/infer/expr.rs b/crates/hir_ty/src/infer/expr.rs
index 262177ffb..f40dec17f 100644
--- a/crates/hir_ty/src/infer/expr.rs
+++ b/crates/hir_ty/src/infer/expr.rs
@@ -18,10 +18,11 @@ use crate::{
    lower::lower_to_chalk_mutability,
    method_resolution, op,
    primitive::{self, UintTy},
-    traits::{FnTrait, InEnvironment},
+    to_assoc_type_id,
+    traits::{chalk::from_chalk, FnTrait, InEnvironment},
    utils::{generics, variant_data, Generics},
-    AdtId, Binders, CallableDefId, FnPointer, FnSig, Obligation, OpaqueTyId, Rawness, Scalar,
+    AdtId, Binders, CallableDefId, FnPointer, FnSig, Interner, Obligation, Rawness, Scalar, Substs,
-    Substs, TraitRef, Ty,
+    TraitRef, Ty, TyKind,
 };
 use super::{
@@ -57,7 +58,7 @@ impl<'a> InferenceContext<'a> {
            // Return actual type when type mismatch.
            // This is needed for diagnostic when return type mismatch.
            ty
-        } else if expected.coercion_target() == &Ty::Unknown {
+        } else if expected.coercion_target().is_unknown() {
            ty
        } else {
            expected.ty.clone()
@@ -84,7 +85,7 @@ impl<'a> InferenceContext<'a> {
            arg_tys.push(arg);
        }
        let parameters = param_builder.build();
-        let arg_ty = Ty::Tuple(num_args, parameters);
+        let arg_ty = TyKind::Tuple(num_args, parameters).intern(&Interner);
        let substs =
            Substs::build_for_generics(&generic_params).push(ty.clone()).push(arg_ty).build();
@@ -97,8 +98,10 @@ impl<'a> InferenceContext<'a> {
        });
        if self.db.trait_solve(krate, goal.value).is_some() {
            self.obligations.push(implements_fn_trait);
-            let output_proj_ty =
+            let output_proj_ty = crate::ProjectionTy {
-                crate::ProjectionTy { associated_ty: output_assoc_type, parameters: substs };
+                associated_ty_id: to_assoc_type_id(output_assoc_type),
+                substitution: substs,
+            };
            let return_ty = self.normalize_projection_ty(output_proj_ty);
            Some((arg_tys, return_ty))
        } else {
@@ -116,10 +119,13 @@ impl<'a> InferenceContext<'a> {
    fn infer_expr_inner(&mut self, tgt_expr: ExprId, expected: &Expectation) -> Ty {
        let body = Arc::clone(&self.body); // avoid borrow checker problem
        let ty = match &body[tgt_expr] {
-            Expr::Missing => Ty::Unknown,
+            Expr::Missing => self.err_ty(),
            Expr::If { condition, then_branch, else_branch } => {
                // if let is desugared to match, so this is always simple if
-                self.infer_expr(*condition, &Expectation::has_type(Ty::Scalar(Scalar::Bool)));
+                self.infer_expr(
+                    *condition,
+                    &Expectation::has_type(TyKind::Scalar(Scalar::Bool).intern(&Interner)),
+                );
                let condition_diverges = mem::replace(&mut self.diverges, Diverges::Maybe);
                let mut both_arms_diverge = Diverges::Always;
@@ -167,14 +173,15 @@ impl<'a> InferenceContext<'a> {
            Expr::TryBlock { body } => {
                let _inner = self.infer_expr(*body, expected);
                // FIXME should be std::result::Result<{inner}, _>
-                Ty::Unknown
+                self.err_ty()
            }
            Expr::Async { body } => {
                // Use the first type parameter as the output type of future.
                // existenail type AsyncBlockImplTrait<InnerType>: Future<Output = InnerType>
                let inner_ty = self.infer_expr(*body, &Expectation::none());
-                let opaque_ty_id = OpaqueTyId::AsyncBlockTypeImplTrait(self.owner, *body);
+                let impl_trait_id = crate::ImplTraitId::AsyncBlockTypeImplTrait(self.owner, *body);
-                Ty::OpaqueType(opaque_ty_id, Substs::single(inner_ty))
+                let opaque_ty_id = self.db.intern_impl_trait_id(impl_trait_id).into();
+                TyKind::OpaqueType(opaque_ty_id, Substs::single(inner_ty)).intern(&Interner)
            }
            Expr::Loop { body, label } => {
                self.breakables.push(BreakableContext {
@@ -192,17 +199,20 @@ impl<'a> InferenceContext<'a> {
                if ctxt.may_break {
                    ctxt.break_ty
                } else {
-                    Ty::Never
+                    TyKind::Never.intern(&Interner)
                }
            }
            Expr::While { condition, body, label } => {
                self.breakables.push(BreakableContext {
                    may_break: false,
-                    break_ty: Ty::Unknown,
+                    break_ty: self.err_ty(),
                    label: label.map(|label| self.body[label].name.clone()),
                });
                // while let is desugared to a match loop, so this is always simple while
-                self.infer_expr(*condition, &Expectation::has_type(Ty::Scalar(Scalar::Bool)));
+                self.infer_expr(
+                    *condition,
+                    &Expectation::has_type(TyKind::Scalar(Scalar::Bool).intern(&Interner)),
+                );
                self.infer_expr(*body, &Expectation::has_type(Ty::unit()));
                let _ctxt = self.breakables.pop().expect("breakable stack broken");
                // the body may not run, so it diverging doesn't mean we diverge
@@ -214,7 +224,7 @@ impl<'a> InferenceContext<'a> {
                self.breakables.push(BreakableContext {
                    may_break: false,
-                    break_ty: Ty::Unknown,
+                    break_ty: self.err_ty(),
                    label: label.map(|label| self.body[label].name.clone()),
                });
                let pat_ty =
@@ -249,12 +259,15 @@ impl<'a> InferenceContext<'a> {
                    None => self.table.new_type_var(),
                };
                sig_tys.push(ret_ty.clone());
-                let sig_ty = Ty::Function(FnPointer {
+                let sig_ty = TyKind::Function(FnPointer {
                    num_args: sig_tys.len() - 1,
-                    sig: FnSig { variadic: false },
+                    sig: FnSig { abi: (), safety: chalk_ir::Safety::Safe, variadic: false },
                    substs: Substs(sig_tys.clone().into()),
-                });
+                })
-                let closure_ty = Ty::Closure(self.owner, tgt_expr, Substs::single(sig_ty));
+                .intern(&Interner);
+                let closure_id = self.db.intern_closure((self.owner, tgt_expr)).into();
+                let closure_ty =
+                    TyKind::Closure(closure_id, Substs::single(sig_ty)).intern(&Interner);
                // Eagerly try to relate the closure type with the expected
                // type, otherwise we often won't have enough information to
@@ -295,7 +308,7 @@ impl<'a> InferenceContext<'a> {
                            args.len(),
                        )
                    })
-                    .unwrap_or((Vec::new(), Ty::Unknown));
+                    .unwrap_or((Vec::new(), self.err_ty()));
                self.register_obligations_for_call(&callee_ty);
                self.check_call_arguments(args, &param_tys);
                self.normalize_associated_types_in(ret_ty)
@@ -305,8 +318,11 @@ impl<'a> InferenceContext<'a> {
            Expr::Match { expr, arms } => {
                let input_ty = self.infer_expr(*expr, &Expectation::none());
-                let mut result_ty =
+                let mut result_ty = if arms.is_empty() {
-                    if arms.is_empty() { Ty::Never } else { self.table.new_type_var() };
+                    TyKind::Never.intern(&Interner)
+                } else {
+                    self.table.new_type_var()
+                };
                let matchee_diverges = self.diverges;
                let mut all_arms_diverge = Diverges::Always;
@@ -317,7 +333,7 @@ impl<'a> InferenceContext<'a> {
                    if let Some(guard_expr) = arm.guard {
                        self.infer_expr(
                            guard_expr,
-                            &Expectation::has_type(Ty::Scalar(Scalar::Bool)),
+                            &Expectation::has_type(TyKind::Scalar(Scalar::Bool).intern(&Interner)),
                        );
                    }
@@ -333,9 +349,9 @@ impl<'a> InferenceContext<'a> {
            Expr::Path(p) => {
                // FIXME this could be more efficient...
                let resolver = resolver_for_expr(self.db.upcast(), self.owner, tgt_expr);
-                self.infer_path(&resolver, p, tgt_expr.into()).unwrap_or(Ty::Unknown)
+                self.infer_path(&resolver, p, tgt_expr.into()).unwrap_or(self.err_ty())
            }
-            Expr::Continue { .. } => Ty::Never,
+            Expr::Continue { .. } => TyKind::Never.intern(&Interner),
            Expr::Break { expr, label } => {
                let val_ty = if let Some(expr) = expr {
                    self.infer_expr(*expr, &Expectation::none())
@@ -347,7 +363,7 @@ impl<'a> InferenceContext<'a> {
                    if let Some(ctxt) = find_breakable(&mut self.breakables, label.as_ref()) {
                        ctxt.break_ty.clone()
                    } else {
-                        Ty::Unknown
+                        self.err_ty()
                    };
                let merged_type = self.coerce_merge_branch(&last_ty, &val_ty);
@@ -360,7 +376,7 @@ impl<'a> InferenceContext<'a> {
                        expr: tgt_expr,
                    });
                }
-                Ty::Never
+                TyKind::Never.intern(&Interner)
            }
            Expr::Return { expr } => {
                if let Some(expr) = expr {
@@ -369,14 +385,14 @@ impl<'a> InferenceContext<'a> {
                    let unit = Ty::unit();
                    self.coerce(&unit, &self.return_ty.clone());
                }
-                Ty::Never
+                TyKind::Never.intern(&Interner)
            }
            Expr::Yield { expr } => {
                // FIXME: track yield type for coercion
                if let Some(expr) = expr {
                    self.infer_expr(*expr, &Expectation::none());
                }
-                Ty::Never
+                TyKind::Never.intern(&Interner)
            }
            Expr::RecordLit { path, fields, spread } => {
                let (ty, def_id) = self.resolve_variant(path.as_ref());
@@ -389,14 +405,13 @@ impl<'a> InferenceContext<'a> {
                let substs = ty.substs().cloned().unwrap_or_else(Substs::empty);
                let field_types = def_id.map(|it| self.db.field_types(it)).unwrap_or_default();
                let variant_data = def_id.map(|it| variant_data(self.db.upcast(), it));
-                for (field_idx, field) in fields.iter().enumerate() {
+                for field in fields.iter() {
                    let field_def =
                        variant_data.as_ref().and_then(|it| match it.field(&field.name) {
                            Some(local_id) => Some(FieldId { parent: def_id.unwrap(), local_id }),
                            None => {
                                self.push_diagnostic(InferenceDiagnostic::NoSuchField {
-                                    expr: tgt_expr,
+                                    expr: field.expr,
-                                    field: field_idx,
                                });
                                None
                            }
@@ -404,8 +419,9 @@ impl<'a> InferenceContext<'a> {
                    if let Some(field_def) = field_def {
                        self.result.record_field_resolutions.insert(field.expr, field_def);
                    }
-                    let field_ty = field_def
+                    let field_ty = field_def.map_or(self.err_ty(), |it| {
-                        .map_or(Ty::Unknown, |it| field_types[it.local_id].clone().subst(&substs));
+                        field_types[it.local_id].clone().subst(&substs)
+                    });
                    self.infer_expr_coerce(field.expr, &Expectation::has_type(field_ty));
                }
                if let Some(expr) = spread {
@@ -424,27 +440,33 @@ impl<'a> InferenceContext<'a> {
                        environment: self.trait_env.clone(),
                    },
                )
-                .find_map(|derefed_ty| match canonicalized.decanonicalize_ty(derefed_ty.value) {
+                .find_map(|derefed_ty| {
-                    Ty::Tuple(_, substs) => {
+                    match canonicalized.decanonicalize_ty(derefed_ty.value).interned(&Interner) {
-                        name.as_tuple_index().and_then(|idx| substs.0.get(idx).cloned())
+                        TyKind::Tuple(_, substs) => {
-                    }
+                            name.as_tuple_index().and_then(|idx| substs.0.get(idx).cloned())
-                    Ty::Adt(AdtId(hir_def::AdtId::StructId(s)), parameters) => {
+                        }
-                        self.db.struct_data(s).variant_data.field(name).map(|local_id| {
+                        TyKind::Adt(AdtId(hir_def::AdtId::StructId(s)), parameters) => {
-                            let field = FieldId { parent: s.into(), local_id };
+                            self.db.struct_data(*s).variant_data.field(name).map(|local_id| {
-                            self.write_field_resolution(tgt_expr, field);
+                                let field = FieldId { parent: (*s).into(), local_id };
-                            self.db.field_types(s.into())[field.local_id].clone().subst(&parameters)
+                                self.write_field_resolution(tgt_expr, field);
-                        })
+                                self.db.field_types((*s).into())[field.local_id]
-                    }
+                                    .clone()
-                    Ty::Adt(AdtId(hir_def::AdtId::UnionId(u)), parameters) => {
+                                    .subst(&parameters)
-                        self.db.union_data(u).variant_data.field(name).map(|local_id| {
+                            })
-                            let field = FieldId { parent: u.into(), local_id };
+                        }
-                            self.write_field_resolution(tgt_expr, field);
+                        TyKind::Adt(AdtId(hir_def::AdtId::UnionId(u)), parameters) => {
-                            self.db.field_types(u.into())[field.local_id].clone().subst(&parameters)
+                            self.db.union_data(*u).variant_data.field(name).map(|local_id| {
-                        })
+                                let field = FieldId { parent: (*u).into(), local_id };
+                                self.write_field_resolution(tgt_expr, field);
+                                self.db.field_types((*u).into())[field.local_id]
+                                    .clone()
+                                    .subst(&parameters)
+                            })
+                        }
+                        _ => None,
                    }
-                    _ => None,
                })
-                .unwrap_or(Ty::Unknown);
+                .unwrap_or(self.err_ty());
                let ty = self.insert_type_vars(ty);
                self.normalize_associated_types_in(ty)
            }
@@ -481,9 +503,10 @@ impl<'a> InferenceContext<'a> {
                };
                let inner_ty = self.infer_expr_inner(*expr, &expectation);
                match rawness {
-                    Rawness::RawPtr => Ty::Raw(mutability, Substs::single(inner_ty)),
+                    Rawness::RawPtr => TyKind::Raw(mutability, inner_ty),
-                    Rawness::Ref => Ty::Ref(mutability, Substs::single(inner_ty)),
+                    Rawness::Ref => TyKind::Ref(mutability, inner_ty),
                }
+                .intern(&Interner)
            }
            Expr::Box { expr } => {
                let inner_ty = self.infer_expr_inner(*expr, &Expectation::none());
@@ -499,7 +522,7 @@ impl<'a> InferenceContext<'a> {
                    sb = sb.fill(repeat_with(|| self.table.new_type_var()));
                    Ty::adt_ty(box_, sb.build())
                } else {
-                    Ty::Unknown
+                    self.err_ty()
                }
            }
            Expr::UnaryOp { expr, op } => {
@@ -519,31 +542,31 @@ impl<'a> InferenceContext<'a> {
                                Some(derefed_ty) => {
                                    canonicalized.decanonicalize_ty(derefed_ty.value)
                                }
-                                None => Ty::Unknown,
+                                None => self.err_ty(),
                            }
                        }
-                        None => Ty::Unknown,
+                        None => self.err_ty(),
                    },
                    UnaryOp::Neg => {
-                        match &inner_ty {
+                        match inner_ty.interned(&Interner) {
                            // Fast path for builtins
-                            Ty::Scalar(Scalar::Int(_))
+                            TyKind::Scalar(Scalar::Int(_))
-                            | Ty::Scalar(Scalar::Uint(_))
+                            | TyKind::Scalar(Scalar::Uint(_))
-                            | Ty::Scalar(Scalar::Float(_))
+                            | TyKind::Scalar(Scalar::Float(_))
-                            | Ty::InferenceVar(_, TyVariableKind::Integer)
+                            | TyKind::InferenceVar(_, TyVariableKind::Integer)
-                            | Ty::InferenceVar(_, TyVariableKind::Float) => inner_ty,
+                            | TyKind::InferenceVar(_, TyVariableKind::Float) => inner_ty,
                            // Otherwise we resolve via the std::ops::Neg trait
                            _ => self
                                .resolve_associated_type(inner_ty, self.resolve_ops_neg_output()),
                        }
                    }
                    UnaryOp::Not => {
-                        match &inner_ty {
+                        match inner_ty.interned(&Interner) {
                            // Fast path for builtins
-                            Ty::Scalar(Scalar::Bool)
+                            TyKind::Scalar(Scalar::Bool)
-                            | Ty::Scalar(Scalar::Int(_))
+                            | TyKind::Scalar(Scalar::Int(_))
-                            | Ty::Scalar(Scalar::Uint(_))
+                            | TyKind::Scalar(Scalar::Uint(_))
-                            | Ty::InferenceVar(_, TyVariableKind::Integer) => inner_ty,
+                            | TyKind::InferenceVar(_, TyVariableKind::Integer) => inner_ty,
                            // Otherwise we resolve via the std::ops::Not trait
                            _ => self
                                .resolve_associated_type(inner_ty, self.resolve_ops_not_output()),
@@ -554,7 +577,9 @@ impl<'a> InferenceContext<'a> {
            Expr::BinaryOp { lhs, rhs, op } => match op {
                Some(op) => {
                    let lhs_expectation = match op {
-                        BinaryOp::LogicOp(..) => Expectation::has_type(Ty::Scalar(Scalar::Bool)),
+                        BinaryOp::LogicOp(..) => {
+                            Expectation::has_type(TyKind::Scalar(Scalar::Bool).intern(&Interner))
+                        }
                        _ => Expectation::none(),
                    };
                    let lhs_ty = self.infer_expr(*lhs, &lhs_expectation);
@@ -563,7 +588,7 @@ impl<'a> InferenceContext<'a> {
                    let ret = op::binary_op_return_ty(*op, lhs_ty.clone(), rhs_ty.clone());
-                    if ret == Ty::Unknown {
+                    if ret.is_unknown() {
                        cov_mark::hit!(infer_expr_inner_binary_operator_overload);
                        self.resolve_associated_type_with_params(
@@ -575,7 +600,7 @@ impl<'a> InferenceContext<'a> {
                        ret
                    }
                }
-                _ => Ty::Unknown,
+                _ => self.err_ty(),
            },
            Expr::Range { lhs, rhs, range_type } => {
                let lhs_ty = lhs.map(|e| self.infer_expr_inner(e, &Expectation::none()));
@@ -586,33 +611,33 @@ impl<'a> InferenceContext<'a> {
                match (range_type, lhs_ty, rhs_ty) {
                    (RangeOp::Exclusive, None, None) => match self.resolve_range_full() {
                        Some(adt) => Ty::adt_ty(adt, Substs::empty()),
-                        None => Ty::Unknown,
+                        None => self.err_ty(),
                    },
                    (RangeOp::Exclusive, None, Some(ty)) => match self.resolve_range_to() {
                        Some(adt) => Ty::adt_ty(adt, Substs::single(ty)),
-                        None => Ty::Unknown,
+                        None => self.err_ty(),
                    },
                    (RangeOp::Inclusive, None, Some(ty)) => {
                        match self.resolve_range_to_inclusive() {
                            Some(adt) => Ty::adt_ty(adt, Substs::single(ty)),
-                            None => Ty::Unknown,
+                            None => self.err_ty(),
                        }
                    }
                    (RangeOp::Exclusive, Some(_), Some(ty)) => match self.resolve_range() {
                        Some(adt) => Ty::adt_ty(adt, Substs::single(ty)),
-                        None => Ty::Unknown,
+                        None => self.err_ty(),
                    },
                    (RangeOp::Inclusive, Some(_), Some(ty)) => {
                        match self.resolve_range_inclusive() {
                            Some(adt) => Ty::adt_ty(adt, Substs::single(ty)),
-                            None => Ty::Unknown,
+                            None => self.err_ty(),
                        }
                    }
                    (RangeOp::Exclusive, Some(ty), None) => match self.resolve_range_from() {
                        Some(adt) => Ty::adt_ty(adt, Substs::single(ty)),
-                        None => Ty::Unknown,
+                        None => self.err_ty(),
                    },
-                    (RangeOp::Inclusive, _, None) => Ty::Unknown,
+                    (RangeOp::Inclusive, _, None) => self.err_ty(),
                }
            }
            Expr::Index { base, index } => {
@@ -631,19 +656,19 @@ impl<'a> InferenceContext<'a> {
                        index_trait,
                    );
                    let self_ty =
-                        self_ty.map_or(Ty::Unknown, |t| canonicalized.decanonicalize_ty(t.value));
+                        self_ty.map_or(self.err_ty(), |t| canonicalized.decanonicalize_ty(t.value));
                    self.resolve_associated_type_with_params(
                        self_ty,
                        self.resolve_ops_index_output(),
                        &[index_ty],
                    )
                } else {
-                    Ty::Unknown
+                    self.err_ty()
                }
            }
            Expr::Tuple { exprs } => {
-                let mut tys = match &expected.ty {
+                let mut tys = match expected.ty.interned(&Interner) {
-                    Ty::Tuple(_, substs) => substs
+                    TyKind::Tuple(_, substs) => substs
                        .iter()
                        .cloned()
                        .chain(repeat_with(|| self.table.new_type_var()))
@@ -656,11 +681,11 @@ impl<'a> InferenceContext<'a> {
                    self.infer_expr_coerce(*expr, &Expectation::has_type(ty.clone()));
                }
-                Ty::Tuple(tys.len(), Substs(tys.into()))
+                TyKind::Tuple(tys.len(), Substs(tys.into())).intern(&Interner)
            }
            Expr::Array(array) => {
-                let elem_ty = match &expected.ty {
+                let elem_ty = match expected.ty.interned(&Interner) {
-                    Ty::Array(st) | Ty::Slice(st) => st.as_single().clone(),
+                    TyKind::Array(st) | TyKind::Slice(st) => st.clone(),
                    _ => self.table.new_type_var(),
                };
@@ -677,43 +702,50 @@ impl<'a> InferenceContext<'a> {
                        );
                        self.infer_expr(
                            *repeat,
-                            &Expectation::has_type(Ty::Scalar(Scalar::Uint(UintTy::Usize))),
+                            &Expectation::has_type(
+                                TyKind::Scalar(Scalar::Uint(UintTy::Usize)).intern(&Interner),
+                            ),
                        );
                    }
                }
-                Ty::Array(Substs::single(elem_ty))
+                TyKind::Array(elem_ty).intern(&Interner)
            }
            Expr::Literal(lit) => match lit {
-                Literal::Bool(..) => Ty::Scalar(Scalar::Bool),
+                Literal::Bool(..) => TyKind::Scalar(Scalar::Bool).intern(&Interner),
-                Literal::String(..) => Ty::Ref(Mutability::Not, Substs::single(Ty::Str)),
+                Literal::String(..) => {
+                    TyKind::Ref(Mutability::Not, TyKind::Str.intern(&Interner)).intern(&Interner)
+                }
                Literal::ByteString(..) => {
-                    let byte_type = Ty::Scalar(Scalar::Uint(UintTy::U8));
+                    let byte_type = TyKind::Scalar(Scalar::Uint(UintTy::U8)).intern(&Interner);
-                    let array_type = Ty::Array(Substs::single(byte_type));
+                    let array_type = TyKind::Array(byte_type).intern(&Interner);
-                    Ty::Ref(Mutability::Not, Substs::single(array_type))
+                    TyKind::Ref(Mutability::Not, array_type).intern(&Interner)
                }
-                Literal::Char(..) => Ty::Scalar(Scalar::Char),
+                Literal::Char(..) => TyKind::Scalar(Scalar::Char).intern(&Interner),
                Literal::Int(_v, ty) => match ty {
                    Some(int_ty) => {
-                        Ty::Scalar(Scalar::Int(primitive::int_ty_from_builtin(*int_ty)))
+                        TyKind::Scalar(Scalar::Int(primitive::int_ty_from_builtin(*int_ty)))
+                            .intern(&Interner)
                    }
                    None => self.table.new_integer_var(),
                },
                Literal::Uint(_v, ty) => match ty {
                    Some(int_ty) => {
-                        Ty::Scalar(Scalar::Uint(primitive::uint_ty_from_builtin(*int_ty)))
+                        TyKind::Scalar(Scalar::Uint(primitive::uint_ty_from_builtin(*int_ty)))
+                            .intern(&Interner)
                    }
                    None => self.table.new_integer_var(),
                },
                Literal::Float(_v, ty) => match ty {
                    Some(float_ty) => {
-                        Ty::Scalar(Scalar::Float(primitive::float_ty_from_builtin(*float_ty)))
+                        TyKind::Scalar(Scalar::Float(primitive::float_ty_from_builtin(*float_ty)))
+                            .intern(&Interner)
                    }
                    None => self.table.new_float_var(),
                },
            },
        };
-        // use a new type variable if we got Ty::Unknown here
+        // use a new type variable if we got unknown here
        let ty = self.insert_type_vars_shallow(ty);
        let ty = self.resolve_ty_as_possible(ty);
        self.write_expr_ty(tgt_expr, ty.clone());
@@ -730,7 +762,7 @@ impl<'a> InferenceContext<'a> {
            match stmt {
                Statement::Let { pat, type_ref, initializer } => {
                    let decl_ty =
-                        type_ref.as_ref().map(|tr| self.make_ty(tr)).unwrap_or(Ty::Unknown);
+                        type_ref.as_ref().map(|tr| self.make_ty(tr)).unwrap_or(self.err_ty());
                    // Always use the declared type when specified
                    let mut ty = decl_ty.clone();
@@ -738,7 +770,7 @@ impl<'a> InferenceContext<'a> {
                    if let Some(expr) = initializer {
                        let actual_ty =
                            self.infer_expr_coerce(*expr, &Expectation::has_type(decl_ty.clone()));
-                        if decl_ty == Ty::Unknown {
+                        if decl_ty.is_unknown() {
                            ty = actual_ty;
                        }
                    }
@@ -766,7 +798,7 @@ impl<'a> InferenceContext<'a> {
                // we don't even make an attempt at coercion
                self.table.new_maybe_never_var()
            } else {
-                self.coerce(&Ty::unit(), expected.coercion_target());
+                self.coerce(&Ty::unit(), &expected.coercion_target());
                Ty::unit()
            }
        };
@@ -802,7 +834,7 @@ impl<'a> InferenceContext<'a> {
                self.write_method_resolution(tgt_expr, func);
                (ty, self.db.value_ty(func.into()), Some(generics(self.db.upcast(), func.into())))
            }
-            None => (receiver_ty, Binders::new(0, Ty::Unknown), None),
+            None => (receiver_ty, Binders::new(0, self.err_ty()), None),
        };
        let substs = self.substs_for_method_call(def_generics, generic_args, &derefed_receiver_ty);
        let method_ty = method_ty.subst(&substs);
@@ -813,15 +845,15 @@ impl<'a> InferenceContext<'a> {
                if !sig.params().is_empty() {
                    (sig.params()[0].clone(), sig.params()[1..].to_vec(), sig.ret().clone())
                } else {
-                    (Ty::Unknown, Vec::new(), sig.ret().clone())
+                    (self.err_ty(), Vec::new(), sig.ret().clone())
                }
            }
-            None => (Ty::Unknown, Vec::new(), Ty::Unknown),
+            None => (self.err_ty(), Vec::new(), self.err_ty()),
        };
        // Apply autoref so the below unification works correctly
        // FIXME: return correct autorefs from lookup_method
        let actual_receiver_ty = match expected_receiver_ty.as_reference() {
-            Some((_, mutability)) => Ty::Ref(mutability, Substs::single(derefed_receiver_ty)),
+            Some((_, mutability)) => TyKind::Ref(mutability, derefed_receiver_ty).intern(&Interner),
            _ => derefed_receiver_ty,
        };
        self.unify(&expected_receiver_ty, &actual_receiver_ty);
@@ -837,7 +869,7 @@ impl<'a> InferenceContext<'a> {
        // that we have more information about the types of arguments when we
        // type-check the functions. This isn't really the right way to do this.
        for &check_closures in &[false, true] {
-            let param_iter = param_tys.iter().cloned().chain(repeat(Ty::Unknown));
+            let param_iter = param_tys.iter().cloned().chain(repeat(self.err_ty()));
            for (&arg, param_ty) in args.iter().zip(param_iter) {
                let is_closure = matches!(&self.body[arg], Expr::Lambda { .. });
                if is_closure != check_closures {
@@ -867,7 +899,7 @@ impl<'a> InferenceContext<'a> {
                if param.provenance == hir_def::generics::TypeParamProvenance::TraitSelf {
                    substs.push(receiver_ty.clone());
                } else {
-                    substs.push(Ty::Unknown);
+                    substs.push(self.err_ty());
                }
            }
        }
@@ -891,14 +923,15 @@ impl<'a> InferenceContext<'a> {
        };