75 files changed, 3138 insertions, 1739 deletions
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/src/lib.rs b/crates/hir/src/lib.rs
index 58adc8fd3..eb1cd66fb 100644
--- a/crates/hir/src/lib.rs
+++ b/crates/hir/src/lib.rs
@@ -51,11 +51,11 @@ 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, 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};
@@ -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
@@ -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,7 +1012,7 @@ pub struct TypeAlias {
 impl TypeAlias {
    pub fn has_non_default_type_params(self, db: &dyn HirDatabase) -> bool {
        let subst = db.generic_defaults(self.id.into());
-        subst.iter().any(|ty| &ty.value == &Ty::Unknown)
+        subst.iter().any(|ty| ty.value.is_unknown())
    }
    pub fn module(self, db: &dyn HirDatabase) -> Module {
@@ -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)
    }
@@ -1499,7 +1499,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 +1563,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 +1586,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(.., substs) => Some(self.derived(substs[0].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 +1685,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 +1717,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 +1745,25 @@ 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 {
+            if ty.is_unknown() {
-                Ty::Unknown => true,
+                true
-                _ => ty.substs().map_or(false, |substs| substs.iter().any(go)),
+            } else {
+                ty.substs().map_or(false, |substs| substs.iter().any(go))
            }
        }
    }
    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 +1778,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()
@@ -1957,33 +1960,33 @@ 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);
                }
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/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 d5ef8ceb5..1b8e885b0 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/Cargo.toml b/crates/hir_expand/Cargo.toml
index 7bb40ba9b..f649ab925 100644
--- a/crates/hir_expand/Cargo.toml
+++ b/crates/hir_expand/Cargo.toml
@@ -25,3 +25,4 @@ mbe = { path = "../mbe", version = "0.0.0" }
 [dev-dependencies]
 test_utils = { path = "../test_utils" }
+expect-test = "1.1"
diff --git a/crates/hir_expand/src/builtin_derive.rs b/crates/hir_expand/src/builtin_derive.rs
index b7f1aae8f..dfdb9cf59 100644
--- a/crates/hir_expand/src/builtin_derive.rs
+++ b/crates/hir_expand/src/builtin_derive.rs
@@ -267,13 +267,14 @@ fn partial_ord_expand(
 #[cfg(test)]
 mod tests {
    use base_db::{fixture::WithFixture, CrateId, SourceDatabase};
+    use expect_test::{expect, Expect};
    use name::{known, Name};
    use crate::{test_db::TestDB, AstId, MacroCallId, MacroCallKind, MacroCallLoc};
    use super::*;
-    fn expand_builtin_derive(s: &str, name: Name) -> String {
+    fn expand_builtin_derive(ra_fixture: &str, name: Name) -> String {
        let expander = BuiltinDeriveExpander::find_by_name(&name).unwrap();
        let fixture = format!(
            r#"//- /main.rs crate:main deps:core
@@ -282,7 +283,7 @@ $0
 //- /lib.rs crate:core
 // empty
 "#,
-            s
+            ra_fixture
        );
        let (db, file_pos) = TestDB::with_position(&fixture);
@@ -314,66 +315,57 @@ $0
        parsed.text().to_string()
    }
+    fn check_derive(ra_fixture: &str, name: Name, expected: Expect) {
+        let expanded = expand_builtin_derive(ra_fixture, name);
+        expected.assert_eq(&expanded);
+    }
    #[test]
    fn test_copy_expand_simple() {
-        let expanded = expand_builtin_derive(
+        check_derive(
            r#"
-        #[derive(Copy)]
+            #[derive(Copy)]
-        struct Foo;
+            struct Foo;
-"#,
+            "#,
            known::Copy,
+            expect![["impl< >core::marker::CopyforFoo< >{}"]],
        );
-        assert_eq!(expanded, "impl< >core::marker::CopyforFoo< >{}");
    }
    #[test]
    fn test_copy_expand_with_type_params() {
-        let expanded = expand_builtin_derive(
+        check_derive(
            r#"
-        #[derive(Copy)]
+            #[derive(Copy)]
-        struct Foo<A, B>;
+            struct Foo<A, B>;
-"#,
+            "#,
            known::Copy,
-        );
+            expect![["impl<T0:core::marker::Copy,T1:core::marker::Copy>core::marker::CopyforFoo<T0,T1>{}"]],
-        assert_eq!(
-            expanded,
-            "impl<T0:core::marker::Copy,T1:core::marker::Copy>core::marker::CopyforFoo<T0,T1>{}"
        );
    }
    #[test]
    fn test_copy_expand_with_lifetimes() {
-        let expanded = expand_builtin_derive(
+        check_derive(
            r#"
-        #[derive(Copy)]
+            #[derive(Copy)]
-        struct Foo<A, B, 'a, 'b>;
+            struct Foo<A, B, 'a, 'b>;
-"#,
+            "#,
            known::Copy,
-        );
+            // We currently just ignore lifetimes
+            expect![["impl<T0:core::marker::Copy,T1:core::marker::Copy>core::marker::CopyforFoo<T0,T1>{}"]],
-        // We currently just ignore lifetimes
-        assert_eq!(
-            expanded,
-            "impl<T0:core::marker::Copy,T1:core::marker::Copy>core::marker::CopyforFoo<T0,T1>{}"
        );
    }
    #[test]
    fn test_clone_expand() {
-        let expanded = expand_builtin_derive(
+        check_derive(
            r#"
-        #[derive(Clone)]
+            #[derive(Clone)]
-        struct Foo<A, B>;
+            struct Foo<A, B>;
-"#,
+            "#,
            known::Clone,
-        );
+            expect![["impl<T0:core::clone::Clone,T1:core::clone::Clone>core::clone::CloneforFoo<T0,T1>{}"]],
-        assert_eq!(
-            expanded,
-            "impl<T0:core::clone::Clone,T1:core::clone::Clone>core::clone::CloneforFoo<T0,T1>{}"
        );
    }
 }
diff --git a/crates/hir_expand/src/builtin_macro.rs b/crates/hir_expand/src/builtin_macro.rs
index b34f1a4f2..2a79c892b 100644
--- a/crates/hir_expand/src/builtin_macro.rs
+++ b/crates/hir_expand/src/builtin_macro.rs
@@ -491,6 +491,7 @@ mod tests {
        MacroCallLoc,
    };
    use base_db::{fixture::WithFixture, SourceDatabase};
+    use expect_test::{expect, Expect};
    use std::sync::Arc;
    use syntax::ast::NameOwner;
@@ -574,87 +575,86 @@ mod tests {
        db.parse_or_expand(file_id).unwrap().to_string()
    }
+    fn check_expansion(ra_fixture: &str, expect: Expect) {
+        let expansion = expand_builtin_macro(ra_fixture);
+        expect.assert_eq(&expansion);
+    }
    #[test]
    fn test_column_expand() {
-        let expanded = expand_builtin_macro(
+        check_expansion(
            r#"
            #[rustc_builtin_macro]
            macro_rules! column {() => {}}
            column!()
            "#,
+            expect![["0"]],
        );
-        assert_eq!(expanded, "0");
    }
    #[test]
    fn test_line_expand() {
-        let expanded = expand_builtin_macro(
+        check_expansion(
            r#"
            #[rustc_builtin_macro]
            macro_rules! line {() => {}}
            line!()
            "#,
+            expect![["0"]],
        );
-        assert_eq!(expanded, "0");
    }
    #[test]
    fn test_stringify_expand() {
-        let expanded = expand_builtin_macro(
+        check_expansion(
            r#"
            #[rustc_builtin_macro]
            macro_rules! stringify {() => {}}
            stringify!(a b c)
            "#,
+            expect![["\"a b c\""]],
        );
-        assert_eq!(expanded, "\"a b c\"");
    }
    #[test]
    fn test_env_expand() {
-        let expanded = expand_builtin_macro(
+        check_expansion(
            r#"
            #[rustc_builtin_macro]
            macro_rules! env {() => {}}
            env!("TEST_ENV_VAR")
            "#,
+            expect![["\"__RA_UNIMPLEMENTED__\""]],
        );
-        assert_eq!(expanded, "\"__RA_UNIMPLEMENTED__\"");
    }
    #[test]
    fn test_option_env_expand() {
-        let expanded = expand_builtin_macro(
+        check_expansion(
            r#"
            #[rustc_builtin_macro]
            macro_rules! option_env {() => {}}
            option_env!("TEST_ENV_VAR")
            "#,
+            expect![["std::option::Option::None:: < &str>"]],
        );
-        assert_eq!(expanded, "std::option::Option::None:: < &str>");
    }
    #[test]
    fn test_file_expand() {
-        let expanded = expand_builtin_macro(
+        check_expansion(
            r#"
            #[rustc_builtin_macro]
            macro_rules! file {() => {}}
            file!()
            "#,
+            expect![[r#""""#]],
        );
-        assert_eq!(expanded, "\"\"");
    }
    #[test]
    fn test_assert_expand() {
-        let expanded = expand_builtin_macro(
+        check_expansion(
            r#"
            #[rustc_builtin_macro]
            macro_rules! assert {
@@ -663,14 +663,13 @@ mod tests {
            }
            assert!(true, "{} {:?}", arg1(a, b, c), arg2);
            "#,
+            expect![["{{(&(true), &(\"{} {:?}\"), &(arg1(a,b,c)), &(arg2),);}}"]],
        );
-        assert_eq!(expanded, "{{(&(true), &(\"{} {:?}\"), &(arg1(a,b,c)), &(arg2),);}}");
    }
    #[test]
    fn test_compile_error_expand() {
-        let expanded = expand_builtin_macro(
+        check_expansion(
            r#"
            #[rustc_builtin_macro]
            macro_rules! compile_error {
@@ -679,15 +678,14 @@ mod tests {
            }
            compile_error!("error!");
            "#,
+            // This expands to nothing (since it's in item position), but emits an error.
+            expect![[""]],
        );
-        // This expands to nothing (since it's in item position), but emits an error.
-        assert_eq!(expanded, "");
    }
    #[test]
    fn test_format_args_expand() {
-        let expanded = expand_builtin_macro(
+        check_expansion(
            r#"
            #[rustc_builtin_macro]
            macro_rules! format_args {
@@ -696,17 +694,15 @@ mod tests {
            }
            format_args!("{} {:?}", arg1(a, b, c), arg2);
            "#,
-        );
+            expect![[
+                r#"std::fmt::Arguments::new_v1(&[], &[std::fmt::ArgumentV1::new(&(arg1(a,b,c)),std::fmt::Display::fmt),std::fmt::ArgumentV1::new(&(arg2),std::fmt::Display::fmt),])"#
-        assert_eq!(
+            ]],
-            expanded,
-            r#"std::fmt::Arguments::new_v1(&[], &[std::fmt::ArgumentV1::new(&(arg1(a,b,c)),std::fmt::Display::fmt),std::fmt::ArgumentV1::new(&(arg2),std::fmt::Display::fmt),])"#
        );
    }
    #[test]
    fn test_format_args_expand_with_comma_exprs() {
-        let expanded = expand_builtin_macro(
+        check_expansion(
            r#"
            #[rustc_builtin_macro]
            macro_rules! format_args {
@@ -715,17 +711,15 @@ mod tests {
            }
            format_args!("{} {:?}", a::<A,B>(), b);
            "#,
-        );
+            expect![[
+                r#"std::fmt::Arguments::new_v1(&[], &[std::fmt::ArgumentV1::new(&(a::<A,B>()),std::fmt::Display::fmt),std::fmt::ArgumentV1::new(&(b),std::fmt::Display::fmt),])"#
-        assert_eq!(
+            ]],
-            expanded,
-            r#"std::fmt::Arguments::new_v1(&[], &[std::fmt::ArgumentV1::new(&(a::<A,B>()),std::fmt::Display::fmt),std::fmt::ArgumentV1::new(&(b),std::fmt::Display::fmt),])"#
        );
    }
    #[test]
    fn test_include_bytes_expand() {
-        let expanded = expand_builtin_macro(
+        check_expansion(
            r#"
            #[rustc_builtin_macro]
            macro_rules! include_bytes {
@@ -734,21 +728,19 @@ mod tests {
            }
            include_bytes("foo");
            "#,
+            expect![[r#"b"""#]],
        );
-        assert_eq!(expanded, r#"b"""#);
    }
    #[test]
    fn test_concat_expand() {
-        let expanded = expand_builtin_macro(
+        check_expansion(
            r##"
            #[rustc_builtin_macro]
            macro_rules! concat {}
            concat!("foo", "r", 0, r#"bar"#, false);
            "##,
+            expect![[r#""foor0barfalse""#]],
        );
-        assert_eq!(expanded, r#""foor0barfalse""#);
    }
 }
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_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..378c951c5 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,32 @@ 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(parameters) => {
                let t = parameters.as_single();
                write!(f, "[")?;
                t.hir_fmt(f)?;
                write!(f, "]")?;
            }
-            Ty::Array(parameters) => {
+            TyKind::Array(parameters) => {
                let t = parameters.as_single();
                write!(f, "[")?;
                t.hir_fmt(f)?;
                write!(f, "; _]")?;
            }
-            Ty::Raw(m, parameters) | Ty::Ref(m, parameters) => {
+            TyKind::Raw(m, parameters) | TyKind::Ref(m, parameters) => {
                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 +313,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 +355,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 +366,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 +409,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 +435,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 +475,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 +493,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 +518,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 +549,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 +558,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 +568,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 +598,7 @@ impl HirDisplay for Ty {
                }
                write!(f, "{{unknown}}")?;
            }
-            Ty::InferenceVar(..) => write!(f, "_")?,
+            TyKind::InferenceVar(..) => write!(f, "_")?,
        }
        Ok(())
    }
@@ -695,7 +711,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 +784,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..fbfedb4e6 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;
@@ -169,7 +170,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(&Ty(TyKind::Unknown))
    }
 }
@@ -177,7 +178,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(&Ty(TyKind::Unknown))
    }
 }
@@ -226,8 +227,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 +240,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 +294,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 +305,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 +384,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 +405,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 +424,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 +433,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 +474,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 +492,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 +512,7 @@ impl<'a> InferenceContext<'a> {
                result
            } else {
                // FIXME diagnostic
-                (Ty::Unknown, None)
+                (TyKind::Unknown.intern(&Interner), None)
            }
        }
@@ -529,7 +541,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,12 +723,12 @@ impl Expectation {
    /// This expresses no expectation on the type.
    fn none() -> Self {
-        Expectation { ty: Ty::Unknown, rvalue_hint: false }
+        Expectation { ty: TyKind::Unknown.intern(&Interner), rvalue_hint: false }
    }
    fn coercion_target(&self) -> &Ty {
        if self.rvalue_hint {
-            &Ty::Unknown
+            &Ty(TyKind::Unknown)
        } else {
            &self.ty
        }
diff --git a/crates/hir_ty/src/infer/coerce.rs b/crates/hir_ty/src/infer/coerce.rs
index 7e8846f27..36670043a 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 (&mut from_ty.0, 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,11 @@ 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[0], &st2[0])
+            }
            // Otherwise, normal unify
            _ => self.unify(&from_ty, to_ty),
diff --git a/crates/hir_ty/src/infer/expr.rs b/crates/hir_ty/src/infer/expr.rs
index 262177ffb..55163c963 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());
@@ -404,8 +420,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 +441,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 +504,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, Substs::single(inner_ty)),
-                    Rawness::Ref => Ty::Ref(mutability, Substs::single(inner_ty)),
+                    Rawness::Ref => TyKind::Ref(mutability, Substs::single(inner_ty)),
                }
+                .intern(&Interner)
            }
            Expr::Box { expr } => {
                let inner_ty = self.infer_expr_inner(*expr, &Expectation::none());
@@ -499,7 +523,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 +543,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 +578,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 +589,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 +601,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 +612,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 +657,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 +682,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.as_single().clone(),
                    _ => self.table.new_type_var(),
                };
@@ -677,43 +703,51 @@ 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(Substs::single(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, Substs::single(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(Substs::single(byte_type)).intern(&Interner);
-                    Ty::Ref(Mutability::Not, Substs::single(array_type))
+                    TyKind::Ref(Mutability::Not, Substs::single(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 +764,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 +772,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;
                        }
                    }
@@ -802,7 +836,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 +847,17 @@ 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, Substs::single(derefed_receiver_ty)).intern(&Interner)
+            }
            _ => derefed_receiver_ty,
        };
        self.unify(&expected_receiver_ty, &actual_receiver_ty);
@@ -837,7 +873,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 +903,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 +927,15 @@ impl<'a> InferenceContext<'a> {
        };
        let supplied_params = substs.len();
        for _ in supplied_params..total_len {
-            substs.push(Ty::Unknown);
+            substs.push(self.err_ty());
        }
        assert_eq!(substs.len(), total_len);
        Substs(substs.into())
    }
    fn register_obligations_for_call(&mut self, callable_ty: &Ty) {
-        if let &Ty::FnDef(def, ref parameters) = callable_ty {
+        if let TyKind::FnDef(fn_def, parameters) = callable_ty.interned(&Interner) {
+            let def: CallableDefId = from_chalk(self.db, *fn_def);
            let generic_predicates = self.db.generic_predicates(def.into());
            for predicate in generic_predicates.iter() {
                let predicate = predicate.clone().subst(parameters);
diff --git a/crates/hir_ty/src/infer/pat.rs b/crates/hir_ty/src/infer/pat.rs
index a0ac8d80f..a16755cda 100644
--- a/crates/hir_ty/src/infer/pat.rs
+++ b/crates/hir_ty/src/infer/pat.rs
@@ -12,7 +12,7 @@ use hir_def::{
 use hir_expand::name::Name;
 use super::{BindingMode, Expectation, InferenceContext};
-use crate::{lower::lower_to_chalk_mutability, utils::variant_data, Substs, Ty};
+use crate::{lower::lower_to_chalk_mutability, utils::variant_data, Interner, Substs, Ty, TyKind};
 impl<'a> InferenceContext<'a> {
    fn infer_tuple_struct_pat(
@@ -46,7 +46,7 @@ impl<'a> InferenceContext<'a> {
            let expected_ty = var_data
                .as_ref()
                .and_then(|d| d.field(&Name::new_tuple_field(i)))
-                .map_or(Ty::Unknown, |field| field_tys[field].clone().subst(&substs));
+                .map_or(self.err_ty(), |field| field_tys[field].clone().subst(&substs));
            let expected_ty = self.normalize_associated_types_in(expected_ty);
            self.infer_pat(subpat, &expected_ty, default_bm);
        }
@@ -80,8 +80,8 @@ impl<'a> InferenceContext<'a> {
                self.result.record_pat_field_resolutions.insert(subpat.pat, field_def);
            }
-            let expected_ty =
+            let expected_ty = matching_field
-                matching_field.map_or(Ty::Unknown, |field| field_tys[field].clone().subst(&substs));
+                .map_or(self.err_ty(), |field| field_tys[field].clone().subst(&substs));
            let expected_ty = self.normalize_associated_types_in(expected_ty);
            self.infer_pat(subpat.pat, &expected_ty, default_bm);
        }
@@ -129,7 +129,8 @@ impl<'a> InferenceContext<'a> {
                    None => (&args[..], &[][..]),
                };
                let n_uncovered_patterns = expectations.len().saturating_sub(args.len());
-                let mut expectations_iter = expectations.iter().chain(repeat(&Ty::Unknown));
+                let err_ty = self.err_ty();
+                let mut expectations_iter = expectations.iter().chain(repeat(&err_ty));
                let mut infer_pat = |(&pat, ty)| self.infer_pat(pat, ty, default_bm);
                let mut inner_tys = Vec::with_capacity(n_uncovered_patterns + args.len());
@@ -137,7 +138,7 @@ impl<'a> InferenceContext<'a> {
                inner_tys.extend(expectations_iter.by_ref().take(n_uncovered_patterns).cloned());
                inner_tys.extend(post.iter().zip(expectations_iter).map(infer_pat));
-                Ty::Tuple(inner_tys.len(), Substs(inner_tys.into()))
+                TyKind::Tuple(inner_tys.len(), Substs(inner_tys.into())).intern(&Interner)
            }
            Pat::Or(ref pats) => {
                if let Some((first_pat, rest)) = pats.split_first() {
@@ -147,7 +148,7 @@ impl<'a> InferenceContext<'a> {
                    }
                    ty
                } else {
-                    Ty::Unknown
+                    self.err_ty()
                }
            }
            Pat::Ref { pat, mutability } => {
@@ -159,10 +160,10 @@ impl<'a> InferenceContext<'a> {
                        }
                        inner_ty
                    }
-                    _ => &Ty::Unknown,
+                    _ => &Ty(TyKind::Unknown),
                };
                let subty = self.infer_pat(*pat, expectation, default_bm);
-                Ty::Ref(mutability, Substs::single(subty))
+                TyKind::Ref(mutability, Substs::single(subty)).intern(&Interner)
            }
            Pat::TupleStruct { path: p, args: subpats, ellipsis } => self.infer_tuple_struct_pat(
                p.as_ref(),
@@ -178,7 +179,7 @@ impl<'a> InferenceContext<'a> {
            Pat::Path(path) => {
                // FIXME use correct resolver for the surrounding expression
                let resolver = self.resolver.clone();
-                self.infer_path(&resolver, &path, pat.into()).unwrap_or(Ty::Unknown)
+                self.infer_path(&resolver, &path, pat.into()).unwrap_or(self.err_ty())
            }
            Pat::Bind { mode, name: _, subpat } => {
                let mode = if mode == &BindingAnnotation::Unannotated {
@@ -195,7 +196,7 @@ impl<'a> InferenceContext<'a> {
                let bound_ty = match mode {
                    BindingMode::Ref(mutability) => {
-                        Ty::Ref(mutability, Substs::single(inner_ty.clone()))
+                        TyKind::Ref(mutability, Substs::single(inner_ty.clone())).intern(&Interner)
                    }
                    BindingMode::Move => inner_ty.clone(),
                };
@@ -204,17 +205,17 @@ impl<'a> InferenceContext<'a> {
                return inner_ty;
            }
            Pat::Slice { prefix, slice, suffix } => {
-                let (container_ty, elem_ty): (fn(_) -> _, _) = match &expected {
+                let (container_ty, elem_ty): (fn(_) -> _, _) = match expected.interned(&Interner) {
-                    Ty::Array(st) => (Ty::Array, st.as_single().clone()),
+                    TyKind::Array(st) => (TyKind::Array, st.as_single().clone()),
-                    Ty::Slice(st) => (Ty::Slice, st.as_single().clone()),
+                    TyKind::Slice(st) => (TyKind::Slice, st.as_single().clone()),
-                    _ => (Ty::Slice, Ty::Unknown),
+                    _ => (TyKind::Slice, self.err_ty()),
                };
                for pat_id in prefix.iter().chain(suffix) {
                    self.infer_pat(*pat_id, &elem_ty, default_bm);
                }
-                let pat_ty = container_ty(Substs::single(elem_ty));
+                let pat_ty = container_ty(Substs::single(elem_ty)).intern(&Interner);
                if let Some(slice_pat_id) = slice {
                    self.infer_pat(*slice_pat_id, &pat_ty, default_bm);
                }
@@ -232,20 +233,20 @@ impl<'a> InferenceContext<'a> {
                Some(box_adt) => {
                    let inner_expected = match expected.as_adt() {
                        Some((adt, substs)) if adt == box_adt => substs.as_single(),
-                        _ => &Ty::Unknown,
+                        _ => &Ty(TyKind::Unknown),
                    };
                    let inner_ty = self.infer_pat(*inner, inner_expected, default_bm);
                    Ty::adt_ty(box_adt, Substs::single(inner_ty))
                }
-                None => Ty::Unknown,
+                None => self.err_ty(),
            },
            Pat::ConstBlock(expr) => {
                self.infer_expr(*expr, &Expectation::has_type(expected.clone()))
            }
-            Pat::Missing => Ty::Unknown,
+            Pat::Missing => self.err_ty(),
        };
-        // use a new type variable if we got Ty::Unknown here
+        // use a new type variable if we got error type here
        let ty = self.insert_type_vars_shallow(ty);
        if !self.unify(&ty, expected) {
            // FIXME record mismatch, we need to change the type of self.type_mismatches for that
diff --git a/crates/hir_ty/src/infer/path.rs b/crates/hir_ty/src/infer/path.rs
index ae3554bac..af108fb6c 100644
--- a/crates/hir_ty/src/infer/path.rs
+++ b/crates/hir_ty/src/infer/path.rs
@@ -9,7 +9,7 @@ use hir_def::{
 };
 use hir_expand::name::Name;
-use crate::{method_resolution, Substs, Ty, ValueTyDefId};
+use crate::{method_resolution, Interner, Substs, Ty, TyKind, ValueTyDefId};
 use super::{ExprOrPatId, InferenceContext, TraitRef};
@@ -40,7 +40,7 @@ impl<'a> InferenceContext<'a> {
            let ty = self.make_ty(type_ref);
            let remaining_segments_for_ty = path.segments().take(path.segments().len() - 1);
            let ctx = crate::lower::TyLoweringContext::new(self.db, &resolver);
-            let (ty, _) = Ty::from_type_relative_path(&ctx, ty, None, remaining_segments_for_ty);
+            let (ty, _) = ctx.lower_ty_relative_path(ty, None, remaining_segments_for_ty);
            self.resolve_ty_assoc_item(
                ty,
                &path.segments().last().expect("path had at least one segment").name,
@@ -79,7 +79,7 @@ impl<'a> InferenceContext<'a> {
            }
            ValueNs::ImplSelf(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);
                if let Some((AdtId::StructId(struct_id), substs)) = ty.as_adt() {
                    let ty = self.db.value_ty(struct_id.into()).subst(&substs);
@@ -96,7 +96,7 @@ impl<'a> InferenceContext<'a> {
        // self_subst is just for the parent
        let parent_substs = self_subst.unwrap_or_else(Substs::empty);
        let ctx = crate::lower::TyLoweringContext::new(self.db, &self.resolver);
-        let substs = Ty::substs_from_path(&ctx, path, typable, true);
+        let substs = ctx.substs_from_path(path, typable, true);
        let full_substs = Substs::builder(substs.len())
            .use_parent_substs(&parent_substs)
            .fill(substs.0[parent_substs.len()..].iter().cloned())
@@ -126,7 +126,8 @@ impl<'a> InferenceContext<'a> {
                let segment =
                    remaining_segments.last().expect("there should be at least one segment here");
                let ctx = crate::lower::TyLoweringContext::new(self.db, &self.resolver);
-                let trait_ref = TraitRef::from_resolved_path(&ctx, trait_, resolved_segment, None);
+                let trait_ref =
+                    ctx.lower_trait_ref_from_resolved_path(trait_, resolved_segment, None);
                self.resolve_trait_assoc_item(trait_ref, segment, id)
            }
            (def, _) => {
@@ -137,14 +138,13 @@ impl<'a> InferenceContext<'a> {
                let remaining_segments_for_ty =
                    remaining_segments.take(remaining_segments.len() - 1);
                let ctx = crate::lower::TyLoweringContext::new(self.db, &self.resolver);
-                let (ty, _) = Ty::from_partly_resolved_hir_path(
+                let (ty, _) = ctx.lower_partly_resolved_path(
-                    &ctx,
                    def,
                    resolved_segment,
                    remaining_segments_for_ty,
                    true,
                );
-                if let Ty::Unknown = ty {
+                if let TyKind::Unknown = ty.interned(&Interner) {
                    return None;
                }
@@ -209,7 +209,7 @@ impl<'a> InferenceContext<'a> {
        name: &Name,
        id: ExprOrPatId,
    ) -> Option<(ValueNs, Option<Substs>)> {
-        if let Ty::Unknown = ty {
+        if let TyKind::Unknown = ty.interned(&Interner) {
            return None;
        }
diff --git a/crates/hir_ty/src/infer/unify.rs b/crates/hir_ty/src/infer/unify.rs
index 54fcfed10..ebc612ca9 100644
--- a/crates/hir_ty/src/infer/unify.rs
+++ b/crates/hir_ty/src/infer/unify.rs
@@ -7,8 +7,8 @@ use ena::unify::{InPlaceUnificationTable, NoError, UnifyKey, UnifyValue};
 use super::{InferenceContext, Obligation};
 use crate::{
-    BoundVar, Canonical, DebruijnIndex, GenericPredicate, InEnvironment, InferenceVar, Scalar,
+    BoundVar, Canonical, DebruijnIndex, GenericPredicate, InEnvironment, InferenceVar, Interner,
-    Substs, Ty, TypeWalk,
+    Scalar, Substs, Ty, TyKind, TypeWalk,
 };
 impl<'a> InferenceContext<'a> {
@@ -49,8 +49,8 @@ impl<'a, 'b> Canonicalizer<'a, 'b> {
    fn do_canonicalize<T: TypeWalk>(&mut self, t: T, binders: DebruijnIndex) -> T {
        t.fold_binders(
-            &mut |ty, binders| match ty {
+            &mut |ty, binders| match ty.interned(&Interner) {
-                Ty::InferenceVar(var, kind) => {
+                &TyKind::InferenceVar(var, kind) => {
                    let inner = var.to_inner();
                    if self.var_stack.contains(&inner) {
                        // recursive type
@@ -66,7 +66,7 @@ impl<'a, 'b> Canonicalizer<'a, 'b> {
                    } else {
                        let root = self.ctx.table.var_unification_table.find(inner);
                        let position = self.add(InferenceVar::from_inner(root), kind);
-                        Ty::BoundVar(BoundVar::new(binders, position))
+                        TyKind::BoundVar(BoundVar::new(binders, position)).intern(&Interner)
                    }
                }
                _ => ty,
@@ -108,10 +108,10 @@ impl<T> Canonicalized<T> {
    pub(super) fn decanonicalize_ty(&self, mut ty: Ty) -> Ty {
        ty.walk_mut_binders(
            &mut |ty, binders| {
-                if let &mut Ty::BoundVar(bound) = ty {
+                if let &mut TyKind::BoundVar(bound) = &mut ty.0 {
                    if bound.debruijn >= binders {
                        let (v, k) = self.free_vars[bound.index];
-                        *ty = Ty::InferenceVar(v, k);
+                        *ty = TyKind::InferenceVar(v, k).intern(&Interner);
                    }
                }
            },
@@ -142,7 +142,7 @@ impl<T> Canonicalized<T> {
            // eagerly replace projections in the type; we may be getting types
            // e.g. from where clauses where this hasn't happened yet
            let ty = ctx.normalize_associated_types_in(ty.clone().subst_bound_vars(&new_vars));
-            ctx.table.unify(&Ty::InferenceVar(v, k), &ty);
+            ctx.table.unify(&TyKind::InferenceVar(v, k).intern(&Interner), &ty);
        }
    }
 }
@@ -166,7 +166,10 @@ pub(crate) fn unify(tys: &Canonical<(Ty, Ty)>) -> Option<Substs> {
    // (kind of hacky)
    for (i, var) in vars.iter().enumerate() {
        if &*table.resolve_ty_shallow(var) == var {
-            table.unify(var, &Ty::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, i)));
+            table.unify(
+                var,
+                &TyKind::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, i)).intern(&Interner),
+            );
        }
    }
    Some(
@@ -196,11 +199,12 @@ impl TypeVariableTable {
    fn fallback_value(&self, iv: InferenceVar, kind: TyVariableKind) -> Ty {
        match kind {
-            _ if self.inner[iv.to_inner().0 as usize].diverging => Ty::Never,
+            _ if self.inner[iv.to_inner().0 as usize].diverging => TyKind::Never,
-            TyVariableKind::General => Ty::Unknown,
+            TyVariableKind::General => TyKind::Unknown,
-            TyVariableKind::Integer => Ty::Scalar(Scalar::Int(IntTy::I32)),
+            TyVariableKind::Integer => TyKind::Scalar(Scalar::Int(IntTy::I32)),
-            TyVariableKind::Float => Ty::Scalar(Scalar::Float(FloatTy::F64)),
+            TyVariableKind::Float => TyKind::Scalar(Scalar::Float(FloatTy::F64)),
        }
+        .intern(&Interner)
    }
 }
@@ -227,7 +231,7 @@ impl InferenceTable {
        self.type_variable_table.push(TypeVariableData { diverging });
        let key = self.var_unification_table.new_key(TypeVarValue::Unknown);
        assert_eq!(key.0 as usize, self.type_variable_table.inner.len() - 1);
-        Ty::InferenceVar(InferenceVar::from_inner(key), kind)
+        TyKind::InferenceVar(InferenceVar::from_inner(key), kind).intern(&Interner)
    }
    pub(crate) fn new_type_var(&mut self) -> Ty {
@@ -290,12 +294,12 @@ impl InferenceTable {
    }
    pub(super) fn unify_inner_trivial(&mut self, ty1: &Ty, ty2: &Ty, depth: usize) -> bool {
-        match (ty1, ty2) {
+        match (ty1.interned(&Interner), ty2.interned(&Interner)) {
-            (Ty::Unknown, _) | (_, Ty::Unknown) => true,
+            (TyKind::Unknown, _) | (_, TyKind::Unknown) => true,
-            (Ty::Placeholder(p1), Ty::Placeholder(p2)) if *p1 == *p2 => true,
+            (TyKind::Placeholder(p1), TyKind::Placeholder(p2)) if *p1 == *p2 => true,
-            (Ty::Dyn(dyn1), Ty::Dyn(dyn2)) if dyn1.len() == dyn2.len() => {
+            (TyKind::Dyn(dyn1), TyKind::Dyn(dyn2)) if dyn1.len() == dyn2.len() => {
                for (pred1, pred2) in dyn1.iter().zip(dyn2.iter()) {
                    if !self.unify_preds(pred1, pred2, depth + 1) {
                        return false;
@@ -305,16 +309,16 @@ impl InferenceTable {
            }
            (
-                Ty::InferenceVar(tv1, TyVariableKind::General),
+                TyKind::InferenceVar(tv1, TyVariableKind::General),
-                Ty::InferenceVar(tv2, TyVariableKind::General),
+                TyKind::InferenceVar(tv2, TyVariableKind::General),
            )
            | (
-                Ty::InferenceVar(tv1, TyVariableKind::Integer),
+                TyKind::InferenceVar(tv1, TyVariableKind::Integer),
-                Ty::InferenceVar(tv2, TyVariableKind::Integer),
+                TyKind::InferenceVar(tv2, TyVariableKind::Integer),
            )
            | (
-                Ty::InferenceVar(tv1, TyVariableKind::Float),
+                TyKind::InferenceVar(tv1, TyVariableKind::Float),
-                Ty::InferenceVar(tv2, TyVariableKind::Float),
+                TyKind::InferenceVar(tv2, TyVariableKind::Float),
            ) if self.type_variable_table.is_diverging(*tv1)
                == self.type_variable_table.is_diverging(*tv2) =>
            {
@@ -326,24 +330,37 @@ impl InferenceTable {
            // The order of MaybeNeverTypeVar matters here.
            // Unifying MaybeNeverTypeVar and TypeVar will let the latter become MaybeNeverTypeVar.
            // Unifying MaybeNeverTypeVar and other concrete type will let the former become it.
-            (Ty::InferenceVar(tv, TyVariableKind::General), other)
+            (TyKind::InferenceVar(tv, TyVariableKind::General), other)
-            | (other, Ty::InferenceVar(tv, TyVariableKind::General))
+            | (other, TyKind::InferenceVar(tv, TyVariableKind::General))
-            | (Ty::InferenceVar(tv, TyVariableKind::Integer), other @ Ty::Scalar(Scalar::Int(_)))
-            | (other @ Ty::Scalar(Scalar::Int(_)), Ty::InferenceVar(tv, TyVariableKind::Integer))
            | (
-                Ty::InferenceVar(tv, TyVariableKind::Integer),
+                TyKind::InferenceVar(tv, TyVariableKind::Integer),
-                other @ Ty::Scalar(Scalar::Uint(_)),
+                other @ TyKind::Scalar(Scalar::Int(_)),
            )
            | (
-                other @ Ty::Scalar(Scalar::Uint(_)),
+                other @ TyKind::Scalar(Scalar::Int(_)),
-                Ty::InferenceVar(tv, TyVariableKind::Integer),
+                TyKind::InferenceVar(tv, TyVariableKind::Integer),
            )
-            | (Ty::InferenceVar(tv, TyVariableKind::Float), other @ Ty::Scalar(Scalar::Float(_)))
+            | (
-            | (other @ Ty::Scalar(Scalar::Float(_)), Ty::InferenceVar(tv, TyVariableKind::Float)) =>
+                TyKind::InferenceVar(tv, TyVariableKind::Integer),
-            {
+                other @ TyKind::Scalar(Scalar::Uint(_)),
+            )
+            | (
+                other @ TyKind::Scalar(Scalar::Uint(_)),
+                TyKind::InferenceVar(tv, TyVariableKind::Integer),
+            )
+            | (
+                TyKind::InferenceVar(tv, TyVariableKind::Float),
+                other @ TyKind::Scalar(Scalar::Float(_)),
+            )
+            | (
+                other @ TyKind::Scalar(Scalar::Float(_)),
+                TyKind::InferenceVar(tv, TyVariableKind::Float),
+            ) => {
                // the type var is unknown since we tried to resolve it
-                self.var_unification_table
+                self.var_unification_table.union_value(
-                    .union_value(tv.to_inner(), TypeVarValue::Known(other.clone()));
+                    tv.to_inner(),
+                    TypeVarValue::Known(other.clone().intern(&Interner)),
+                );
                true
            }
@@ -364,11 +381,11 @@ impl InferenceTable {
                self.unify_substs(&tr1.substs, &tr2.substs, depth + 1)
            }
            (GenericPredicate::Projection(proj1), GenericPredicate::Projection(proj2))
-                if proj1.projection_ty.associated_ty == proj2.projection_ty.associated_ty =>
+                if proj1.projection_ty.associated_ty_id == proj2.projection_ty.associated_ty_id =>
            {
                self.unify_substs(
-                    &proj1.projection_ty.parameters,
+                    &proj1.projection_ty.substitution,
-                    &proj2.projection_ty.parameters,
+                    &proj2.projection_ty.substitution,
                    depth + 1,
                ) && self.unify_inner(&proj1.ty, &proj2.ty, depth + 1)
            }
@@ -387,8 +404,8 @@ impl InferenceTable {
            if i > 0 {
                cov_mark::hit!(type_var_resolves_to_int_var);
            }
-            match &*ty {
+            match &ty.0 {
-                Ty::InferenceVar(tv, _) => {
+                TyKind::InferenceVar(tv, _) => {
                    let inner = tv.to_inner();
                    match self.var_unification_table.inlined_probe_value(inner).known() {
                        Some(known_ty) => {
@@ -410,8 +427,8 @@ impl InferenceTable {
    /// be resolved as far as possible, i.e. contain no type variables with
    /// known type.
    fn resolve_ty_as_possible_inner(&mut self, tv_stack: &mut Vec<TypeVarId>, ty: Ty) -> Ty {
-        ty.fold(&mut |ty| match ty {
+        ty.fold(&mut |ty| match ty.interned(&Interner) {
-            Ty::InferenceVar(tv, kind) => {
+            &TyKind::InferenceVar(tv, kind) => {
                let inner = tv.to_inner();
                if tv_stack.contains(&inner) {
                    cov_mark::hit!(type_var_cycles_resolve_as_possible);
@@ -435,10 +452,10 @@ impl InferenceTable {
    }
    /// Resolves the type completely; type variables without known type are
-    /// replaced by Ty::Unknown.
+    /// replaced by TyKind::Unknown.
    fn resolve_ty_completely_inner(&mut self, tv_stack: &mut Vec<TypeVarId>, ty: Ty) -> Ty {
-        ty.fold(&mut |ty| match ty {
+        ty.fold(&mut |ty| match ty.interned(&Interner) {
-            Ty::InferenceVar(tv, kind) => {
+            &TyKind::InferenceVar(tv, kind) => {
                let inner = tv.to_inner();
                if tv_stack.contains(&inner) {
                    cov_mark::hit!(type_var_cycles_resolve_completely);
diff --git a/crates/hir_ty/src/lib.rs b/crates/hir_ty/src/lib.rs
index e77f24e4e..484652073 100644
--- a/crates/hir_ty/src/lib.rs
+++ b/crates/hir_ty/src/lib.rs
@@ -27,9 +27,8 @@ use std::{iter, mem, ops::Deref, sync::Arc};
 use base_db::salsa;
 use hir_def::{
-    builtin_type::BuiltinType, expr::ExprId, type_ref::Rawness, AssocContainerId, DefWithBodyId,
+    builtin_type::BuiltinType, expr::ExprId, type_ref::Rawness, AssocContainerId, FunctionId,
-    FunctionId, GenericDefId, HasModule, LifetimeParamId, Lookup, TraitId, TypeAliasId,
+    GenericDefId, HasModule, LifetimeParamId, Lookup, TraitId, TypeAliasId, TypeParamId,
-    TypeParamId,
 };
 use itertools::Itertools;
@@ -47,9 +46,16 @@ pub use lower::{
 };
 pub use traits::{InEnvironment, Obligation, ProjectionPredicate, TraitEnvironment};
-pub use chalk_ir::{AdtId, BoundVar, DebruijnIndex, Mutability, Scalar, TyVariableKind};
+pub use chalk_ir::{AdtId, BoundVar, DebruijnIndex, Mutability, Safety, Scalar, TyVariableKind};
-pub(crate) use crate::traits::chalk::Interner;
+pub use crate::traits::chalk::Interner;
+pub type ForeignDefId = chalk_ir::ForeignDefId<Interner>;
+pub type AssocTypeId = chalk_ir::AssocTypeId<Interner>;
+pub type FnDefId = chalk_ir::FnDefId<Interner>;
+pub type ClosureId = chalk_ir::ClosureId<Interner>;
+pub type OpaqueTyId = chalk_ir::OpaqueTyId<Interner>;
+pub type PlaceholderIndex = chalk_ir::PlaceholderIndex;
 #[derive(Clone, PartialEq, Eq, Debug, Hash)]
 pub enum Lifetime {
@@ -60,7 +66,7 @@ pub enum Lifetime {
 #[derive(Clone, PartialEq, Eq, Debug, Hash)]
 pub struct OpaqueTy {
    pub opaque_ty_id: OpaqueTyId,
-    pub parameters: Substs,
+    pub substitution: Substs,
 }
 /// A "projection" type corresponds to an (unnormalized)
@@ -68,17 +74,17 @@ pub struct OpaqueTy {
 /// trait and all its parameters are fully known.
 #[derive(Clone, PartialEq, Eq, Debug, Hash)]
 pub struct ProjectionTy {
-    pub associated_ty: TypeAliasId,
+    pub associated_ty_id: AssocTypeId,
-    pub parameters: Substs,
+    pub substitution: Substs,
 }
 impl ProjectionTy {
    pub fn trait_ref(&self, db: &dyn HirDatabase) -> TraitRef {
-        TraitRef { trait_: self.trait_(db), substs: self.parameters.clone() }
+        TraitRef { trait_: self.trait_(db), substs: self.substitution.clone() }
    }
    fn trait_(&self, db: &dyn HirDatabase) -> TraitId {
-        match self.associated_ty.lookup(db.upcast()).container {
+        match from_assoc_type_id(self.associated_ty_id).lookup(db.upcast()).container {
            AssocContainerId::TraitId(it) => it,
            _ => panic!("projection ty without parent trait"),
        }
@@ -87,7 +93,7 @@ impl ProjectionTy {
 impl TypeWalk for ProjectionTy {
    fn walk(&self, f: &mut impl FnMut(&Ty)) {
-        self.parameters.walk(f);
+        self.substitution.walk(f);
    }
    fn walk_mut_binders(
@@ -95,14 +101,11 @@ impl TypeWalk for ProjectionTy {
        f: &mut impl FnMut(&mut Ty, DebruijnIndex),
        binders: DebruijnIndex,
    ) {
-        self.parameters.walk_mut_binders(f, binders);
+        self.substitution.walk_mut_binders(f, binders);
    }
 }
-#[derive(Clone, Copy, PartialEq, Eq, Debug, Hash)]
+pub type FnSig = chalk_ir::FnSig<Interner>;
-pub struct FnSig {
-    pub variadic: bool,
-}
 #[derive(Clone, PartialEq, Eq, Debug, Hash)]
 pub struct FnPointer {
@@ -131,7 +134,7 @@ pub enum AliasTy {
 ///
 /// This should be cheap to clone.
 #[derive(Clone, PartialEq, Eq, Debug, Hash)]
-pub enum Ty {
+pub enum TyKind {
    /// Structures, enumerations and unions.
    Adt(AdtId<Interner>, Substs),
@@ -139,7 +142,7 @@ pub enum Ty {
    /// when we have tried to normalize a projection like `T::Item` but
    /// couldn't find a better representation.  In that case, we generate
    /// an **application type** like `(Iterator::Item)<T>`.
-    AssociatedType(TypeAliasId, Substs),
+    AssociatedType(AssocTypeId, Substs),
    /// a scalar type like `bool` or `u32`
    Scalar(Scalar),
@@ -179,7 +182,7 @@ pub enum Ty {
    /// fn foo() -> i32 { 1 }
    /// let bar = foo; // bar: fn() -> i32 {foo}
    /// ```
-    FnDef(CallableDefId, Substs),
+    FnDef(FnDefId, Substs),
    /// The pointee of a string slice. Written as `str`.
    Str,
@@ -191,10 +194,10 @@ pub enum Ty {
    ///
    /// The closure signature is stored in a `FnPtr` type in the first type
    /// parameter.
-    Closure(DefWithBodyId, ExprId, Substs),
+    Closure(ClosureId, Substs),
    /// Represents a foreign type declared in external blocks.
-    ForeignType(TypeAliasId),
+    ForeignType(ForeignDefId),
    /// A pointer to a function.  Written as `fn() -> i32`.
    ///
@@ -216,7 +219,7 @@ pub enum Ty {
    /// {}` when we're type-checking the body of that function. In this
    /// situation, we know this stands for *some* type, but don't know the exact
    /// type.
-    Placeholder(TypeParamId),
+    Placeholder(PlaceholderIndex),
    /// A bound type variable. This is used in various places: when representing
    /// some polymorphic type like the type of function `fn f<T>`, the type
@@ -244,6 +247,21 @@ pub enum Ty {
    Unknown,
 }
+#[derive(Clone, PartialEq, Eq, Debug, Hash)]
+pub struct Ty(TyKind);
+impl TyKind {
+    pub fn intern(self, _interner: &Interner) -> Ty {
+        Ty(self)
+    }
+}
+impl Ty {
+    pub fn interned(&self, _interner: &Interner) -> &TyKind {
+        &self.0
+    }
+}
 /// A list of substitutions for generic parameters.
 #[derive(Clone, PartialEq, Eq, Debug, Hash)]
 pub struct Substs(Arc<[Ty]>);
@@ -291,14 +309,22 @@ impl Substs {
    }
    /// Return Substs that replace each parameter by itself (i.e. `Ty::Param`).
-    pub(crate) fn type_params_for_generics(generic_params: &Generics) -> Substs {
+    pub(crate) fn type_params_for_generics(
-        Substs(generic_params.iter().map(|(id, _)| Ty::Placeholder(id)).collect())
+        db: &dyn HirDatabase,
+        generic_params: &Generics,
+    ) -> Substs {
+        Substs(
+            generic_params
+                .iter()
+                .map(|(id, _)| TyKind::Placeholder(to_placeholder_idx(db, id)).intern(&Interner))
+                .collect(),
+        )
    }
    /// Return Substs that replace each parameter by itself (i.e. `Ty::Param`).
    pub fn type_params(db: &dyn HirDatabase, def: impl Into<GenericDefId>) -> Substs {
        let params = generics(db.upcast(), def.into());
-        Substs::type_params_for_generics(&params)
+        Substs::type_params_for_generics(db, &params)
    }
    /// Return Substs that replace each parameter by a bound variable.
@@ -307,7 +333,7 @@ impl Substs {
            generic_params
                .iter()
                .enumerate()
-                .map(|(idx, _)| Ty::BoundVar(BoundVar::new(debruijn, idx)))
+                .map(|(idx, _)| TyKind::BoundVar(BoundVar::new(debruijn, idx)).intern(&Interner))
                .collect(),
        )
    }
@@ -355,11 +381,14 @@ impl SubstsBuilder {
    }
    pub fn fill_with_bound_vars(self, debruijn: DebruijnIndex, starting_from: usize) -> Self {
-        self.fill((starting_from..).map(|idx| Ty::BoundVar(BoundVar::new(debruijn, idx))))
+        self.fill(
+            (starting_from..)
+                .map(|idx| TyKind::BoundVar(BoundVar::new(debruijn, idx)).intern(&Interner)),
+        )
    }
    pub fn fill_with_unknown(self) -> Self {
-        self.fill(iter::repeat(Ty::Unknown))
+        self.fill(iter::repeat(TyKind::Unknown.intern(&Interner)))
    }
    pub fn fill(mut self, filler: impl Iterator<Item = Ty>) -> Self {
@@ -601,45 +630,52 @@ impl TypeWalk for CallableSig {
 impl Ty {
    pub fn unit() -> Self {
-        Ty::Tuple(0, Substs::empty())
+        TyKind::Tuple(0, Substs::empty()).intern(&Interner)
    }
    pub fn adt_ty(adt: hir_def::AdtId, substs: Substs) -> Ty {
-        Ty::Adt(AdtId(adt), substs)
+        TyKind::Adt(AdtId(adt), substs).intern(&Interner)
    }
    pub fn fn_ptr(sig: CallableSig) -> Self {
-        Ty::Function(FnPointer {
+        TyKind::Function(FnPointer {
            num_args: sig.params().len(),
-            sig: FnSig { variadic: sig.is_varargs },
+            sig: FnSig { abi: (), safety: Safety::Safe, variadic: sig.is_varargs },
            substs: Substs(sig.params_and_return),
        })
+        .intern(&Interner)
    }
    pub fn builtin(builtin: BuiltinType) -> Self {
        match builtin {
-            BuiltinType::Char => Ty::Scalar(Scalar::Char),
+            BuiltinType::Char => TyKind::Scalar(Scalar::Char).intern(&Interner),
-            BuiltinType::Bool => Ty::Scalar(Scalar::Bool),
+            BuiltinType::Bool => TyKind::Scalar(Scalar::Bool).intern(&Interner),
-            BuiltinType::Str => Ty::Str,
+            BuiltinType::Str => TyKind::Str.intern(&Interner),
-            BuiltinType::Int(t) => Ty::Scalar(Scalar::Int(primitive::int_ty_from_builtin(t))),
+            BuiltinType::Int(t) => {
-            BuiltinType::Uint(t) => Ty::Scalar(Scalar::Uint(primitive::uint_ty_from_builtin(t))),
+                TyKind::Scalar(Scalar::Int(primitive::int_ty_from_builtin(t))).intern(&Interner)
-            BuiltinType::Float(t) => Ty::Scalar(Scalar::Float(primitive::float_ty_from_builtin(t))),
+            }
+            BuiltinType::Uint(t) => {
+                TyKind::Scalar(Scalar::Uint(primitive::uint_ty_from_builtin(t))).intern(&Interner)
+            }
+            BuiltinType::Float(t) => {
+                TyKind::Scalar(Scalar::Float(primitive::float_ty_from_builtin(t))).intern(&Interner)
+            }
        }
    }
    pub fn as_reference(&self) -> Option<(&Ty, Mutability)> {
-        match self {
+        match self.interned(&Interner) {
-            Ty::Ref(mutability, parameters) => Some((parameters.as_single(), *mutability)),
+            TyKind::Ref(mutability, parameters) => Some((parameters.as_single(), *mutability)),
            _ => None,
        }
    }
    pub fn as_reference_or_ptr(&self) -> Option<(&Ty, Rawness, Mutability)> {
-        match self {
+        match self.interned(&Interner) {
-            Ty::Ref(mutability, parameters) => {
+            TyKind::Ref(mutability, parameters) => {
                Some((parameters.as_single(), Rawness::Ref, *mutability))
            }
-            Ty::Raw(mutability, parameters) => {
+            TyKind::Raw(mutability, parameters) => {
                Some((parameters.as_single(), Rawness::RawPtr, *mutability))
            }
            _ => None,
@@ -649,7 +685,7 @@ impl Ty {
    pub fn strip_references(&self) -> &Ty {
        let mut t: &Ty = self;
-        while let Ty::Ref(_mutability, parameters) = t {
+        while let TyKind::Ref(_mutability, parameters) = t.interned(&Interner) {
            t = parameters.as_single();
        }
@@ -657,65 +693,71 @@ impl Ty {
    }
    pub fn as_adt(&self) -> Option<(hir_def::AdtId, &Substs)> {
-        match self {
+        match self.interned(&Interner) {
-            Ty::Adt(AdtId(adt), parameters) => Some((*adt, parameters)),
+            TyKind::Adt(AdtId(adt), parameters) => Some((*adt, parameters)),
            _ => None,
        }
    }
    pub fn as_tuple(&self) -> Option<&Substs> {
-        match self {
+        match self.interned(&Interner) {
-            Ty::Tuple(_, substs) => Some(substs),
+            TyKind::Tuple(_, substs) => Some(substs),
            _ => None,
        }
    }
-    pub fn as_generic_def(&self) -> Option<GenericDefId> {
+    pub fn as_generic_def(&self, db: &dyn HirDatabase) -> Option<GenericDefId> {
-        match *self {
+        match *self.interned(&Interner) {
-            Ty::Adt(AdtId(adt), ..) => Some(adt.into()),
+            TyKind::Adt(AdtId(adt), ..) => Some(adt.into()),
-            Ty::FnDef(callable, ..) => Some(callable.into()),
+            TyKind::FnDef(callable, ..) => {
-            Ty::AssociatedType(type_alias, ..) => Some(type_alias.into()),
+                Some(db.lookup_intern_callable_def(callable.into()).into())
-            Ty::ForeignType(type_alias, ..) => Some(type_alias.into()),
+            }
+            TyKind::AssociatedType(type_alias, ..) => Some(from_assoc_type_id(type_alias).into()),
+            TyKind::ForeignType(type_alias, ..) => Some(from_foreign_def_id(type_alias).into()),
            _ => None,
        }
    }
    pub fn is_never(&self) -> bool {
-        matches!(self, Ty::Never)
+        matches!(self.interned(&Interner), TyKind::Never)
    }
    pub fn is_unknown(&self) -> bool {
-        matches!(self, Ty::Unknown)
+        matches!(self.interned(&Interner), TyKind::Unknown)
    }
    pub fn equals_ctor(&self, other: &Ty) -> bool {
-        match (self, other) {
+        match (self.interned(&Interner), other.interned(&Interner)) {
-            (Ty::Adt(adt, ..), Ty::Adt(adt2, ..)) => adt == adt2,
+            (TyKind::Adt(adt, ..), TyKind::Adt(adt2, ..)) => adt == adt2,
-            (Ty::Slice(_), Ty::Slice(_)) | (Ty::Array(_), Ty::Array(_)) => true,
+            (TyKind::Slice(_), TyKind::Slice(_)) | (TyKind::Array(_), TyKind::Array(_)) => true,
-            (Ty::FnDef(def_id, ..), Ty::FnDef(def_id2, ..)) => def_id == def_id2,
+            (TyKind::FnDef(def_id, ..), TyKind::FnDef(def_id2, ..)) => def_id == def_id2,
-            (Ty::OpaqueType(ty_id, ..), Ty::OpaqueType(ty_id2, ..)) => ty_id == ty_id2,
+            (TyKind::OpaqueType(ty_id, ..), TyKind::OpaqueType(ty_id2, ..)) => ty_id == ty_id2,
-            (Ty::AssociatedType(ty_id, ..), Ty::AssociatedType(ty_id2, ..))
+            (TyKind::AssociatedType(ty_id, ..), TyKind::AssociatedType(ty_id2, ..)) => {
-            | (Ty::ForeignType(ty_id, ..), Ty::ForeignType(ty_id2, ..)) => ty_id == ty_id2,
+                ty_id == ty_id2
-            (Ty::Closure(def, expr, _), Ty::Closure(def2, expr2, _)) => {
+            }
-                expr == expr2 && def == def2
+            (TyKind::ForeignType(ty_id, ..), TyKind::ForeignType(ty_id2, ..)) => ty_id == ty_id2,
+            (TyKind::Closure(id1, _), TyKind::Closure(id2, _)) => id1 == id2,
+            (TyKind::Ref(mutability, ..), TyKind::Ref(mutability2, ..))
+            | (TyKind::Raw(mutability, ..), TyKind::Raw(mutability2, ..)) => {
+                mutability == mutability2
            }
-            (Ty::Ref(mutability, ..), Ty::Ref(mutability2, ..))
-            | (Ty::Raw(mutability, ..), Ty::Raw(mutability2, ..)) => mutability == mutability2,
            (
-                Ty::Function(FnPointer { num_args, sig, .. }),
+                TyKind::Function(FnPointer { num_args, sig, .. }),
-                Ty::Function(FnPointer { num_args: num_args2, sig: sig2, .. }),
+                TyKind::Function(FnPointer { num_args: num_args2, sig: sig2, .. }),
            ) => num_args == num_args2 && sig == sig2,
-            (Ty::Tuple(cardinality, _), Ty::Tuple(cardinality2, _)) => cardinality == cardinality2,
+            (TyKind::Tuple(cardinality, _), TyKind::Tuple(cardinality2, _)) => {
-            (Ty::Str, Ty::Str) | (Ty::Never, Ty::Never) => true,
+                cardinality == cardinality2
-            (Ty::Scalar(scalar), Ty::Scalar(scalar2)) => scalar == scalar2,
+            }
+            (TyKind::Str, TyKind::Str) | (TyKind::Never, TyKind::Never) => true,
+            (TyKind::Scalar(scalar), TyKind::Scalar(scalar2)) => scalar == scalar2,
            _ => false,
        }
    }
    /// If this is a `dyn Trait` type, this returns the `Trait` part.
    pub fn dyn_trait_ref(&self) -> Option<&TraitRef> {
-        match self {
+        match self.interned(&Interner) {
-            Ty::Dyn(bounds) => bounds.get(0).and_then(|b| match b {
+            TyKind::Dyn(bounds) => bounds.get(0).and_then(|b| match b {
                GenericPredicate::Implemented(trait_ref) => Some(trait_ref),
                _ => None,
            }),
@@ -729,28 +771,37 @@ impl Ty {
    }
    fn builtin_deref(&self) -> Option<Ty> {
-        match self {
+        match self.interned(&Interner) {
-            Ty::Ref(.., parameters) => Some(Ty::clone(parameters.as_single())),
+            TyKind::Ref(.., parameters) => Some(Ty::clone(parameters.as_single())),
-            Ty::Raw(.., parameters) => Some(Ty::clone(parameters.as_single())),
+            TyKind::Raw(.., parameters) => Some(Ty::clone(parameters.as_single())),
            _ => None,
        }
    }
-    pub fn as_fn_def(&self) -> Option<FunctionId> {
+    pub fn callable_def(&self, db: &dyn HirDatabase) -> Option<CallableDefId> {
-        match self {
+        match self.interned(&Interner) {
-            &Ty::FnDef(CallableDefId::FunctionId(func), ..) => Some(func),
+            &TyKind::FnDef(def, ..) => Some(db.lookup_intern_callable_def(def.into())),
            _ => None,
        }
    }
+    pub fn as_fn_def(&self, db: &dyn HirDatabase) -> Option<FunctionId> {
+        if let Some(CallableDefId::FunctionId(func)) = self.callable_def(db) {
+            Some(func)
+        } else {
+            None
+        }
+    }
    pub fn callable_sig(&self, db: &dyn HirDatabase) -> Option<CallableSig> {
-        match self {
+        match self.interned(&Interner) {
-            Ty::Function(fn_ptr) => Some(CallableSig::from_fn_ptr(fn_ptr)),
+            TyKind::Function(fn_ptr) => Some(CallableSig::from_fn_ptr(fn_ptr)),
-            Ty::FnDef(def, parameters) => {
+            TyKind::FnDef(def, parameters) => {
-                let sig = db.callable_item_signature(*def);
+                let callable_def = db.lookup_intern_callable_def((*def).into());
+                let sig = db.callable_item_signature(callable_def);
                Some(sig.subst(&parameters))
            }
-            Ty::Closure(.., substs) => {
+            TyKind::Closure(.., substs) => {
                let sig_param = &substs[0];
                sig_param.callable_sig(db)
            }
@@ -763,18 +814,18 @@ impl Ty {
    /// `self` is `Option<_>` and the substs contain `u32`, we'll have
    /// `Option<u32>` afterwards.)
    pub fn apply_substs(mut self, new_substs: Substs) -> Ty {
-        match &mut self {
+        match &mut self.0 {
-            Ty::Adt(_, substs)
+            TyKind::Adt(_, substs)
-            | Ty::Slice(substs)
+            | TyKind::Slice(substs)
-            | Ty::Array(substs)
+            | TyKind::Array(substs)
-            | Ty::Raw(_, substs)
+            | TyKind::Raw(_, substs)
-            | Ty::Ref(_, substs)
+            | TyKind::Ref(_, substs)
-            | Ty::FnDef(_, substs)
+            | TyKind::FnDef(_, substs)
-            | Ty::Function(FnPointer { substs, .. })
+            | TyKind::Function(FnPointer { substs, .. })
-            | Ty::Tuple(_, substs)
+            | TyKind::Tuple(_, substs)
-            | Ty::OpaqueType(_, substs)
+            | TyKind::OpaqueType(_, substs)
-            | Ty::AssociatedType(_, substs)
+            | TyKind::AssociatedType(_, substs)
-            | Ty::Closure(.., substs) => {
+            | TyKind::Closure(.., substs) => {
                assert_eq!(substs.len(), new_substs.len());
                *substs = new_substs;
            }
@@ -786,44 +837,44 @@ impl Ty {
    /// Returns the type parameters of this type if it has some (i.e. is an ADT
    /// or function); so if `self` is `Option<u32>`, this returns the `u32`.
    pub fn substs(&self) -> Option<&Substs> {
-        match self {
+        match self.interned(&Interner) {
-            Ty::Adt(_, substs)
+            TyKind::Adt(_, substs)
-            | Ty::Slice(substs)
+            | TyKind::Slice(substs)
-            | Ty::Array(substs)
+            | TyKind::Array(substs)
-            | Ty::Raw(_, substs)
+            | TyKind::Raw(_, substs)
-            | Ty::Ref(_, substs)
+            | TyKind::Ref(_, substs)
-            | Ty::FnDef(_, substs)
+            | TyKind::FnDef(_, substs)
-            | Ty::Function(FnPointer { substs, .. })
+            | TyKind::Function(FnPointer { substs, .. })
-            | Ty::Tuple(_, substs)
+            | TyKind::Tuple(_, substs)
-            | Ty::OpaqueType(_, substs)
+            | TyKind::OpaqueType(_, substs)
-            | Ty::AssociatedType(_, substs)
+            | TyKind::AssociatedType(_, substs)
-            | Ty::Closure(.., substs) => Some(substs),
+            | TyKind::Closure(.., substs) => Some(substs),
            _ => None,
        }
    }
    pub fn substs_mut(&mut self) -> Option<&mut Substs> {
-        match self {
+        match &mut self.0 {
-            Ty::Adt(_, substs)
+            TyKind::Adt(_, substs)
-            | Ty::Slice(substs)
+            | TyKind::Slice(substs)
-            | Ty::Array(substs)
+            | TyKind::Array(substs)
-            | Ty::Raw(_, substs)
+            | TyKind::Raw(_, substs)
-            | Ty::Ref(_, substs)
+            | TyKind::Ref(_, substs)
-            | Ty::FnDef(_, substs)
+            | TyKind::FnDef(_, substs)
-            | Ty::Function(FnPointer { substs, .. })
+            | TyKind::Function(FnPointer { substs, .. })
-            | Ty::Tuple(_, substs)
+            | TyKind::Tuple(_, substs)
-            | Ty::OpaqueType(_, substs)
+            | TyKind::OpaqueType(_, substs)
-            | Ty::AssociatedType(_, substs)
+            | TyKind::AssociatedType(_, substs)
-            | Ty::Closure(.., substs) => Some(substs),
+            | TyKind::Closure(.., substs) => Some(substs),
            _ => None,
        }
    }
    pub fn impl_trait_bounds(&self, db: &dyn HirDatabase) -> Option<Vec<GenericPredicate>> {
-        match self {
+        match self.interned(&Interner) {
-            Ty::OpaqueType(opaque_ty_id, ..) => {
+            TyKind::OpaqueType(opaque_ty_id, ..) => {
-                match opaque_ty_id {
+                match db.lookup_intern_impl_trait_id((*opaque_ty_id).into()) {
-                    OpaqueTyId::AsyncBlockTypeImplTrait(def, _expr) => {
+                    ImplTraitId::AsyncBlockTypeImplTrait(def, _expr) => {
                        let krate = def.module(db.upcast()).krate();
                        if let Some(future_trait) = db
                            .lang_item(krate, "future_trait".into())
@@ -841,32 +892,34 @@ impl Ty {
                            None
                        }
                    }
-                    OpaqueTyId::ReturnTypeImplTrait(..) => None,
+                    ImplTraitId::ReturnTypeImplTrait(..) => None,
                }
            }
-            Ty::Alias(AliasTy::Opaque(opaque_ty)) => {
+            TyKind::Alias(AliasTy::Opaque(opaque_ty)) => {
-                let predicates = match opaque_ty.opaque_ty_id {
+                let predicates = match db.lookup_intern_impl_trait_id(opaque_ty.opaque_ty_id.into())
-                    OpaqueTyId::ReturnTypeImplTrait(func, idx) => {
+                {
+                    ImplTraitId::ReturnTypeImplTrait(func, idx) => {
                        db.return_type_impl_traits(func).map(|it| {
                            let data = (*it)
                                .as_ref()
                                .map(|rpit| rpit.impl_traits[idx as usize].bounds.clone());
-                            data.subst(&opaque_ty.parameters)
+                            data.subst(&opaque_ty.substitution)
                        })
                    }
                    // It always has an parameter for Future::Output type.
-                    OpaqueTyId::AsyncBlockTypeImplTrait(..) => unreachable!(),
+                    ImplTraitId::AsyncBlockTypeImplTrait(..) => unreachable!(),
                };
                predicates.map(|it| it.value)
            }
-            Ty::Placeholder(id) => {
+            TyKind::Placeholder(idx) => {
+                let id = from_placeholder_idx(db, *idx);
                let generic_params = db.generic_params(id.parent);
                let param_data = &generic_params.types[id.local_id];
                match param_data.provenance {
                    hir_def::generics::TypeParamProvenance::ArgumentImplTrait => {
                        let predicates = db
-                            .generic_predicates_for_param(*id)
+                            .generic_predicates_for_param(id)
                            .into_iter()
                            .map(|pred| pred.value.clone())
                            .collect_vec();
@@ -881,15 +934,18 @@ impl Ty {
    }
    pub fn associated_type_parent_trait(&self, db: &dyn HirDatabase) -> Option<TraitId> {
-        match self {
+        match self.interned(&Interner) {
-            Ty::AssociatedType(type_alias_id, ..) => {
+            TyKind::AssociatedType(id, ..) => {
-                match type_alias_id.lookup(db.upcast()).container {
+                match from_assoc_type_id(*id).lookup(db.upcast()).container {
                    AssocContainerId::TraitId(trait_id) => Some(trait_id),
                    _ => None,
                }
            }
-            Ty::Alias(AliasTy::Projection(projection_ty)) => {
+            TyKind::Alias(AliasTy::Projection(projection_ty)) => {
-                match projection_ty.associated_ty.lookup(db.upcast()).container {
+                match from_assoc_type_id(projection_ty.associated_ty_id)
+                    .lookup(db.upcast())
+                    .container
+                {
                    AssocContainerId::TraitId(trait_id) => Some(trait_id),
                    _ => None,
                }
@@ -908,13 +964,13 @@ pub trait TypeWalk {
    }
    /// Walk the type, counting entered binders.
    ///
-    /// `Ty::Bound` variables use DeBruijn indexing, which means that 0 refers
+    /// `TyKind::Bound` variables use DeBruijn indexing, which means that 0 refers
    /// to the innermost binder, 1 to the next, etc.. So when we want to
    /// substitute a certain bound variable, we can't just walk the whole type
    /// and blindly replace each instance of a certain index; when we 'enter'
    /// things that introduce new bound variables, we have to keep track of
    /// that. Currently, the only thing that introduces bound variables on our
-    /// side are `Ty::Dyn` and `Ty::Opaque`, which each introduce a bound
+    /// side are `TyKind::Dyn` and `TyKind::Opaque`, which each introduce a bound
    /// variable for the self type.
    fn walk_mut_binders(
        &mut self,
@@ -932,7 +988,7 @@ pub trait TypeWalk {
    {
        self.walk_mut_binders(
            &mut |ty_mut, binders| {
-                let ty = mem::replace(ty_mut, Ty::Unknown);
+                let ty = mem::replace(ty_mut, Ty(TyKind::Unknown));
                *ty_mut = f(ty, binders);
            },
            binders,
@@ -945,13 +1001,13 @@ pub trait TypeWalk {
        Self: Sized,
    {
        self.walk_mut(&mut |ty_mut| {
-            let ty = mem::replace(ty_mut, Ty::Unknown);
+            let ty = mem::replace(ty_mut, Ty(TyKind::Unknown));
            *ty_mut = f(ty);
        });
        self
    }
-    /// Substitutes `Ty::Bound` vars with the given substitution.
+    /// Substitutes `TyKind::Bound` vars with the given substitution.
    fn subst_bound_vars(self, substs: &Substs) -> Self
    where
        Self: Sized,
@@ -959,14 +1015,14 @@ pub trait TypeWalk {
        self.subst_bound_vars_at_depth(substs, DebruijnIndex::INNERMOST)
    }
-    /// Substitutes `Ty::Bound` vars with the given substitution.
+    /// Substitutes `TyKind::Bound` vars with the given substitution.
    fn subst_bound_vars_at_depth(mut self, substs: &Substs, depth: DebruijnIndex) -> Self
    where
        Self: Sized,
    {
        self.walk_mut_binders(
            &mut |ty, binders| {
-                if let &mut Ty::BoundVar(bound) = ty {
+                if let &mut TyKind::BoundVar(bound) = &mut ty.0 {
                    if bound.debruijn >= binders {
                        *ty = substs.0[bound.index].clone().shift_bound_vars(binders);
                    }
@@ -977,17 +1033,17 @@ pub trait TypeWalk {
        self
    }
-    /// Shifts up debruijn indices of `Ty::Bound` vars by `n`.
+    /// Shifts up debruijn indices of `TyKind::Bound` vars by `n`.
    fn shift_bound_vars(self, n: DebruijnIndex) -> Self
    where
        Self: Sized,
    {
        self.fold_binders(
-            &mut |ty, binders| match ty {
+            &mut |ty, binders| match &ty.0 {
-                Ty::BoundVar(bound) if bound.debruijn >= binders => {
+                TyKind::BoundVar(bound) if bound.debruijn >= binders => {
-                    Ty::BoundVar(bound.shifted_in_from(n))
+                    TyKind::BoundVar(bound.shifted_in_from(n)).intern(&Interner)
                }
-                ty => ty,
+                _ => ty,
            },
            DebruijnIndex::INNERMOST,
        )
@@ -996,18 +1052,18 @@ pub trait TypeWalk {
 impl TypeWalk for Ty {
    fn walk(&self, f: &mut impl FnMut(&Ty)) {
-        match self {
+        match self.interned(&Interner) {
-            Ty::Alias(AliasTy::Projection(p_ty)) => {
+            TyKind::Alias(AliasTy::Projection(p_ty)) => {
-                for t in p_ty.parameters.iter() {
+                for t in p_ty.substitution.iter() {
                    t.walk(f);
                }
            }
-            Ty::Alias(AliasTy::Opaque(o_ty)) => {
+            TyKind::Alias(AliasTy::Opaque(o_ty)) => {
-                for t in o_ty.parameters.iter() {
+                for t in o_ty.substitution.iter() {
                    t.walk(f);
                }
            }
-            Ty::Dyn(predicates) => {
+            TyKind::Dyn(predicates) => {
                for p in predicates.iter() {
                    p.walk(f);
                }
@@ -1028,17 +1084,17 @@ impl TypeWalk for Ty {
        f: &mut impl FnMut(&mut Ty, DebruijnIndex),
        binders: DebruijnIndex,
    ) {
-        match self {
+        match &mut self.0 {
-            Ty::Alias(AliasTy::Projection(p_ty)) => {
+            TyKind::Alias(AliasTy::Projection(p_ty)) => {
-                p_ty.parameters.walk_mut_binders(f, binders);
+                p_ty.substitution.walk_mut_binders(f, binders);
            }
-            Ty::Dyn(predicates) => {
+            TyKind::Dyn(predicates) => {
                for p in make_mut_slice(predicates) {
                    p.walk_mut_binders(f, binders.shifted_in());
                }
            }
-            Ty::Alias(AliasTy::Opaque(o_ty)) => {
+            TyKind::Alias(AliasTy::Opaque(o_ty)) => {
-                o_ty.parameters.walk_mut_binders(f, binders);
+                o_ty.substitution.walk_mut_binders(f, binders);
            }
            _ => {
                if let Some(substs) = self.substs_mut() {
@@ -1068,7 +1124,7 @@ impl<T: TypeWalk> TypeWalk for Vec<T> {
 }
 #[derive(Copy, Clone, PartialEq, Eq, Debug, Hash)]
-pub enum OpaqueTyId {
+pub enum ImplTraitId {
    ReturnTypeImplTrait(hir_def::FunctionId, u16),
    AsyncBlockTypeImplTrait(hir_def::DefWithBodyId, ExprId),
 }
@@ -1082,3 +1138,33 @@ pub struct ReturnTypeImplTraits {
 pub(crate) struct ReturnTypeImplTrait {
    pub(crate) bounds: Binders<Vec<GenericPredicate>>,
 }
+pub fn to_foreign_def_id(id: TypeAliasId) -> ForeignDefId {
+    chalk_ir::ForeignDefId(salsa::InternKey::as_intern_id(&id))
+}
+pub fn from_foreign_def_id(id: ForeignDefId) -> TypeAliasId {
+    salsa::InternKey::from_intern_id(id.0)
+}
+pub fn to_assoc_type_id(id: TypeAliasId) -> AssocTypeId {
+    chalk_ir::AssocTypeId(salsa::InternKey::as_intern_id(&id))
+}
+pub fn from_assoc_type_id(id: AssocTypeId) -> TypeAliasId {
+    salsa::InternKey::from_intern_id(id.0)
+}
+pub fn from_placeholder_idx(db: &dyn HirDatabase, idx: PlaceholderIndex) -> TypeParamId {
+    assert_eq!(idx.ui, chalk_ir::UniverseIndex::ROOT);
+    let interned_id = salsa::InternKey::from_intern_id(salsa::InternId::from(idx.idx));
+    db.lookup_intern_type_param_id(interned_id)
+}
+pub fn to_placeholder_idx(db: &dyn HirDatabase, id: TypeParamId) -> PlaceholderIndex {
+    let interned_id = db.intern_type_param_id(id);
+    PlaceholderIndex {
+        ui: chalk_ir::UniverseIndex::ROOT,
+        idx: salsa::InternKey::as_intern_id(&interned_id).as_usize(),
+    }
+}
diff --git a/crates/hir_ty/src/lower.rs b/crates/hir_ty/src/lower.rs
index 5fa83567b..d026310f4 100644
--- a/crates/hir_ty/src/lower.rs
+++ b/crates/hir_ty/src/lower.rs
@@ -8,7 +8,7 @@
 use std::{iter, sync::Arc};
 use base_db::CrateId;
-use chalk_ir::Mutability;
+use chalk_ir::{cast::Cast, Mutability, Safety};
 use hir_def::{
    adt::StructKind,
    builtin_type::BuiltinType,
@@ -27,13 +27,15 @@ use stdx::impl_from;
 use crate::{
    db::HirDatabase,
+    to_assoc_type_id, to_placeholder_idx,
+    traits::chalk::{Interner, ToChalk},
    utils::{
        all_super_trait_refs, associated_type_by_name_including_super_traits, generics,
        make_mut_slice, variant_data,
    },
    AliasTy, Binders, BoundVar, CallableSig, DebruijnIndex, FnPointer, FnSig, GenericPredicate,
-    OpaqueTy, OpaqueTyId, PolyFnSig, ProjectionPredicate, ProjectionTy, ReturnTypeImplTrait,
+    ImplTraitId, OpaqueTy, PolyFnSig, ProjectionPredicate, ProjectionTy, ReturnTypeImplTrait,
-    ReturnTypeImplTraits, Substs, TraitEnvironment, TraitRef, Ty, TypeWalk,
+    ReturnTypeImplTraits, Substs, TraitEnvironment, TraitRef, Ty, TyKind, TypeWalk,
 };
 #[derive(Debug)]
@@ -138,69 +140,71 @@ pub enum TypeParamLoweringMode {
    Variable,
 }
-impl Ty {
+impl<'a> TyLoweringContext<'a> {
-    pub fn from_hir(ctx: &TyLoweringContext<'_>, type_ref: &TypeRef) -> Self {
+    pub fn lower_ty(&self, type_ref: &TypeRef) -> Ty {
-        Ty::from_hir_ext(ctx, type_ref).0
+        self.lower_ty_ext(type_ref).0
    }
-    pub fn from_hir_ext(ctx: &TyLoweringContext<'_>, type_ref: &TypeRef) -> (Self, Option<TypeNs>) {
+    fn lower_ty_ext(&self, type_ref: &TypeRef) -> (Ty, Option<TypeNs>) {
        let mut res = None;
        let ty = match type_ref {
-            TypeRef::Never => Ty::Never,
+            TypeRef::Never => TyKind::Never.intern(&Interner),
            TypeRef::Tuple(inner) => {
-                let inner_tys: Arc<[Ty]> = inner.iter().map(|tr| Ty::from_hir(ctx, tr)).collect();
+                let inner_tys: Arc<[Ty]> = inner.iter().map(|tr| self.lower_ty(tr)).collect();
-                Ty::Tuple(inner_tys.len(), Substs(inner_tys))
+                TyKind::Tuple(inner_tys.len(), Substs(inner_tys)).intern(&Interner)
            }
            TypeRef::Path(path) => {
-                let (ty, res_) = Ty::from_hir_path(ctx, path);
+                let (ty, res_) = self.lower_path(path);
                res = res_;
                ty
            }
            TypeRef::RawPtr(inner, mutability) => {
-                let inner_ty = Ty::from_hir(ctx, inner);
+                let inner_ty = self.lower_ty(inner);
-                Ty::Raw(lower_to_chalk_mutability(*mutability), Substs::single(inner_ty))
+                TyKind::Raw(lower_to_chalk_mutability(*mutability), Substs::single(inner_ty))
+                    .intern(&Interner)
            }
            TypeRef::Array(inner) => {
-                let inner_ty = Ty::from_hir(ctx, inner);
+                let inner_ty = self.lower_ty(inner);
-                Ty::Array(Substs::single(inner_ty))
+                TyKind::Array(Substs::single(inner_ty)).intern(&Interner)
            }
            TypeRef::Slice(inner) => {
-                let inner_ty = Ty::from_hir(ctx, inner);
+                let inner_ty = self.lower_ty(inner);
-                Ty::Slice(Substs::single(inner_ty))
+                TyKind::Slice(Substs::single(inner_ty)).intern(&Interner)
            }
            TypeRef::Reference(inner, _, mutability) => {
-                let inner_ty = Ty::from_hir(ctx, inner);
+                let inner_ty = self.lower_ty(inner);
-                Ty::Ref(lower_to_chalk_mutability(*mutability), Substs::single(inner_ty))
+                TyKind::Ref(lower_to_chalk_mutability(*mutability), Substs::single(inner_ty))
+                    .intern(&Interner)
            }
-            TypeRef::Placeholder => Ty::Unknown,
+            TypeRef::Placeholder => TyKind::Unknown.intern(&Interner),
            TypeRef::Fn(params, is_varargs) => {
-                let substs = Substs(params.iter().map(|tr| Ty::from_hir(ctx, tr)).collect());
+                let substs = Substs(params.iter().map(|tr| self.lower_ty(tr)).collect());
-                Ty::Function(FnPointer {
+                TyKind::Function(FnPointer {
                    num_args: substs.len() - 1,
-                    sig: FnSig { variadic: *is_varargs },
+                    sig: FnSig { abi: (), safety: Safety::Safe, variadic: *is_varargs },
                    substs,
                })
+                .intern(&Interner)
            }
            TypeRef::DynTrait(bounds) => {
-                let self_ty = Ty::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, 0));
+                let self_ty =
-                let predicates = ctx.with_shifted_in(DebruijnIndex::ONE, |ctx| {
+                    TyKind::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, 0)).intern(&Interner);
-                    bounds
+                let predicates = self.with_shifted_in(DebruijnIndex::ONE, |ctx| {
-                        .iter()
+                    bounds.iter().flat_map(|b| ctx.lower_type_bound(b, self_ty.clone())).collect()
-                        .flat_map(|b| GenericPredicate::from_type_bound(ctx, b, self_ty.clone()))
-                        .collect()
                });
-                Ty::Dyn(predicates)
+                TyKind::Dyn(predicates).intern(&Interner)
            }
            TypeRef::ImplTrait(bounds) => {
-                match ctx.impl_trait_mode {
+                match self.impl_trait_mode {
                    ImplTraitLoweringMode::Opaque => {
-                        let idx = ctx.impl_trait_counter.get();
+                        let idx = self.impl_trait_counter.get();
-                        ctx.impl_trait_counter.set(idx + 1);
+                        self.impl_trait_counter.set(idx + 1);
-                        assert!(idx as usize == ctx.opaque_type_data.borrow().len());
+                        assert!(idx as usize == self.opaque_type_data.borrow().len());
                        // this dance is to make sure the data is in the right
                        // place even if we encounter more opaque types while
                        // lowering the bounds
-                        ctx.opaque_type_data
+                        self.opaque_type_data
                            .borrow_mut()
                            .push(ReturnTypeImplTrait { bounds: Binders::new(1, Vec::new()) });
                        // We don't want to lower the bounds inside the binders
@@ -212,65 +216,70 @@ impl Ty {
                        // other, but separately. So if the `T` refers to a type
                        // parameter of the outer function, it's just one binder
                        // away instead of two.
-                        let actual_opaque_type_data = ctx
+                        let actual_opaque_type_data = self
                            .with_debruijn(DebruijnIndex::INNERMOST, |ctx| {
-                                ReturnTypeImplTrait::from_hir(ctx, &bounds)
+                                ctx.lower_impl_trait(&bounds)
                            });
-                        ctx.opaque_type_data.borrow_mut()[idx as usize] = actual_opaque_type_data;
+                        self.opaque_type_data.borrow_mut()[idx as usize] = actual_opaque_type_data;
-                        let func = match ctx.resolver.generic_def() {
+                        let func = match self.resolver.generic_def() {
                            Some(GenericDefId::FunctionId(f)) => f,
                            _ => panic!("opaque impl trait lowering in non-function"),
                        };
-                        let impl_trait_id = OpaqueTyId::ReturnTypeImplTrait(func, idx);
+                        let impl_trait_id = ImplTraitId::ReturnTypeImplTrait(func, idx);
-                        let generics = generics(ctx.db.upcast(), func.into());
+                        let opaque_ty_id = self.db.intern_impl_trait_id(impl_trait_id).into();
-                        let parameters = Substs::bound_vars(&generics, ctx.in_binders);
+                        let generics = generics(self.db.upcast(), func.into());
-                        Ty::Alias(AliasTy::Opaque(OpaqueTy {
+                        let parameters = Substs::bound_vars(&generics, self.in_binders);
-                            opaque_ty_id: impl_trait_id,
+                        TyKind::Alias(AliasTy::Opaque(OpaqueTy {
-                            parameters,
+                            opaque_ty_id,
+                            substitution: parameters,
                        }))
+                        .intern(&Interner)
                    }
                    ImplTraitLoweringMode::Param => {
-                        let idx = ctx.impl_trait_counter.get();
+                        let idx = self.impl_trait_counter.get();
                        // FIXME we're probably doing something wrong here
-                        ctx.impl_trait_counter.set(idx + count_impl_traits(type_ref) as u16);
+                        self.impl_trait_counter.set(idx + count_impl_traits(type_ref) as u16);
-                        if let Some(def) = ctx.resolver.generic_def() {
+                        if let Some(def) = self.resolver.generic_def() {
-                            let generics = generics(ctx.db.upcast(), def);
+                            let generics = generics(self.db.upcast(), def);
                            let param = generics
                                .iter()
                                .filter(|(_, data)| {
                                    data.provenance == TypeParamProvenance::ArgumentImplTrait
                                })
                                .nth(idx as usize)
-                                .map_or(Ty::Unknown, |(id, _)| Ty::Placeholder(id));
+                                .map_or(TyKind::Unknown, |(id, _)| {
-                            param
+                                    TyKind::Placeholder(to_placeholder_idx(self.db, id))
+                                });
+                            param.intern(&Interner)
                        } else {
-                            Ty::Unknown
+                            TyKind::Unknown.intern(&Interner)
                        }
                    }
                    ImplTraitLoweringMode::Variable => {
-                        let idx = ctx.impl_trait_counter.get();
+                        let idx = self.impl_trait_counter.get();
                        // FIXME we're probably doing something wrong here
-                        ctx.impl_trait_counter.set(idx + count_impl_traits(type_ref) as u16);
+                        self.impl_trait_counter.set(idx + count_impl_traits(type_ref) as u16);
                        let (parent_params, self_params, list_params, _impl_trait_params) =
-                            if let Some(def) = ctx.resolver.generic_def() {
+                            if let Some(def) = self.resolver.generic_def() {
-                                let generics = generics(ctx.db.upcast(), def);
+                                let generics = generics(self.db.upcast(), def);
                                generics.provenance_split()
                            } else {
                                (0, 0, 0, 0)
                            };
-                        Ty::BoundVar(BoundVar::new(
+                        TyKind::BoundVar(BoundVar::new(
-                            ctx.in_binders,
+                            self.in_binders,
                            idx as usize + parent_params + self_params + list_params,
                        ))
+                        .intern(&Interner)
                    }
                    ImplTraitLoweringMode::Disallowed => {
                        // FIXME: report error
-                        Ty::Unknown
+                        TyKind::Unknown.intern(&Interner)
                    }
                }
            }
-            TypeRef::Error => Ty::Unknown,
+            TypeRef::Error => TyKind::Unknown.intern(&Interner),
        };
        (ty, res)
    }
@@ -278,7 +287,7 @@ impl Ty {
    /// This is only for `generic_predicates_for_param`, where we can't just
    /// lower the self types of the predicates since that could lead to cycles.
    /// So we just check here if the `type_ref` resolves to a generic param, and which.
-    fn from_hir_only_param(ctx: &TyLoweringContext<'_>, type_ref: &TypeRef) -> Option<TypeParamId> {
+    fn lower_ty_only_param(&self, type_ref: &TypeRef) -> Option<TypeParamId> {
        let path = match type_ref {
            TypeRef::Path(path) => path,
            _ => return None,
@@ -290,7 +299,7 @@ impl Ty {
            return None;
        }
        let resolution =
-            match ctx.resolver.resolve_path_in_type_ns(ctx.db.upcast(), path.mod_path()) {
+            match self.resolver.resolve_path_in_type_ns(self.db.upcast(), path.mod_path()) {
                Some((it, None)) => it,
                _ => return None,
            };
@@ -301,8 +310,8 @@ impl Ty {
        }
    }
-    pub(crate) fn from_type_relative_path(
+    pub(crate) fn lower_ty_relative_path(
-        ctx: &TyLoweringContext<'_>,
+        &self,
        ty: Ty,
        // We need the original resolution to lower `Self::AssocTy` correctly
        res: Option<TypeNs>,
@@ -311,17 +320,17 @@ impl Ty {
        if remaining_segments.len() == 1 {
            // resolve unselected assoc types
            let segment = remaining_segments.first().unwrap();
-            (Ty::select_associated_type(ctx, res, segment), None)
+            (self.select_associated_type(res, segment), None)
        } else if remaining_segments.len() > 1 {
            // FIXME report error (ambiguous associated type)
-            (Ty::Unknown, None)
+            (TyKind::Unknown.intern(&Interner), None)
        } else {
            (ty, res)
        }
    }
-    pub(crate) fn from_partly_resolved_hir_path(
+    pub(crate) fn lower_partly_resolved_path(
-        ctx: &TyLoweringContext<'_>,
+        &self,
        resolution: TypeNs,
        resolved_segment: PathSegment<'_>,
        remaining_segments: PathSegments<'_>,
@@ -331,103 +340,109 @@ impl Ty {
            TypeNs::TraitId(trait_) => {
                // if this is a bare dyn Trait, we'll directly put the required ^0 for the self type in there
                let self_ty = if remaining_segments.len() == 0 {
-                    Some(Ty::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, 0)))
+                    Some(
+                        TyKind::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, 0))
+                            .intern(&Interner),
+                    )
                } else {
                    None
                };
                let trait_ref =
-                    TraitRef::from_resolved_path(ctx, trait_, resolved_segment, self_ty);
+                    self.lower_trait_ref_from_resolved_path(trait_, resolved_segment, self_ty);
                let ty = if remaining_segments.len() == 1 {
                    let segment = remaining_segments.first().unwrap();
                    let found = associated_type_by_name_including_super_traits(
-                        ctx.db,
+                        self.db,
                        trait_ref,
                        &segment.name,
                    );
                    match found {
                        Some((super_trait_ref, associated_ty)) => {
                            // FIXME handle type parameters on the segment
-                            Ty::Alias(AliasTy::Projection(ProjectionTy {
+                            TyKind::Alias(AliasTy::Projection(ProjectionTy {
-                                associated_ty,
+                                associated_ty_id: to_assoc_type_id(associated_ty),
-                                parameters: super_trait_ref.substs,
+                                substitution: super_trait_ref.substs,
                            }))
+                            .intern(&Interner)
                        }
                        None => {
                            // FIXME: report error (associated type not found)
-                            Ty::Unknown
+                            TyKind::Unknown.intern(&Interner)
                        }
                    }
                } else if remaining_segments.len() > 1 {
                    // FIXME report error (ambiguous associated type)
-                    Ty::Unknown
+                    TyKind::Unknown.intern(&Interner)
                } else {
-                    Ty::Dyn(Arc::new([GenericPredicate::Implemented(trait_ref)]))
+                    TyKind::Dyn(Arc::new([GenericPredicate::Implemented(trait_ref)]))
+                        .intern(&Interner)
                };
                return (ty, None);
            }
            TypeNs::GenericParam(param_id) => {
                let generics = generics(
-                    ctx.db.upcast(),
+                    self.db.upcast(),
-                    ctx.resolver.generic_def().expect("generics in scope"),
+                    self.resolver.generic_def().expect("generics in scope"),
                );
-                match ctx.type_param_mode {
+                match self.type_param_mode {
-                    TypeParamLoweringMode::Placeholder => Ty::Placeholder(param_id),
+                    TypeParamLoweringMode::Placeholder => {
+                        TyKind::Placeholder(to_placeholder_idx(self.db, param_id))
+                    }
                    TypeParamLoweringMode::Variable => {
                        let idx = generics.param_idx(param_id).expect("matching generics");
-                        Ty::BoundVar(BoundVar::new(ctx.in_binders, idx))
+                        TyKind::BoundVar(BoundVar::new(self.in_binders, idx))
                    }
                }
+                .intern(&Interner)
            }
            TypeNs::SelfType(impl_id) => {
-                let generics = generics(ctx.db.upcast(), impl_id.into());
+                let generics = generics(self.db.upcast(), impl_id.into());
-                let substs = match ctx.type_param_mode {
+                let substs = match self.type_param_mode {
                    TypeParamLoweringMode::Placeholder => {
-                        Substs::type_params_for_generics(&generics)
+                        Substs::type_params_for_generics(self.db, &generics)
                    }
                    TypeParamLoweringMode::Variable => {
-                        Substs::bound_vars(&generics, ctx.in_binders)
+                        Substs::bound_vars(&generics, self.in_binders)
                    }
                };
-                ctx.db.impl_self_ty(impl_id).subst(&substs)
+                self.db.impl_self_ty(impl_id).subst(&substs)
            }
            TypeNs::AdtSelfType(adt) => {
-                let generics = generics(ctx.db.upcast(), adt.into());
+                let generics = generics(self.db.upcast(), adt.into());
-                let substs = match ctx.type_param_mode {
+                let substs = match self.type_param_mode {
                    TypeParamLoweringMode::Placeholder => {
-                        Substs::type_params_for_generics(&generics)
+                        Substs::type_params_for_generics(self.db, &generics)
                    }
                    TypeParamLoweringMode::Variable => {
-                        Substs::bound_vars(&generics, ctx.in_binders)
+                        Substs::bound_vars(&generics, self.in_binders)
                    }
                };
-                ctx.db.ty(adt.into()).subst(&substs)
+                self.db.ty(adt.into()).subst(&substs)
            }
-            TypeNs::AdtId(it) => {
+            TypeNs::AdtId(it) => self.lower_path_inner(resolved_segment, it.into(), infer_args),
-                Ty::from_hir_path_inner(ctx, resolved_segment, it.into(), infer_args)
-            }
            TypeNs::BuiltinType(it) => {
-                Ty::from_hir_path_inner(ctx, resolved_segment, it.into(), infer_args)
+                self.lower_path_inner(resolved_segment, it.into(), infer_args)
            }
            TypeNs::TypeAliasId(it) => {
-                Ty::from_hir_path_inner(ctx, resolved_segment, it.into(), infer_args)
+                self.lower_path_inner(resolved_segment, it.into(), infer_args)
            }
            // FIXME: report error
-            TypeNs::EnumVariantId(_) => return (Ty::Unknown, None),
+            TypeNs::EnumVariantId(_) => return (TyKind::Unknown.intern(&Interner), None),
        };
-        Ty::from_type_relative_path(ctx, ty, Some(resolution), remaining_segments)
+        self.lower_ty_relative_path(ty, Some(resolution), remaining_segments)
    }
-    pub(crate) fn from_hir_path(ctx: &TyLoweringContext<'_>, path: &Path) -> (Ty, Option<TypeNs>) {
+    pub(crate) fn lower_path(&self, path: &Path) -> (Ty, Option<TypeNs>) {
        // Resolve the path (in type namespace)
        if let Some(type_ref) = path.type_anchor() {
-            let (ty, res) = Ty::from_hir_ext(ctx, &type_ref);
+            let (ty, res) = self.lower_ty_ext(&type_ref);
-            return Ty::from_type_relative_path(ctx, ty, res, path.segments());
+            return self.lower_ty_relative_path(ty, res, path.segments());
        }
        let (resolution, remaining_index) =
-            match ctx.resolver.resolve_path_in_type_ns(ctx.db.upcast(), path.mod_path()) {
+            match self.resolver.resolve_path_in_type_ns(self.db.upcast(), path.mod_path()) {
                Some(it) => it,
-                None => return (Ty::Unknown, None),
+                None => return (TyKind::Unknown.intern(&Interner), None),
            };
        let (resolved_segment, remaining_segments) = match remaining_index {
            None => (
@@ -436,31 +451,23 @@ impl Ty {
            ),
            Some(i) => (path.segments().get(i - 1).unwrap(), path.segments().skip(i)),
        };
-        Ty::from_partly_resolved_hir_path(
+        self.lower_partly_resolved_path(resolution, resolved_segment, remaining_segments, false)
-            ctx,
-            resolution,
-            resolved_segment,
-            remaining_segments,
-            false,
-        )
    }
-    fn select_associated_type(
+    fn select_associated_type(&self, res: Option<TypeNs>, segment: PathSegment<'_>) -> Ty {
-        ctx: &TyLoweringContext<'_>,
-        res: Option<TypeNs>,
-        segment: PathSegment<'_>,
-    ) -> Ty {
        if let Some(res) = res {
-            let ty =
+            let ty = associated_type_shorthand_candidates(
-                associated_type_shorthand_candidates(ctx.db, res, move |name, t, associated_ty| {
+                self.db,
+                res,
+                move |name, t, associated_ty| {
                    if name == segment.name {
-                        let substs = match ctx.type_param_mode {
+                        let substs = match self.type_param_mode {
                            TypeParamLoweringMode::Placeholder => {
                                // if we're lowering to placeholders, we have to put
                                // them in now
                                let s = Substs::type_params(
-                                    ctx.db,
+                                    self.db,
-                                    ctx.resolver.generic_def().expect(
+                                    self.resolver.generic_def().expect(
                                        "there should be generics if there's a generic param",
                                    ),
                                );
@@ -470,25 +477,29 @@ impl Ty {
                        };
                        // We need to shift in the bound vars, since
                        // associated_type_shorthand_candidates does not do that
-                        let substs = substs.shift_bound_vars(ctx.in_binders);
+                        let substs = substs.shift_bound_vars(self.in_binders);
                        // FIXME handle type parameters on the segment
-                        return Some(Ty::Alias(AliasTy::Projection(ProjectionTy {
+                        return Some(
-                            associated_ty,
+                            TyKind::Alias(AliasTy::Projection(ProjectionTy {
-                            parameters: substs,
+                                associated_ty_id: to_assoc_type_id(associated_ty),
-                        })));
+                                substitution: substs,
+                            }))
+                            .intern(&Interner),
+                        );
                    }
                    None
-                });
+                },
+            );
-            ty.unwrap_or(Ty::Unknown)
+            ty.unwrap_or(TyKind::Unknown.intern(&Interner))
        } else {
-            Ty::Unknown
+            TyKind::Unknown.intern(&Interner)
        }
    }
-    fn from_hir_path_inner(
+    fn lower_path_inner(
-        ctx: &TyLoweringContext<'_>,
+        &self,
        segment: PathSegment<'_>,
        typeable: TyDefId,
        infer_args: bool,
@@ -498,14 +509,14 @@ impl Ty {
            TyDefId::AdtId(it) => Some(it.into()),
            TyDefId::TypeAliasId(it) => Some(it.into()),
        };
-        let substs = substs_from_path_segment(ctx, segment, generic_def, infer_args);
+        let substs = self.substs_from_path_segment(segment, generic_def, infer_args);
-        ctx.db.ty(typeable).subst(&substs)
+        self.db.ty(typeable).subst(&substs)
    }
    /// Collect generic arguments from a path into a `Substs`. See also
    /// `create_substs_for_ast_path` and `def_to_ty` in rustc.
    pub(super) fn substs_from_path(
-        ctx: &TyLoweringContext<'_>,
+        &self,
        path: &Path,
        // Note that we don't call `db.value_type(resolved)` here,
        // `ValueTyDefId` is just a convenient way to pass generics and
@@ -535,169 +546,161 @@ impl Ty {
                (segment, Some(var.parent.into()))
            }
        };
-        substs_from_path_segment(ctx, segment, generic_def, infer_args)
+        self.substs_from_path_segment(segment, generic_def, infer_args)
    }
-}
-fn substs_from_path_segment(
+    fn substs_from_path_segment(
-    ctx: &TyLoweringContext<'_>,
+        &self,
-    segment: PathSegment<'_>,
+        segment: PathSegment<'_>,
-    def_generic: Option<GenericDefId>,
+        def_generic: Option<GenericDefId>,
-    infer_args: bool,
+        infer_args: bool,
-) -> Substs {
+    ) -> Substs {
-    let mut substs = Vec::new();
+        let mut substs = Vec::new();
-    let def_generics = def_generic.map(|def| generics(ctx.db.upcast(), def));
+        let def_generics = def_generic.map(|def| generics(self.db.upcast(), def));
-    let (parent_params, self_params, type_params, impl_trait_params) =
+        let (parent_params, self_params, type_params, impl_trait_params) =
-        def_generics.map_or((0, 0, 0, 0), |g| g.provenance_split());
+            def_generics.map_or((0, 0, 0, 0), |g| g.provenance_split());
-    let total_len = parent_params + self_params + type_params + impl_trait_params;
+        let total_len = parent_params + self_params + type_params + impl_trait_params;
-    substs.extend(iter::repeat(Ty::Unknown).take(parent_params));
+        substs.extend(iter::repeat(TyKind::Unknown.intern(&Interner)).take(parent_params));
-    let mut had_explicit_type_args = false;
+        let mut had_explicit_type_args = false;
-    if let Some(generic_args) = &segment.args_and_bindings {
+        if let Some(generic_args) = &segment.args_and_bindings {
-        if !generic_args.has_self_type {
+            if !generic_args.has_self_type {
-            substs.extend(iter::repeat(Ty::Unknown).take(self_params));
+                substs.extend(iter::repeat(TyKind::Unknown.intern(&Interner)).take(self_params));
-        }
+            }
-        let expected_num =
+            let expected_num =
-            if generic_args.has_self_type { self_params + type_params } else { type_params };
+                if generic_args.has_self_type { self_params + type_params } else { type_params };
-        let skip = if generic_args.has_self_type && self_params == 0 { 1 } else { 0 };
+            let skip = if generic_args.has_self_type && self_params == 0 { 1 } else { 0 };
-        // if args are provided, it should be all of them, but we can't rely on that
+            // if args are provided, it should be all of them, but we can't rely on that
-        for arg in generic_args
+            for arg in generic_args
-            .args
+                .args
-            .iter()
+                .iter()
-            .filter(|arg| matches!(arg, GenericArg::Type(_)))
+                .filter(|arg| matches!(arg, GenericArg::Type(_)))
-            .skip(skip)
+                .skip(skip)
-            .take(expected_num)
+                .take(expected_num)
-        {
+            {
-            match arg {
+                match arg {
-                GenericArg::Type(type_ref) => {
+                    GenericArg::Type(type_ref) => {
-                    had_explicit_type_args = true;
+                        had_explicit_type_args = true;
-                    let ty = Ty::from_hir(ctx, type_ref);
+                        let ty = self.lower_ty(type_ref);
-                    substs.push(ty);
+                        substs.push(ty);
+                    }
+                    GenericArg::Lifetime(_) => {}
                }
-                GenericArg::Lifetime(_) => {}
            }
        }
-    }
-    // handle defaults. In expression or pattern path segments without
+        // handle defaults. In expression or pattern path segments without
-    // explicitly specified type arguments, missing type arguments are inferred
+        // explicitly specified type arguments, missing type arguments are inferred
-    // (i.e. defaults aren't used).
+        // (i.e. defaults aren't used).
-    if !infer_args || had_explicit_type_args {
+        if !infer_args || had_explicit_type_args {
-        if let Some(def_generic) = def_generic {
+            if let Some(def_generic) = def_generic {
-            let defaults = ctx.db.generic_defaults(def_generic);
+                let defaults = self.db.generic_defaults(def_generic);
-            assert_eq!(total_len, defaults.len());
+                assert_eq!(total_len, defaults.len());
-            for default_ty in defaults.iter().skip(substs.len()) {
+                for default_ty in defaults.iter().skip(substs.len()) {
-                // each default can depend on the previous parameters
+                    // each default can depend on the previous parameters
-                let substs_so_far = Substs(substs.clone().into());
+                    let substs_so_far = Substs(substs.clone().into());
-                substs.push(default_ty.clone().subst(&substs_so_far));
+                    substs.push(default_ty.clone().subst(&substs_so_far));
+                }
            }
        }
-    }
-    // add placeholders for args that were not provided
+        // add placeholders for args that were not provided
-    // FIXME: emit diagnostics in contexts where this is not allowed
+        // FIXME: emit diagnostics in contexts where this is not allowed
-    for _ in substs.len()..total_len {
+        for _ in substs.len()..total_len {
-        substs.push(Ty::Unknown);
+            substs.push(TyKind::Unknown.intern(&Interner));
-    }
+        }
-    assert_eq!(substs.len(), total_len);
+        assert_eq!(substs.len(), total_len);
-    Substs(substs.into())
+        Substs(substs.into())
-}
+    }
-impl TraitRef {
+    fn lower_trait_ref_from_path(
-    fn from_path(
+        &self,
-        ctx: &TyLoweringContext<'_>,
        path: &Path,
        explicit_self_ty: Option<Ty>,
-    ) -> Option<Self> {
+    ) -> Option<TraitRef> {
        let resolved =
-            match ctx.resolver.resolve_path_in_type_ns_fully(ctx.db.upcast(), path.mod_path())? {
+            match self.resolver.resolve_path_in_type_ns_fully(self.db.upcast(), path.mod_path())? {
                TypeNs::TraitId(tr) => tr,
                _ => return None,
            };
        let segment = path.segments().last().expect("path should have at least one segment");
-        Some(TraitRef::from_resolved_path(ctx, resolved, segment, explicit_self_ty))
+        Some(self.lower_trait_ref_from_resolved_path(resolved, segment, explicit_self_ty))
    }
-    pub(crate) fn from_resolved_path(
+    pub(crate) fn lower_trait_ref_from_resolved_path(
-        ctx: &TyLoweringContext<'_>,
+        &self,
        resolved: TraitId,
        segment: PathSegment<'_>,
        explicit_self_ty: Option<Ty>,
-    ) -> Self {
+    ) -> TraitRef {
-        let mut substs = TraitRef::substs_from_path(ctx, segment, resolved);
+        let mut substs = self.trait_ref_substs_from_path(segment, resolved);
        if let Some(self_ty) = explicit_self_ty {
            make_mut_slice(&mut substs.0)[0] = self_ty;
        }
        TraitRef { trait_: resolved, substs }
    }
-    fn from_hir(
+    fn lower_trait_ref(
-        ctx: &TyLoweringContext<'_>,
+        &self,
        type_ref: &TypeRef,
        explicit_self_ty: Option<Ty>,
-    ) -> Option<Self> {
+    ) -> Option<TraitRef> {
        let path = match type_ref {
            TypeRef::Path(path) => path,
            _ => return None,
        };
-        TraitRef::from_path(ctx, path, explicit_self_ty)
+        self.lower_trait_ref_from_path(path, explicit_self_ty)
    }
-    fn substs_from_path(
+    fn trait_ref_substs_from_path(&self, segment: PathSegment<'_>, resolved: TraitId) -> Substs {
-        ctx: &TyLoweringContext<'_>,
+        self.substs_from_path_segment(segment, Some(resolved.into()), false)
-        segment: PathSegment<'_>,
-        resolved: TraitId,
-    ) -> Substs {
-        substs_from_path_segment(ctx, segment, Some(resolved.into()), false)
    }
-}
-impl GenericPredicate {
+    pub(crate) fn lower_where_predicate(
-    pub(crate) fn from_where_predicate<'a>(
+        &'a self,
-        ctx: &'a TyLoweringContext<'a>,
        where_predicate: &'a WherePredicate,
    ) -> impl Iterator<Item = GenericPredicate> + 'a {
        match where_predicate {
            WherePredicate::ForLifetime { target, bound, .. }
            | WherePredicate::TypeBound { target, bound } => {
                let self_ty = match target {
-                    WherePredicateTypeTarget::TypeRef(type_ref) => Ty::from_hir(ctx, type_ref),
+                    WherePredicateTypeTarget::TypeRef(type_ref) => self.lower_ty(type_ref),
                    WherePredicateTypeTarget::TypeParam(param_id) => {
-                        let generic_def = ctx.resolver.generic_def().expect("generics in scope");
+                        let generic_def = self.resolver.generic_def().expect("generics in scope");
-                        let generics = generics(ctx.db.upcast(), generic_def);
+                        let generics = generics(self.db.upcast(), generic_def);
                        let param_id =
                            hir_def::TypeParamId { parent: generic_def, local_id: *param_id };
-                        match ctx.type_param_mode {
+                        let placeholder = to_placeholder_idx(self.db, param_id);
-                            TypeParamLoweringMode::Placeholder => Ty::Placeholder(param_id),
+                        match self.type_param_mode {
+                            TypeParamLoweringMode::Placeholder => TyKind::Placeholder(placeholder),
                            TypeParamLoweringMode::Variable => {
                                let idx = generics.param_idx(param_id).expect("matching generics");
-                                Ty::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, idx))
+                                TyKind::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, idx))
                            }
                        }
+                        .intern(&Interner)
                    }
                };
-                GenericPredicate::from_type_bound(ctx, bound, self_ty)
+                self.lower_type_bound(bound, self_ty).collect::<Vec<_>>().into_iter()
-                    .collect::<Vec<_>>()
-                    .into_iter()
            }
            WherePredicate::Lifetime { .. } => vec![].into_iter(),
        }
    }
-    pub(crate) fn from_type_bound<'a>(
+    pub(crate) fn lower_type_bound(
-        ctx: &'a TyLoweringContext<'a>,
+        &'a self,
        bound: &'a TypeBound,
        self_ty: Ty,
    ) -> impl Iterator<Item = GenericPredicate> + 'a {
        let mut bindings = None;
        let trait_ref = match bound {
            TypeBound::Path(path) => {
-                bindings = TraitRef::from_path(ctx, path, Some(self_ty));
+                bindings = self.lower_trait_ref_from_path(path, Some(self_ty));
                Some(
                    bindings.clone().map_or(GenericPredicate::Error, GenericPredicate::Implemented),
                )
@@ -708,64 +711,62 @@ impl GenericPredicate {
        trait_ref.into_iter().chain(
            bindings
                .into_iter()
-                .flat_map(move |tr| assoc_type_bindings_from_type_bound(ctx, bound, tr)),
+                .flat_map(move |tr| self.assoc_type_bindings_from_type_bound(bound, tr)),
        )
    }
-}
-fn assoc_type_bindings_from_type_bound<'a>(
+    fn assoc_type_bindings_from_type_bound(
-    ctx: &'a TyLoweringContext<'a>,
+        &'a self,
-    bound: &'a TypeBound,
+        bound: &'a TypeBound,
-    trait_ref: TraitRef,
+        trait_ref: TraitRef,
-) -> impl Iterator<Item = GenericPredicate> + 'a {
+    ) -> impl Iterator<Item = GenericPredicate> + 'a {
-    let last_segment = match bound {
+        let last_segment = match bound {
-        TypeBound::Path(path) => path.segments().last(),
+            TypeBound::Path(path) => path.segments().last(),
-        TypeBound::Error | TypeBound::Lifetime(_) => None,
+            TypeBound::Error | TypeBound::Lifetime(_) => None,
-    };
+        };
-    last_segment
+        last_segment
-        .into_iter()
+            .into_iter()
-        .flat_map(|segment| segment.args_and_bindings.into_iter())
+            .flat_map(|segment| segment.args_and_bindings.into_iter())
-        .flat_map(|args_and_bindings| args_and_bindings.bindings.iter())
+            .flat_map(|args_and_bindings| args_and_bindings.bindings.iter())
-        .flat_map(move |binding| {
+            .flat_map(move |binding| {
-            let found = associated_type_by_name_including_super_traits(
+                let found = associated_type_by_name_including_super_traits(
-                ctx.db,
+                    self.db,
-                trait_ref.clone(),
+                    trait_ref.clone(),
-                &binding.name,
+                    &binding.name,
-            );
+                );
-            let (super_trait_ref, associated_ty) = match found {
+                let (super_trait_ref, associated_ty) = match found {
-                None => return SmallVec::<[GenericPredicate; 1]>::new(),
+                    None => return SmallVec::<[GenericPredicate; 1]>::new(),
-                Some(t) => t,
+                    Some(t) => t,
-            };
+                };
-            let projection_ty = ProjectionTy { associated_ty, parameters: super_trait_ref.substs };
+                let projection_ty = ProjectionTy {
-            let mut preds = SmallVec::with_capacity(
+                    associated_ty_id: to_assoc_type_id(associated_ty),
-                binding.type_ref.as_ref().map_or(0, |_| 1) + binding.bounds.len(),
+                    substitution: super_trait_ref.substs,
-            );
+                };
-            if let Some(type_ref) = &binding.type_ref {
+                let mut preds = SmallVec::with_capacity(
-                let ty = Ty::from_hir(ctx, type_ref);
+                    binding.type_ref.as_ref().map_or(0, |_| 1) + binding.bounds.len(),
-                let projection_predicate =
+                );
-                    ProjectionPredicate { projection_ty: projection_ty.clone(), ty };
+                if let Some(type_ref) = &binding.type_ref {
-                preds.push(GenericPredicate::Projection(projection_predicate));
+                    let ty = self.lower_ty(type_ref);
-            }
+                    let projection_predicate =
-            for bound in &binding.bounds {
+                        ProjectionPredicate { projection_ty: projection_ty.clone(), ty };
-                preds.extend(GenericPredicate::from_type_bound(
+                    preds.push(GenericPredicate::Projection(projection_predicate));
-                    ctx,
+                }
-                    bound,
+                for bound in &binding.bounds {
-                    Ty::Alias(AliasTy::Projection(projection_ty.clone())),
+                    preds.extend(self.lower_type_bound(
-                ));
+                        bound,
-            }
+                        TyKind::Alias(AliasTy::Projection(projection_ty.clone())).intern(&Interner),
-            preds
+                    ));
-        })
+                }
-}
+                preds
+            })
+    }
-impl ReturnTypeImplTrait {
+    fn lower_impl_trait(&self, bounds: &[TypeBound]) -> ReturnTypeImplTrait {
-    fn from_hir(ctx: &TyLoweringContext, bounds: &[TypeBound]) -> Self {
        cov_mark::hit!(lower_rpit);
-        let self_ty = Ty::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, 0));
+        let self_ty =
-        let predicates = ctx.with_shifted_in(DebruijnIndex::ONE, |ctx| {
+            TyKind::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, 0)).intern(&Interner);
-            bounds
+        let predicates = self.with_shifted_in(DebruijnIndex::ONE, |ctx| {
-                .iter()
+            bounds.iter().flat_map(|b| ctx.lower_type_bound(b, self_ty.clone())).collect()
-                .flat_map(|b| GenericPredicate::from_type_bound(ctx, b, self_ty.clone()))
-                .collect()
        });
        ReturnTypeImplTrait { bounds: Binders::new(1, predicates) }
    }
@@ -861,7 +862,7 @@ pub(crate) fn field_types_query(
    let ctx =
        TyLoweringContext::new(db, &resolver).with_type_param_mode(TypeParamLoweringMode::Variable);
    for (field_id, field_data) in var_data.fields().iter() {
-        res.insert(field_id, Binders::new(generics.len(), Ty::from_hir(&ctx, &field_data.type_ref)))
+        res.insert(field_id, Binders::new(generics.len(), ctx.lower_ty(&field_data.type_ref)))
    }
    Arc::new(res)
 }
@@ -889,16 +890,13 @@ pub(crate) fn generic_predicates_for_param_query(
            WherePredicate::ForLifetime { target, .. }
            | WherePredicate::TypeBound { target, .. } => match target {
                WherePredicateTypeTarget::TypeRef(type_ref) => {
-                    Ty::from_hir_only_param(&ctx, type_ref) == Some(param_id)
+                    ctx.lower_ty_only_param(type_ref) == Some(param_id)
                }
                WherePredicateTypeTarget::TypeParam(local_id) => *local_id == param_id.local_id,
            },
            WherePredicate::Lifetime { .. } => false,
        })
-        .flat_map(|pred| {
+        .flat_map(|pred| ctx.lower_where_predicate(pred).map(|p| Binders::new(generics.len(), p)))
-            GenericPredicate::from_where_predicate(&ctx, pred)
-                .map(|p| Binders::new(generics.len(), p))
-        })
        .collect()
 }
@@ -910,41 +908,55 @@ pub(crate) fn generic_predicates_for_param_recover(
    Arc::new([])
 }
-impl TraitEnvironment {
+pub(crate) fn trait_environment_query(
-    pub fn lower(db: &dyn HirDatabase, resolver: &Resolver) -> Arc<TraitEnvironment> {
+    db: &dyn HirDatabase,
-        let ctx = TyLoweringContext::new(db, &resolver)
+    def: GenericDefId,
-            .with_type_param_mode(TypeParamLoweringMode::Placeholder);
+) -> Arc<TraitEnvironment> {
-        let mut predicates = resolver
+    let resolver = def.resolver(db.upcast());
-            .where_predicates_in_scope()
+    let ctx = TyLoweringContext::new(db, &resolver)
-            .flat_map(|pred| GenericPredicate::from_where_predicate(&ctx, pred))
+        .with_type_param_mode(TypeParamLoweringMode::Placeholder);
-            .collect::<Vec<_>>();
+    let mut traits_in_scope = Vec::new();
+    let mut clauses = Vec::new();
-        if let Some(def) = resolver.generic_def() {
+    for pred in resolver.where_predicates_in_scope() {
-            let container: Option<AssocContainerId> = match def {
+        for pred in ctx.lower_where_predicate(pred) {
-                // FIXME: is there a function for this?
+            if pred.is_error() {
-                GenericDefId::FunctionId(f) => Some(f.lookup(db.upcast()).container),
+                continue;
-                GenericDefId::AdtId(_) => None,
-                GenericDefId::TraitId(_) => None,
-                GenericDefId::TypeAliasId(t) => Some(t.lookup(db.upcast()).container),
-                GenericDefId::ImplId(_) => None,
-                GenericDefId::EnumVariantId(_) => None,
-                GenericDefId::ConstId(c) => Some(c.lookup(db.upcast()).container),
-            };
-            if let Some(AssocContainerId::TraitId(trait_id)) = container {
-                // add `Self: Trait<T1, T2, ...>` to the environment in trait
-                // function default implementations (and hypothetical code
-                // inside consts or type aliases)
-                cov_mark::hit!(trait_self_implements_self);
-                let substs = Substs::type_params(db, trait_id);
-                let trait_ref = TraitRef { trait_: trait_id, substs };
-                let pred = GenericPredicate::Implemented(trait_ref);
-                predicates.push(pred);
            }
+            if let GenericPredicate::Implemented(tr) = &pred {
+                traits_in_scope.push((tr.self_ty().clone(), tr.trait_));
+            }
+            let program_clause: chalk_ir::ProgramClause<Interner> =
+                pred.clone().to_chalk(db).cast(&Interner);
+            clauses.push(program_clause.into_from_env_clause(&Interner));
        }
+    }
-        Arc::new(TraitEnvironment { predicates })
+    let container: Option<AssocContainerId> = match def {
+        // FIXME: is there a function for this?
+        GenericDefId::FunctionId(f) => Some(f.lookup(db.upcast()).container),
+        GenericDefId::AdtId(_) => None,
+        GenericDefId::TraitId(_) => None,
+        GenericDefId::TypeAliasId(t) => Some(t.lookup(db.upcast()).container),
+        GenericDefId::ImplId(_) => None,
+        GenericDefId::EnumVariantId(_) => None,
+        GenericDefId::ConstId(c) => Some(c.lookup(db.upcast()).container),
+    };
+    if let Some(AssocContainerId::TraitId(trait_id)) = container {
+        // add `Self: Trait<T1, T2, ...>` to the environment in trait
+        // function default implementations (and hypothetical code
+        // inside consts or type aliases)
+        cov_mark::hit!(trait_self_implements_self);
+        let substs = Substs::type_params(db, trait_id);
+        let trait_ref = TraitRef { trait_: trait_id, substs };
+        let pred = GenericPredicate::Implemented(trait_ref);
+        let program_clause: chalk_ir::ProgramClause<Interner> =
+            pred.clone().to_chalk(db).cast(&Interner);
+        clauses.push(program_clause.into_from_env_clause(&Interner));
    }
+    let env = chalk_ir::Environment::new(&Interner).add_clauses(&Interner, clauses);
+    Arc::new(TraitEnvironment { traits_from_clauses: traits_in_scope, env })
 }
 /// Resolve the where clause(s) of an item with generics.
@@ -958,10 +970,7 @@ pub(crate) fn generic_predicates_query(
    let generics = generics(db.upcast(), def);
    resolver
        .where_predicates_in_scope()
-        .flat_map(|pred| {
+        .flat_map(|pred| ctx.lower_where_predicate(pred).map(|p| Binders::new(generics.len(), p)))
-            GenericPredicate::from_where_predicate(&ctx, pred)
-                .map(|p| Binders::new(generics.len(), p))
-        })
        .collect()
 }
@@ -979,17 +988,18 @@ pub(crate) fn generic_defaults_query(
        .iter()
        .enumerate()
        .map(|(idx, (_, p))| {
-            let mut ty = p.default.as_ref().map_or(Ty::Unknown, |t| Ty::from_hir(&ctx, t));
+            let mut ty =
+                p.default.as_ref().map_or(TyKind::Unknown.intern(&Interner), |t| ctx.lower_ty(t));
            // Each default can only refer to previous parameters.
            ty.walk_mut_binders(
-                &mut |ty, binders| match ty {
+                &mut |ty, binders| match &mut ty.0 {
-                    Ty::BoundVar(BoundVar { debruijn, index }) if *debruijn == binders => {
+                    TyKind::BoundVar(BoundVar { debruijn, index }) if *debruijn == binders => {
                        if *index >= idx {
                            // type variable default referring to parameter coming
                            // after it. This is forbidden (FIXME: report
                            // diagnostic)
-                            *ty = Ty::Unknown;
+                            *ty = TyKind::Unknown.intern(&Interner);
                        }
                    }
                    _ => {}
@@ -1010,11 +1020,11 @@ fn fn_sig_for_fn(db: &dyn HirDatabase, def: FunctionId) -> PolyFnSig {
    let ctx_params = TyLoweringContext::new(db, &resolver)
        .with_impl_trait_mode(ImplTraitLoweringMode::Variable)
        .with_type_param_mode(TypeParamLoweringMode::Variable);
-    let params = data.params.iter().map(|tr| Ty::from_hir(&ctx_params, tr)).collect::<Vec<_>>();
+    let params = data.params.iter().map(|tr| (&ctx_params).lower_ty(tr)).collect::<Vec<_>>();
    let ctx_ret = TyLoweringContext::new(db, &resolver)
        .with_impl_trait_mode(ImplTraitLoweringMode::Opaque)
        .with_type_param_mode(TypeParamLoweringMode::Variable);
-    let ret = Ty::from_hir(&ctx_ret, &data.ret_type);
+    let ret = (&ctx_ret).lower_ty(&data.ret_type);
    let generics = generics(db.upcast(), def.into());
    let num_binders = generics.len();
    Binders::new(num_binders, CallableSig::from_params_and_return(params, ret, data.is_varargs))
@@ -1025,7 +1035,10 @@ fn fn_sig_for_fn(db: &dyn HirDatabase, def: FunctionId) -> PolyFnSig {
 fn type_for_fn(db: &dyn HirDatabase, def: FunctionId) -> Binders<Ty> {
    let generics = generics(db.upcast(), def.into());
    let substs = Substs::bound_vars(&generics, DebruijnIndex::INNERMOST);
-    Binders::new(substs.len(), Ty::FnDef(def.into(), substs))
+    Binders::new(
+        substs.len(),
+        TyKind::FnDef(CallableDefId::FunctionId(def).to_chalk(db), substs).intern(&Interner),
+    )
 }
 /// Build the declared type of a const.
@@ -1036,7 +1049,7 @@ fn type_for_const(db: &dyn HirDatabase, def: ConstId) -> Binders<Ty> {
    let ctx =
        TyLoweringContext::new(db, &resolver).with_type_param_mode(TypeParamLoweringMode::Variable);
-    Binders::new(generics.len(), Ty::from_hir(&ctx, &data.type_ref))
+    Binders::new(generics.len(), ctx.lower_ty(&data.type_ref))
 }
 /// Build the declared type of a static.
@@ -1045,7 +1058,7 @@ fn type_for_static(db: &dyn HirDatabase, def: StaticId) -> Binders<Ty> {
    let resolver = def.resolver(db.upcast());
    let ctx = TyLoweringContext::new(db, &resolver);
-    Binders::new(0, Ty::from_hir(&ctx, &data.type_ref))
+    Binders::new(0, ctx.lower_ty(&data.type_ref))
 }
 fn fn_sig_for_struct_constructor(db: &dyn HirDatabase, def: StructId) -> PolyFnSig {
@@ -1054,8 +1067,7 @@ fn fn_sig_for_struct_constructor(db: &dyn HirDatabase, def: StructId) -> PolyFnS
    let resolver = def.resolver(db.upcast());
    let ctx =
        TyLoweringContext::new(db, &resolver).with_type_param_mode(TypeParamLoweringMode::Variable);
-    let params =
+    let params = fields.iter().map(|(_, field)| ctx.lower_ty(&field.type_ref)).collect::<Vec<_>>();
-        fields.iter().map(|(_, field)| Ty::from_hir(&ctx, &field.type_ref)).collect::<Vec<_>>();
    let ret = type_for_adt(db, def.into());
    Binders::new(ret.num_binders, CallableSig::from_params_and_return(params, ret.value, false))
 }
@@ -1068,7 +1080,10 @@ fn type_for_struct_constructor(db: &dyn HirDatabase, def: StructId) -> Binders<T
    }
    let generics = generics(db.upcast(), def.into());
    let substs = Substs::bound_vars(&generics, DebruijnIndex::INNERMOST);
-    Binders::new(substs.len(), Ty::FnDef(def.into(), substs))
+    Binders::new(
+        substs.len(),
+        TyKind::FnDef(CallableDefId::StructId(def).to_chalk(db), substs).intern(&Interner),
+    )
 }
 fn fn_sig_for_enum_variant_constructor(db: &dyn HirDatabase, def: EnumVariantId) -> PolyFnSig {
@@ -1078,8 +1093,7 @@ fn fn_sig_for_enum_variant_constructor(db: &dyn HirDatabase, def: EnumVariantId)
    let resolver = def.parent.resolver(db.upcast());
    let ctx =
        TyLoweringContext::new(db, &resolver).with_type_param_mode(TypeParamLoweringMode::Variable);
-    let params =
+    let params = fields.iter().map(|(_, field)| ctx.lower_ty(&field.type_ref)).collect::<Vec<_>>();
-        fields.iter().map(|(_, field)| Ty::from_hir(&ctx, &field.type_ref)).collect::<Vec<_>>();
    let ret = type_for_adt(db, def.parent.into());
    Binders::new(ret.num_binders, CallableSig::from_params_and_return(params, ret.value, false))
 }
@@ -1093,7 +1107,10 @@ fn type_for_enum_variant_constructor(db: &dyn HirDatabase, def: EnumVariantId) -
    }
    let generics = generics(db.upcast(), def.parent.into());
    let substs = Substs::bound_vars(&generics, DebruijnIndex::INNERMOST);
-    Binders::new(substs.len(), Ty::FnDef(def.into(), substs))
+    Binders::new(
+        substs.len(),
+        TyKind::FnDef(CallableDefId::EnumVariantId(def).to_chalk(db), substs).intern(&Interner),
+    )
 }
 fn type_for_adt(db: &dyn HirDatabase, adt: AdtId) -> Binders<Ty> {
@@ -1108,11 +1125,11 @@ fn type_for_type_alias(db: &dyn HirDatabase, t: TypeAliasId) -> Binders<Ty> {
    let ctx =
        TyLoweringContext::new(db, &resolver).with_type_param_mode(TypeParamLoweringMode::Variable);
    if db.type_alias_data(t).is_extern {
-        Binders::new(0, Ty::ForeignType(t))
+        Binders::new(0, TyKind::ForeignType(crate::to_foreign_def_id(t)).intern(&Interner))
    } else {
        let substs = Substs::bound_vars(&generics, DebruijnIndex::INNERMOST);
        let type_ref = &db.type_alias_data(t).type_ref;
-        let inner = Ty::from_hir(&ctx, type_ref.as_ref().unwrap_or(&TypeRef::Error));
+        let inner = ctx.lower_ty(type_ref.as_ref().unwrap_or(&TypeRef::Error));
        Binders::new(substs.len(), inner)
    }
 }
@@ -1184,7 +1201,7 @@ pub(crate) fn ty_recover(db: &dyn HirDatabase, _cycle: &[String], def: &TyDefId)
        TyDefId::AdtId(it) => generics(db.upcast(), it.into()).len(),
        TyDefId::TypeAliasId(it) => generics(db.upcast(), it.into()).len(),
    };
-    Binders::new(num_binders, Ty::Unknown)
+    Binders::new(num_binders, TyKind::Unknown.intern(&Interner))
 }
 pub(crate) fn value_ty_query(db: &dyn HirDatabase, def: ValueTyDefId) -> Binders<Ty> {
@@ -1204,7 +1221,7 @@ pub(crate) fn impl_self_ty_query(db: &dyn HirDatabase, impl_id: ImplId) -> Binde
    let generics = generics(db.upcast(), impl_id.into());
    let ctx =
        TyLoweringContext::new(db, &resolver).with_type_param_mode(TypeParamLoweringMode::Variable);
-    Binders::new(generics.len(), Ty::from_hir(&ctx, &impl_data.target_type))
+    Binders::new(generics.len(), ctx.lower_ty(&impl_data.target_type))
 }
 pub(crate) fn const_param_ty_query(db: &dyn HirDatabase, def: ConstParamId) -> Ty {
@@ -1213,7 +1230,7 @@ pub(crate) fn const_param_ty_query(db: &dyn HirDatabase, def: ConstParamId) -> T
    let resolver = def.parent.resolver(db.upcast());
    let ctx = TyLoweringContext::new(db, &resolver);
-    Ty::from_hir(&ctx, &data.ty)
+    ctx.lower_ty(&data.ty)
 }
 pub(crate) fn impl_self_ty_recover(
@@ -1222,7 +1239,7 @@ pub(crate) fn impl_self_ty_recover(
    impl_id: &ImplId,
 ) -> Binders<Ty> {
    let generics = generics(db.upcast(), (*impl_id).into());
-    Binders::new(generics.len(), Ty::Unknown)
+    Binders::new(generics.len(), TyKind::Unknown.intern(&Interner))
 }
 pub(crate) fn impl_trait_query(db: &dyn HirDatabase, impl_id: ImplId) -> Option<Binders<TraitRef>> {
@@ -1232,10 +1249,7 @@ pub(crate) fn impl_trait_query(db: &dyn HirDatabase, impl_id: ImplId) -> Option<
        TyLoweringContext::new(db, &resolver).with_type_param_mode(TypeParamLoweringMode::Variable);
    let self_ty = db.impl_self_ty(impl_id);
    let target_trait = impl_data.target_trait.as_ref()?;
-    Some(Binders::new(
+    Some(Binders::new(self_ty.num_binders, ctx.lower_trait_ref(target_trait, Some(self_ty.value))?))
-        self_ty.num_binders,
-        TraitRef::from_hir(&ctx, target_trait, Some(self_ty.value))?,
-    ))
 }
 pub(crate) fn return_type_impl_traits(
@@ -1248,7 +1262,7 @@ pub(crate) fn return_type_impl_traits(
    let ctx_ret = TyLoweringContext::new(db, &resolver)
        .with_impl_trait_mode(ImplTraitLoweringMode::Opaque)
        .with_type_param_mode(TypeParamLoweringMode::Variable);
-    let _ret = Ty::from_hir(&ctx_ret, &data.ret_type);
+    let _ret = (&ctx_ret).lower_ty(&data.ret_type);
    let generics = generics(db.upcast(), def.into());
    let num_binders = generics.len();
    let return_type_impl_traits =
diff --git a/crates/hir_ty/src/method_resolution.rs b/crates/hir_ty/src/method_resolution.rs
index ccc12c075..c7055bee5 100644
--- a/crates/hir_ty/src/method_resolution.rs
+++ b/crates/hir_ty/src/method_resolution.rs
@@ -9,7 +9,7 @@ use base_db::CrateId;
 use chalk_ir::Mutability;
 use hir_def::{
    lang_item::LangItemTarget, AssocContainerId, AssocItemId, FunctionId, GenericDefId, HasModule,
-    ImplId, Lookup, ModuleId, TraitId, TypeAliasId,
+    ImplId, Lookup, ModuleId, TraitId,
 };
 use hir_expand::name::Name;
 use rustc_hash::{FxHashMap, FxHashSet};
@@ -17,10 +17,11 @@ use rustc_hash::{FxHashMap, FxHashSet};
 use crate::{
    autoderef,
    db::HirDatabase,
+    from_foreign_def_id,
    primitive::{self, FloatTy, IntTy, UintTy},
    utils::all_super_traits,
-    AdtId, Canonical, DebruijnIndex, FnPointer, FnSig, InEnvironment, Scalar, Substs,
+    AdtId, Canonical, DebruijnIndex, FnPointer, FnSig, ForeignDefId, InEnvironment, Interner,
-    TraitEnvironment, TraitRef, Ty, TypeWalk,
+    Scalar, Substs, TraitEnvironment, TraitRef, Ty, TyKind, TypeWalk,
 };
 /// This is used as a key for indexing impls.
@@ -35,7 +36,7 @@ pub enum TyFingerprint {
    Adt(hir_def::AdtId),
    Dyn(TraitId),
    Tuple(usize),
-    ForeignType(TypeAliasId),
+    ForeignType(ForeignDefId),
    FnPtr(usize, FnSig),
 }
@@ -44,18 +45,20 @@ impl TyFingerprint {
    /// have impls: if we have some `struct S`, we can have an `impl S`, but not
    /// `impl &S`. Hence, this will return `None` for reference types and such.
    pub(crate) fn for_impl(ty: &Ty) -> Option<TyFingerprint> {
-        let fp = match ty {
+        let fp = match *ty.interned(&Interner) {
-            &Ty::Str => TyFingerprint::Str,
+            TyKind::Str => TyFingerprint::Str,
-            &Ty::Never => TyFingerprint::Never,
+            TyKind::Never => TyFingerprint::Never,
-            &Ty::Slice(..) => TyFingerprint::Slice,
+            TyKind::Slice(..) => TyFingerprint::Slice,
-            &Ty::Array(..) => TyFingerprint::Array,
+            TyKind::Array(..) => TyFingerprint::Array,
-            &Ty::Scalar(scalar) => TyFingerprint::Scalar(scalar),
+            TyKind::Scalar(scalar) => TyFingerprint::Scalar(scalar),
-            &Ty::Adt(AdtId(adt), _) => TyFingerprint::Adt(adt),
+            TyKind::Adt(AdtId(adt), _) => TyFingerprint::Adt(adt),
-            &Ty::Tuple(cardinality, _) => TyFingerprint::Tuple(cardinality),
+            TyKind::Tuple(cardinality, _) => TyFingerprint::Tuple(cardinality),
-            &Ty::Raw(mutability, ..) => TyFingerprint::RawPtr(mutability),
+            TyKind::Raw(mutability, ..) => TyFingerprint::RawPtr(mutability),
-            &Ty::ForeignType(alias_id, ..) => TyFingerprint::ForeignType(alias_id),
+            TyKind::ForeignType(alias_id, ..) => TyFingerprint::ForeignType(alias_id),
-            &Ty::Function(FnPointer { num_args, sig, .. }) => TyFingerprint::FnPtr(num_args, sig),
+            TyKind::Function(FnPointer { num_args, sig, .. }) => {
-            Ty::Dyn(_) => ty.dyn_trait().map(|trait_| TyFingerprint::Dyn(trait_))?,
+                TyFingerprint::FnPtr(num_args, sig)
+            }
+            TyKind::Dyn(_) => ty.dyn_trait().map(|trait_| TyFingerprint::Dyn(trait_))?,
            _ => return None,
        };
        Some(fp)
@@ -230,31 +233,33 @@ impl Ty {
        let mod_to_crate_ids = |module: ModuleId| Some(std::iter::once(module.krate()).collect());
-        let lang_item_targets = match self {
+        let lang_item_targets = match self.interned(&Interner) {
-            Ty::Adt(AdtId(def_id), _) => {
+            TyKind::Adt(AdtId(def_id), _) => {
                return mod_to_crate_ids(def_id.module(db.upcast()));
            }
-            Ty::ForeignType(type_alias_id) => {
+            TyKind::ForeignType(id) => {
-                return mod_to_crate_ids(type_alias_id.lookup(db.upcast()).module(db.upcast()));
+                return mod_to_crate_ids(
+                    from_foreign_def_id(*id).lookup(db.upcast()).module(db.upcast()),
+                );
            }
-            Ty::Scalar(Scalar::Bool) => lang_item_crate!("bool"),
+            TyKind::Scalar(Scalar::Bool) => lang_item_crate!("bool"),
-            Ty::Scalar(Scalar::Char) => lang_item_crate!("char"),
+            TyKind::Scalar(Scalar::Char) => lang_item_crate!("char"),
-            Ty::Scalar(Scalar::Float(f)) => match f {
+            TyKind::Scalar(Scalar::Float(f)) => match f {
                // There are two lang items: one in libcore (fXX) and one in libstd (fXX_runtime)
                FloatTy::F32 => lang_item_crate!("f32", "f32_runtime"),
                FloatTy::F64 => lang_item_crate!("f64", "f64_runtime"),
            },
-            &Ty::Scalar(Scalar::Int(t)) => {
+            &TyKind::Scalar(Scalar::Int(t)) => {
                lang_item_crate!(primitive::int_ty_to_string(t))
            }
-            &Ty::Scalar(Scalar::Uint(t)) => {
+            &TyKind::Scalar(Scalar::Uint(t)) => {
                lang_item_crate!(primitive::uint_ty_to_string(t))
            }
-            Ty::Str => lang_item_crate!("str_alloc", "str"),
+            TyKind::Str => lang_item_crate!("str_alloc", "str"),
-            Ty::Slice(_) => lang_item_crate!("slice_alloc", "slice"),
+            TyKind::Slice(_) => lang_item_crate!("slice_alloc", "slice"),
-            Ty::Raw(Mutability::Not, _) => lang_item_crate!("const_ptr"),
+            TyKind::Raw(Mutability::Not, _) => lang_item_crate!("const_ptr"),
-            Ty::Raw(Mutability::Mut, _) => lang_item_crate!("mut_ptr"),
+            TyKind::Raw(Mutability::Mut, _) => lang_item_crate!("mut_ptr"),
-            Ty::Dyn(_) => {
+            TyKind::Dyn(_) => {
                return self.dyn_trait().and_then(|trait_| {
                    mod_to_crate_ids(GenericDefId::TraitId(trait_).module(db.upcast()))
                });
@@ -430,7 +435,8 @@ fn iterate_method_candidates_with_autoref(
    }
    let refed = Canonical {
        kinds: deref_chain[0].kinds.clone(),
-        value: Ty::Ref(Mutability::Not, Substs::single(deref_chain[0].value.clone())),
+        value: TyKind::Ref(Mutability::Not, Substs::single(deref_chain[0].value.clone()))
+            .intern(&Interner),
    };
    if iterate_method_candidates_by_receiver(
        &refed,
@@ -446,7 +452,8 @@ fn iterate_method_candidates_with_autoref(
    }
    let ref_muted = Canonical {
        kinds: deref_chain[0].kinds.clone(),
-        value: Ty::Ref(Mutability::Mut, Substs::single(deref_chain[0].value.clone())),
+        value: TyKind::Ref(Mutability::Mut, Substs::single(deref_chain[0].value.clone()))
+            .intern(&Interner),
    };
    if iterate_method_candidates_by_receiver(
        &ref_muted,
@@ -526,10 +533,9 @@ fn iterate_trait_method_candidates(
    // if ty is `dyn Trait`, the trait doesn't need to be in scope
    let inherent_trait =
        self_ty.value.dyn_trait().into_iter().flat_map(|t| all_super_traits(db.upcast(), t));
-    let env_traits = if let Ty::Placeholder(_) = self_ty.value {
+    let env_traits = if let TyKind::Placeholder(_) = self_ty.value.interned(&Interner) {
        // if we have `T: Trait` in the param env, the trait doesn't need to be in scope
-        env.trait_predicates_for_self_ty(&self_ty.value)
+        env.traits_in_scope_from_clauses(&self_ty.value)
-            .map(|tr| tr.trait_)
            .flat_map(|t| all_super_traits(db.upcast(), t))
            .collect()
    } else {
@@ -680,13 +686,13 @@ pub(crate) fn inherent_impl_substs(
 }
 /// This replaces any 'free' Bound vars in `s` (i.e. those with indices past
-/// num_vars_to_keep) by `Ty::Unknown`.
+/// num_vars_to_keep) by `TyKind::Unknown`.
 fn fallback_bound_vars(s: Substs, num_vars_to_keep: usize) -> Substs {
    s.fold_binders(
        &mut |ty, binders| {
-            if let Ty::BoundVar(bound) = &ty {
+            if let TyKind::BoundVar(bound) = ty.interned(&Interner) {
                if bound.index >= num_vars_to_keep && bound.debruijn >= binders {
-                    Ty::Unknown
+                    TyKind::Unknown.intern(&Interner)
                } else {
                    ty
                }
@@ -773,9 +779,11 @@ fn autoderef_method_receiver(
 ) -> Vec<Canonical<Ty>> {
    let mut deref_chain: Vec<_> = autoderef::autoderef(db, Some(krate), ty).collect();
    // As a last step, we can do array unsizing (that's the only unsizing that rustc does for method receivers!)
-    if let Some(Ty::Array(parameters)) = deref_chain.last().map(|ty| &ty.value) {
+    if let Some(TyKind::Array(parameters)) =
+        deref_chain.last().map(|ty| ty.value.interned(&Interner))
+    {
        let kinds = deref_chain.last().unwrap().kinds.clone();
-        let unsized_ty = Ty::Slice(parameters.clone());
+        let unsized_ty = TyKind::Slice(parameters.clone()).intern(&Interner);
        deref_chain.push(Canonical { value: unsized_ty, kinds })
    }
    deref_chain
diff --git a/crates/hir_ty/src/op.rs b/crates/hir_ty/src/op.rs
index bb9b8bbfc..527c5cbbd 100644
--- a/crates/hir_ty/src/op.rs
+++ b/crates/hir_ty/src/op.rs
@@ -2,51 +2,55 @@
 use chalk_ir::TyVariableKind;
 use hir_def::expr::{ArithOp, BinaryOp, CmpOp};
-use crate::{Scalar, Ty};
+use crate::{Interner, Scalar, Ty, TyKind};
 pub(super) fn binary_op_return_ty(op: BinaryOp, lhs_ty: Ty, rhs_ty: Ty) -> Ty {
    match op {
-        BinaryOp::LogicOp(_) | BinaryOp::CmpOp(_) => Ty::Scalar(Scalar::Bool),
+        BinaryOp::LogicOp(_) | BinaryOp::CmpOp(_) => TyKind::Scalar(Scalar::Bool).intern(&Interner),
        BinaryOp::Assignment { .. } => Ty::unit(),
-        BinaryOp::ArithOp(ArithOp::Shl) | BinaryOp::ArithOp(ArithOp::Shr) => match lhs_ty {
+        BinaryOp::ArithOp(ArithOp::Shl) | BinaryOp::ArithOp(ArithOp::Shr) => {
-            Ty::Scalar(Scalar::Int(_))
+            match lhs_ty.interned(&Interner) {
-            | Ty::Scalar(Scalar::Uint(_))
+                TyKind::Scalar(Scalar::Int(_))
-            | Ty::Scalar(Scalar::Float(_)) => lhs_ty,
+                | TyKind::Scalar(Scalar::Uint(_))
-            Ty::InferenceVar(_, TyVariableKind::Integer)
+                | TyKind::Scalar(Scalar::Float(_)) => lhs_ty,
-            | Ty::InferenceVar(_, TyVariableKind::Float) => lhs_ty,
+                TyKind::InferenceVar(_, TyVariableKind::Integer)
-            _ => Ty::Unknown,
+                | TyKind::InferenceVar(_, TyVariableKind::Float) => lhs_ty,
-        },
+                _ => TyKind::Unknown.intern(&Interner),
-        BinaryOp::ArithOp(_) => match rhs_ty {
+            }
-            Ty::Scalar(Scalar::Int(_))
+        }
-            | Ty::Scalar(Scalar::Uint(_))
+        BinaryOp::ArithOp(_) => match rhs_ty.interned(&Interner) {
-            | Ty::Scalar(Scalar::Float(_)) => rhs_ty,
+            TyKind::Scalar(Scalar::Int(_))
-            Ty::InferenceVar(_, TyVariableKind::Integer)
+            | TyKind::Scalar(Scalar::Uint(_))
-            | Ty::InferenceVar(_, TyVariableKind::Float) => rhs_ty,
+            | TyKind::Scalar(Scalar::Float(_)) => rhs_ty,
-            _ => Ty::Unknown,
+            TyKind::InferenceVar(_, TyVariableKind::Integer)
+            | TyKind::InferenceVar(_, TyVariableKind::Float) => rhs_ty,
+            _ => TyKind::Unknown.intern(&Interner),
        },
    }
 }
 pub(super) fn binary_op_rhs_expectation(op: BinaryOp, lhs_ty: Ty) -> Ty {
    match op {
-        BinaryOp::LogicOp(..) => Ty::Scalar(Scalar::Bool),
+        BinaryOp::LogicOp(..) => TyKind::Scalar(Scalar::Bool).intern(&Interner),
        BinaryOp::Assignment { op: None } => lhs_ty,
-        BinaryOp::CmpOp(CmpOp::Eq { .. }) => match lhs_ty {
+        BinaryOp::CmpOp(CmpOp::Eq { .. }) => match lhs_ty.interned(&Interner) {
-            Ty::Scalar(_) | Ty::Str => lhs_ty,
+            TyKind::Scalar(_) | TyKind::Str => lhs_ty,
-            Ty::InferenceVar(_, TyVariableKind::Integer)
+            TyKind::InferenceVar(_, TyVariableKind::Integer)
-            | Ty::InferenceVar(_, TyVariableKind::Float) => lhs_ty,
+            | TyKind::InferenceVar(_, TyVariableKind::Float) => lhs_ty,
-            _ => Ty::Unknown,
+            _ => TyKind::Unknown.intern(&Interner),
        },
-        BinaryOp::ArithOp(ArithOp::Shl) | BinaryOp::ArithOp(ArithOp::Shr) => Ty::Unknown,
+        BinaryOp::ArithOp(ArithOp::Shl) | BinaryOp::ArithOp(ArithOp::Shr) => {
+            TyKind::Unknown.intern(&Interner)
+        }
        BinaryOp::CmpOp(CmpOp::Ord { .. })
        | BinaryOp::Assignment { op: Some(_) }
-        | BinaryOp::ArithOp(_) => match lhs_ty {
+        | BinaryOp::ArithOp(_) => match lhs_ty.interned(&Interner) {
-            Ty::Scalar(Scalar::Int(_))
+            TyKind::Scalar(Scalar::Int(_))
-            | Ty::Scalar(Scalar::Uint(_))
+            | TyKind::Scalar(Scalar::Uint(_))
-            | Ty::Scalar(Scalar::Float(_)) => lhs_ty,
+            | TyKind::Scalar(Scalar::Float(_)) => lhs_ty,
-            Ty::InferenceVar(_, TyVariableKind::Integer)
+            TyKind::InferenceVar(_, TyVariableKind::Integer)
-            | Ty::InferenceVar(_, TyVariableKind::Float) => lhs_ty,
+            | TyKind::InferenceVar(_, TyVariableKind::Float) => lhs_ty,
-            _ => Ty::Unknown,
+            _ => TyKind::Unknown.intern(&Interner),
        },
    }
 }
diff --git a/crates/hir_ty/src/tests.rs b/crates/hir_ty/src/tests.rs
index fc770ea60..0a4141e69 100644
--- a/crates/hir_ty/src/tests.rs
+++ b/crates/hir_ty/src/tests.rs
@@ -19,6 +19,7 @@ use hir_def::{
    item_scope::ItemScope,
    keys,
    nameres::DefMap,
+    src::HasSource,
    AssocItemId, DefWithBodyId, LocalModuleId, Lookup, ModuleDefId,
 };
 use hir_expand::{db::AstDatabase, InFile};
@@ -195,18 +196,15 @@ fn infer_with_mismatches(content: &str, include_mismatches: bool) -> String {
    defs.sort_by_key(|def| match def {
        DefWithBodyId::FunctionId(it) => {
            let loc = it.lookup(&db);
-            let tree = db.item_tree(loc.id.file_id);
+            loc.source(&db).value.syntax().text_range().start()
-            tree.source(&db, loc.id).syntax().text_range().start()
        }
        DefWithBodyId::ConstId(it) => {
            let loc = it.lookup(&db);
-            let tree = db.item_tree(loc.id.file_id);
+            loc.source(&db).value.syntax().text_range().start()
-            tree.source(&db, loc.id).syntax().text_range().start()
        }
        DefWithBodyId::StaticId(it) => {
            let loc = it.lookup(&db);
-            let tree = db.item_tree(loc.id.file_id);
+            loc.source(&db).value.syntax().text_range().start()
-            tree.source(&db, loc.id).syntax().text_range().start()
        }
    });
    for def in defs {
diff --git a/crates/hir_ty/src/traits.rs b/crates/hir_ty/src/traits.rs
index e4cdb6d53..a6a63c673 100644
--- a/crates/hir_ty/src/traits.rs
+++ b/crates/hir_ty/src/traits.rs
@@ -10,7 +10,9 @@ use stdx::panic_context;
 use crate::{db::HirDatabase, DebruijnIndex, Substs};
-use super::{Canonical, GenericPredicate, HirDisplay, ProjectionTy, TraitRef, Ty, TypeWalk};
+use super::{
+    Canonical, GenericPredicate, HirDisplay, ProjectionTy, TraitRef, Ty, TyKind, TypeWalk,
+};
 use self::chalk::{from_chalk, Interner, ToChalk};
@@ -38,26 +40,38 @@ fn create_chalk_solver() -> chalk_recursive::RecursiveSolver<Interner> {
 /// fn foo<T: Default>(t: T) {}
 /// ```
 /// we assume that `T: Default`.
-#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct TraitEnvironment {
-    pub predicates: Vec<GenericPredicate>,
+    // When we're using Chalk's Ty we can make this a BTreeMap since it's Ord,
+    // but for now it's too annoying...
+    pub(crate) traits_from_clauses: Vec<(Ty, TraitId)>,
+    pub(crate) env: chalk_ir::Environment<Interner>,
 }
 impl TraitEnvironment {
-    /// Returns trait refs with the given self type which are supposed to hold
+    pub(crate) fn traits_in_scope_from_clauses<'a>(
-    /// in this trait env. E.g. if we are in `foo<T: SomeTrait>()`, this will
-    /// find that `T: SomeTrait` if we call it for `T`.
-    pub(crate) fn trait_predicates_for_self_ty<'a>(
        &'a self,
        ty: &'a Ty,
-    ) -> impl Iterator<Item = &'a TraitRef> + 'a {
+    ) -> impl Iterator<Item = TraitId> + 'a {
-        self.predicates.iter().filter_map(move |pred| match pred {
+        self.traits_from_clauses.iter().filter_map(move |(self_ty, trait_id)| {
-            GenericPredicate::Implemented(tr) if tr.self_ty() == ty => Some(tr),
+            if self_ty == ty {
-            _ => None,
+                Some(*trait_id)
+            } else {
+                None
+            }
        })
    }
 }
+impl Default for TraitEnvironment {
+    fn default() -> Self {
+        TraitEnvironment {
+            traits_from_clauses: Vec::new(),
+            env: chalk_ir::Environment::new(&Interner),
+        }
+    }
+}
 /// Something (usually a goal), along with an environment.
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct InEnvironment<T> {
@@ -129,7 +143,7 @@ pub(crate) fn trait_solve_query(
    log::info!("trait_solve_query({})", goal.value.value.display(db));
    if let Obligation::Projection(pred) = &goal.value.value {
-        if let Ty::BoundVar(_) = &pred.projection_ty.parameters[0] {
+        if let TyKind::BoundVar(_) = &pred.projection_ty.substitution[0].interned(&Interner) {
            // Hack: don't ask Chalk to normalize with an unknown self type, it'll say that's impossible
            return Some(Solution::Ambig(Guidance::Unknown));
        }
diff --git a/crates/hir_ty/src/traits/chalk.rs b/crates/hir_ty/src/traits/chalk.rs
index 565672b6b..232cf9cd0 100644
--- a/crates/hir_ty/src/traits/chalk.rs
+++ b/crates/hir_ty/src/traits/chalk.rs
@@ -17,29 +17,31 @@ use super::ChalkContext;
 use crate::{
    db::HirDatabase,
    display::HirDisplay,
+    from_assoc_type_id,
    method_resolution::{TyFingerprint, ALL_FLOAT_FPS, ALL_INT_FPS},
+    to_assoc_type_id,
    utils::generics,
-    BoundVar, CallableDefId, CallableSig, DebruijnIndex, GenericPredicate, ProjectionPredicate,
+    BoundVar, CallableDefId, CallableSig, DebruijnIndex, FnDefId, GenericPredicate,
-    ProjectionTy, Substs, TraitRef, Ty,
+    ProjectionPredicate, ProjectionTy, Substs, TraitRef, Ty, TyKind,
 };
 use mapping::{
-    convert_where_clauses, generic_predicate_to_inline_bound, make_binders, TypeAliasAsAssocType,
+    convert_where_clauses, generic_predicate_to_inline_bound, make_binders, TypeAliasAsValue,
-    TypeAliasAsValue,
 };
+pub use self::interner::Interner;
 pub(crate) use self::interner::*;
 pub(super) mod tls;
 mod interner;
 mod mapping;
-pub(super) trait ToChalk {
+pub(crate) trait ToChalk {
    type Chalk;
    fn to_chalk(self, db: &dyn HirDatabase) -> Self::Chalk;
    fn from_chalk(db: &dyn HirDatabase, chalk: Self::Chalk) -> Self;
 }
-pub(super) fn from_chalk<T, ChalkT>(db: &dyn HirDatabase, chalk: ChalkT) -> T
+pub(crate) fn from_chalk<T, ChalkT>(db: &dyn HirDatabase, chalk: ChalkT) -> T
 where
    T: ToChalk<Chalk = ChalkT>,
 {
@@ -90,7 +92,7 @@ impl<'a> chalk_solve::RustIrDatabase<Interner> for ChalkContext<'a> {
            ty: &Ty,
            binders: &CanonicalVarKinds<Interner>,
        ) -> Option<chalk_ir::TyVariableKind> {
-            if let Ty::BoundVar(bv) = ty {
+            if let TyKind::BoundVar(bv) = ty.interned(&Interner) {
                let binders = binders.as_slice(&Interner);
                if bv.debruijn == DebruijnIndex::INNERMOST {
                    if let chalk_ir::VariableKind::Ty(tk) = binders[bv.index].kind {
@@ -175,10 +177,9 @@ impl<'a> chalk_solve::RustIrDatabase<Interner> for ChalkContext<'a> {
    }
    fn opaque_ty_data(&self, id: chalk_ir::OpaqueTyId<Interner>) -> Arc<OpaqueTyDatum> {
-        let interned_id = crate::db::InternedOpaqueTyId::from(id);
+        let full_id = self.db.lookup_intern_impl_trait_id(id.into());
-        let full_id = self.db.lookup_intern_impl_trait_id(interned_id);
        let bound = match full_id {
-            crate::OpaqueTyId::ReturnTypeImplTrait(func, idx) => {
+            crate::ImplTraitId::ReturnTypeImplTrait(func, idx) => {
                let datas = self
                    .db
                    .return_type_impl_traits(func)
@@ -200,7 +201,7 @@ impl<'a> chalk_solve::RustIrDatabase<Interner> for ChalkContext<'a> {
                let num_vars = datas.num_binders;
                make_binders(bound, num_vars)
            }
-            crate::OpaqueTyId::AsyncBlockTypeImplTrait(..) => {
+            crate::ImplTraitId::AsyncBlockTypeImplTrait(..) => {
                if let Some((future_trait, future_output)) = self
                    .db
                    .lang_item(self.krate, "future_trait".into())
@@ -220,21 +221,25 @@ impl<'a> chalk_solve::RustIrDatabase<Interner> for ChalkContext<'a> {
                    let impl_bound = GenericPredicate::Implemented(TraitRef {
                        trait_: future_trait,
                        // Self type as the first parameter.
-                        substs: Substs::single(Ty::BoundVar(BoundVar {
+                        substs: Substs::single(
-                            debruijn: DebruijnIndex::INNERMOST,
+                            TyKind::BoundVar(BoundVar {
-                            index: 0,
+                                debruijn: DebruijnIndex::INNERMOST,
-                        })),
+                                index: 0,
+                            })
+                            .intern(&Interner),
+                        ),
                    });
                    let proj_bound = GenericPredicate::Projection(ProjectionPredicate {
                        // The parameter of the opaque type.
-                        ty: Ty::BoundVar(BoundVar { debruijn: DebruijnIndex::ONE, index: 0 }),
+                        ty: TyKind::BoundVar(BoundVar { debruijn: DebruijnIndex::ONE, index: 0 })
+                            .intern(&Interner),
                        projection_ty: ProjectionTy {
-                            associated_ty: future_output,
+                            associated_ty_id: to_assoc_type_id(future_output),
                            // Self type as the first parameter.
-                            parameters: Substs::single(Ty::BoundVar(BoundVar::new(
+                            substitution: Substs::single(
-                                DebruijnIndex::INNERMOST,
+                                TyKind::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, 0))
-                                0,
+                                    .intern(&Interner),
-                            ))),
+                            ),
                        },
                    });
                    let bound = OpaqueTyDatumBound {
@@ -263,7 +268,7 @@ impl<'a> chalk_solve::RustIrDatabase<Interner> for ChalkContext<'a> {
    fn hidden_opaque_type(&self, _id: chalk_ir::OpaqueTyId<Interner>) -> chalk_ir::Ty<Interner> {
        // FIXME: actually provide the hidden type; it is relevant for auto traits
-        Ty::Unknown.to_chalk(self.db)
+        TyKind::Unknown.intern(&Interner).to_chalk(self.db)
    }
    fn is_object_safe(&self, _trait_id: chalk_ir::TraitId<Interner>) -> bool {
@@ -378,7 +383,7 @@ pub(crate) fn associated_ty_data_query(
    id: AssocTypeId,
 ) -> Arc<AssociatedTyDatum> {
    debug!("associated_ty_data {:?}", id);
-    let type_alias: TypeAliasId = from_chalk::<TypeAliasAsAssocType, _>(db, id).0;
+    let type_alias: TypeAliasId = from_assoc_type_id(id);
    let trait_ = match type_alias.lookup(db.upcast()).container {
        AssocContainerId::TraitId(t) => t,
        _ => panic!("associated type not in trait"),
@@ -391,11 +396,12 @@ pub(crate) fn associated_ty_data_query(
    let resolver = hir_def::resolver::HasResolver::resolver(type_alias, db.upcast());
    let ctx = crate::TyLoweringContext::new(db, &resolver)
        .with_type_param_mode(crate::lower::TypeParamLoweringMode::Variable);
-    let self_ty = Ty::BoundVar(crate::BoundVar::new(crate::DebruijnIndex::INNERMOST, 0));
+    let self_ty =
+        TyKind::BoundVar(BoundVar::new(crate::DebruijnIndex::INNERMOST, 0)).intern(&Interner);
    let bounds = type_alias_data
        .bounds
        .iter()
-        .flat_map(|bound| GenericPredicate::from_type_bound(&ctx, bound, self_ty.clone()))
+        .flat_map(|bound| ctx.lower_type_bound(bound, self_ty.clone()))
        .filter_map(|pred| generic_predicate_to_inline_bound(db, &pred, &self_ty))
        .map(|bound| make_binders(bound.shifted_in(&Interner), 0))
        .collect();
@@ -432,10 +438,8 @@ pub(crate) fn trait_datum_query(
        fundamental: false,
    };
    let where_clauses = convert_where_clauses(db, trait_.into(), &bound_vars);
-    let associated_ty_ids = trait_data
+    let associated_ty_ids =
-        .associated_types()
+        trait_data.associated_types().map(|type_alias| to_assoc_type_id(type_alias)).collect();
-        .map(|type_alias| TypeAliasAsAssocType(type_alias).to_chalk(db))
-        .collect();
    let trait_datum_bound = rust_ir::TraitDatumBound { where_clauses };
    let well_known =
        lang_attr(db.upcast(), trait_).and_then(|name| well_known_trait_from_lang_attr(&name));
@@ -487,19 +491,14 @@ pub(crate) fn struct_datum_query(
    struct_id: AdtId,
 ) -> Arc<StructDatum> {
    debug!("struct_datum {:?}", struct_id);
-    let type_ctor = Ty::Adt(struct_id, Substs::empty());
    let chalk_ir::AdtId(adt_id) = struct_id;
-    debug!("struct {:?} = {:?}", struct_id, type_ctor);
    let num_params = generics(db.upcast(), adt_id.into()).len();
    let upstream = adt_id.module(db.upcast()).krate() != krate;
-    let where_clauses = type_ctor
+    let where_clauses = {
-        .as_generic_def()
+        let generic_params = generics(db.upcast(), adt_id.into());
-        .map(|generic_def| {
+        let bound_vars = Substs::bound_vars(&generic_params, DebruijnIndex::INNERMOST);
-            let generic_params = generics(db.upcast(), generic_def);
+        convert_where_clauses(db, adt_id.into(), &bound_vars)
-            let bound_vars = Substs::bound_vars(&generic_params, DebruijnIndex::INNERMOST);
+    };
-            convert_where_clauses(db, generic_def, &bound_vars)
-        })
-        .unwrap_or_else(Vec::new);
    let flags = rust_ir::AdtFlags {
        upstream,
        // FIXME set fundamental and phantom_data flags correctly
@@ -622,7 +621,7 @@ fn type_alias_associated_ty_value(
    let value_bound = rust_ir::AssociatedTyValueBound { ty: ty.value.to_chalk(db) };
    let value = rust_ir::AssociatedTyValue {
        impl_id: impl_id.to_chalk(db),
-        associated_ty_id: TypeAliasAsAssocType(assoc_ty).to_chalk(db),
+        associated_ty_id: to_assoc_type_id(assoc_ty),
        value: make_binders(value_bound, ty.num_binders),
    };
    Arc::new(value)
@@ -716,14 +715,14 @@ impl From<crate::db::InternedOpaqueTyId> for OpaqueTyId {
    }
 }
-impl From<chalk_ir::ClosureId<Interner>> for crate::db::ClosureId {
+impl From<chalk_ir::ClosureId<Interner>> for crate::db::InternedClosureId {
    fn from(id: chalk_ir::ClosureId<Interner>) -> Self {
        Self::from_intern_id(id.0)
    }
 }
-impl From<crate::db::ClosureId> for chalk_ir::ClosureId<Interner> {
+impl From<crate::db::InternedClosureId> for chalk_ir::ClosureId<Interner> {
-    fn from(id: crate::db::ClosureId) -> Self {
+    fn from(id: crate::db::InternedClosureId) -> Self {
        chalk_ir::ClosureId(id.as_intern_id())
    }
 }
diff --git a/crates/hir_ty/src/traits/chalk/interner.rs b/crates/hir_ty/src/traits/chalk/interner.rs
index 54bd1c724..1dc3f497d 100644
--- a/crates/hir_ty/src/traits/chalk/interner.rs
+++ b/crates/hir_ty/src/traits/chalk/interner.rs
@@ -12,7 +12,6 @@ pub struct Interner;
 pub(crate) type AssocTypeId = chalk_ir::AssocTypeId<Interner>;
 pub(crate) type AssociatedTyDatum = chalk_solve::rust_ir::AssociatedTyDatum<Interner>;
-pub(crate) type ForeignDefId = chalk_ir::ForeignDefId<Interner>;
 pub(crate) type TraitId = chalk_ir::TraitId<Interner>;
 pub(crate) type TraitDatum = chalk_solve::rust_ir::TraitDatum<Interner>;
 pub(crate) type AdtId = chalk_ir::AdtId<Interner>;
@@ -21,7 +20,6 @@ pub(crate) type ImplId = chalk_ir::ImplId<Interner>;
 pub(crate) type ImplDatum = chalk_solve::rust_ir::ImplDatum<Interner>;
 pub(crate) type AssociatedTyValueId = chalk_solve::rust_ir::AssociatedTyValueId<Interner>;
 pub(crate) type AssociatedTyValue = chalk_solve::rust_ir::AssociatedTyValue<Interner>;
-pub(crate) type FnDefId = chalk_ir::FnDefId<Interner>;
 pub(crate) type FnDefDatum = chalk_solve::rust_ir::FnDefDatum<Interner>;
 pub(crate) type OpaqueTyId = chalk_ir::OpaqueTyId<Interner>;
 pub(crate) type OpaqueTyDatum = chalk_solve::rust_ir::OpaqueTyDatum<Interner>;
diff --git a/crates/hir_ty/src/traits/chalk/mapping.rs b/crates/hir_ty/src/traits/chalk/mapping.rs
index 3a08b67e9..05a4bf0df 100644
--- a/crates/hir_ty/src/traits/chalk/mapping.rs
+++ b/crates/hir_ty/src/traits/chalk/mapping.rs
@@ -3,10 +3,7 @@
 //! Chalk (in both directions); plus some helper functions for more specialized
 //! conversions.
-use chalk_ir::{
+use chalk_ir::{cast::Cast, fold::shift::Shift, interner::HasInterner, LifetimeData};
-    cast::Cast, fold::shift::Shift, interner::HasInterner, LifetimeData, PlaceholderIndex,
-    UniverseIndex,
-};
 use chalk_solve::rust_ir;
 use base_db::salsa::InternKey;
@@ -14,10 +11,11 @@ use hir_def::{AssocContainerId, GenericDefId, Lookup, TypeAliasId};
 use crate::{
    db::HirDatabase,
+    from_assoc_type_id,
    primitive::UintTy,
    traits::{Canonical, Obligation},
-    AliasTy, CallableDefId, FnPointer, FnSig, GenericPredicate, InEnvironment, OpaqueTy,
+    AliasTy, CallableDefId, FnPointer, GenericPredicate, InEnvironment, OpaqueTy,
-    OpaqueTyId, ProjectionPredicate, ProjectionTy, Scalar, Substs, TraitEnvironment, TraitRef, Ty,
+    ProjectionPredicate, ProjectionTy, Scalar, Substs, TraitRef, Ty,
 };
 use super::interner::*;
@@ -26,71 +24,62 @@ use super::*;
 impl ToChalk for Ty {
    type Chalk = chalk_ir::Ty<Interner>;
    fn to_chalk(self, db: &dyn HirDatabase) -> chalk_ir::Ty<Interner> {
-        match self {
+        match self.0 {
-            Ty::Ref(m, parameters) => ref_to_chalk(db, m, parameters),
+            TyKind::Ref(m, parameters) => ref_to_chalk(db, m, parameters),
-            Ty::Array(parameters) => array_to_chalk(db, parameters),
+            TyKind::Array(parameters) => array_to_chalk(db, parameters),
-            Ty::Function(FnPointer { sig: FnSig { variadic }, substs, .. }) => {
+            TyKind::Function(FnPointer { sig, substs, .. }) => {
                let substitution = chalk_ir::FnSubst(substs.to_chalk(db).shifted_in(&Interner));
                chalk_ir::TyKind::Function(chalk_ir::FnPointer {
                    num_binders: 0,
-                    sig: chalk_ir::FnSig { abi: (), safety: chalk_ir::Safety::Safe, variadic },
+                    sig,
                    substitution,
                })
                .intern(&Interner)
            }
-            Ty::AssociatedType(type_alias, substs) => {
+            TyKind::AssociatedType(assoc_type_id, substs) => {
-                let assoc_type = TypeAliasAsAssocType(type_alias);
-                let assoc_type_id = assoc_type.to_chalk(db);
                let substitution = substs.to_chalk(db);
                chalk_ir::TyKind::AssociatedType(assoc_type_id, substitution).intern(&Interner)
            }
-            Ty::OpaqueType(impl_trait_id, substs) => {
+            TyKind::OpaqueType(id, substs) => {
-                let id = impl_trait_id.to_chalk(db);
                let substitution = substs.to_chalk(db);
                chalk_ir::TyKind::OpaqueType(id, substitution).intern(&Interner)
            }
-            Ty::ForeignType(type_alias) => {
+            TyKind::ForeignType(id) => chalk_ir::TyKind::Foreign(id).intern(&Interner),
-                let foreign_type = TypeAliasAsForeignType(type_alias);
-                let foreign_type_id = foreign_type.to_chalk(db);
-                chalk_ir::TyKind::Foreign(foreign_type_id).intern(&Interner)
-            }
-            Ty::Scalar(scalar) => chalk_ir::TyKind::Scalar(scalar).intern(&Interner),
+            TyKind::Scalar(scalar) => chalk_ir::TyKind::Scalar(scalar).intern(&Interner),
-            Ty::Tuple(cardinality, substs) => {
+            TyKind::Tuple(cardinality, substs) => {
                let substitution = substs.to_chalk(db);
                chalk_ir::TyKind::Tuple(cardinality.into(), substitution).intern(&Interner)
            }
-            Ty::Raw(mutability, substs) => {
+            TyKind::Raw(mutability, substs) => {
                let ty = substs[0].clone().to_chalk(db);
                chalk_ir::TyKind::Raw(mutability, ty).intern(&Interner)
            }
-            Ty::Slice(substs) => {
+            TyKind::Slice(substs) => {
                chalk_ir::TyKind::Slice(substs[0].clone().to_chalk(db)).intern(&Interner)
            }
-            Ty::Str => chalk_ir::TyKind::Str.intern(&Interner),
+            TyKind::Str => chalk_ir::TyKind::Str.intern(&Interner),
-            Ty::FnDef(callable_def, substs) => {
+            TyKind::FnDef(id, substs) => {
-                let id = callable_def.to_chalk(db);
                let substitution = substs.to_chalk(db);
                chalk_ir::TyKind::FnDef(id, substitution).intern(&Interner)
            }
-            Ty::Never => chalk_ir::TyKind::Never.intern(&Interner),
+            TyKind::Never => chalk_ir::TyKind::Never.intern(&Interner),
-            Ty::Closure(def, expr, substs) => {
+            TyKind::Closure(closure_id, substs) => {
-                let closure_id = db.intern_closure((def, expr));
                let substitution = substs.to_chalk(db);
-                chalk_ir::TyKind::Closure(closure_id.into(), substitution).intern(&Interner)
+                chalk_ir::TyKind::Closure(closure_id, substitution).intern(&Interner)
            }
-            Ty::Adt(adt_id, substs) => {
+            TyKind::Adt(adt_id, substs) => {
                let substitution = substs.to_chalk(db);
                chalk_ir::TyKind::Adt(adt_id, substitution).intern(&Interner)
            }
-            Ty::Alias(AliasTy::Projection(proj_ty)) => {
+            TyKind::Alias(AliasTy::Projection(proj_ty)) => {
-                let associated_ty_id = TypeAliasAsAssocType(proj_ty.associated_ty).to_chalk(db);
+                let associated_ty_id = proj_ty.associated_ty_id;
-                let substitution = proj_ty.parameters.to_chalk(db);
+                let substitution = proj_ty.substitution.to_chalk(db);
                chalk_ir::AliasTy::Projection(chalk_ir::ProjectionTy {
                    associated_ty_id,
                    substitution,
@@ -98,17 +87,17 @@ impl ToChalk for Ty {
                .cast(&Interner)
                .intern(&Interner)
            }
-            Ty::Placeholder(id) => {
+            TyKind::Alias(AliasTy::Opaque(opaque_ty)) => {
-                let interned_id = db.intern_type_param_id(id);
+                let opaque_ty_id = opaque_ty.opaque_ty_id;
-                PlaceholderIndex {
+                let substitution = opaque_ty.substitution.to_chalk(db);
-                    ui: UniverseIndex::ROOT,
+                chalk_ir::AliasTy::Opaque(chalk_ir::OpaqueTy { opaque_ty_id, substitution })
-                    idx: interned_id.as_intern_id().as_usize(),
+                    .cast(&Interner)
-                }
+                    .intern(&Interner)
-                .to_ty::<Interner>(&Interner)
+            }
-            }
+            TyKind::Placeholder(idx) => idx.to_ty::<Interner>(&Interner),
-            Ty::BoundVar(idx) => chalk_ir::TyKind::BoundVar(idx).intern(&Interner),
+            TyKind::BoundVar(idx) => chalk_ir::TyKind::BoundVar(idx).intern(&Interner),
-            Ty::InferenceVar(..) => panic!("uncanonicalized infer ty"),
+            TyKind::InferenceVar(..) => panic!("uncanonicalized infer ty"),
-            Ty::Dyn(predicates) => {
+            TyKind::Dyn(predicates) => {
                let where_clauses = chalk_ir::QuantifiedWhereClauses::from_iter(
                    &Interner,
                    predicates.iter().filter(|p| !p.is_error()).cloned().map(|p| p.to_chalk(db)),
@@ -119,43 +108,30 @@ impl ToChalk for Ty {
                };
                chalk_ir::TyKind::Dyn(bounded_ty).intern(&Interner)
            }
-            Ty::Alias(AliasTy::Opaque(opaque_ty)) => {
+            TyKind::Unknown => chalk_ir::TyKind::Error.intern(&Interner),
-                let opaque_ty_id = opaque_ty.opaque_ty_id.to_chalk(db);
-                let substitution = opaque_ty.parameters.to_chalk(db);
-                chalk_ir::TyKind::Alias(chalk_ir::AliasTy::Opaque(chalk_ir::OpaqueTy {
-                    opaque_ty_id,
-                    substitution,
-                }))
-                .intern(&Interner)
-            }
-            Ty::Unknown => chalk_ir::TyKind::Error.intern(&Interner),
        }
    }
    fn from_chalk(db: &dyn HirDatabase, chalk: chalk_ir::Ty<Interner>) -> Self {
        match chalk.data(&Interner).kind.clone() {
-            chalk_ir::TyKind::Error => Ty::Unknown,
+            chalk_ir::TyKind::Error => TyKind::Unknown,
-            chalk_ir::TyKind::Array(ty, _size) => Ty::Array(Substs::single(from_chalk(db, ty))),
+            chalk_ir::TyKind::Array(ty, _size) => TyKind::Array(Substs::single(from_chalk(db, ty))),
-            chalk_ir::TyKind::Placeholder(idx) => {
+            chalk_ir::TyKind::Placeholder(idx) => TyKind::Placeholder(idx),
-                assert_eq!(idx.ui, UniverseIndex::ROOT);
-                let interned_id = crate::db::GlobalTypeParamId::from_intern_id(
-                    crate::salsa::InternId::from(idx.idx),
-                );
-                Ty::Placeholder(db.lookup_intern_type_param_id(interned_id))
-            }
            chalk_ir::TyKind::Alias(chalk_ir::AliasTy::Projection(proj)) => {
-                let associated_ty =
+                let associated_ty = proj.associated_ty_id;
-                    from_chalk::<TypeAliasAsAssocType, _>(db, proj.associated_ty_id).0;
                let parameters = from_chalk(db, proj.substitution);
-                Ty::Alias(AliasTy::Projection(ProjectionTy { associated_ty, parameters }))
+                TyKind::Alias(AliasTy::Projection(ProjectionTy {
+                    associated_ty_id: associated_ty,
+                    substitution: parameters,
+                }))
            }
            chalk_ir::TyKind::Alias(chalk_ir::AliasTy::Opaque(opaque_ty)) => {
-                let impl_trait_id = from_chalk(db, opaque_ty.opaque_ty_id);
+                let opaque_ty_id = opaque_ty.opaque_ty_id;
                let parameters = from_chalk(db, opaque_ty.substitution);
-                Ty::Alias(AliasTy::Opaque(OpaqueTy { opaque_ty_id: impl_trait_id, parameters }))
+                TyKind::Alias(AliasTy::Opaque(OpaqueTy { opaque_ty_id, substitution: parameters }))
            }
            chalk_ir::TyKind::Function(chalk_ir::FnPointer {
                num_binders,
-                sig: chalk_ir::FnSig { variadic, .. },
+                sig,
                substitution,
                ..
            }) => {
@@ -164,14 +140,10 @@ impl ToChalk for Ty {
                    db,
                    substitution.0.shifted_out(&Interner).expect("fn ptr should have no binders"),
                );
-                Ty::Function(FnPointer {
+                TyKind::Function(FnPointer { num_args: (substs.len() - 1), sig, substs })
-                    num_args: (substs.len() - 1),
-                    sig: FnSig { variadic },
-                    substs,
-                })
            }
-            chalk_ir::TyKind::BoundVar(idx) => Ty::BoundVar(idx),
+            chalk_ir::TyKind::BoundVar(idx) => TyKind::BoundVar(idx),
-            chalk_ir::TyKind::InferenceVar(_iv, _kind) => Ty::Unknown,
+            chalk_ir::TyKind::InferenceVar(_iv, _kind) => TyKind::Unknown,
            chalk_ir::TyKind::Dyn(where_clauses) => {
                assert_eq!(where_clauses.bounds.binders.len(&Interner), 1);
                let predicates = where_clauses
@@ -180,49 +152,43 @@ impl ToChalk for Ty {
                    .iter(&Interner)
                    .map(|c| from_chalk(db, c.clone()))
                    .collect();
-                Ty::Dyn(predicates)
+                TyKind::Dyn(predicates)
            }
-            chalk_ir::TyKind::Adt(adt_id, subst) => Ty::Adt(adt_id, from_chalk(db, subst)),
+            chalk_ir::TyKind::Adt(adt_id, subst) => TyKind::Adt(adt_id, from_chalk(db, subst)),
-            chalk_ir::TyKind::AssociatedType(type_id, subst) => Ty::AssociatedType(
+            chalk_ir::TyKind::AssociatedType(type_id, subst) => {
-                from_chalk::<TypeAliasAsAssocType, _>(db, type_id).0,
+                TyKind::AssociatedType(type_id, from_chalk(db, subst))
-                from_chalk(db, subst),
+            }
-            ),
            chalk_ir::TyKind::OpaqueType(opaque_type_id, subst) => {
-                Ty::OpaqueType(from_chalk(db, opaque_type_id), from_chalk(db, subst))
+                TyKind::OpaqueType(opaque_type_id, from_chalk(db, subst))
            }
-            chalk_ir::TyKind::Scalar(scalar) => Ty::Scalar(scalar),
+            chalk_ir::TyKind::Scalar(scalar) => TyKind::Scalar(scalar),
            chalk_ir::TyKind::Tuple(cardinality, subst) => {
-                Ty::Tuple(cardinality, from_chalk(db, subst))
+                TyKind::Tuple(cardinality, from_chalk(db, subst))
            }
            chalk_ir::TyKind::Raw(mutability, ty) => {
-                Ty::Raw(mutability, Substs::single(from_chalk(db, ty)))
+                TyKind::Raw(mutability, Substs::single(from_chalk(db, ty)))
            }
-            chalk_ir::TyKind::Slice(ty) => Ty::Slice(Substs::single(from_chalk(db, ty))),
+            chalk_ir::TyKind::Slice(ty) => TyKind::Slice(Substs::single(from_chalk(db, ty))),
            chalk_ir::TyKind::Ref(mutability, _lifetime, ty) => {
-                Ty::Ref(mutability, Substs::single(from_chalk(db, ty)))
+                TyKind::Ref(mutability, Substs::single(from_chalk(db, ty)))
            }
-            chalk_ir::TyKind::Str => Ty::Str,
+            chalk_ir::TyKind::Str => TyKind::Str,
-            chalk_ir::TyKind::Never => Ty::Never,
+            chalk_ir::TyKind::Never => TyKind::Never,
            chalk_ir::TyKind::FnDef(fn_def_id, subst) => {
-                Ty::FnDef(from_chalk(db, fn_def_id), from_chalk(db, subst))
+                TyKind::FnDef(fn_def_id, from_chalk(db, subst))
            }
-            chalk_ir::TyKind::Closure(id, subst) => {
+            chalk_ir::TyKind::Closure(id, subst) => TyKind::Closure(id, from_chalk(db, subst)),
-                let id: crate::db::ClosureId = id.into();
-                let (def, expr) = db.lookup_intern_closure(id);
-                Ty::Closure(def, expr, from_chalk(db, subst))
-            }
-            chalk_ir::TyKind::Foreign(foreign_def_id) => {
+            chalk_ir::TyKind::Foreign(foreign_def_id) => TyKind::ForeignType(foreign_def_id),
-                Ty::ForeignType(from_chalk::<TypeAliasAsForeignType, _>(db, foreign_def_id).0)
-            }
            chalk_ir::TyKind::Generator(_, _) => unimplemented!(), // FIXME
            chalk_ir::TyKind::GeneratorWitness(_, _) => unimplemented!(), // FIXME
        }
+        .intern(&Interner)
    }
 }
@@ -298,21 +264,6 @@ impl ToChalk for hir_def::TraitId {
    }
 }
-impl ToChalk for OpaqueTyId {
-    type Chalk = chalk_ir::OpaqueTyId<Interner>;
-    fn to_chalk(self, db: &dyn HirDatabase) -> chalk_ir::OpaqueTyId<Interner> {
-        db.intern_impl_trait_id(self).into()
-    }
-    fn from_chalk(
-        db: &dyn HirDatabase,
-        opaque_ty_id: chalk_ir::OpaqueTyId<Interner>,
-    ) -> OpaqueTyId {
-        db.lookup_intern_impl_trait_id(opaque_ty_id.into())
-    }
-}
 impl ToChalk for hir_def::ImplId {
    type Chalk = ImplId;
@@ -337,34 +288,6 @@ impl ToChalk for CallableDefId {
    }
 }
-pub(crate) struct TypeAliasAsAssocType(pub(crate) TypeAliasId);
-impl ToChalk for TypeAliasAsAssocType {
-    type Chalk = AssocTypeId;
-    fn to_chalk(self, _db: &dyn HirDatabase) -> AssocTypeId {
-        chalk_ir::AssocTypeId(self.0.as_intern_id())
-    }
-    fn from_chalk(_db: &dyn HirDatabase, assoc_type_id: AssocTypeId) -> TypeAliasAsAssocType {
-        TypeAliasAsAssocType(InternKey::from_intern_id(assoc_type_id.0))
-    }
-}
-pub(crate) struct TypeAliasAsForeignType(pub(crate) TypeAliasId);
-impl ToChalk for TypeAliasAsForeignType {
-    type Chalk = ForeignDefId;
-    fn to_chalk(self, _db: &dyn HirDatabase) -> ForeignDefId {
-        chalk_ir::ForeignDefId(self.0.as_intern_id())
-    }
-    fn from_chalk(_db: &dyn HirDatabase, foreign_def_id: ForeignDefId) -> TypeAliasAsForeignType {
-        TypeAliasAsForeignType(InternKey::from_intern_id(foreign_def_id.0))
-    }
-}
 pub(crate) struct TypeAliasAsValue(pub(crate) TypeAliasId);
 impl ToChalk for TypeAliasAsValue {
@@ -446,8 +369,8 @@ impl ToChalk for ProjectionTy {
    fn to_chalk(self, db: &dyn HirDatabase) -> chalk_ir::ProjectionTy<Interner> {
        chalk_ir::ProjectionTy {
-            associated_ty_id: TypeAliasAsAssocType(self.associated_ty).to_chalk(db),
+            associated_ty_id: self.associated_ty_id,
-            substitution: self.parameters.to_chalk(db),
+            substitution: self.substitution.to_chalk(db),
        }
    }
@@ -456,12 +379,8 @@ impl ToChalk for ProjectionTy {
        projection_ty: chalk_ir::ProjectionTy<Interner>,
    ) -> ProjectionTy {
        ProjectionTy {
-            associated_ty: from_chalk::<TypeAliasAsAssocType, _>(
+            associated_ty_id: projection_ty.associated_ty_id,
-                db,
+            substitution: from_chalk(db, projection_ty.substitution),
-                projection_ty.associated_ty_id,
-            )
-            .0,
-            parameters: from_chalk(db, projection_ty.substitution),
        }
    }
 }
@@ -536,31 +455,6 @@ where
    }
 }
-impl ToChalk for Arc<TraitEnvironment> {
-    type Chalk = chalk_ir::Environment<Interner>;
-    fn to_chalk(self, db: &dyn HirDatabase) -> chalk_ir::Environment<Interner> {
-        let mut clauses = Vec::new();
-        for pred in &self.predicates {
-            if pred.is_error() {
-                // for env, we just ignore errors
-                continue;
-            }
-            let program_clause: chalk_ir::ProgramClause<Interner> =
-                pred.clone().to_chalk(db).cast(&Interner);
-            clauses.push(program_clause.into_from_env_clause(&Interner));
-        }
-        chalk_ir::Environment::new(&Interner).add_clauses(&Interner, clauses)
-    }
-    fn from_chalk(
-        _db: &dyn HirDatabase,
-        _env: chalk_ir::Environment<Interner>,
-    ) -> Arc<TraitEnvironment> {
-        unimplemented!()
-    }
-}
 impl<T: ToChalk> ToChalk for InEnvironment<T>
 where
    T::Chalk: chalk_ir::interner::HasInterner<Interner = Interner>,
@@ -569,19 +463,16 @@ where
    fn to_chalk(self, db: &dyn HirDatabase) -> chalk_ir::InEnvironment<T::Chalk> {
        chalk_ir::InEnvironment {
-            environment: self.environment.to_chalk(db),
+            environment: self.environment.env.clone(),
            goal: self.value.to_chalk(db),
        }
    }
    fn from_chalk(
-        db: &dyn HirDatabase,
+        _db: &dyn HirDatabase,
-        in_env: chalk_ir::InEnvironment<T::Chalk>,
+        _in_env: chalk_ir::InEnvironment<T::Chalk>,
    ) -> InEnvironment<T> {
-        InEnvironment {
+        unimplemented!()
-            environment: from_chalk(db, in_env.environment),
-            value: from_chalk(db, in_env.goal),
-        }
    }
 }
@@ -639,22 +530,24 @@ pub(super) fn generic_predicate_to_inline_bound(
            Some(rust_ir::InlineBound::TraitBound(trait_bound))
        }
        GenericPredicate::Projection(proj) => {
-            if &proj.projection_ty.parameters[0] != self_ty {
+            if &proj.projection_ty.substitution[0] != self_ty {
                return None;
            }
-            let trait_ = match proj.projection_ty.associated_ty.lookup(db.upcast()).container {
+            let trait_ = match from_assoc_type_id(proj.projection_ty.associated_ty_id)
+                .lookup(db.upcast())
+                .container
+            {
                AssocContainerId::TraitId(t) => t,
                _ => panic!("associated type not in trait"),
            };
-            let args_no_self = proj.projection_ty.parameters[1..]
+            let args_no_self = proj.projection_ty.substitution[1..]
                .iter()
                .map(|ty| ty.clone().to_chalk(db).cast(&Interner))
                .collect();
            let alias_eq_bound = rust_ir::AliasEqBound {
                value: proj.ty.clone().to_chalk(db),
                trait_bound: rust_ir::TraitBound { trait_id: trait_.to_chalk(db), args_no_self },
-                associated_ty_id: TypeAliasAsAssocType(proj.projection_ty.associated_ty)
+                associated_ty_id: proj.projection_ty.associated_ty_id,
-                    .to_chalk(db),
                parameters: Vec::new(), // FIXME we don't support generic associated types yet
            };
            Some(rust_ir::InlineBound::AliasEqBound(alias_eq_bound))
diff --git a/crates/hir_ty/src/traits/chalk/tls.rs b/crates/hir_ty/src/traits/chalk/tls.rs
index 75b16172e..8892a63a9 100644
--- a/crates/hir_ty/src/traits/chalk/tls.rs
+++ b/crates/hir_ty/src/traits/chalk/tls.rs
@@ -4,8 +4,8 @@ use std::fmt;
 use chalk_ir::{AliasTy, GenericArg, Goal, Goals, Lifetime, ProgramClauseImplication};
 use itertools::Itertools;
-use super::{from_chalk, Interner, TypeAliasAsAssocType};
+use super::{from_chalk, Interner};
-use crate::{db::HirDatabase, CallableDefId};
+use crate::{db::HirDatabase, from_assoc_type_id, CallableDefId};
 use hir_def::{AdtId, AssocContainerId, Lookup, TypeAliasId};
 pub(crate) use unsafe_tls::{set_current_program, with_current_program};
@@ -41,7 +41,7 @@ impl DebugContext<'_> {
        id: super::AssocTypeId,
        fmt: &mut fmt::Formatter<'_>,
    ) -> Result<(), fmt::Error> {
-        let type_alias: TypeAliasId = from_chalk::<TypeAliasAsAssocType, _>(self.0, id).0;
+        let type_alias: TypeAliasId = from_assoc_type_id(id);
        let type_alias_data = self.0.type_alias_data(type_alias);
        let trait_ = match type_alias.lookup(self.0.upcast()).container {
            AssocContainerId::TraitId(t) => t,
@@ -75,8 +75,7 @@ impl DebugContext<'_> {
        projection_ty: &chalk_ir::ProjectionTy<Interner>,
        fmt: &mut fmt::Formatter<'_>,
    ) -> Result<(), fmt::Error> {
-        let type_alias: TypeAliasId =
+        let type_alias = from_assoc_type_id(projection_ty.associated_ty_id);
-            from_chalk::<TypeAliasAsAssocType, _>(self.0, projection_ty.associated_ty_id).0;
        let type_alias_data = self.0.type_alias_data(type_alias);
        let trait_ = match type_alias.lookup(self.0.upcast()).container {
            AssocContainerId::TraitId(t) => t,
diff --git a/crates/ide/src/lib.rs b/crates/ide/src/lib.rs
index d1a250d48..a8b169e87 100644
--- a/crates/ide/src/lib.rs
+++ b/crates/ide/src/lib.rs
@@ -87,7 +87,7 @@ pub use crate::{
 pub use hir::{Documentation, Semantics};
 pub use ide_assists::{Assist, AssistConfig, AssistId, AssistKind};
 pub use ide_completion::{
-    CompletionConfig, CompletionItem, CompletionItemKind, CompletionScore, ImportEdit,
+    CompletionConfig, CompletionItem, CompletionItemKind, CompletionRelevance, ImportEdit,
    InsertTextFormat,
 };
 pub use ide_db::{
@@ -447,6 +447,15 @@ impl Analysis {
        self.with_db(|db| runnables::runnables(db, file_id))
    }
+    /// Returns the set of tests for the given file position.
+    pub fn related_tests(
+        &self,
+        position: FilePosition,
+        search_scope: Option<SearchScope>,
+    ) -> Cancelable<Vec<Runnable>> {
+        self.with_db(|db| runnables::related_tests(db, position, search_scope))
+    }
    /// Computes syntax highlighting for the given file
    pub fn highlight(&self, file_id: FileId) -> Cancelable<Vec<HlRange>> {
        self.with_db(|db| syntax_highlighting::highlight(db, file_id, None, false))
diff --git a/crates/ide/src/references/rename.rs b/crates/ide/src/references/rename.rs
index bb68bcc78..1e378279d 100644
--- a/crates/ide/src/references/rename.rs
+++ b/crates/ide/src/references/rename.rs
@@ -21,7 +21,7 @@ use crate::{display::TryToNav, FilePosition, FileSystemEdit, RangeInfo, SourceCh
 type RenameResult<T> = Result<T, RenameError>;
 #[derive(Debug)]
-pub struct RenameError(pub(crate) String);
+pub struct RenameError(String);
 impl fmt::Display for RenameError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
@@ -47,16 +47,15 @@ pub(crate) fn prepare_rename(
    let sema = Semantics::new(db);
    let source_file = sema.parse(position.file_id);
    let syntax = source_file.syntax();
-    let range = match &sema
+    let name_like = sema
        .find_node_at_offset_with_descend(&syntax, position.offset)
-        .ok_or_else(|| format_err!("No references found at position"))?
+        .ok_or_else(|| format_err!("No references found at position"))?;
-    {
+    let node = match &name_like {
        ast::NameLike::Name(it) => it.syntax(),
        ast::NameLike::NameRef(it) => it.syntax(),
        ast::NameLike::Lifetime(it) => it.syntax(),
-    }
+    };
-    .text_range();
+    Ok(RangeInfo::new(sema.original_range(node).range, ()))
-    Ok(RangeInfo::new(range, ()))
 }
 // Feature: Rename
@@ -546,6 +545,8 @@ mod tests {
    use crate::{fixture, FileId};
+    use super::{RangeInfo, RenameError};
    fn check(new_name: &str, ra_fixture_before: &str, ra_fixture_after: &str) {
        let ra_fixture_after = &trim_indent(ra_fixture_after);
        let (analysis, position) = fixture::position(ra_fixture_before);
@@ -591,6 +592,45 @@ mod tests {
        expect.assert_debug_eq(&source_change)
    }
+    fn check_prepare(ra_fixture: &str, expect: Expect) {
+        let (analysis, position) = fixture::position(ra_fixture);
+        let result = analysis
+            .prepare_rename(position)
+            .unwrap_or_else(|err| panic!("PrepareRename was cancelled: {}", err));
+        match result {
+            Ok(RangeInfo { range, info: () }) => {
+                let source = analysis.file_text(position.file_id).unwrap();
+                expect.assert_eq(&format!("{:?}: {}", range, &source[range]))
+            }
+            Err(RenameError(err)) => expect.assert_eq(&err),
+        };
+    }
+    #[test]
+    fn test_prepare_rename_namelikes() {
+        check_prepare(r"fn name$0<'lifetime>() {}", expect![[r#"3..7: name"#]]);
+        check_prepare(r"fn name<'lifetime$0>() {}", expect![[r#"8..17: 'lifetime"#]]);
+        check_prepare(r"fn name<'lifetime>() { name$0(); }", expect![[r#"23..27: name"#]]);
+    }
+    #[test]
+    fn test_prepare_rename_in_macro() {
+        check_prepare(
+            r"macro_rules! foo {
+    ($ident:ident) => {
+        pub struct $ident;
+    }
+}
+foo!(Foo$0);",
+            expect![[r#"83..86: Foo"#]],
+        );
+    }
+    #[test]
+    fn test_prepare_rename_keyword() {
+        check_prepare(r"struct$0 Foo;", expect![[r#"No references found at position"#]]);
+    }
    #[test]
    fn test_rename_to_underscore() {
        check("_", r#"fn main() { let i$0 = 1; }"#, r#"fn main() { let _ = 1; }"#);
diff --git a/crates/ide/src/runnables.rs b/crates/ide/src/runnables.rs
index 280565563..27d35de5b 100644
--- a/crates/ide/src/runnables.rs
+++ b/crates/ide/src/runnables.rs
@@ -1,10 +1,17 @@
 use std::fmt;
+use ast::NameOwner;
 use cfg::CfgExpr;
-use hir::{AsAssocItem, HasAttrs, HasSource, Semantics};
+use hir::{AsAssocItem, HasAttrs, HasSource, HirDisplay, Semantics};
 use ide_assists::utils::test_related_attribute;
-use ide_db::{defs::Definition, RootDatabase, SymbolKind};
+use ide_db::{
+    base_db::{FilePosition, FileRange},
+    defs::Definition,
+    search::SearchScope,
+    RootDatabase, SymbolKind,
+};
 use itertools::Itertools;
+use rustc_hash::FxHashSet;
 use syntax::{
    ast::{self, AstNode, AttrsOwner},
    match_ast, SyntaxNode,
@@ -12,17 +19,17 @@ use syntax::{
 use crate::{
    display::{ToNav, TryToNav},
-    FileId, NavigationTarget,
+    references, FileId, NavigationTarget,
 };
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Hash, PartialEq, Eq)]
 pub struct Runnable {
    pub nav: NavigationTarget,
    pub kind: RunnableKind,
    pub cfg: Option<CfgExpr>,
 }
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Hash, PartialEq, Eq)]
 pub enum TestId {
    Name(String),
    Path(String),
@@ -37,7 +44,7 @@ impl fmt::Display for TestId {
    }
 }
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Hash, PartialEq, Eq)]
 pub enum RunnableKind {
    Test { test_id: TestId, attr: TestAttr },
    TestMod { path: String },
@@ -105,6 +112,105 @@ pub(crate) fn runnables(db: &RootDatabase, file_id: FileId) -> Vec<Runnable> {
    res
 }
+// Feature: Related Tests
+//
+// Provides a sneak peek of all tests where the current item is used.
+//
+// The simplest way to use this feature is via the context menu:
+//  - Right-click on the selected item. The context menu opens.
+//  - Select **Peek related tests**
+//
+// |===
+// | Editor  | Action Name
+//
+// | VS Code | **Rust Analyzer: Peek related tests**
+// |===
+pub(crate) fn related_tests(
+    db: &RootDatabase,
+    position: FilePosition,
+    search_scope: Option<SearchScope>,
+) -> Vec<Runnable> {
+    let sema = Semantics::new(db);
+    let mut res: FxHashSet<Runnable> = FxHashSet::default();
+    find_related_tests(&sema, position, search_scope, &mut res);
+    res.into_iter().collect_vec()
+}
+fn find_related_tests(
+    sema: &Semantics<RootDatabase>,
+    position: FilePosition,
+    search_scope: Option<SearchScope>,
+    tests: &mut FxHashSet<Runnable>,
+) {
+    if let Some(refs) = references::find_all_refs(&sema, position, search_scope) {
+        for (file_id, refs) in refs.references {
+            let file = sema.parse(file_id);
+            let file = file.syntax();
+            let functions = refs.iter().filter_map(|(range, _)| {
+                let token = file.token_at_offset(range.start()).next()?;
+                let token = sema.descend_into_macros(token);
+                let syntax = token.parent();
+                syntax.ancestors().find_map(ast::Fn::cast)
+            });
+            for fn_def in functions {
+                if let Some(runnable) = as_test_runnable(&sema, &fn_def) {
+                    // direct test
+                    tests.insert(runnable);
+                } else if let Some(module) = parent_test_module(&sema, &fn_def) {
+                    // indirect test
+                    find_related_tests_in_module(sema, &fn_def, &module, tests);
+                }
+            }
+        }
+    }
+}
+fn find_related_tests_in_module(
+    sema: &Semantics<RootDatabase>,
+    fn_def: &ast::Fn,
+    parent_module: &hir::Module,
+    tests: &mut FxHashSet<Runnable>,
+) {
+    if let Some(fn_name) = fn_def.name() {
+        let mod_source = parent_module.definition_source(sema.db);
+        let range = match mod_source.value {
+            hir::ModuleSource::Module(m) => m.syntax().text_range(),
+            hir::ModuleSource::BlockExpr(b) => b.syntax().text_range(),
+            hir::ModuleSource::SourceFile(f) => f.syntax().text_range(),
+        };
+        let file_id = mod_source.file_id.original_file(sema.db);
+        let mod_scope = SearchScope::file_range(FileRange { file_id, range });
+        let fn_pos = FilePosition { file_id, offset: fn_name.syntax().text_range().start() };
+        find_related_tests(sema, fn_pos, Some(mod_scope), tests)
+    }
+}
+fn as_test_runnable(sema: &Semantics<RootDatabase>, fn_def: &ast::Fn) -> Option<Runnable> {
+    if test_related_attribute(&fn_def).is_some() {
+        let function = sema.to_def(fn_def)?;
+        runnable_fn(sema, function)
+    } else {
+        None
+    }
+}
+fn parent_test_module(sema: &Semantics<RootDatabase>, fn_def: &ast::Fn) -> Option<hir::Module> {
+    fn_def.syntax().ancestors().find_map(|node| {
+        let module = ast::Module::cast(node)?;
+        let module = sema.to_def(&module)?;
+        if has_test_function_or_multiple_test_submodules(sema, &module) {
+            Some(module)
+        } else {
+            None
+        }
+    })
+}
 fn runnables_mod(sema: &Semantics<RootDatabase>, acc: &mut Vec<Runnable>, module: hir::Module) {
    acc.extend(module.declarations(sema.db).into_iter().filter_map(|def| {
        let runnable = match def {
@@ -234,11 +340,21 @@ fn module_def_doctest(sema: &Semantics<RootDatabase>, def: hir::ModuleDef) -> Op
            // FIXME: this also looks very wrong
            if let Some(assoc_def) = assoc_def {
                if let hir::AssocItemContainer::Impl(imp) = assoc_def.container(sema.db) {
-                    if let Some(adt) = imp.target_ty(sema.db).as_adt() {
+                    let ty = imp.target_ty(sema.db);
-                        let name = adt.name(sema.db).to_string();
+                    if let Some(adt) = ty.as_adt() {
+                        let name = adt.name(sema.db);
                        let idx = path.rfind(':').map_or(0, |idx| idx + 1);
                        let (prefix, suffix) = path.split_at(idx);
-                        return format!("{}{}::{}", prefix, name, suffix);
+                        let mut ty_params = ty.type_parameters().peekable();
+                        let params = if ty_params.peek().is_some() {
+                            format!(
+                                "<{}>",
+                                ty_params.format_with(", ", |ty, cb| cb(&ty.display(sema.db)))
+                            )
+                        } else {
+                            String::new()
+                        };
+                        return format!("{}{}{}::{}", prefix, name, params, suffix);
                    }
                }
            }
@@ -256,7 +372,7 @@ fn module_def_doctest(sema: &Semantics<RootDatabase>, def: hir::ModuleDef) -> Op
    Some(res)
 }
-#[derive(Debug, Copy, Clone)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
 pub struct TestAttr {
    pub ignore: bool,
 }
@@ -349,6 +465,12 @@ mod tests {
        );
    }
+    fn check_tests(ra_fixture: &str, expect: Expect) {
+        let (analysis, position) = fixture::position(ra_fixture);
+        let tests = analysis.related_tests(position, None).unwrap();
+        expect.assert_debug_eq(&tests);
+    }
    #[test]
    fn test_runnables() {
        check(
@@ -1074,4 +1196,261 @@ mod tests {
            "#]],
        );
    }
+    #[test]
+    fn find_no_tests() {
+        check_tests(
+            r#"
+//- /lib.rs
+fn foo$0() {  };
+"#,
+            expect![[r#"
+                []
+            "#]],
+        );
+    }
+    #[test]
+    fn find_direct_fn_test() {
+        check_tests(
+            r#"
+//- /lib.rs
+fn foo$0() { };
+mod tests {
+    #[test]
+    fn foo_test() {
+        super::foo()
+    }
+}
+"#,
+            expect![[r#"
+                [
+                    Runnable {
+                        nav: NavigationTarget {
+                            file_id: FileId(
+                                0,
+                            ),
+                            full_range: 31..85,
+                            focus_range: 46..54,
+                            name: "foo_test",
+                            kind: Function,
+                        },
+                        kind: Test {
+                            test_id: Path(
+                                "tests::foo_test",
+                            ),
+                            attr: TestAttr {
+                                ignore: false,
+                            },
+                        },
+                        cfg: None,
+                    },
+                ]
+            "#]],
+        );
+    }
+    #[test]
+    fn find_direct_struct_test() {
+        check_tests(
+            r#"
+//- /lib.rs
+struct Fo$0o;
+fn foo(arg: &Foo) { };
+mod tests {
+    use super::*;
+    #[test]
+    fn foo_test() {
+        foo(Foo);
+    }
+}
+"#,
+            expect![[r#"
+            [
+                Runnable {
+                    nav: NavigationTarget {
+                        file_id: FileId(
+                            0,
+                        ),
+                        full_range: 71..122,
+                        focus_range: 86..94,
+                        name: "foo_test",
+                        kind: Function,
+                    },
+                    kind: Test {
+                        test_id: Path(
+                            "tests::foo_test",
+                        ),
+                        attr: TestAttr {
+                            ignore: false,
+                        },
+                    },
+                    cfg: None,
+                },
+            ]
+            "#]],
+        );
+    }
+    #[test]
+    fn find_indirect_fn_test() {
+        check_tests(
+            r#"
+//- /lib.rs
+fn foo$0() { };
+mod tests {
+    use super::foo;
+    fn check1() {
+        check2()
+    }
+    fn check2() {
+        foo()
+    }
+    #[test]
+    fn foo_test() {
+        check1()
+    }
+}
+"#,
+            expect![[r#"
+                [
+                    Runnable {
+                        nav: NavigationTarget {
+                            file_id: FileId(
+                                0,
+                            ),
+                            full_range: 133..183,
+                            focus_range: 148..156,
+                            name: "foo_test",
+                            kind: Function,
+                        },
+                        kind: Test {
+                            test_id: Path(
+                                "tests::foo_test",
+                            ),
+                            attr: TestAttr {
+                                ignore: false,
+                            },
+                        },
+                        cfg: None,
+                    },
+                ]
+            "#]],
+        );
+    }
+    #[test]
+    fn tests_are_unique() {
+        check_tests(
+            r#"
+//- /lib.rs
+fn foo$0() { };
+mod tests {
+    use super::foo;
+    #[test]
+    fn foo_test() {
+        foo();
+        foo();
+    }
+    #[test]
+    fn foo2_test() {
+        foo();
+        foo();
+    }
+}
+"#,
+            expect![[r#"
+            [
+                Runnable {
+                    nav: NavigationTarget {
+                        file_id: FileId(
+                            0,
+                        ),
+                        full_range: 52..115,
+                        focus_range: 67..75,
+                        name: "foo_test",
+                        kind: Function,
+                    },
+                    kind: Test {
+                        test_id: Path(
+                            "tests::foo_test",
+                        ),
+                        attr: TestAttr {
+                            ignore: false,
+                        },
+                    },
+                    cfg: None,
+                },
+                Runnable {
+                    nav: NavigationTarget {
+                        file_id: FileId(
+                            0,
+                        ),
+                        full_range: 121..185,
+                        focus_range: 136..145,
+                        name: "foo2_test",
+                        kind: Function,
+                    },
+                    kind: Test {
+                        test_id: Path(
+                            "tests::foo2_test",
+                        ),
+                        attr: TestAttr {
+                            ignore: false,
+                        },
+                    },
+                    cfg: None,
+                },
+            ]
+            "#]],
+        );
+    }
+    #[test]
+    fn doc_test_type_params() {
+        check(
+            r#"
+//- /lib.rs
+$0
+struct Foo<T, U>;
+impl<T, U> Foo<T, U> {
+    /// ```rust
+    /// ````
+    fn t() {}
+}
+"#,
+            &[&DOCTEST],
+            expect![[r#"
+                [
+                    Runnable {
+                        nav: NavigationTarget {
+                            file_id: FileId(
+                                0,
+                            ),
+                            full_range: 47..85,
+                            name: "t",
+                        },
+                        kind: DocTest {
+                            test_id: Path(
+                                "Foo<T, U>::t",
+                            ),
+                        },
+                        cfg: None,
+                    },
+                ]
+            "#]],
+        );
+    }
 }
diff --git a/crates/ide_assists/src/handlers/add_turbo_fish.rs b/crates/ide_assists/src/handlers/add_turbo_fish.rs
index 3b6efbab4..ee879c151 100644
--- a/crates/ide_assists/src/handlers/add_turbo_fish.rs
+++ b/crates/ide_assists/src/handlers/add_turbo_fish.rs
@@ -56,13 +56,20 @@ pub(crate) fn add_turbo_fish(acc: &mut Assists, ctx: &AssistContext) -> Option<(
    if let Some(let_stmt) = ctx.find_node_at_offset::<ast::LetStmt>() {
        if let_stmt.colon_token().is_none() {
            let type_pos = let_stmt.pat()?.syntax().last_token()?.text_range().end();
+            let semi_pos = let_stmt.syntax().last_token()?.text_range().end();
            acc.add(
                AssistId("add_type_ascription", AssistKind::RefactorRewrite),
                "Add `: _` before assignment operator",
                ident.text_range(),
-                |builder| match ctx.config.snippet_cap {
+                |builder| {
-                    Some(cap) => builder.insert_snippet(cap, type_pos, ": ${0:_}"),
+                    if let_stmt.semicolon_token().is_none() {
-                    None => builder.insert(type_pos, ": _"),
+                        builder.insert(semi_pos, ";");
+                    }
+                    match ctx.config.snippet_cap {
+                        Some(cap) => builder.insert_snippet(cap, type_pos, ": ${0:_}"),
+                        None => builder.insert(type_pos, ": _"),
+                    }
                },
            )?
        } else {
@@ -265,4 +272,24 @@ fn main() {
 "#,
        );
    }
+    #[test]
+    fn add_type_ascription_append_semicolon() {
+        check_assist_by_label(
+            add_turbo_fish,
+            r#"
+fn make<T>() -> T {}
+fn main() {
+    let x = make$0()
+}
+"#,
+            r#"
+fn make<T>() -> T {}
+fn main() {
+    let x: ${0:_} = make();
+}
+"#,
+            "Add `: _` before assignment operator",
+        );
+    }
 }
diff --git a/crates/ide_assists/src/handlers/apply_demorgan.rs b/crates/ide_assists/src/handlers/apply_demorgan.rs
index a1c339603..5c936a510 100644
--- a/crates/ide_assists/src/handlers/apply_demorgan.rs
+++ b/crates/ide_assists/src/handlers/apply_demorgan.rs
@@ -1,3 +1,5 @@
+use std::collections::VecDeque;
 use syntax::ast::{self, AstNode};
 use crate::{utils::invert_boolean_expression, AssistContext, AssistId, AssistKind, Assists};
@@ -30,19 +32,52 @@ pub(crate) fn apply_demorgan(acc: &mut Assists, ctx: &AssistContext) -> Option<(
        return None;
    }
-    let lhs = expr.lhs()?;
+    let mut expr = expr;
-    let lhs_range = lhs.syntax().text_range();
-    let not_lhs = invert_boolean_expression(&ctx.sema, lhs);
+    // Walk up the tree while we have the same binary operator
+    while let Some(parent_expr) = expr.syntax().parent().and_then(ast::BinExpr::cast) {
+        if let Some(parent_op) = expr.op_kind() {
+            if parent_op == op {
+                expr = parent_expr
+            }
+        }
+    }
+    let mut expr_stack = vec![expr.clone()];
+    let mut terms = Vec::new();
+    let mut op_ranges = Vec::new();
+    // Find all the children with the same binary operator
+    while let Some(expr) = expr_stack.pop() {
+        let mut traverse_bin_expr_arm = |expr| {
+            if let ast::Expr::BinExpr(bin_expr) = expr {
+                if let Some(expr_op) = bin_expr.op_kind() {
+                    if expr_op == op {
+                        expr_stack.push(bin_expr);
+                    } else {
+                        terms.push(ast::Expr::BinExpr(bin_expr));
+                    }
+                } else {
+                    terms.push(ast::Expr::BinExpr(bin_expr));
+                }
+            } else {
+                terms.push(expr);
+            }
+        };
-    let rhs = expr.rhs()?;
+        op_ranges.extend(expr.op_token().map(|t| t.text_range()));
-    let rhs_range = rhs.syntax().text_range();
+        traverse_bin_expr_arm(expr.lhs()?);
-    let not_rhs = invert_boolean_expression(&ctx.sema, rhs);
+        traverse_bin_expr_arm(expr.rhs()?);
+    }
    acc.add(
        AssistId("apply_demorgan", AssistKind::RefactorRewrite),
        "Apply De Morgan's law",
        op_range,
        |edit| {
+            terms.sort_by_key(|t| t.syntax().text_range().start());
+            let mut terms = VecDeque::from(terms);
            let paren_expr = expr.syntax().parent().and_then(|parent| ast::ParenExpr::cast(parent));
            let neg_expr = paren_expr
@@ -57,11 +92,18 @@ pub(crate) fn apply_demorgan(acc: &mut Assists, ctx: &AssistContext) -> Option<(
                    }
                });
-            edit.replace(op_range, opposite_op);
+            for op_range in op_ranges {
+                edit.replace(op_range, opposite_op);
+            }
            if let Some(paren_expr) = paren_expr {
-                edit.replace(lhs_range, not_lhs.syntax().text());
+                for term in terms {
-                edit.replace(rhs_range, not_rhs.syntax().text());
+                    let range = term.syntax().text_range();
+                    let not_term = invert_boolean_expression(&ctx.sema, term);
+                    edit.replace(range, not_term.syntax().text());
+                }
                if let Some(neg_expr) = neg_expr {
                    cov_mark::hit!(demorgan_double_negation);
                    edit.replace(neg_expr.op_token().unwrap().text_range(), "");
@@ -70,8 +112,25 @@ pub(crate) fn apply_demorgan(acc: &mut Assists, ctx: &AssistContext) -> Option<(
                    edit.replace(paren_expr.l_paren_token().unwrap().text_range(), "!(");
                }
            } else {
-                edit.replace(lhs_range, format!("!({}", not_lhs.syntax().text()));
+                if let Some(lhs) = terms.pop_front() {
-                edit.replace(rhs_range, format!("{})", not_rhs.syntax().text()));
+                    let lhs_range = lhs.syntax().text_range();
+                    let not_lhs = invert_boolean_expression(&ctx.sema, lhs);
+                    edit.replace(lhs_range, format!("!({}", not_lhs.syntax().text()));
+                }
+                if let Some(rhs) = terms.pop_back() {
+                    let rhs_range = rhs.syntax().text_range();
+                    let not_rhs = invert_boolean_expression(&ctx.sema, rhs);
+                    edit.replace(rhs_range, format!("{})", not_rhs.syntax().text()));
+                }
+                for term in terms {
+                    let term_range = term.syntax().text_range();
+                    let not_term = invert_boolean_expression(&ctx.sema, term);
+                    edit.replace(term_range, not_term.syntax().text());
+                }
            }
        },
    )
@@ -180,6 +239,12 @@ fn f() {
    }
    #[test]
+    fn demorgan_multiple_terms() {
+        check_assist(apply_demorgan, "fn f() { x ||$0 y || z }", "fn f() { !(!x && !y && !z) }");
+        check_assist(apply_demorgan, "fn f() { x || y ||$0 z }", "fn f() { !(!x && !y && !z) }");
+    }
+    #[test]
    fn demorgan_doesnt_apply_with_cursor_not_on_op() {
        check_assist_not_applicable(apply_demorgan, "fn f() { $0 !x || !x }")
    }
diff --git a/crates/ide_assists/src/handlers/convert_iter_for_each_to_for.rs b/crates/ide_assists/src/handlers/convert_iter_for_each_to_for.rs
new file mode 100644
index 000000000..4e75a7b14
--- /dev/null
+++ b/crates/ide_assists/src/handlers/convert_iter_for_each_to_for.rs
@@ -0,0 +1,248 @@
+use ide_db::helpers::FamousDefs;
+use syntax::{
+    ast::{self, edit::AstNodeEdit, make, ArgListOwner},
+    AstNode,
+};
+use crate::{AssistContext, AssistId, AssistKind, Assists};
+// Assist: convert_iter_for_each_to_for
+//
+// Converts an Iterator::for_each function into a for loop.
+//
+// ```
+// # //- /lib.rs crate:core
+// # pub mod iter { pub mod traits { pub mod iterator { pub trait Iterator {} } } }
+// # pub struct SomeIter;
+// # impl self::iter::traits::iterator::Iterator for SomeIter {}
+// # //- /lib.rs crate:main deps:core
+// # use core::SomeIter;
+// fn main() {
+//     let iter = SomeIter;
+//     iter.for_each$0(|(x, y)| {
+//         println!("x: {}, y: {}", x, y);
+//     });
+// }
+// ```
+// ->
+// ```
+// # use core::SomeIter;
+// fn main() {
+//     let iter = SomeIter;
+//     for (x, y) in iter {
+//         println!("x: {}, y: {}", x, y);
+//     }
+// }
+// ```
+pub(crate) fn convert_iter_for_each_to_for(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
+    let method = ctx.find_node_at_offset::<ast::MethodCallExpr>()?;
+    let closure = match method.arg_list()?.args().next()? {
+        ast::Expr::ClosureExpr(expr) => expr,
+        _ => return None,
+    };
+    let (method, receiver) = validate_method_call_expr(ctx, method)?;
+    let param_list = closure.param_list()?;
+    let param = param_list.params().next()?.pat()?;
+    let body = closure.body()?;
+    let stmt = method.syntax().parent().and_then(ast::ExprStmt::cast);
+    let syntax = stmt.as_ref().map_or(method.syntax(), |stmt| stmt.syntax());
+    acc.add(
+        AssistId("convert_iter_for_each_to_for", AssistKind::RefactorRewrite),
+        "Replace this `Iterator::for_each` with a for loop",
+        syntax.text_range(),
+        |builder| {
+            let indent = stmt.as_ref().map_or(method.indent_level(), |stmt| stmt.indent_level());
+            let block = match body {
+                ast::Expr::BlockExpr(block) => block,
+                _ => make::block_expr(Vec::new(), Some(body)),
+            }
+            .reset_indent()
+            .indent(indent);
+            let expr_for_loop = make::expr_for_loop(param, receiver, block);
+            builder.replace(syntax.text_range(), expr_for_loop.syntax().text())
+        },
+    )
+}
+fn validate_method_call_expr(
+    ctx: &AssistContext,
+    expr: ast::MethodCallExpr,
+) -> Option<(ast::Expr, ast::Expr)> {
+    let name_ref = expr.name_ref()?;
+    if name_ref.syntax().text_range().intersect(ctx.frange.range).is_none()
+        || name_ref.text() != "for_each"
+    {
+        return None;
+    }
+    let sema = &ctx.sema;
+    let receiver = expr.receiver()?;
+    let expr = ast::Expr::MethodCallExpr(expr);
+    let it_type = sema.type_of_expr(&receiver)?;
+    let module = sema.scope(receiver.syntax()).module()?;
+    let krate = module.krate();
+    let iter_trait = FamousDefs(sema, Some(krate)).core_iter_Iterator()?;
+    it_type.impls_trait(sema.db, iter_trait, &[]).then(|| (expr, receiver))
+}
+#[cfg(test)]
+mod tests {
+    use crate::tests::{self, check_assist};
+    use super::*;
+    const EMPTY_ITER_FIXTURE: &'static str = r"
+//- /lib.rs deps:core crate:empty_iter
+pub struct EmptyIter;
+impl Iterator for EmptyIter {
+    type Item = usize;
+    fn next(&mut self) -> Option<Self::Item> { None }
+}
+pub struct Empty;
+impl Empty {
+    pub fn iter(&self) -> EmptyIter { EmptyIter }
+}
+";
+    fn check_assist_with_fixtures(before: &str, after: &str) {
+        let before = &format!(
+            "//- /main.rs crate:main deps:core,empty_iter{}{}{}",
+            before,
+            EMPTY_ITER_FIXTURE,
+            FamousDefs::FIXTURE,
+        );
+        check_assist(convert_iter_for_each_to_for, before, after);
+    }
+    fn check_assist_not_applicable(before: &str) {
+        let before = &format!(
+            "//- /main.rs crate:main deps:core,empty_iter{}{}{}",
+            before,
+            EMPTY_ITER_FIXTURE,
+            FamousDefs::FIXTURE,
+        );
+        tests::check_assist_not_applicable(convert_iter_for_each_to_for, before);
+    }
+    #[test]
+    fn test_for_each_in_method_stmt() {
+        check_assist_with_fixtures(
+            r#"
+use empty_iter::*;
+fn main() {
+    let x = Empty;
+    x.iter().$0for_each(|(x, y)| {
+        println!("x: {}, y: {}", x, y);
+    });
+}"#,
+            r#"
+use empty_iter::*;
+fn main() {
+    let x = Empty;
+    for (x, y) in x.iter() {
+        println!("x: {}, y: {}", x, y);
+    }
+}
+"#,
+        )
+    }
+    #[test]
+    fn test_for_each_in_method() {
+        check_assist_with_fixtures(
+            r#"
+use empty_iter::*;
+fn main() {
+    let x = Empty;
+    x.iter().$0for_each(|(x, y)| {
+        println!("x: {}, y: {}", x, y);
+    })
+}"#,
+            r#"
+use empty_iter::*;
+fn main() {
+    let x = Empty;
+    for (x, y) in x.iter() {
+        println!("x: {}, y: {}", x, y);
+    }
+}
+"#,
+        )
+    }
+    #[test]
+    fn test_for_each_in_iter_stmt() {
+        check_assist_with_fixtures(
+            r#"
+use empty_iter::*;
+fn main() {
+    let x = Empty.iter();
+    x.$0for_each(|(x, y)| {
+        println!("x: {}, y: {}", x, y);
+    });
+}"#,
+            r#"
+use empty_iter::*;
+fn main() {
+    let x = Empty.iter();
+    for (x, y) in x {
+        println!("x: {}, y: {}", x, y);
+    }
+}
+"#,
+        )
+    }
+    #[test]
+    fn test_for_each_without_braces_stmt() {
+        check_assist_with_fixtures(
+            r#"
+use empty_iter::*;
+fn main() {
+    let x = Empty;
+    x.iter().$0for_each(|(x, y)| println!("x: {}, y: {}", x, y));
+}"#,
+            r#"
+use empty_iter::*;
+fn main() {
+    let x = Empty;
+    for (x, y) in x.iter() {
+        println!("x: {}, y: {}", x, y)
+    }
+}
+"#,
+        )
+    }
+    #[test]
+    fn test_for_each_not_applicable() {
+        check_assist_not_applicable(
+            r#"
+fn main() {
+    ().$0for_each(|x| println!("{}", x));
+}"#,
+        )
+    }
+    #[test]
+    fn test_for_each_not_applicable_invalid_cursor_pos() {
+        check_assist_not_applicable(
+            r#"
+use empty_iter::*;
+fn main() {
+    Empty.iter().for_each(|(x, y)| $0println!("x: {}, y: {}", x, y));
+}"#,
+        )
+    }
+}
diff --git a/crates/ide_assists/src/lib.rs b/crates/ide_assists/src/lib.rs
index ea62d5f5d..f1aab74d4 100644
--- a/crates/ide_assists/src/lib.rs
+++ b/crates/ide_assists/src/lib.rs
@@ -116,6 +116,7 @@ mod handlers {
    mod change_visibility;
    mod convert_integer_literal;
    mod convert_comment_block;
+    mod convert_iter_for_each_to_for;
    mod early_return;
    mod expand_glob_import;
    mod extract_function;
@@ -181,6 +182,7 @@ mod handlers {
            change_visibility::change_visibility,
            convert_integer_literal::convert_integer_literal,
            convert_comment_block::convert_comment_block,
+            convert_iter_for_each_to_for::convert_iter_for_each_to_for,
            early_return::convert_to_guarded_return,
            expand_glob_import::expand_glob_import,
            extract_struct_from_enum_variant::extract_struct_from_enum_variant,
diff --git a/crates/ide_assists/src/tests/generated.rs b/crates/ide_assists/src/tests/generated.rs
index 304b5798f..3f77edd8d 100644
--- a/crates/ide_assists/src/tests/generated.rs
+++ b/crates/ide_assists/src/tests/generated.rs
@@ -206,6 +206,36 @@ const _: i32 = 0b1010;
 }
 #[test]
+fn doctest_convert_iter_for_each_to_for() {
+    check_doc_test(
+        "convert_iter_for_each_to_for",
+        r#####"
+//- /lib.rs crate:core
+pub mod iter { pub mod traits { pub mod iterator { pub trait Iterator {} } } }
+pub struct SomeIter;
+impl self::iter::traits::iterator::Iterator for SomeIter {}
+//- /lib.rs crate:main deps:core
+use core::SomeIter;
+fn main() {
+    let iter = SomeIter;
+    iter.for_each$0(|(x, y)| {
+        println!("x: {}, y: {}", x, y);
+    });
+}
+"#####,
+        r#####"
+use core::SomeIter;
+fn main() {
+    let iter = SomeIter;
+    for (x, y) in iter {
+        println!("x: {}, y: {}", x, y);
+    }
+}
+"#####,
+    )
+}
+#[test]
 fn doctest_convert_to_guarded_return() {
    check_doc_test(
        "convert_to_guarded_return",
diff --git a/crates/ide_completion/src/completions/attribute.rs b/crates/ide_completion/src/completions/attribute.rs
index cb05e85fc..e846678b4 100644
--- a/crates/ide_completion/src/completions/attribute.rs
+++ b/crates/ide_completion/src/completions/attribute.rs
@@ -45,15 +45,15 @@ fn complete_attribute_start(acc: &mut Completions, ctx: &CompletionContext, attr
            CompletionKind::Attribute,
            ctx.source_range(),
            attr_completion.label,
-        )
+        );
-        .kind(CompletionItemKind::Attribute);
+        item.kind(CompletionItemKind::Attribute);
        if let Some(lookup) = attr_completion.lookup {
-            item = item.lookup_by(lookup);
+            item.lookup_by(lookup);
        }
        if let Some((snippet, cap)) = attr_completion.snippet.zip(ctx.config.snippet_cap) {
-            item = item.insert_snippet(cap, snippet);
+            item.insert_snippet(cap, snippet);
        }
        if attribute.kind() == ast::AttrKind::Inner || !attr_completion.prefer_inner {
@@ -168,16 +168,20 @@ fn complete_derive(acc: &mut Completions, ctx: &CompletionContext, derive_input:
            );
            let lookup = components.join(", ");
            let label = components.iter().rev().join(", ");
-            CompletionItem::new(CompletionKind::Attribute, ctx.source_range(), label)
+            let mut item =
-                .lookup_by(lookup)
+                CompletionItem::new(CompletionKind::Attribute, ctx.source_range(), label);
-                .kind(CompletionItemKind::Attribute)
+            item.lookup_by(lookup).kind(CompletionItemKind::Attribute);
-                .add_to(acc)
+            item.add_to(acc);
        }
        for custom_derive_name in get_derive_names_in_scope(ctx).difference(&existing_derives) {
-            CompletionItem::new(CompletionKind::Attribute, ctx.source_range(), custom_derive_name)
+            let mut item = CompletionItem::new(
-                .kind(CompletionItemKind::Attribute)
+                CompletionKind::Attribute,
-                .add_to(acc)
+                ctx.source_range(),
+                custom_derive_name,
+            );
+            item.kind(CompletionItemKind::Attribute);
+            item.add_to(acc);
        }
    }
 }
@@ -193,14 +197,13 @@ fn complete_lint(
            .into_iter()
            .filter(|completion| !existing_lints.contains(completion.label))
        {
-            CompletionItem::new(
+            let mut item = CompletionItem::new(
                CompletionKind::Attribute,
                ctx.source_range(),
                lint_completion.label,
-            )
+            );
-            .kind(CompletionItemKind::Attribute)
+            item.kind(CompletionItemKind::Attribute).detail(lint_completion.description);
-            .detail(lint_completion.description)
+            item.add_to(acc)
-            .add_to(acc)
        }
    }
 }
diff --git a/crates/ide_completion/src/completions/fn_param.rs b/crates/ide_completion/src/completions/fn_param.rs
index 1bcc8727f..0243dce56 100644
--- a/crates/ide_completion/src/completions/fn_param.rs
+++ b/crates/ide_completion/src/completions/fn_param.rs
@@ -54,10 +54,9 @@ pub(crate) fn complete_fn_param(acc: &mut Completions, ctx: &CompletionContext)
    }
    params.into_iter().for_each(|(label, lookup)| {
-        CompletionItem::new(CompletionKind::Magic, ctx.source_range(), label)
+        let mut item = CompletionItem::new(CompletionKind::Magic, ctx.source_range(), label);
-            .kind(CompletionItemKind::Binding)
+        item.kind(CompletionItemKind::Binding).lookup_by(lookup);
-            .lookup_by(lookup)
+        item.add_to(acc)
-            .add_to(acc)
    });
 }
diff --git a/crates/ide_completion/src/completions/keyword.rs b/crates/ide_completion/src/completions/keyword.rs
index 80aa9fb06..b635e0ca3 100644
--- a/crates/ide_completion/src/completions/keyword.rs
+++ b/crates/ide_completion/src/completions/keyword.rs
@@ -12,21 +12,19 @@ pub(crate) fn complete_use_tree_keyword(acc: &mut Completions, ctx: &CompletionC
    if ctx.use_item_syntax.is_some() {
        if ctx.path_qual.is_none() {
-            CompletionItem::new(CompletionKind::Keyword, source_range, "crate::")
+            let mut item = CompletionItem::new(CompletionKind::Keyword, source_range, "crate::");
-                .kind(CompletionItemKind::Keyword)
+            item.kind(CompletionItemKind::Keyword).insert_text("crate::");
-                .insert_text("crate::")
+            item.add_to(acc);
-                .add_to(acc);
        }
-        CompletionItem::new(CompletionKind::Keyword, source_range, "self")
+        let mut item = CompletionItem::new(CompletionKind::Keyword, source_range, "self");
-            .kind(CompletionItemKind::Keyword)
+        item.kind(CompletionItemKind::Keyword);
-            .add_to(acc);
+        item.add_to(acc);
        if iter::successors(ctx.path_qual.clone(), |p| p.qualifier())
            .all(|p| p.segment().and_then(|s| s.super_token()).is_some())
        {
-            CompletionItem::new(CompletionKind::Keyword, source_range, "super::")
+            let mut item = CompletionItem::new(CompletionKind::Keyword, source_range, "super::");
-                .kind(CompletionItemKind::Keyword)
+            item.kind(CompletionItemKind::Keyword).insert_text("super::");
-                .insert_text("super::")
+            item.add_to(acc);
-                .add_to(acc);
        }
    }
@@ -34,11 +32,10 @@ pub(crate) fn complete_use_tree_keyword(acc: &mut Completions, ctx: &CompletionC
    if let Some(receiver) = &ctx.dot_receiver {
        if let Some(ty) = ctx.sema.type_of_expr(receiver) {
            if ty.impls_future(ctx.db) {
-                CompletionItem::new(CompletionKind::Keyword, ctx.source_range(), "await")
+                let mut item =
-                    .kind(CompletionItemKind::Keyword)
+                    CompletionItem::new(CompletionKind::Keyword, ctx.source_range(), "await");
-                    .detail("expr.await")
+                item.kind(CompletionItemKind::Keyword).detail("expr.await").insert_text("await");
-                    .insert_text("await")
+                item.add_to(acc);
-                    .add_to(acc);
            }
        };
    }
@@ -165,9 +162,10 @@ pub(crate) fn complete_expr_keyword(acc: &mut Completions, ctx: &CompletionConte
 }
 fn add_keyword(ctx: &CompletionContext, acc: &mut Completions, kw: &str, snippet: &str) {
-    let builder = CompletionItem::new(CompletionKind::Keyword, ctx.source_range(), kw)
+    let mut item = CompletionItem::new(CompletionKind::Keyword, ctx.source_range(), kw);
-        .kind(CompletionItemKind::Keyword);
+    item.kind(CompletionItemKind::Keyword);
-    let builder = match ctx.config.snippet_cap {
+    match ctx.config.snippet_cap {
        Some(cap) => {
            let tmp;
            let snippet = if snippet.ends_with('}') && ctx.incomplete_let {
@@ -177,11 +175,13 @@ fn add_keyword(ctx: &CompletionContext, acc: &mut Completions, kw: &str, snippet
            } else {
                snippet
            };
-            builder.insert_snippet(cap, snippet)
+            item.insert_snippet(cap, snippet);
+        }
+        None => {
+            item.insert_text(if snippet.contains('$') { kw } else { snippet });
        }
-        None => builder.insert_text(if snippet.contains('$') { kw } else { snippet }),
    };
-    acc.add(builder.build());
+    item.add_to(acc);
 }
 #[cfg(test)]
diff --git a/crates/ide_completion/src/completions/mod_.rs b/crates/ide_completion/src/completions/mod_.rs
index 352fc7c77..4f9415736 100644
--- a/crates/ide_completion/src/completions/mod_.rs
+++ b/crates/ide_completion/src/completions/mod_.rs
@@ -80,9 +80,9 @@ pub(crate) fn complete_mod(acc: &mut Completions, ctx: &CompletionContext) -> Op
            if mod_under_caret.semicolon_token().is_none() {
                label.push(';');
            }
-            CompletionItem::new(CompletionKind::Magic, ctx.source_range(), &label)
+            let mut item = CompletionItem::new(CompletionKind::Magic, ctx.source_range(), &label);
-                .kind(SymbolKind::Module)
+            item.kind(SymbolKind::Module);
-                .add_to(acc)
+            item.add_to(acc)
        });
    Some(())
diff --git a/crates/ide_completion/src/completions/postfix.rs b/crates/ide_completion/src/completions/postfix.rs
index d45ad7944..ac69b720a 100644
--- a/crates/ide_completion/src/completions/postfix.rs
+++ b/crates/ide_completion/src/completions/postfix.rs
@@ -297,10 +297,9 @@ fn postfix_snippet(
        let delete_range = TextRange::new(receiver_range.start(), ctx.source_range().end());
        TextEdit::replace(delete_range, snippet.to_string())
    };
-    CompletionItem::new(CompletionKind::Postfix, ctx.source_range(), label)
+    let mut item = CompletionItem::new(CompletionKind::Postfix, ctx.source_range(), label);
-        .detail(detail)
+    item.detail(detail).kind(CompletionItemKind::Snippet).snippet_edit(cap, edit);
-        .kind(CompletionItemKind::Snippet)
+    item
-        .snippet_edit(cap, edit)
 }
 #[cfg(test)]
diff --git a/crates/ide_completion/src/completions/record.rs b/crates/ide_completion/src/completions/record.rs
index 0a7927eb8..2f95b8687 100644
--- a/crates/ide_completion/src/completions/record.rs
+++ b/crates/ide_completion/src/completions/record.rs
@@ -22,16 +22,13 @@ pub(crate) fn complete_record(acc: &mut Completions, ctx: &CompletionContext) ->
                let completion_text = completion_text
                    .strip_prefix(ctx.token.to_string().as_str())
                    .unwrap_or(completion_text);
-                acc.add(
+                let mut item = CompletionItem::new(
-                    CompletionItem::new(
+                    CompletionKind::Snippet,
-                        CompletionKind::Snippet,
+                    ctx.source_range(),
-                        ctx.source_range(),
+                    "..Default::default()",
-                        "..Default::default()",
-                    )
-                    .insert_text(completion_text)
-                    .kind(SymbolKind::Field)
-                    .build(),
                );
+                item.insert_text(completion_text).kind(SymbolKind::Field);
+                item.add_to(acc);
            }
            missing_fields
diff --git a/crates/ide_completion/src/completions/snippet.rs b/crates/ide_completion/src/completions/snippet.rs
index df17a15c5..7f7830976 100644
--- a/crates/ide_completion/src/completions/snippet.rs
+++ b/crates/ide_completion/src/completions/snippet.rs
@@ -8,9 +8,9 @@ use crate::{
 };
 fn snippet(ctx: &CompletionContext, cap: SnippetCap, label: &str, snippet: &str) -> Builder {
-    CompletionItem::new(CompletionKind::Snippet, ctx.source_range(), label)
+    let mut item = CompletionItem::new(CompletionKind::Snippet, ctx.source_range(), label);
-        .insert_snippet(cap, snippet)
+    item.insert_snippet(cap, snippet).kind(CompletionItemKind::Snippet);
-        .kind(CompletionItemKind::Snippet)
+    item
 }
 pub(crate) fn complete_expr_snippet(acc: &mut Completions, ctx: &CompletionContext) {
@@ -35,7 +35,7 @@ pub(crate) fn complete_item_snippet(acc: &mut Completions, ctx: &CompletionConte
        None => return,
    };
-    snippet(
+    let mut item = snippet(
        ctx,
        cap,
        "tmod (Test module)",
@@ -49,11 +49,11 @@ mod tests {
        $0
    }
 }",
-    )
+    );
-    .lookup_by("tmod")
+    item.lookup_by("tmod");
-    .add_to(acc);
+    item.add_to(acc);
-    snippet(
+    let mut item = snippet(
        ctx,
        cap,
        "tfn (Test function)",
@@ -62,11 +62,12 @@ mod tests {
 fn ${1:feature}() {
    $0
 }",
-    )
+    );
-    .lookup_by("tfn")
+    item.lookup_by("tfn");
-    .add_to(acc);
+    item.add_to(acc);
-    snippet(ctx, cap, "macro_rules", "macro_rules! $1 {\n\t($2) => {\n\t\t$0\n\t};\n}").add_to(acc);
+    let item = snippet(ctx, cap, "macro_rules", "macro_rules! $1 {\n\t($2) => {\n\t\t$0\n\t};\n}");
+    item.add_to(acc);
 }
 #[cfg(test)]
diff --git a/crates/ide_completion/src/completions/trait_impl.rs b/crates/ide_completion/src/completions/trait_impl.rs
index b999540b8..5a7361f8e 100644
--- a/crates/ide_completion/src/completions/trait_impl.rs
+++ b/crates/ide_completion/src/completions/trait_impl.rs
@@ -145,9 +145,8 @@ fn add_function_impl(
        format!("fn {}(..)", fn_name)
    };
-    let builder = CompletionItem::new(CompletionKind::Magic, ctx.source_range(), label)
+    let mut item = CompletionItem::new(CompletionKind::Magic, ctx.source_range(), label);
-        .lookup_by(fn_name)
+    item.lookup_by(fn_name).set_documentation(func.docs(ctx.db));
-        .set_documentation(func.docs(ctx.db));
    let completion_kind = if func.self_param(ctx.db).is_some() {
        CompletionItemKind::Method
@@ -161,15 +160,15 @@ fn add_function_impl(
        match ctx.config.snippet_cap {
            Some(cap) => {
                let snippet = format!("{} {{\n    $0\n}}", function_decl);
-                builder.snippet_edit(cap, TextEdit::replace(range, snippet))
+                item.snippet_edit(cap, TextEdit::replace(range, snippet));
            }
            None => {
                let header = format!("{} {{", function_decl);
-                builder.text_edit(TextEdit::replace(range, header))
+                item.text_edit(TextEdit::replace(range, header));
            }
-        }
+        };
-        .kind(completion_kind)
+        item.kind(completion_kind);
-        .add_to(acc);
+        item.add_to(acc);
    }
 }
@@ -185,12 +184,12 @@ fn add_type_alias_impl(
    let range = TextRange::new(type_def_node.text_range().start(), ctx.source_range().end());
-    CompletionItem::new(CompletionKind::Magic, ctx.source_range(), snippet.clone())
+    let mut item = CompletionItem::new(CompletionKind::Magic, ctx.source_range(), snippet.clone());
-        .text_edit(TextEdit::replace(range, snippet))
+    item.text_edit(TextEdit::replace(range, snippet))
        .lookup_by(alias_name)
        .kind(SymbolKind::TypeAlias)
-        .set_documentation(type_alias.docs(ctx.db))
+        .set_documentation(type_alias.docs(ctx.db));
-        .add_to(acc);
+    item.add_to(acc);
 }
 fn add_const_impl(
@@ -208,12 +207,13 @@ fn add_const_impl(
            let range =
                TextRange::new(const_def_node.text_range().start(), ctx.source_range().end());
-            CompletionItem::new(CompletionKind::Magic, ctx.source_range(), snippet.clone())
+            let mut item =
-                .text_edit(TextEdit::replace(range, snippet))
+                CompletionItem::new(CompletionKind::Magic, ctx.source_range(), snippet.clone());
+            item.text_edit(TextEdit::replace(range, snippet))
                .lookup_by(const_name)
                .kind(SymbolKind::Const)
-                .set_documentation(const_.docs(ctx.db))
+                .set_documentation(const_.docs(ctx.db));
-                .add_to(acc);
+            item.add_to(acc);
        }
    }
 }
diff --git a/crates/ide_completion/src/item.rs b/crates/ide_completion/src/item.rs
index 14afec603..9a4b5217a 100644
--- a/crates/ide_completion/src/item.rs
+++ b/crates/ide_completion/src/item.rs
@@ -70,7 +70,7 @@ pub struct CompletionItem {
    /// Note that Relevance ignores fuzzy match score. We compute Relevance for
    /// all possible items, and then separately build an ordered completion list
    /// based on relevance and fuzzy matching with the already typed identifier.
-    relevance: Relevance,
+    relevance: CompletionRelevance,
    /// Indicates that a reference or mutable reference to this variable is a
    /// possible match.
@@ -107,9 +107,11 @@ impl fmt::Debug for CompletionItem {
        if self.deprecated {
            s.field("deprecated", &true);
        }
-        if self.relevance.is_relevant() {
+        if self.relevance != CompletionRelevance::default() {
            s.field("relevance", &self.relevance);
        }
        if let Some(mutability) = &self.ref_match {
            s.field("ref_match", &format!("&{}", mutability.as_keyword_for_ref()));
        }
@@ -120,16 +122,8 @@ impl fmt::Debug for CompletionItem {
    }
 }
-#[derive(Debug, Clone, Copy, Ord, PartialOrd, Eq, PartialEq)]
-pub enum CompletionScore {
-    /// If only type match
-    TypeMatch,
-    /// If type and name match
-    TypeAndNameMatch,
-}
 #[derive(Debug, Clone, Copy, Ord, PartialOrd, Eq, PartialEq, Default)]
-pub struct Relevance {
+pub struct CompletionRelevance {
    /// This is set in cases like these:
    ///
    /// ```
@@ -150,11 +144,54 @@ pub struct Relevance {
    /// }
    /// ```
    pub exact_type_match: bool,
+    /// This is set in cases like these:
+    ///
+    /// ```
+    /// fn foo(bar: u32) {
+    ///     $0 // `bar` is local
+    /// }
+    /// ```
+    ///
+    /// ```
+    /// fn foo() {
+    ///     let bar = 0;
+    ///     $0 // `bar` is local
+    /// }
+    /// ```
+    pub is_local: bool,
 }
-impl Relevance {
+impl CompletionRelevance {
+    /// Provides a relevance score. Higher values are more relevant.
+    ///
+    /// The absolute value of the relevance score is not meaningful, for
+    /// example a value of 0 doesn't mean "not relevant", rather
+    /// it means "least relevant". The score value should only be used
+    /// for relative ordering.
+    ///
+    /// See is_relevant if you need to make some judgement about score
+    /// in an absolute sense.
+    pub fn score(&self) -> u32 {
+        let mut score = 0;
+        if self.exact_name_match {
+            score += 1;
+        }
+        if self.exact_type_match {
+            score += 3;
+        }
+        if self.is_local {
+            score += 1;
+        }
+        score
+    }
+    /// Returns true when the score for this threshold is above
+    /// some threshold such that we think it is especially likely
+    /// to be relevant.
    pub fn is_relevant(&self) -> bool {
-        self != &Relevance::default()
+        self.score() > 0
    }
 }
@@ -249,7 +286,7 @@ impl CompletionItem {
            text_edit: None,
            deprecated: false,
            trigger_call_info: None,
-            relevance: Relevance::default(),
+            relevance: CompletionRelevance::default(),
            ref_match: None,
            import_to_add: None,
        }
@@ -292,7 +329,7 @@ impl CompletionItem {
        self.deprecated
    }
-    pub fn relevance(&self) -> Relevance {
+    pub fn relevance(&self) -> CompletionRelevance {
        self.relevance
    }
@@ -300,8 +337,14 @@ impl CompletionItem {
        self.trigger_call_info
    }
-    pub fn ref_match(&self) -> Option<Mutability> {
+    pub fn ref_match(&self) -> Option<(Mutability, CompletionRelevance)> {
-        self.ref_match
+        // Relevance of the ref match should be the same as the original
+        // match, but with exact type match set because self.ref_match
+        // is only set if there is an exact type match.
+        let mut relevance = self.relevance;
+        relevance.exact_type_match = true;
+        self.ref_match.map(|mutability| (mutability, relevance))
    }
    pub fn import_to_add(&self) -> Option<&ImportEdit> {
@@ -349,7 +392,7 @@ pub(crate) struct Builder {
    text_edit: Option<TextEdit>,
    deprecated: bool,
    trigger_call_info: Option<bool>,
-    relevance: Relevance,
+    relevance: CompletionRelevance,
    ref_match: Option<Mutability>,
 }
@@ -401,42 +444,42 @@ impl Builder {
            import_to_add: self.import_to_add,
        }
    }
-    pub(crate) fn lookup_by(mut self, lookup: impl Into<String>) -> Builder {
+    pub(crate) fn lookup_by(&mut self, lookup: impl Into<String>) -> &mut Builder {
        self.lookup = Some(lookup.into());
        self
    }
-    pub(crate) fn label(mut self, label: impl Into<String>) -> Builder {
+    pub(crate) fn label(&mut self, label: impl Into<String>) -> &mut Builder {
        self.label = label.into();
        self
    }
-    pub(crate) fn insert_text(mut self, insert_text: impl Into<String>) -> Builder {
+    pub(crate) fn insert_text(&mut self, insert_text: impl Into<String>) -> &mut Builder {
        self.insert_text = Some(insert_text.into());
        self
    }
    pub(crate) fn insert_snippet(
-        mut self,
+        &mut self,
        _cap: SnippetCap,
        snippet: impl Into<String>,
-    ) -> Builder {
+    ) -> &mut Builder {
        self.insert_text_format = InsertTextFormat::Snippet;
        self.insert_text(snippet)
    }
-    pub(crate) fn kind(mut self, kind: impl Into<CompletionItemKind>) -> Builder {
+    pub(crate) fn kind(&mut self, kind: impl Into<CompletionItemKind>) -> &mut Builder {
        self.kind = Some(kind.into());
        self
    }
-    pub(crate) fn text_edit(mut self, edit: TextEdit) -> Builder {
+    pub(crate) fn text_edit(&mut self, edit: TextEdit) -> &mut Builder {
        self.text_edit = Some(edit);
        self
    }
-    pub(crate) fn snippet_edit(mut self, _cap: SnippetCap, edit: TextEdit) -> Builder {
+    pub(crate) fn snippet_edit(&mut self, _cap: SnippetCap, edit: TextEdit) -> &mut Builder {
        self.insert_text_format = InsertTextFormat::Snippet;
        self.text_edit(edit)
    }
-    pub(crate) fn detail(self, detail: impl Into<String>) -> Builder {
+    pub(crate) fn detail(&mut self, detail: impl Into<String>) -> &mut Builder {
        self.set_detail(Some(detail))
    }
-    pub(crate) fn set_detail(mut self, detail: Option<impl Into<String>>) -> Builder {
+    pub(crate) fn set_detail(&mut self, detail: Option<impl Into<String>>) -> &mut Builder {
        self.detail = detail.map(Into::into);
        if let Some(detail) = &self.detail {
            if never!(detail.contains('\n'), "multiline detail:\n{}", detail) {
@@ -446,31 +489,106 @@ impl Builder {
        self
    }
    #[allow(unused)]
-    pub(crate) fn documentation(self, docs: Documentation) -> Builder {
+    pub(crate) fn documentation(&mut self, docs: Documentation) -> &mut Builder {
        self.set_documentation(Some(docs))
    }
-    pub(crate) fn set_documentation(mut self, docs: Option<Documentation>) -> Builder {
+    pub(crate) fn set_documentation(&mut self, docs: Option<Documentation>) -> &mut Builder {
        self.documentation = docs.map(Into::into);
        self
    }
-    pub(crate) fn set_deprecated(mut self, deprecated: bool) -> Builder {
+    pub(crate) fn set_deprecated(&mut self, deprecated: bool) -> &mut Builder {
        self.deprecated = deprecated;
        self
    }
-    pub(crate) fn set_relevance(mut self, relevance: Relevance) -> Builder {
+    pub(crate) fn set_relevance(&mut self, relevance: CompletionRelevance) -> &mut Builder {
        self.relevance = relevance;
        self
    }
-    pub(crate) fn trigger_call_info(mut self) -> Builder {
+    pub(crate) fn trigger_call_info(&mut self) -> &mut Builder {
        self.trigger_call_info = Some(true);
        self
    }
-    pub(crate) fn add_import(mut self, import_to_add: Option<ImportEdit>) -> Builder {
+    pub(crate) fn add_import(&mut self, import_to_add: Option<ImportEdit>) -> &mut Builder {
        self.import_to_add = import_to_add;
        self
    }
-    pub(crate) fn ref_match(mut self, mutability: Mutability) -> Builder {
+    pub(crate) fn ref_match(&mut self, mutability: Mutability) -> &mut Builder {
        self.ref_match = Some(mutability);
        self
    }
 }
+#[cfg(test)]
+mod tests {
+    use itertools::Itertools;
+    use test_utils::assert_eq_text;
+    use super::CompletionRelevance;
+    /// Check that these are CompletionRelevance are sorted in ascending order
+    /// by their relevance score.
+    ///
+    /// We want to avoid making assertions about the absolute score of any
+    /// item, but we do want to assert whether each is >, <, or == to the
+    /// others.
+    ///
+    /// If provided vec![vec![a], vec![b, c], vec![d]], then this will assert:
+    ///     a.score < b.score == c.score < d.score
+    fn check_relevance_score_ordered(expected_relevance_order: Vec<Vec<CompletionRelevance>>) {
+        let expected = format!("{:#?}", &expected_relevance_order);
+        let actual_relevance_order = expected_relevance_order
+            .into_iter()
+            .flatten()
+            .map(|r| (r.score(), r))
+            .sorted_by_key(|(score, _r)| *score)
+            .fold(
+                (u32::MIN, vec![vec![]]),
+                |(mut currently_collecting_score, mut out), (score, r)| {
+                    if currently_collecting_score == score {
+                        out.last_mut().unwrap().push(r);
+                    } else {
+                        currently_collecting_score = score;
+                        out.push(vec![r]);
+                    }
+                    (currently_collecting_score, out)
+                },
+            )
+            .1;
+        let actual = format!("{:#?}", &actual_relevance_order);
+        assert_eq_text!(&expected, &actual);
+    }
+    #[test]
+    fn relevance_score() {
+        // This test asserts that the relevance score for these items is ascending, and
+        // that any items in the same vec have the same score.
+        let expected_relevance_order = vec![
+            vec![CompletionRelevance::default()],
+            vec![
+                CompletionRelevance { exact_name_match: true, ..CompletionRelevance::default() },
+                CompletionRelevance { is_local: true, ..CompletionRelevance::default() },
+            ],
+            vec![CompletionRelevance {
+                exact_name_match: true,
+                is_local: true,
+                ..CompletionRelevance::default()
+            }],
+            vec![CompletionRelevance { exact_type_match: true, ..CompletionRelevance::default() }],
+            vec![CompletionRelevance {
+                exact_name_match: true,
+                exact_type_match: true,
+                ..CompletionRelevance::default()
+            }],
+            vec![CompletionRelevance {
+                exact_name_match: true,
+                exact_type_match: true,
+                is_local: true,
+            }],
+        ];
+        check_relevance_score_ordered(expected_relevance_order);
+    }
+}
diff --git a/crates/ide_completion/src/lib.rs b/crates/ide_completion/src/lib.rs
index d46f521a0..263554ecf 100644
--- a/crates/ide_completion/src/lib.rs
+++ b/crates/ide_completion/src/lib.rs
@@ -23,10 +23,7 @@ use crate::{completions::Completions, context::CompletionContext, item::Completi
 pub use crate::{
    config::CompletionConfig,
-    item::{
+    item::{CompletionItem, CompletionItemKind, CompletionRelevance, ImportEdit, InsertTextFormat},
-        CompletionItem, CompletionItemKind, CompletionScore, ImportEdit, InsertTextFormat,
-        Relevance,
-    },
 };
 //FIXME: split the following feature into fine-grained features.
diff --git a/crates/ide_completion/src/render.rs b/crates/ide_completion/src/render.rs
index 8c8b149a1..905f0b197 100644
--- a/crates/ide_completion/src/render.rs
+++ b/crates/ide_completion/src/render.rs
@@ -10,8 +10,10 @@ pub(crate) mod type_alias;
 mod builder_ext;
+use base_db::Upcast;
 use hir::{
-    AsAssocItem, Documentation, HasAttrs, HirDisplay, ModuleDef, Mutability, ScopeDef, Type,
+    db::HirDatabase, AsAssocItem, Documentation, HasAttrs, HirDisplay, ModuleDef, Mutability,
+    ScopeDef, Type,
 };
 use ide_db::{
    helpers::{item_name, SnippetCap},
@@ -20,7 +22,7 @@ use ide_db::{
 use syntax::TextRange;
 use crate::{
-    item::{ImportEdit, Relevance},
+    item::{CompletionRelevance, ImportEdit},
    CompletionContext, CompletionItem, CompletionItemKind, CompletionKind,
 };
@@ -149,24 +151,27 @@ impl<'a> Render<'a> {
            CompletionKind::Reference,
            self.ctx.source_range(),
            name.to_string(),
-        )
+        );
-        .kind(SymbolKind::Field)
+        item.kind(SymbolKind::Field)
-        .detail(ty.display(self.ctx.db()).to_string())
+            .detail(ty.display(self.ctx.db()).to_string())
-        .set_documentation(field.docs(self.ctx.db()))
+            .set_documentation(field.docs(self.ctx.db()))
-        .set_deprecated(is_deprecated);
+            .set_deprecated(is_deprecated);
-        if let Some(relevance) = compute_relevance(&self.ctx, &ty, &name.to_string()) {
+        item.set_relevance(compute_relevance(&self.ctx, &ty, &name.to_string()));
-            item = item.set_relevance(relevance);
-        }
        item.build()
    }
    fn add_tuple_field(&mut self, field: usize, ty: &Type) -> CompletionItem {
-        CompletionItem::new(CompletionKind::Reference, self.ctx.source_range(), field.to_string())
+        let mut item = CompletionItem::new(
-            .kind(SymbolKind::Field)
+            CompletionKind::Reference,
-            .detail(ty.display(self.ctx.db()).to_string())
+            self.ctx.source_range(),
-            .build()
+            field.to_string(),
+        );
+        item.kind(SymbolKind::Field).detail(ty.display(self.ctx.db()).to_string());
+        item.build()
    }
    fn render_resolution(
@@ -225,15 +230,13 @@ impl<'a> Render<'a> {
                CompletionItemKind::SymbolKind(SymbolKind::SelfParam)
            }
            ScopeDef::Unknown => {
-                let item = CompletionItem::new(
+                let mut item = CompletionItem::new(
                    CompletionKind::Reference,
                    self.ctx.source_range(),
                    local_name,
-                )
+                );
-                .kind(CompletionItemKind::UnresolvedReference)
+                item.kind(CompletionItemKind::UnresolvedReference).add_import(import_to_add);
-                .add_import(import_to_add)
+                return Some(item.build());
-                .build();
-                return Some(item);
            }
        };
@@ -242,25 +245,29 @@ impl<'a> Render<'a> {
        if let ScopeDef::Local(local) = resolution {
            let ty = local.ty(self.ctx.db());
            if !ty.is_unknown() {
-                item = item.detail(ty.display(self.ctx.db()).to_string());
+                item.detail(ty.display(self.ctx.db()).to_string());
            }
        };
        if let ScopeDef::Local(local) = resolution {
            let ty = local.ty(self.ctx.db());
-            if let Some(relevance) = compute_relevance(&self.ctx, &ty, &local_name) {
-                item = item.set_relevance(relevance)
+            let mut relevance = compute_relevance(&self.ctx, &ty, &local_name);
-            }
+            relevance.is_local = true;
+            item.set_relevance(relevance);
            if let Some((_expected_name, expected_type)) = self.ctx.expected_name_and_type() {
-                if let Some(ty_without_ref) = expected_type.remove_ref() {
+                if ty != expected_type {
-                    if ty_without_ref == ty {
+                    if let Some(ty_without_ref) = expected_type.remove_ref() {
-                        cov_mark::hit!(suggest_ref);
+                        if relevance_type_match(self.ctx.db().upcast(), &ty, &ty_without_ref) {
-                        let mutability = if expected_type.is_mutable_reference() {
+                            cov_mark::hit!(suggest_ref);
-                            Mutability::Mut
+                            let mutability = if expected_type.is_mutable_reference() {
-                        } else {
+                                Mutability::Mut
-                            Mutability::Shared
+                            } else {
-                        };
+                                Mutability::Shared
-                        item = item.ref_match(mutability)
+                            };
+                            item.ref_match(mutability);
+                        }
                    }
                }
            }
@@ -281,21 +288,17 @@ impl<'a> Render<'a> {
                };
                if has_non_default_type_params {
                    cov_mark::hit!(inserts_angle_brackets_for_generics);
-                    item = item
+                    item.lookup_by(local_name.clone())
-                        .lookup_by(local_name.clone())
                        .label(format!("{}<…>", local_name))
                        .insert_snippet(cap, format!("{}<$0>", local_name));
                }
            }
        }
+        item.kind(kind)
-        Some(
+            .add_import(import_to_add)
-            item.kind(kind)
+            .set_documentation(self.docs(resolution))
-                .add_import(import_to_add)
+            .set_deprecated(self.is_deprecated(resolution));
-                .set_documentation(self.docs(resolution))
+        Some(item.build())
-                .set_deprecated(self.is_deprecated(resolution))
-                .build(),
-        )
    }
    fn docs(&self, resolution: &ScopeDef) -> Option<Documentation> {
@@ -323,23 +326,29 @@ impl<'a> Render<'a> {
    }
 }
-fn compute_relevance(ctx: &RenderContext, ty: &Type, name: &str) -> Option<Relevance> {
+fn compute_relevance(ctx: &RenderContext, ty: &Type, name: &str) -> CompletionRelevance {
-    let (expected_name, expected_type) = ctx.expected_name_and_type()?;
+    let mut res = CompletionRelevance::default();
-    let mut res = Relevance::default();
-    res.exact_type_match = ty == &expected_type;
+    if let Some((expected_name, expected_type)) = ctx.expected_name_and_type() {
-    res.exact_name_match = name == &expected_name;
+        res.exact_type_match = ty == &expected_type;
-    Some(res)
+        res.exact_name_match = name == &expected_name;
+    }
+    res
+}
+fn relevance_type_match(db: &dyn HirDatabase, ty: &Type, expected_type: &Type) -> bool {
+    ty == expected_type || ty.autoderef(db).any(|deref_ty| &deref_ty == expected_type)
 }
 #[cfg(test)]
 mod tests {
-    use std::cmp::Reverse;
    use expect_test::{expect, Expect};
+    use itertools::Itertools;
    use crate::{
        test_utils::{check_edit, do_completion, get_all_items, TEST_CONFIG},
-        CompletionKind, Relevance,
+        CompletionKind, CompletionRelevance,
    };
    fn check(ra_fixture: &str, expect: Expect) {
@@ -348,26 +357,40 @@ mod tests {
    }
    fn check_relevance(ra_fixture: &str, expect: Expect) {
-        fn display_relevance(relevance: Relevance) -> &'static str {
+        fn display_relevance(relevance: CompletionRelevance) -> String {
-            match relevance {
+            let relevance_factors = vec![
-                Relevance { exact_type_match: true, exact_name_match: true } => "[type+name]",
+                (relevance.exact_type_match, "type"),
-                Relevance { exact_type_match: true, exact_name_match: false } => "[type]",
+                (relevance.exact_name_match, "name"),
-                Relevance { exact_type_match: false, exact_name_match: true } => "[name]",
+                (relevance.is_local, "local"),
-                Relevance { exact_type_match: false, exact_name_match: false } => "[]",
+            ]
-            }
+            .into_iter()
+            .filter_map(|(cond, desc)| if cond { Some(desc) } else { None })
+            .join("+");
+            format!("[{}]", relevance_factors)
        }
-        let mut completions = get_all_items(TEST_CONFIG, ra_fixture);
+        let actual = get_all_items(TEST_CONFIG, ra_fixture)
-        completions.sort_by_key(|it| (Reverse(it.relevance()), it.label().to_string()));
-        let actual = completions
            .into_iter()
            .filter(|it| it.completion_kind == CompletionKind::Reference)
-            .map(|it| {
+            .flat_map(|it| {
+                let mut items = vec![];
                let tag = it.kind().unwrap().tag();
                let relevance = display_relevance(it.relevance());
-                format!("{} {} {}\n", tag, it.label(), relevance)
+                items.push(format!("{} {} {}\n", tag, it.label(), relevance));
+                if let Some((mutability, relevance)) = it.ref_match() {
+                    let label = format!("&{}{}", mutability.as_keyword_for_ref(), it.label());
+                    let relevance = display_relevance(relevance);
+                    items.push(format!("{} {} {}\n", tag, label, relevance));
+                }
+                items
            })
            .collect::<String>();
        expect.assert_eq(&actual);
    }
@@ -837,9 +860,9 @@ fn test(bar: u32) { }
 fn foo(s: S) { test(s.$0) }
 "#,
            expect![[r#"
+                fd foo []
                fd bar [type+name]
                fd baz [type]
-                fd foo []
            "#]],
        );
    }
@@ -854,9 +877,9 @@ struct B { x: (), y: f32, bar: u32 }
 fn foo(a: A) { B { bar: a.$0 }; }
 "#,
            expect![[r#"
+                fd foo []
                fd bar [type+name]
                fd baz [type]
-                fd foo []
            "#]],
        )
    }
@@ -884,9 +907,9 @@ fn f(foo: i64) {  }
 fn foo(a: A) { f(B { bar: a.$0 }); }
 "#,
            expect![[r#"
+                fd foo []
                fd bar [type+name]
                fd baz [type]
-                fd foo []
            "#]],
        );
    }
@@ -899,7 +922,7 @@ struct WorldSnapshot { _f: () };
 fn go(world: &WorldSnapshot) { go(w$0) }
 "#,
            expect![[r#"
-                lc world [type+name]
+                lc world [type+name+local]
                st WorldSnapshot []
                fn go(…) []
            "#]],
@@ -914,9 +937,9 @@ struct Foo;
 fn f(foo: &Foo) { f(foo, w$0) }
 "#,
            expect![[r#"
+                lc foo [local]
                st Foo []
                fn f(…) []
-                lc foo []
            "#]],
        );
    }
@@ -976,9 +999,10 @@ fn main() {
                            Local,
                        ),
                        detail: "S",
-                        relevance: Relevance {
+                        relevance: CompletionRelevance {
                            exact_name_match: true,
                            exact_type_match: false,
+                            is_local: true,
                        },
                        ref_match: "&mut ",
                    },
@@ -986,4 +1010,120 @@ fn main() {
            "#]],
        )
    }
+    #[test]
+    fn suggest_deref() {
+        check_relevance(
+            r#"
+#[lang = "deref"]
+trait Deref {
+    type Target;
+    fn deref(&self) -> &Self::Target;
+}
+struct S;
+struct T(S);
+impl Deref for T {
+    type Target = S;
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+fn foo(s: &S) {}
+fn main() {
+    let t = T(S);
+    let m = 123;
+    foo($0);
+}
+            "#,
+            expect![[r#"
+                lc m [local]
+                lc t [local]
+                lc &t [type+local]
+                st T []
+                st S []
+                fn main() []
+                tt Deref []
+                fn foo(…) []
+            "#]],
+        )
+    }
+    #[test]
+    fn suggest_deref_mut() {
+        check_relevance(
+            r#"
+#[lang = "deref"]
+trait Deref {
+    type Target;
+    fn deref(&self) -> &Self::Target;
+}
+#[lang = "deref_mut"]
+pub trait DerefMut: Deref {
+    fn deref_mut(&mut self) -> &mut Self::Target;
+}
+struct S;
+struct T(S);
+impl Deref for T {
+    type Target = S;
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl DerefMut for T {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+fn foo(s: &mut S) {}
+fn main() {
+    let t = T(S);
+    let m = 123;
+    foo($0);
+}
+            "#,
+            expect![[r#"
+                lc m [local]
+                lc t [local]
+                lc &mut t [type+local]
+                tt DerefMut []
+                tt Deref []
+                fn foo(…) []
+                st T []
+                st S []
+                fn main() []
+            "#]],
+        )
+    }
+    #[test]
+    fn locals() {
+        check_relevance(
+            r#"
+fn foo(bar: u32) {
+    let baz = 0;
+    f$0
+}
+"#,
+            expect![[r#"
+                lc baz [local]
+                lc bar [local]
+                fn foo(…) []
+            "#]],
+        );
+    }
 }
diff --git a/crates/ide_completion/src/render/builder_ext.rs b/crates/ide_completion/src/render/builder_ext.rs
index 95a7596c1..6d062b3b9 100644
--- a/crates/ide_completion/src/render/builder_ext.rs
+++ b/crates/ide_completion/src/render/builder_ext.rs
@@ -52,11 +52,11 @@ impl Builder {
    }
    pub(super) fn add_call_parens(
-        mut self,
+        &mut self,
        ctx: &CompletionContext,
        name: String,
        params: Params,
-    ) -> Builder {
+    ) -> &mut Builder {
        if !self.should_add_parens(ctx) {
            return self;
        }
@@ -71,7 +71,7 @@ impl Builder {
        let (snippet, label) = if params.is_empty() {
            (format!("{}()$0", name), format!("{}()", name))
        } else {
-            self = self.trigger_call_info();
+            self.trigger_call_info();
            let snippet = match (ctx.config.add_call_argument_snippets, params) {
                (true, Params::Named(params)) => {
                    let function_params_snippet =
diff --git a/crates/ide_completion/src/render/const_.rs b/crates/ide_completion/src/render/const_.rs
index 5010b642a..8add369e4 100644
--- a/crates/ide_completion/src/render/const_.rs
+++ b/crates/ide_completion/src/render/const_.rs
@@ -36,17 +36,17 @@ impl<'a> ConstRender<'a> {
        let name = self.name()?;
        let detail = self.detail();
-        let item = CompletionItem::new(CompletionKind::Reference, self.ctx.source_range(), name)
+        let mut item =
-            .kind(SymbolKind::Const)
+            CompletionItem::new(CompletionKind::Reference, self.ctx.source_range(), name);
+        item.kind(SymbolKind::Const)
            .set_documentation(self.ctx.docs(self.const_))
            .set_deprecated(
                self.ctx.is_deprecated(self.const_)
                    || self.ctx.is_deprecated_assoc_item(self.const_),
            )
-            .detail(detail)
+            .detail(detail);
-            .build();
-        Some(item)
+        Some(item.build())
    }
    fn name(&self) -> Option<String> {
diff --git a/crates/ide_completion/src/render/enum_variant.rs b/crates/ide_completion/src/render/enum_variant.rs
index ed055c1fb..e8cfcc0c7 100644
--- a/crates/ide_completion/src/render/enum_variant.rs
+++ b/crates/ide_completion/src/render/enum_variant.rs
@@ -55,27 +55,26 @@ impl<'a> EnumRender<'a> {
    }
    fn render(self, import_to_add: Option<ImportEdit>) -> CompletionItem {
-        let mut builder = CompletionItem::new(
+        let mut item = CompletionItem::new(
            CompletionKind::Reference,
            self.ctx.source_range(),
            self.qualified_name.clone(),
-        )
+        );
-        .kind(SymbolKind::Variant)
+        item.kind(SymbolKind::Variant)
-        .set_documentation(self.variant.docs(self.ctx.db()))
+            .set_documentation(self.variant.docs(self.ctx.db()))
-        .set_deprecated(self.ctx.is_deprecated(self.variant))
+            .set_deprecated(self.ctx.is_deprecated(self.variant))
-        .add_import(import_to_add)
+            .add_import(import_to_add)
-        .detail(self.detail());
+            .detail(self.detail());
        if self.variant_kind == StructKind::Tuple {
            cov_mark::hit!(inserts_parens_for_tuple_enums);
            let params = Params::Anonymous(self.variant.fields(self.ctx.db()).len());
-            builder =
+            item.add_call_parens(self.ctx.completion, self.short_qualified_name, params);
-                builder.add_call_parens(self.ctx.completion, self.short_qualified_name, params);
        } else if self.path.is_some() {
-            builder = builder.lookup_by(self.short_qualified_name);
+            item.lookup_by(self.short_qualified_name);
        }
-        builder.build()
+        item.build()
    }
    fn detail(&self) -> String {
diff --git a/crates/ide_completion/src/render/function.rs b/crates/ide_completion/src/render/function.rs
index 5931945a8..f4dabe3d1 100644
--- a/crates/ide_completion/src/render/function.rs
+++ b/crates/ide_completion/src/render/function.rs
@@ -41,16 +41,21 @@ impl<'a> FunctionRender<'a> {
    fn render(self, import_to_add: Option<ImportEdit>) -> CompletionItem {
        let params = self.params();
-        CompletionItem::new(CompletionKind::Reference, self.ctx.source_range(), self.name.clone())
+        let mut item = CompletionItem::new(
-            .kind(self.kind())
+            CompletionKind::Reference,
+            self.ctx.source_range(),
+            self.name.clone(),
+        );
+        item.kind(self.kind())
            .set_documentation(self.ctx.docs(self.func))
            .set_deprecated(
                self.ctx.is_deprecated(self.func) || self.ctx.is_deprecated_assoc_item(self.func),
            )
            .detail(self.detail())
            .add_call_parens(self.ctx.completion, self.name, params)
-            .add_import(import_to_add)
+            .add_import(import_to_add);
-            .build()
+        item.build()
    }
    fn detail(&self) -> String {
diff --git a/crates/ide_completion/src/render/macro_.rs b/crates/ide_completion/src/render/macro_.rs
index a6cf3e479..3fa21ba7c 100644
--- a/crates/ide_completion/src/render/macro_.rs
+++ b/crates/ide_completion/src/render/macro_.rs
@@ -39,29 +39,31 @@ impl<'a> MacroRender<'a> {
    }
    fn render(&self, import_to_add: Option<ImportEdit>) -> Option<CompletionItem> {
-        let mut builder =
+        let mut item =
-            CompletionItem::new(CompletionKind::Reference, self.ctx.source_range(), &self.label())
+            CompletionItem::new(CompletionKind::Reference, self.ctx.source_range(), &self.label());
-                .kind(SymbolKind::Macro)
+        item.kind(SymbolKind::Macro)
-                .set_documentation(self.docs.clone())
+            .set_documentation(self.docs.clone())
-                .set_deprecated(self.ctx.is_deprecated(self.macro_))
+            .set_deprecated(self.ctx.is_deprecated(self.macro_))
-                .add_import(import_to_add)
+            .add_import(import_to_add)
-                .set_detail(self.detail());
+            .set_detail(self.detail());
        let needs_bang = self.needs_bang();
-        builder = match self.ctx.snippet_cap() {
+        match self.ctx.snippet_cap() {
            Some(cap) if needs_bang => {
                let snippet = self.snippet();
                let lookup = self.lookup();
-                builder.insert_snippet(cap, snippet).lookup_by(lookup)
+                item.insert_snippet(cap, snippet).lookup_by(lookup);
+            }
+            None if needs_bang => {
+                item.insert_text(self.banged_name());
            }
-            None if needs_bang => builder.insert_text(self.banged_name()),
            _ => {
                cov_mark::hit!(dont_insert_macro_call_parens_unncessary);
-                builder.insert_text(&self.name)
+                item.insert_text(&self.name);
            }
        };
-        Some(builder.build())
+        Some(item.build())
    }
    fn needs_bang(&self) -> bool {
diff --git a/crates/ide_completion/src/render/pattern.rs b/crates/ide_completion/src/render/pattern.rs
index 465dfe00c..ca2926125 100644
--- a/crates/ide_completion/src/render/pattern.rs
+++ b/crates/ide_completion/src/render/pattern.rs
@@ -69,19 +69,19 @@ fn build_completion(
    ctx: RenderContext<'_>,
    name: String,
    pat: String,
-    item: impl HasAttrs + Copy,
+    def: impl HasAttrs + Copy,
 ) -> CompletionItem {
-    let completion = CompletionItem::new(CompletionKind::Snippet, ctx.source_range(), name)
+    let mut item = CompletionItem::new(CompletionKind::Snippet, ctx.source_range(), name);
-        .kind(CompletionItemKind::Binding)
+    item.kind(CompletionItemKind::Binding)
-        .set_documentation(ctx.docs(item))
+        .set_documentation(ctx.docs(def))
-        .set_deprecated(ctx.is_deprecated(item))
+        .set_deprecated(ctx.is_deprecated(def))
        .detail(&pat);
-    let completion = if let Some(snippet_cap) = ctx.snippet_cap() {
+    if let Some(snippet_cap) = ctx.snippet_cap() {
-        completion.insert_snippet(snippet_cap, pat)
+        item.insert_snippet(snippet_cap, pat);
    } else {
-        completion.insert_text(pat)
+        item.insert_text(pat);
    };
-    completion.build()
+    item.build()
 }
 fn render_pat(
diff --git a/crates/ide_completion/src/render/type_alias.rs b/crates/ide_completion/src/render/type_alias.rs
index bd97c3692..e47b4c745 100644
--- a/crates/ide_completion/src/render/type_alias.rs
+++ b/crates/ide_completion/src/render/type_alias.rs
@@ -36,17 +36,17 @@ impl<'a> TypeAliasRender<'a> {
        let name = self.name()?;
        let detail = self.detail();
-        let item = CompletionItem::new(CompletionKind::Reference, self.ctx.source_range(), name)
+        let mut item =
-            .kind(SymbolKind::TypeAlias)
+            CompletionItem::new(CompletionKind::Reference, self.ctx.source_range(), name);
+        item.kind(SymbolKind::TypeAlias)
            .set_documentation(self.ctx.docs(self.type_alias))
            .set_deprecated(
                self.ctx.is_deprecated(self.type_alias)
                    || self.ctx.is_deprecated_assoc_item(self.type_alias),
            )
-            .detail(detail)
+            .detail(detail);
-            .build();
-        Some(item)
+        Some(item.build())
    }
    fn name(&self) -> Option<String> {
diff --git a/crates/ide_db/src/search.rs b/crates/ide_db/src/search.rs
index ddcfbd3f3..fa18703e1 100644
--- a/crates/ide_db/src/search.rs
+++ b/crates/ide_db/src/search.rs
@@ -86,6 +86,10 @@ impl SearchScope {
        SearchScope::new(std::iter::once((file, None)).collect())
    }
+    pub fn file_range(range: FileRange) -> SearchScope {
+        SearchScope::new(std::iter::once((range.file_id, Some(range.range))).collect())
+    }
    pub fn files(files: &[FileId]) -> SearchScope {
        SearchScope::new(files.iter().map(|f| (*f, None)).collect())
    }
diff --git a/crates/mbe/src/expander.rs b/crates/mbe/src/expander.rs
index 2efff8f52..3197c834c 100644
--- a/crates/mbe/src/expander.rs
+++ b/crates/mbe/src/expander.rs
@@ -5,7 +5,7 @@
 mod matcher;
 mod transcriber;
-use smallvec::SmallVec;
+use rustc_hash::FxHashMap;
 use syntax::SmolStr;
 use crate::{ExpandError, ExpandResult};
@@ -96,7 +96,7 @@ pub(crate) fn expand_rules(
 /// many is not a plain `usize`, but an `&[usize]`.
 #[derive(Debug, Default, Clone, PartialEq, Eq)]
 struct Bindings {
-    inner: SmallVec<[(SmolStr, Binding); 4]>,
+    inner: FxHashMap<SmolStr, Binding>,
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
diff --git a/crates/mbe/src/expander/matcher.rs b/crates/mbe/src/expander/matcher.rs
index 9d3d28055..2c69e8968 100644
--- a/crates/mbe/src/expander/matcher.rs
+++ b/crates/mbe/src/expander/matcher.rs
@@ -59,6 +59,8 @@
 //! eof: [a $( a )* a b ·]
 //! ```
+use std::rc::Rc;
 use crate::{
    expander::{Binding, Bindings, Fragment},
    parser::{Op, OpDelimited, OpDelimitedIter, RepeatKind, Separator},
@@ -76,43 +78,15 @@ impl Bindings {
        // FIXME: Do we have a better way to represent an empty token ?
        // Insert an empty subtree for empty token
        let tt = tt::Subtree::default().into();
-        self.inner.push((name.clone(), Binding::Fragment(Fragment::Tokens(tt))));
+        self.inner.insert(name.clone(), Binding::Fragment(Fragment::Tokens(tt)));
    }
    fn push_empty(&mut self, name: &SmolStr) {
-        self.inner.push((name.clone(), Binding::Empty));
+        self.inner.insert(name.clone(), Binding::Empty);
-    }
-    fn push_nested(&mut self, idx: usize, nested: Bindings) -> Result<(), ExpandError> {
-        for (key, value) in nested.inner {
-            if self.get_mut(&key).is_none() {
-                self.inner.push((key.clone(), Binding::Nested(Vec::new())));
-            }
-            match self.get_mut(&key) {
-                Some(Binding::Nested(it)) => {
-                    // insert empty nested bindings before this one
-                    while it.len() < idx {
-                        it.push(Binding::Nested(vec![]));
-                    }
-                    it.push(value);
-                }
-                _ => {
-                    return Err(ExpandError::BindingError(format!(
-                        "could not find binding `{}`",
-                        key
-                    )));
-                }
-            }
-        }
-        Ok(())
-    }
-    fn get_mut(&mut self, name: &str) -> Option<&mut Binding> {
-        self.inner.iter_mut().find_map(|(n, b)| if n == name { Some(b) } else { None })
    }
    fn bindings(&self) -> impl Iterator<Item = &Binding> {
-        self.inner.iter().map(|(_, b)| b)
+        self.inner.values()
    }
 }
@@ -163,6 +137,181 @@ pub(super) fn match_(pattern: &MetaTemplate, input: &tt::Subtree) -> Match {
 }
 #[derive(Debug, Clone)]
+enum BindingKind {
+    Empty(SmolStr),
+    Optional(SmolStr),
+    Fragment(SmolStr, Fragment),
+    Nested(usize, usize),
+}
+#[derive(Debug, Clone)]
+struct BindingsIdx(usize, usize);
+#[derive(Debug, Clone)]
+enum LinkNode<T> {
+    Node(T),
+    Parent { idx: usize, len: usize },
+}
+#[derive(Default)]
+struct BindingsBuilder {
+    nodes: Vec<Vec<LinkNode<Rc<BindingKind>>>>,
+    nested: Vec<Vec<LinkNode<usize>>>,
+}
+impl BindingsBuilder {
+    fn alloc(&mut self) -> BindingsIdx {
+        let idx = self.nodes.len();
+        self.nodes.push(Vec::new());
+        let nidx = self.nested.len();
+        self.nested.push(Vec::new());
+        BindingsIdx(idx, nidx)
+    }
+    fn copy(&mut self, bindings: &BindingsIdx) -> BindingsIdx {
+        let idx = copy_parent(bindings.0, &mut self.nodes);
+        let nidx = copy_parent(bindings.1, &mut self.nested);
+        return BindingsIdx(idx, nidx);
+        fn copy_parent<T>(idx: usize, target: &mut Vec<Vec<LinkNode<T>>>) -> usize
+        where
+            T: Clone,
+        {
+            let new_idx = target.len();
+            let len = target[idx].len();
+            if len < 4 {
+                target.push(target[idx].clone())
+            } else {
+                target.push(vec![LinkNode::Parent { idx, len }]);
+            }
+            new_idx
+        }
+    }
+    fn push_empty(&mut self, idx: &mut BindingsIdx, var: &SmolStr) {
+        self.nodes[idx.0].push(LinkNode::Node(Rc::new(BindingKind::Empty(var.clone()))));
+    }
+    fn push_optional(&mut self, idx: &mut BindingsIdx, var: &SmolStr) {
+        self.nodes[idx.0].push(LinkNode::Node(Rc::new(BindingKind::Optional(var.clone()))));
+    }
+    fn push_fragment(&mut self, idx: &mut BindingsIdx, var: &SmolStr, fragment: Fragment) {
+        self.nodes[idx.0]
+            .push(LinkNode::Node(Rc::new(BindingKind::Fragment(var.clone(), fragment))));
+    }
+    fn push_nested(&mut self, parent: &mut BindingsIdx, child: &BindingsIdx) {
+        let BindingsIdx(idx, nidx) = self.copy(&child);
+        self.nodes[parent.0].push(LinkNode::Node(Rc::new(BindingKind::Nested(idx, nidx))));
+    }
+    fn push_default(&mut self, idx: &mut BindingsIdx) {
+        self.nested[idx.1].push(LinkNode::Node(idx.0));
+        let new_idx = self.nodes.len();
+        self.nodes.push(Vec::new());
+        idx.0 = new_idx;
+    }
+    fn build(self, idx: &BindingsIdx) -> Bindings {
+        let mut bindings = Bindings::default();
+        self.build_inner(&mut bindings, &self.nodes[idx.0]);
+        bindings
+    }
+    fn build_inner(&self, bindings: &mut Bindings, link_nodes: &Vec<LinkNode<Rc<BindingKind>>>) {
+        let mut nodes = Vec::new();
+        self.collect_nodes(&link_nodes, &mut nodes);
+        for cmd in nodes {
+            match &**cmd {
+                BindingKind::Empty(name) => {
+                    bindings.push_empty(name);
+                }
+                BindingKind::Optional(name) => {
+                    bindings.push_optional(name);
+                }
+                BindingKind::Fragment(name, fragment) => {
+                    bindings.inner.insert(name.clone(), Binding::Fragment(fragment.clone()));
+                }
+                BindingKind::Nested(idx, nested_idx) => {
+                    let mut nested_nodes = Vec::new();
+                    self.collect_nested(*idx, *nested_idx, &mut nested_nodes);
+                    for (idx, iter) in nested_nodes.into_iter().enumerate() {
+                        for (key, value) in &iter.inner {
+                            let bindings = bindings
+                                .inner
+                                .entry(key.clone())
+                                .or_insert_with(|| Binding::Nested(Vec::new()));
+                            if let Binding::Nested(it) = bindings {
+                                // insert empty nested bindings before this one
+                                while it.len() < idx {
+                                    it.push(Binding::Nested(Vec::new()));
+                                }
+                                it.push(value.clone());
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    fn collect_nested_ref<'a>(
+        &'a self,
+        id: usize,
+        len: usize,
+        nested_refs: &mut Vec<&'a Vec<LinkNode<Rc<BindingKind>>>>,
+    ) {
+        self.nested[id].iter().take(len).for_each(|it| match it {
+            LinkNode::Node(id) => nested_refs.push(&self.nodes[*id]),
+            LinkNode::Parent { idx, len } => self.collect_nested_ref(*idx, *len, nested_refs),
+        });
+    }
+    fn collect_nested(&self, idx: usize, nested_idx: usize, nested: &mut Vec<Bindings>) {
+        let last = &self.nodes[idx];
+        let mut nested_refs = Vec::new();
+        self.nested[nested_idx].iter().for_each(|it| match *it {
+            LinkNode::Node(idx) => nested_refs.push(&self.nodes[idx]),
+            LinkNode::Parent { idx, len } => self.collect_nested_ref(idx, len, &mut nested_refs),
+        });
+        nested_refs.push(last);
+        nested_refs.into_iter().for_each(|iter| {
+            let mut child_bindings = Bindings::default();
+            self.build_inner(&mut child_bindings, &iter);
+            nested.push(child_bindings)
+        })
+    }
+    fn collect_nodes_ref<'a>(
+        &'a self,
+        id: usize,
+        len: usize,
+        nodes: &mut Vec<&'a Rc<BindingKind>>,
+    ) {
+        self.nodes[id].iter().take(len).for_each(|it| match it {
+            LinkNode::Node(it) => nodes.push(it),
+            LinkNode::Parent { idx, len } => self.collect_nodes_ref(*idx, *len, nodes),
+        });
+    }
+    fn collect_nodes<'a>(
+        &'a self,
+        link_nodes: &'a Vec<LinkNode<Rc<BindingKind>>>,
+        nodes: &mut Vec<&'a Rc<BindingKind>>,
+    ) {
+        link_nodes.into_iter().for_each(|it| match it {
+            LinkNode::Node(it) => nodes.push(it),
+            LinkNode::Parent { idx, len } => self.collect_nodes_ref(*idx, *len, nodes),
+        });
+    }
+}
+#[derive(Debug, Clone)]
 struct MatchState<'t> {
    /// The position of the "dot" in this matcher
    dot: OpDelimitedIter<'t>,
@@ -187,7 +336,7 @@ struct MatchState<'t> {
    sep_parsed: Option<usize>,
    /// Matched meta variables bindings
-    bindings: SmallVec<[Bindings; 4]>,
+    bindings: BindingsIdx,
    /// Cached result of meta variable parsing
    meta_result: Option<(TtIter<'t>, ExpandResult<Option<Fragment>>)>,
@@ -218,6 +367,7 @@ fn match_loop_inner<'t>(
    src: TtIter<'t>,
    stack: &[TtIter<'t>],
    res: &mut Match,
+    bindings_builder: &mut BindingsBuilder,
    cur_items: &mut SmallVec<[MatchState<'t>; 1]>,
    bb_items: &mut SmallVec<[MatchState<'t>; 1]>,
    next_items: &mut Vec<MatchState<'t>>,
@@ -251,12 +401,10 @@ fn match_loop_inner<'t>(
                    if item.sep_parsed.is_none() {
                        // Get the `up` matcher
                        let mut new_pos = *item.up.clone().unwrap();
+                        new_pos.bindings = bindings_builder.copy(&new_pos.bindings);
                        // Add matches from this repetition to the `matches` of `up`
-                        if let Some(bindings) = new_pos.bindings.last_mut() {
+                        bindings_builder.push_nested(&mut new_pos.bindings, &item.bindings);
-                            for (i, b) in item.bindings.iter_mut().enumerate() {
-                                bindings.push_nested(i, b.clone()).unwrap();
-                            }
-                        }
                        // Move the "dot" past the repetition in `up`
                        new_pos.dot.next();
                        new_pos.is_error = new_pos.is_error || item.is_error;
@@ -280,7 +428,7 @@ fn match_loop_inner<'t>(
                    else if item.sep_kind != Some(RepeatKind::ZeroOrOne) {
                        item.dot = item.dot.reset();
                        item.sep_parsed = None;
-                        item.bindings.push(Bindings::default());
+                        bindings_builder.push_default(&mut item.bindings);
                        cur_items.push(item);
                    }
                } else {
@@ -298,12 +446,12 @@ fn match_loop_inner<'t>(
            OpDelimited::Op(Op::Repeat { tokens, kind, separator }) => {
                if matches!(kind, RepeatKind::ZeroOrMore | RepeatKind::ZeroOrOne) {
                    let mut new_item = item.clone();
+                    new_item.bindings = bindings_builder.copy(&new_item.bindings);
                    new_item.dot.next();
                    let mut vars = Vec::new();
-                    let bindings = new_item.bindings.last_mut().unwrap();
                    collect_vars(&mut vars, tokens);
                    for var in vars {
-                        bindings.push_empty(&var);
+                        bindings_builder.push_empty(&mut new_item.bindings, &var);
                    }
                    cur_items.push(new_item);
                }
@@ -314,7 +462,7 @@ fn match_loop_inner<'t>(
                    sep: separator.clone(),
                    sep_kind: Some(*kind),
                    sep_parsed: None,
-                    bindings: smallvec![Bindings::default()],
+                    bindings: bindings_builder.alloc(),
                    meta_result: None,
                    is_error: false,
                })
@@ -339,7 +487,7 @@ fn match_loop_inner<'t>(
                                item.meta_result = Some((fork, match_res));
                                try_push!(bb_items, item);
                            } else {
-                                item.bindings.last_mut().unwrap().push_optional(name);
+                                bindings_builder.push_optional(&mut item.bindings, &name);
                                item.dot.next();
                                cur_items.push(item);
                            }
@@ -348,11 +496,11 @@ fn match_loop_inner<'t>(
                            res.add_err(err);
                            match match_res.value {
                                Some(fragment) => {
-                                    item.bindings
+                                    bindings_builder.push_fragment(
-                                        .last_mut()
+                                        &mut item.bindings,
-                                        .unwrap()
+                                        &name,
-                                        .inner
+                                        fragment,
-                                        .push((name.clone(), Binding::Fragment(fragment)));
+                                    );
                                }
                                _ => {}
                            }
@@ -394,6 +542,8 @@ fn match_loop(pattern: &MetaTemplate, src: &tt::Subtree) -> Match {
    let mut res = Match::default();
    let mut error_reover_item = None;
+    let mut bindings_builder = BindingsBuilder::default();
    let mut cur_items = smallvec![MatchState {
        dot: pattern.iter_delimited(None),
        stack: Default::default(),
@@ -401,7 +551,7 @@ fn match_loop(pattern: &MetaTemplate, src: &tt::Subtree) -> Match {
        sep: None,
        sep_kind: None,
        sep_parsed: None,
-        bindings: smallvec![Bindings::default()],
+        bindings: bindings_builder.alloc(),
        is_error: false,
        meta_result: None,
    }];
@@ -419,6 +569,7 @@ fn match_loop(pattern: &MetaTemplate, src: &tt::Subtree) -> Match {
            src.clone(),
            &stack,
            &mut res,
+            &mut bindings_builder,
            &mut cur_items,
            &mut bb_items,
            &mut next_items,
@@ -428,9 +579,9 @@ fn match_loop(pattern: &MetaTemplate, src: &tt::Subtree) -> Match {
        stdx::always!(cur_items.is_empty());
        if error_items.len() > 0 {
-            error_reover_item = error_items.pop();
+            error_reover_item = error_items.pop().map(|it| it.bindings);
        } else if eof_items.len() > 0 {
-            error_reover_item = Some(eof_items[0].clone());
+            error_reover_item = Some(eof_items[0].bindings.clone());
        }
        // We need to do some post processing after the `match_loop_inner`.
@@ -440,11 +591,11 @@ fn match_loop(pattern: &MetaTemplate, src: &tt::Subtree) -> Match {
            if eof_items.len() == 1 {
                // remove all errors, because it is the correct answer !
                res = Match::default();
-                res.bindings = eof_items[0].bindings[0].clone();
+                res.bindings = bindings_builder.build(&eof_items[0].bindings);
            } else {
                // Error recovery
                if error_reover_item.is_some() {
-                    res.bindings = error_reover_item.unwrap().bindings[0].clone();
+                    res.bindings = bindings_builder.build(&error_reover_item.unwrap());
                }
                res.add_err(ExpandError::UnexpectedToken);
            }
@@ -467,8 +618,8 @@ fn match_loop(pattern: &MetaTemplate, src: &tt::Subtree) -> Match {
            }
            res.add_err(err!("leftover tokens"));
-            if let Some(mut error_reover_item) = error_reover_item {
+            if let Some(error_reover_item) = error_reover_item {
-                res.bindings = error_reover_item.bindings.remove(0);
+                res.bindings = bindings_builder.build(&error_reover_item);
            }
            return res;
        }
@@ -494,12 +645,13 @@ fn match_loop(pattern: &MetaTemplate, src: &tt::Subtree) -> Match {
            if let Some(OpDelimited::Op(Op::Var { name, .. })) = item.dot.peek() {
                let (iter, match_res) = item.meta_result.take().unwrap();
-                let bindings = item.bindings.last_mut().unwrap();
                match match_res.value {
                    Some(fragment) => {
-                        bindings.inner.push((name.clone(), Binding::Fragment(fragment)));
+                        bindings_builder.push_fragment(&mut item.bindings, &name, fragment);
+                    }
+                    None if match_res.err.is_none() => {
+                        bindings_builder.push_optional(&mut item.bindings, &name);
                    }
-                    None if match_res.err.is_none() => bindings.push_optional(name),
                    _ => {}
                }
                if let Some(err) = match_res.err {
diff --git a/crates/mbe/src/expander/transcriber.rs b/crates/mbe/src/expander/transcriber.rs
index ad9953a7d..dd7fa97d7 100644
--- a/crates/mbe/src/expander/transcriber.rs
+++ b/crates/mbe/src/expander/transcriber.rs
@@ -2,7 +2,7 @@
 //! `$ident => foo`, interpolates variables in the template, to get `fn foo() {}`
 use syntax::SmolStr;
-use tt::Delimiter;
+use tt::{Delimiter, Subtree};
 use super::ExpandResult;
 use crate::{
@@ -13,17 +13,13 @@ use crate::{
 impl Bindings {
    fn contains(&self, name: &str) -> bool {
-        self.inner.iter().any(|(n, _)| n == name)
+        self.inner.contains_key(name)
    }
    fn get(&self, name: &str, nesting: &mut [NestingState]) -> Result<&Fragment, ExpandError> {
-        let mut b: &Binding = self
+        let mut b: &Binding = self.inner.get(name).ok_or_else(|| {
-            .inner
+            ExpandError::BindingError(format!("could not find binding `{}`", name))
-            .iter()
+        })?;
-            .find_map(|(n, b)| if n == name { Some(b) } else { None })
-            .ok_or_else(|| {
-                ExpandError::BindingError(format!("could not find binding `{}`", name))
-            })?;
        for nesting_state in nesting.iter_mut() {
            nesting_state.hit = true;
            b = match b {
@@ -179,7 +175,10 @@ fn expand_repeat(
        counter += 1;
        if counter == limit {
            log::warn!("expand_tt in repeat pattern exceed limit => {:#?}\n{:#?}", template, ctx);
-            break;
+            return ExpandResult {
+                value: Fragment::Tokens(Subtree::default().into()),
+                err: Some(ExpandError::Other("Expand exceed limit".to_string())),
+            };
        }
        if e.is_some() {
diff --git a/crates/parser/src/grammar.rs b/crates/parser/src/grammar.rs
index 6159d064c..6c0e22722 100644
--- a/crates/parser/src/grammar.rs
+++ b/crates/parser/src/grammar.rs
@@ -18,7 +18,7 @@
 //! // fn foo() {}
 //! ```
 //!
-//! After adding a new inline-test, run `cargo xtask codegen` to
+//! After adding a new inline-test, run `cargo test -p xtask` to
 //! extract it as a standalone text-fixture into
 //! `crates/syntax/test_data/parser/`, and run `cargo test` once to
 //! create the "gold" value.
diff --git a/crates/rust-analyzer/build.rs b/crates/rust-analyzer/build.rs
index 5ae76ba30..999dc5928 100644
--- a/crates/rust-analyzer/build.rs
+++ b/crates/rust-analyzer/build.rs
@@ -39,8 +39,7 @@ fn set_rerun() {
 }
 fn rev() -> Option<String> {
-    let output = Command::new("git").args(&["rev-parse", "HEAD"]).output().ok()?;
+    let output = Command::new("git").args(&["describe", "--tags"]).output().ok()?;
    let stdout = String::from_utf8(output.stdout).ok()?;
-    let short_hash = stdout.get(0..7)?;
+    Some(stdout)
-    Some(short_hash.to_owned())
 }
diff --git a/crates/rust-analyzer/src/bin/flags.rs b/crates/rust-analyzer/src/bin/flags.rs
index 3a7caaf3f..d8987633d 100644
--- a/crates/rust-analyzer/src/bin/flags.rs
+++ b/crates/rust-analyzer/src/bin/flags.rs
@@ -65,6 +65,8 @@ xflags::xflags! {
            optional -o, --only path: String
            /// Also analyze all dependencies.
            optional --with-deps
+            /// Don't load sysroot crates (`std`, `core` & friends).
+            optional --no-sysroot
            /// Load OUT_DIR values by running `cargo check` before analysis.
            optional --load-output-dirs
@@ -176,6 +178,7 @@ pub struct AnalysisStats {
    pub memory_usage: bool,
    pub only: Option<String>,
    pub with_deps: bool,
+    pub no_sysroot: bool,
    pub load_output_dirs: bool,
    pub with_proc_macro: bool,
 }
diff --git a/crates/rust-analyzer/src/bin/main.rs b/crates/rust-analyzer/src/bin/main.rs
index 288847980..a0b611bff 100644
--- a/crates/rust-analyzer/src/bin/main.rs
+++ b/crates/rust-analyzer/src/bin/main.rs
@@ -74,6 +74,7 @@ fn try_main() -> Result<()> {
            memory_usage: cmd.memory_usage,
            only: cmd.only,
            with_deps: cmd.with_deps,
+            no_sysroot: cmd.no_sysroot,
            path: cmd.path,
            load_output_dirs: cmd.load_output_dirs,
            with_proc_macro: cmd.with_proc_macro,
diff --git a/crates/rust-analyzer/src/cli/analysis_stats.rs b/crates/rust-analyzer/src/cli/analysis_stats.rs
index ad0759bda..9c59e7ee4 100644
--- a/crates/rust-analyzer/src/cli/analysis_stats.rs
+++ b/crates/rust-analyzer/src/cli/analysis_stats.rs
@@ -12,13 +12,14 @@ use hir::{
    AssocItem, Crate, HasSource, HirDisplay, ModuleDef,
 };
 use hir_def::FunctionId;
-use hir_ty::{Ty, TypeWalk};
+use hir_ty::TypeWalk;
 use ide_db::base_db::{
    salsa::{self, ParallelDatabase},
    SourceDatabaseExt,
 };
 use itertools::Itertools;
 use oorandom::Rand32;
+use project_model::CargoConfig;
 use rayon::prelude::*;
 use rustc_hash::FxHashSet;
 use stdx::format_to;
@@ -46,6 +47,7 @@ pub struct AnalysisStatsCmd {
    pub memory_usage: bool,
    pub only: Option<String>,
    pub with_deps: bool,
+    pub no_sysroot: bool,
    pub path: PathBuf,
    pub load_output_dirs: bool,
    pub with_proc_macro: bool,
@@ -59,7 +61,8 @@ impl AnalysisStatsCmd {
        };
        let mut db_load_sw = self.stop_watch();
-        let cargo_config = Default::default();
+        let mut cargo_config = CargoConfig::default();
+        cargo_config.no_sysroot = self.no_sysroot;
        let load_cargo_config = LoadCargoConfig {
            load_out_dirs_from_check: self.load_output_dirs,
            with_proc_macro: self.with_proc_macro,
@@ -187,12 +190,12 @@ impl AnalysisStatsCmd {
            for (expr_id, _) in body.exprs.iter() {
                let ty = &inference_result[expr_id];
                num_exprs += 1;
-                if let Ty::Unknown = ty {
+                if ty.is_unknown() {
                    num_exprs_unknown += 1;
                } else {
                    let mut is_partially_unknown = false;
                    ty.walk(&mut |ty| {
-                        if let Ty::Unknown = ty {
+                        if ty.is_unknown() {
                            is_partially_unknown = true;
                        }
                    });
diff --git a/crates/rust-analyzer/src/handlers.rs b/crates/rust-analyzer/src/handlers.rs
index 6cc433cb8..706a39dab 100644
--- a/crates/rust-analyzer/src/handlers.rs
+++ b/crates/rust-analyzer/src/handlers.rs
@@ -555,7 +555,7 @@ pub(crate) fn handle_runnables(
        if should_skip_target(&runnable, cargo_spec.as_ref()) {
            continue;
        }
-        let mut runnable = to_proto::runnable(&snap, file_id, runnable)?;
+        let mut runnable = to_proto::runnable(&snap, runnable)?;
        if expect_test {
            runnable.label = format!("{} + expect", runnable.label);
            runnable.args.expect_test = Some(true);
@@ -607,6 +607,24 @@ pub(crate) fn handle_runnables(
    Ok(res)
 }
+pub(crate) fn handle_related_tests(
+    snap: GlobalStateSnapshot,
+    params: lsp_types::TextDocumentPositionParams,
+) -> Result<Vec<lsp_ext::TestInfo>> {
+    let _p = profile::span("handle_related_tests");
+    let position = from_proto::file_position(&snap, params)?;
+    let tests = snap.analysis.related_tests(position, None)?;
+    let mut res = Vec::new();
+    for it in tests {
+        if let Ok(runnable) = to_proto::runnable(&snap, it) {
+            res.push(lsp_ext::TestInfo { runnable })
+        }
+    }
+    Ok(res)
+}
 pub(crate) fn handle_completion(
    snap: GlobalStateSnapshot,
    params: lsp_types::CompletionParams,
@@ -772,7 +790,7 @@ pub(crate) fn handle_hover(
            contents: HoverContents::Markup(to_proto::markup_content(info.info.markup)),
            range: Some(range),
        },
-        actions: prepare_hover_actions(&snap, position.file_id, &info.info.actions),
+        actions: prepare_hover_actions(&snap, &info.info.actions),
    };
    Ok(Some(hover))
@@ -1440,17 +1458,16 @@ fn show_impl_command_link(
 fn runnable_action_links(
    snap: &GlobalStateSnapshot,
-    file_id: FileId,
    runnable: Runnable,
 ) -> Option<lsp_ext::CommandLinkGroup> {
-    let cargo_spec = CargoTargetSpec::for_file(&snap, file_id).ok()?;
+    let cargo_spec = CargoTargetSpec::for_file(&snap, runnable.nav.file_id).ok()?;
    let hover_config = snap.config.hover();
    if !hover_config.runnable() || should_skip_target(&runnable, cargo_spec.as_ref()) {
        return None;
    }
    let action: &'static _ = runnable.action();
-    to_proto::runnable(snap, file_id, runnable).ok().map(|r| {
+    to_proto::runnable(snap, runnable).ok().map(|r| {
        let mut group = lsp_ext::CommandLinkGroup::default();
        if hover_config.run {
@@ -1489,7 +1506,6 @@ fn goto_type_action_links(
 fn prepare_hover_actions(
    snap: &GlobalStateSnapshot,
-    file_id: FileId,
    actions: &[HoverAction],
 ) -> Vec<lsp_ext::CommandLinkGroup> {
    if snap.config.hover().none() || !snap.config.hover_actions() {
@@ -1500,7 +1516,7 @@ fn prepare_hover_actions(
        .iter()
        .filter_map(|it| match it {
            HoverAction::Implementation(position) => show_impl_command_link(snap, position),
-            HoverAction::Runnable(r) => runnable_action_links(snap, file_id, r.clone()),
+            HoverAction::Runnable(r) => runnable_action_links(snap, r.clone()),
            HoverAction::GoToType(targets) => goto_type_action_links(snap, targets),
        })
        .collect()
diff --git a/crates/rust-analyzer/src/lsp_ext.rs b/crates/rust-analyzer/src/lsp_ext.rs
index 0d2c8f7ff..efcdcd1d9 100644
--- a/crates/rust-analyzer/src/lsp_ext.rs
+++ b/crates/rust-analyzer/src/lsp_ext.rs
@@ -177,6 +177,19 @@ pub struct CargoRunnable {
    pub expect_test: Option<bool>,
 }
+pub enum RelatedTests {}
+impl Request for RelatedTests {
+    type Params = lsp_types::TextDocumentPositionParams;
+    type Result = Vec<TestInfo>;
+    const METHOD: &'static str = "rust-analyzer/relatedTests";
+}
+#[derive(Debug, Deserialize, Serialize)]
+pub struct TestInfo {
+    pub runnable: Runnable,
+}
 pub enum InlayHints {}
 impl Request for InlayHints {
diff --git a/crates/rust-analyzer/src/main_loop.rs b/crates/rust-analyzer/src/main_loop.rs
index f0cb309e4..984790d35 100644
--- a/crates/rust-analyzer/src/main_loop.rs
+++ b/crates/rust-analyzer/src/main_loop.rs
@@ -500,6 +500,7 @@ impl GlobalState {
            .on::<lsp_ext::ExpandMacro>(handlers::handle_expand_macro)
            .on::<lsp_ext::ParentModule>(handlers::handle_parent_module)
            .on::<lsp_ext::Runnables>(handlers::handle_runnables)
+            .on::<lsp_ext::RelatedTests>(handlers::handle_related_tests)
            .on::<lsp_ext::InlayHints>(handlers::handle_inlay_hints)
            .on::<lsp_ext::CodeActionRequest>(handlers::handle_code_action)
            .on::<lsp_ext::CodeActionResolveRequest>(handlers::handle_code_action_resolve)
diff --git a/crates/rust-analyzer/src/to_proto.rs b/crates/rust-analyzer/src/to_proto.rs
index a9846fa70..d415ed4d3 100644
--- a/crates/rust-analyzer/src/to_proto.rs
+++ b/crates/rust-analyzer/src/to_proto.rs
@@ -6,9 +6,10 @@ use std::{
 use ide::{
    Annotation, AnnotationKind, Assist, AssistKind, CallInfo, CompletionItem, CompletionItemKind,
-    Documentation, FileId, FileRange, FileSystemEdit, Fold, FoldKind, Highlight, HlMod, HlPunct,
+    CompletionRelevance, Documentation, FileId, FileRange, FileSystemEdit, Fold, FoldKind,
-    HlRange, HlTag, Indel, InlayHint, InlayKind, InsertTextFormat, Markup, NavigationTarget,
+    Highlight, HlMod, HlPunct, HlRange, HlTag, Indel, InlayHint, InlayKind, InsertTextFormat,
-    ReferenceAccess, RenameError, Runnable, Severity, SourceChange, TextEdit, TextRange, TextSize,
+    Markup, NavigationTarget, ReferenceAccess, RenameError, Runnable, Severity, SourceChange,
+    TextEdit, TextRange, TextSize,
 };
 use ide_db::SymbolKind;
 use itertools::Itertools;
@@ -213,12 +214,22 @@ pub(crate) fn completion_item(
        ..Default::default()
    };
-    if item.relevance().is_relevant() {
+    fn set_score(res: &mut lsp_types::CompletionItem, relevance: CompletionRelevance) {
-        lsp_item.preselect = Some(true);
+        if relevance.is_relevant() {
-        // HACK: sort preselect items first
+            res.preselect = Some(true);
-        lsp_item.sort_text = Some(format!(" {}", item.label()));
+        }
+        // The relevance needs to be inverted to come up with a sort score
+        // because the client will sort ascending.
+        let sort_score = relevance.score() ^ 0xFF_FF_FF_FF;
+        // Zero pad the string to ensure values can be properly sorted
+        // by the client. Hex format is used because it is easier to
+        // visually compare very large values, which the sort text
+        // tends to be since it is the opposite of the score.
+        res.sort_text = Some(format!("{:08x}", sort_score));
    }
+    set_score(&mut lsp_item, item.relevance());
    if item.deprecated() {
        lsp_item.tags = Some(vec![lsp_types::CompletionItemTag::Deprecated])
    }
@@ -228,10 +239,9 @@ pub(crate) fn completion_item(
    }
    let mut res = match item.ref_match() {
-        Some(mutability) => {
+        Some((mutability, relevance)) => {
            let mut lsp_item_with_ref = lsp_item.clone();
-            lsp_item.preselect = Some(true);
+            set_score(&mut lsp_item_with_ref, relevance);
-            lsp_item.sort_text = Some(format!(" {}", item.label()));
            lsp_item_with_ref.label =
                format!("&{}{}", mutability.as_keyword_for_ref(), lsp_item_with_ref.label);
            if let Some(lsp_types::CompletionTextEdit::Edit(it)) = &mut lsp_item_with_ref.text_edit
@@ -474,7 +484,8 @@ pub(crate) fn folding_range(
    let kind = match fold.kind {
        FoldKind::Comment => Some(lsp_types::FoldingRangeKind::Comment),
        FoldKind::Imports => Some(lsp_types::FoldingRangeKind::Imports),
-        FoldKind::Mods | FoldKind::Block | FoldKind::ArgList | FoldKind::Region => None,
+        FoldKind::Region => Some(lsp_types::FoldingRangeKind::Region),
+        FoldKind::Mods | FoldKind::Block | FoldKind::ArgList => None,
    };
    let range = range(line_index, fold.range);
@@ -828,11 +839,10 @@ pub(crate) fn resolved_code_action(
 pub(crate) fn runnable(
    snap: &GlobalStateSnapshot,
-    file_id: FileId,
    runnable: Runnable,
 ) -> Result<lsp_ext::Runnable> {
    let config = snap.config.runnables();
-    let spec = CargoTargetSpec::for_file(snap, file_id)?;
+    let spec = CargoTargetSpec::for_file(snap, runnable.nav.file_id)?;
    let workspace_root = spec.as_ref().map(|it| it.workspace_root.clone());
    let target = spec.as_ref().map(|s| s.target.clone());
    let (cargo_args, executable_args) =
@@ -865,7 +875,7 @@ pub(crate) fn code_lens(
            let annotation_range = range(&line_index, annotation.range);
            let action = run.action();
-            let r = runnable(&snap, run.nav.file_id, run)?;
+            let r = runnable(&snap, run)?;
            let command = if debug {
                command::debug_single(&r)
@@ -1107,13 +1117,13 @@ mod tests {
                (
                    "&arg",
                    Some(
-                        " arg",
+                        "fffffffa",
                    ),
                ),
                (
                    "arg",
                    Some(
-                        " arg",
+                        "fffffffd",
                    ),
                ),
            ]
diff --git a/crates/syntax/src/ast/make.rs b/crates/syntax/src/ast/make.rs
index 70ba8adb4..05a6b0b25 100644
--- a/crates/syntax/src/ast/make.rs
+++ b/crates/syntax/src/ast/make.rs
@@ -222,6 +222,9 @@ pub fn expr_if(
    };
    expr_from_text(&format!("if {} {} {}", condition, then_branch, else_branch))
 }
+pub fn expr_for_loop(pat: ast::Pat, expr: ast::Expr, block: ast::BlockExpr) -> ast::Expr {
+    expr_from_text(&format!("for {} in {} {}", pat, expr, block))
+}
 pub fn expr_prefix(op: SyntaxKind, expr: ast::Expr) -> ast::Expr {
    let token = token(op);
    expr_from_text(&format!("{}{}", token, expr))
diff --git a/crates/syntax/src/parsing/text_tree_sink.rs b/crates/syntax/src/parsing/text_tree_sink.rs
index d5ddc076f..bb10f20c9 100644
--- a/crates/syntax/src/parsing/text_tree_sink.rs
+++ b/crates/syntax/src/parsing/text_tree_sink.rs
@@ -147,8 +147,8 @@ fn n_attached_trivias<'a>(
    trivias: impl Iterator<Item = (SyntaxKind, &'a str)>,
 ) -> usize {
    match kind {
-        MACRO_CALL | MACRO_RULES | CONST | TYPE_ALIAS | STRUCT | ENUM | VARIANT | FN | TRAIT
+        MACRO_CALL | MACRO_RULES | CONST | TYPE_ALIAS | STRUCT | UNION | ENUM | VARIANT | FN
-        | MODULE | RECORD_FIELD | STATIC | USE => {
+        | TRAIT | MODULE | RECORD_FIELD | STATIC | USE => {
            let mut res = 0;
            let mut trivias = trivias.enumerate().peekable();
diff --git a/crates/tt/src/lib.rs b/crates/tt/src/lib.rs
index 8301dc28a..9d9a01e30 100644
--- a/crates/tt/src/lib.rs
+++ b/crates/tt/src/lib.rs
@@ -227,6 +227,53 @@ impl Subtree {
    }
 }
+impl Subtree {
+    /// A simple line string used for debugging
+    pub fn as_debug_string(&self) -> String {
+        let delim = match self.delimiter_kind() {
+            Some(DelimiterKind::Brace) => ("{", "}"),
+            Some(DelimiterKind::Bracket) => ("[", "]"),
+            Some(DelimiterKind::Parenthesis) => ("(", ")"),
+            None => (" ", " "),
+        };
+        let mut res = String::new();
+        res.push_str(delim.0);
+        let mut iter = self.token_trees.iter();
+        let mut last = None;
+        while let Some(child) = iter.next() {
+            let s = match child {
+                TokenTree::Leaf(it) => {
+                    let s = match it {
+                        Leaf::Literal(it) => it.text.to_string(),
+                        Leaf::Punct(it) => it.char.to_string(),
+                        Leaf::Ident(it) => it.text.to_string(),
+                    };
+                    match (it, last) {
+                        (Leaf::Ident(_), Some(&TokenTree::Leaf(Leaf::Ident(_)))) => {
+                            " ".to_string() + &s
+                        }
+                        (Leaf::Punct(_), Some(&TokenTree::Leaf(Leaf::Punct(punct)))) => {
+                            if punct.spacing == Spacing::Alone {
+                                " ".to_string() + &s
+                            } else {
+                                s
+                            }
+                        }
+                        _ => s,
+                    }
+                }
+                TokenTree::Subtree(it) => it.as_debug_string(),
+            };
+            res.push_str(&s);
+            last = Some(child);
+        }
+        res.push_str(delim.1);
+        res
+    }
+}
 pub mod buffer;
 #[derive(Debug, PartialEq, Eq, Clone)]