55 files changed, 1454 insertions, 2184 deletions
diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index 1850068a3..0f68b234c 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -76,7 +76,7 @@ jobs:
      run: cargo test --no-run --locked
    - name: Test
-      run: cargo test
+      run: cargo test -- --nocapture
    - name: Prepare cache
      run: cargo xtask pre-cache
diff --git a/Cargo.lock b/Cargo.lock
index bcb1cbd9f..d7e6d3ac8 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -852,9 +852,9 @@ dependencies = [
 [[package]]
 name = "lsp-types"
-version = "0.88.0"
+version = "0.89.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d8e8e042772e4e10b3785822f63c82399d0dd233825de44d2596f7fa86e023e0"
+checksum = "07731ecd4ee0654728359a5b95e2a254c857876c04b85225496a35d60345daa7"
 dependencies = [
 "bitflags",
 "serde",
@@ -1577,9 +1577,9 @@ dependencies = [
 [[package]]
 name = "syn"
-version = "1.0.68"
+version = "1.0.69"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3ce15dd3ed8aa2f8eeac4716d6ef5ab58b6b9256db41d7e1a0224c2788e8fd87"
+checksum = "48fe99c6bd8b1cc636890bcc071842de909d902c81ac7dab53ba33c421ab8ffb"
 dependencies = [
 "proc-macro2",
 "quote",
diff --git a/crates/hir/src/lib.rs b/crates/hir/src/lib.rs
index 0afc06906..eba46a056 100644
--- a/crates/hir/src/lib.rs
+++ b/crates/hir/src/lib.rs
@@ -1580,11 +1580,24 @@ impl Impl {
            ty.equals_ctor(rref.as_ref().map_or(&self_ty.ty, |it| &it.ty))
        };
+        let fp = TyFingerprint::for_inherent_impl(&ty);
+        let fp = if let Some(fp) = fp {
+            fp
+        } else {
+            return Vec::new();
+        };
        let mut all = Vec::new();
        def_crates.iter().for_each(|&id| {
-            all.extend(db.inherent_impls_in_crate(id).all_impls().map(Self::from).filter(filter))
+            all.extend(
+                db.inherent_impls_in_crate(id)
+                    .for_self_ty(&ty)
+                    .into_iter()
+                    .cloned()
+                    .map(Self::from)
+                    .filter(filter),
+            )
        });
-        let fp = TyFingerprint::for_impl(&ty);
        for id in def_crates
            .iter()
            .flat_map(|&id| Crate { id }.transitive_reverse_dependencies(db))
@@ -1592,13 +1605,12 @@ impl Impl {
            .chain(def_crates.iter().copied())
            .unique()
        {
-            match fp {
+            all.extend(
-                Some(fp) => all.extend(
+                db.trait_impls_in_crate(id)
-                    db.trait_impls_in_crate(id).for_self_ty(fp).map(Self::from).filter(filter),
+                    .for_self_ty_without_blanket_impls(fp)
-                ),
+                    .map(Self::from)
-                None => all
+                    .filter(filter),
-                    .extend(db.trait_impls_in_crate(id).all_impls().map(Self::from).filter(filter)),
+            );
-            }
        }
        all
    }
@@ -1825,7 +1837,7 @@ impl Type {
            Solution::Unique(s) => s
                .value
                .subst
-                .interned()
+                .as_slice(&Interner)
                .first()
                .map(|ty| self.derived(ty.assert_ty_ref(&Interner).clone())),
            Solution::Ambig(_) => None,
@@ -1903,7 +1915,9 @@ impl Type {
                | TyKind::Dyn(_)
                | TyKind::Function(_)
                | TyKind::Alias(_)
-                | TyKind::Foreign(_) => false,
+                | TyKind::Foreign(_)
+                | TyKind::Generator(..)
+                | TyKind::GeneratorWitness(..) => false,
            }
        }
    }
diff --git a/crates/hir_def/src/attr.rs b/crates/hir_def/src/attr.rs
index d9df7564d..786fad6e1 100644
--- a/crates/hir_def/src/attr.rs
+++ b/crates/hir_def/src/attr.rs
@@ -9,7 +9,7 @@ use std::{
 use base_db::CrateId;
 use cfg::{CfgExpr, CfgOptions};
 use either::Either;
-use hir_expand::{hygiene::Hygiene, name::AsName, AstId, InFile};
+use hir_expand::{hygiene::Hygiene, name::AsName, AstId, AttrId, InFile};
 use itertools::Itertools;
 use la_arena::ArenaMap;
 use mbe::ast_to_token_tree;
@@ -98,13 +98,16 @@ impl RawAttrs {
    pub(crate) fn new(owner: &dyn ast::AttrsOwner, hygiene: &Hygiene) -> Self {
        let entries = collect_attrs(owner)
            .enumerate()
-            .flat_map(|(i, attr)| match attr {
+            .flat_map(|(i, attr)| {
-                Either::Left(attr) => Attr::from_src(attr, hygiene, i as u32),
+                let index = AttrId(i as u32);
-                Either::Right(comment) => comment.doc_comment().map(|doc| Attr {
+                match attr {
-                    index: i as u32,
+                    Either::Left(attr) => Attr::from_src(attr, hygiene, index),
-                    input: Some(AttrInput::Literal(SmolStr::new(doc))),
+                    Either::Right(comment) => comment.doc_comment().map(|doc| Attr {
-                    path: Interned::new(ModPath::from(hir_expand::name!(doc))),
+                        id: index,
-                }),
+                        input: Some(AttrInput::Literal(SmolStr::new(doc))),
+                        path: Interned::new(ModPath::from(hir_expand::name!(doc))),
+                    }),
+                }
            })
            .collect::<Arc<_>>();
@@ -161,7 +164,7 @@ impl RawAttrs {
                let cfg = parts.next().unwrap();
                let cfg = Subtree { delimiter: subtree.delimiter, token_trees: cfg.to_vec() };
                let cfg = CfgExpr::parse(&cfg);
-                let index = attr.index;
+                let index = attr.id;
                let attrs = parts.filter(|a| !a.is_empty()).filter_map(|attr| {
                    let tree = Subtree { delimiter: None, token_trees: attr.to_vec() };
                    let attr = ast::Attr::parse(&format!("#[{}]", tree)).ok()?;
@@ -468,7 +471,7 @@ impl AttrsWithOwner {
    ) -> Option<(Documentation, DocsRangeMap)> {
        // FIXME: code duplication in `docs` above
        let docs = self.by_key("doc").attrs().flat_map(|attr| match attr.input.as_ref()? {
-            AttrInput::Literal(s) => Some((s, attr.index)),
+            AttrInput::Literal(s) => Some((s, attr.id)),
            AttrInput::TokenTree(_) => None,
        });
        let indent = docs
@@ -560,8 +563,8 @@ impl AttrSourceMap {
    /// the attribute represented by `Attr`.
    pub fn source_of(&self, attr: &Attr) -> InFile<&Either<ast::Attr, ast::Comment>> {
        self.attrs
-            .get(attr.index as usize)
+            .get(attr.id.0 as usize)
-            .unwrap_or_else(|| panic!("cannot find `Attr` at index {}", attr.index))
+            .unwrap_or_else(|| panic!("cannot find `Attr` at index {:?}", attr.id))
            .as_ref()
    }
 }
@@ -572,7 +575,7 @@ pub struct DocsRangeMap {
    // (docstring-line-range, attr_index, attr-string-range)
    // a mapping from the text range of a line of the [`Documentation`] to the attribute index and
    // the original (untrimmed) syntax doc line
-    mapping: Vec<(TextRange, u32, TextRange)>,
+    mapping: Vec<(TextRange, AttrId, TextRange)>,
 }
 impl DocsRangeMap {
@@ -585,7 +588,7 @@ impl DocsRangeMap {
        let relative_range = range - line_docs_range.start();
-        let &InFile { file_id, value: ref source } = &self.source[idx as usize];
+        let &InFile { file_id, value: ref source } = &self.source[idx.0 as usize];
        match source {
            Either::Left(_) => None, // FIXME, figure out a nice way to handle doc attributes here
            // as well as for whats done in syntax highlight doc injection
@@ -606,7 +609,7 @@ impl DocsRangeMap {
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Attr {
-    index: u32,
+    pub(crate) id: AttrId,
    pub(crate) path: Interned<ModPath>,
    pub(crate) input: Option<AttrInput>,
 }
@@ -620,7 +623,7 @@ pub enum AttrInput {
 }
 impl Attr {
-    fn from_src(ast: ast::Attr, hygiene: &Hygiene, index: u32) -> Option<Attr> {
+    fn from_src(ast: ast::Attr, hygiene: &Hygiene, id: AttrId) -> Option<Attr> {
        let path = Interned::new(ModPath::from_src(ast.path()?, hygiene)?);
        let input = if let Some(ast::Expr::Literal(lit)) = ast.expr() {
            let value = match lit.kind() {
@@ -633,7 +636,7 @@ impl Attr {
        } else {
            None
        };
-        Some(Attr { index, path, input })
+        Some(Attr { id, path, input })
    }
    /// Parses this attribute as a `#[derive]`, returns an iterator that yields all contained paths
@@ -748,9 +751,7 @@ fn collect_attrs(
        .chain(inner_docs.into_iter().flatten())
        .map(|docs_text| (docs_text.syntax().text_range().start(), Either::Right(docs_text)));
    // sort here by syntax node offset because the source can have doc attributes and doc strings be interleaved
-    let attrs: Vec<_> = docs.chain(attrs).sorted_by_key(|&(offset, _)| offset).collect();
+    docs.chain(attrs).sorted_by_key(|&(offset, _)| offset).map(|(_, attr)| attr)
-    attrs.into_iter().map(|(_, attr)| attr)
 }
 pub(crate) fn variants_attrs_source_map(
diff --git a/crates/hir_def/src/child_by_source.rs b/crates/hir_def/src/child_by_source.rs
index f40a7f80d..f2e809ca9 100644
--- a/crates/hir_def/src/child_by_source.rs
+++ b/crates/hir_def/src/child_by_source.rs
@@ -80,6 +80,10 @@ impl ChildBySource for ModuleId {
 impl ChildBySource for ItemScope {
    fn child_by_source_to(&self, db: &dyn DefDatabase, res: &mut DynMap) {
        self.declarations().for_each(|item| add_module_def(db, res, item));
+        self.unnamed_consts().for_each(|konst| {
+            let src = konst.lookup(db).source(db);
+            res[keys::CONST].insert(src, konst);
+        });
        self.impls().for_each(|imp| add_impl(db, res, imp));
        fn add_module_def(db: &dyn DefDatabase, map: &mut DynMap, item: ModuleDefId) {
diff --git a/crates/hir_def/src/lib.rs b/crates/hir_def/src/lib.rs
index e2af0e514..d69116d51 100644
--- a/crates/hir_def/src/lib.rs
+++ b/crates/hir_def/src/lib.rs
@@ -62,7 +62,7 @@ use hir_expand::{
    ast_id_map::FileAstId,
    eager::{expand_eager_macro, ErrorEmitted, ErrorSink},
    hygiene::Hygiene,
-    AstId, HirFileId, InFile, MacroCallId, MacroCallKind, MacroDefId, MacroDefKind,
+    AstId, AttrId, HirFileId, InFile, MacroCallId, MacroCallKind, MacroDefId, MacroDefKind,
 };
 use la_arena::Idx;
 use nameres::DefMap;
@@ -690,13 +690,16 @@ fn macro_call_as_call_id(
        )
        .map(MacroCallId::from)
    } else {
-        Ok(def.as_lazy_macro(db.upcast(), krate, MacroCallKind::FnLike(call.ast_id)).into())
+        Ok(def
+            .as_lazy_macro(db.upcast(), krate, MacroCallKind::FnLike { ast_id: call.ast_id })
+            .into())
    };
    Ok(res)
 }
 fn derive_macro_as_call_id(
    item_attr: &AstIdWithPath<ast::Item>,
+    derive_attr: AttrId,
    db: &dyn db::DefDatabase,
    krate: CrateId,
    resolver: impl Fn(path::ModPath) -> Option<MacroDefId>,
@@ -707,7 +710,11 @@ fn derive_macro_as_call_id(
        .as_lazy_macro(
            db.upcast(),
            krate,
-            MacroCallKind::Derive(item_attr.ast_id, last_segment.to_string()),
+            MacroCallKind::Derive {
+                ast_id: item_attr.ast_id,
+                derive_name: last_segment.to_string(),
+                derive_attr,
+            },
        )
        .into();
    Ok(res)
diff --git a/crates/hir_def/src/nameres.rs b/crates/hir_def/src/nameres.rs
index 7dd68219f..9e181751c 100644
--- a/crates/hir_def/src/nameres.rs
+++ b/crates/hir_def/src/nameres.rs
@@ -613,12 +613,12 @@ mod diagnostics {
                DiagnosticKind::UnresolvedProcMacro { ast } => {
                    let mut precise_location = None;
                    let (file, ast, name) = match ast {
-                        MacroCallKind::FnLike(ast) => {
+                        MacroCallKind::FnLike { ast_id } => {
-                            let node = ast.to_node(db.upcast());
+                            let node = ast_id.to_node(db.upcast());
-                            (ast.file_id, SyntaxNodePtr::from(AstPtr::new(&node)), None)
+                            (ast_id.file_id, SyntaxNodePtr::from(AstPtr::new(&node)), None)
                        }
-                        MacroCallKind::Derive(ast, name) => {
+                        MacroCallKind::Derive { ast_id, derive_name, .. } => {
-                            let node = ast.to_node(db.upcast());
+                            let node = ast_id.to_node(db.upcast());
                            // Compute the precise location of the macro name's token in the derive
                            // list.
@@ -639,7 +639,7 @@ mod diagnostics {
                                    });
                                for token in tokens {
                                    if token.kind() == SyntaxKind::IDENT
-                                        && token.text() == name.as_str()
+                                        && token.text() == derive_name.as_str()
                                    {
                                        precise_location = Some(token.text_range());
                                        break 'outer;
@@ -648,9 +648,9 @@ mod diagnostics {
                            }
                            (
-                                ast.file_id,
+                                ast_id.file_id,
                                SyntaxNodePtr::from(AstPtr::new(&node)),
-                                Some(name.clone()),
+                                Some(derive_name.clone()),
                            )
                        }
                    };
@@ -669,13 +669,13 @@ mod diagnostics {
                DiagnosticKind::MacroError { ast, message } => {
                    let (file, ast) = match ast {
-                        MacroCallKind::FnLike(ast) => {
+                        MacroCallKind::FnLike { ast_id, .. } => {
-                            let node = ast.to_node(db.upcast());
+                            let node = ast_id.to_node(db.upcast());
-                            (ast.file_id, SyntaxNodePtr::from(AstPtr::new(&node)))
+                            (ast_id.file_id, SyntaxNodePtr::from(AstPtr::new(&node)))
                        }
-                        MacroCallKind::Derive(ast, _) => {
+                        MacroCallKind::Derive { ast_id, .. } => {
-                            let node = ast.to_node(db.upcast());
+                            let node = ast_id.to_node(db.upcast());
-                            (ast.file_id, SyntaxNodePtr::from(AstPtr::new(&node)))
+                            (ast_id.file_id, SyntaxNodePtr::from(AstPtr::new(&node)))
                        }
                    };
                    sink.push(MacroError { file, node: ast, message: message.clone() });
diff --git a/crates/hir_def/src/nameres/collector.rs b/crates/hir_def/src/nameres/collector.rs
index 492d8c71f..fb4ddff5e 100644
--- a/crates/hir_def/src/nameres/collector.rs
+++ b/crates/hir_def/src/nameres/collector.rs
@@ -13,7 +13,7 @@ use hir_expand::{
    builtin_macro::find_builtin_macro,
    name::{AsName, Name},
    proc_macro::ProcMacroExpander,
-    HirFileId, MacroCallId, MacroCallKind, MacroDefId, MacroDefKind,
+    AttrId, HirFileId, MacroCallId, MacroCallKind, MacroDefId, MacroDefKind,
 };
 use hir_expand::{InFile, MacroCallLoc};
 use rustc_hash::{FxHashMap, FxHashSet};
@@ -216,7 +216,7 @@ struct MacroDirective {
 #[derive(Clone, Debug, Eq, PartialEq)]
 enum MacroDirectiveKind {
    FnLike { ast_id: AstIdWithPath<ast::MacroCall> },
-    Derive { ast_id: AstIdWithPath<ast::Item> },
+    Derive { ast_id: AstIdWithPath<ast::Item>, derive_attr: AttrId },
 }
 struct DefData<'a> {
@@ -478,7 +478,7 @@ impl DefCollector<'_> {
            self.def_map.edition,
        );
-        let res = self.def_map.resolve_name_in_extern_prelude(&extern_crate.name);
+        let res = self.def_map.resolve_name_in_extern_prelude(self.db, &extern_crate.name);
        if let Some(ModuleDefId::ModuleId(m)) = res.take_types() {
            cov_mark::hit!(macro_rules_from_other_crates_are_visible_with_macro_use);
@@ -534,6 +534,7 @@ impl DefCollector<'_> {
        log::debug!("resolving import: {:?} ({:?})", import, self.def_map.edition);
        if import.is_extern_crate {
            let res = self.def_map.resolve_name_in_extern_prelude(
+                self.db,
                &import
                    .path
                    .as_ident()
@@ -831,12 +832,16 @@ impl DefCollector<'_> {
                        Err(UnresolvedMacro) | Ok(Err(_)) => {}
                    }
                }
-                MacroDirectiveKind::Derive { ast_id } => {
+                MacroDirectiveKind::Derive { ast_id, derive_attr } => {
-                    match derive_macro_as_call_id(ast_id, self.db, self.def_map.krate, |path| {
+                    match derive_macro_as_call_id(
-                        self.resolve_derive_macro(directive.module_id, &path)
+                        ast_id,
-                    }) {
+                        *derive_attr,
+                        self.db,
+                        self.def_map.krate,
+                        |path| self.resolve_derive_macro(directive.module_id, &path),
+                    ) {
                        Ok(call_id) => {
-                            resolved.push((directive.module_id, call_id, 0));
+                            resolved.push((directive.module_id, call_id, directive.depth));
                            res = ReachedFixedPoint::No;
                            return false;
                        }
@@ -1368,7 +1373,7 @@ impl ModCollector<'_, '_> {
                        self.def_collector.unexpanded_macros.push(MacroDirective {
                            module_id: self.module_id,
                            depth: self.macro_depth + 1,
-                            kind: MacroDirectiveKind::Derive { ast_id },
+                            kind: MacroDirectiveKind::Derive { ast_id, derive_attr: derive.id },
                        });
                    }
                }
@@ -1520,7 +1525,7 @@ impl ModCollector<'_, '_> {
                // Built-in macro failed eager expansion.
                self.def_collector.def_map.diagnostics.push(DefDiagnostic::macro_error(
                    self.module_id,
-                    MacroCallKind::FnLike(ast_id.ast_id),
+                    MacroCallKind::FnLike { ast_id: ast_id.ast_id },
                    error.unwrap().to_string(),
                ));
                return;
diff --git a/crates/hir_def/src/nameres/path_resolution.rs b/crates/hir_def/src/nameres/path_resolution.rs
index 60471937c..ccc9f22eb 100644
--- a/crates/hir_def/src/nameres/path_resolution.rs
+++ b/crates/hir_def/src/nameres/path_resolution.rs
@@ -60,12 +60,26 @@ impl ResolvePathResult {
 }
 impl DefMap {
-    pub(super) fn resolve_name_in_extern_prelude(&self, name: &Name) -> PerNs {
+    pub(super) fn resolve_name_in_extern_prelude(
+        &self,
+        db: &dyn DefDatabase,
+        name: &Name,
+    ) -> PerNs {
        if name == &name!(self) {
            cov_mark::hit!(extern_crate_self_as);
            return PerNs::types(self.module_id(self.root).into(), Visibility::Public);
        }
-        self.extern_prelude
+        let arc;
+        let root = match self.block {
+            Some(_) => {
+                arc = self.crate_root(db).def_map(db);
+                &*arc
+            }
+            None => self,
+        };
+        root.extern_prelude
            .get(name)
            .map_or(PerNs::none(), |&it| PerNs::types(it, Visibility::Public))
    }
@@ -191,7 +205,7 @@ impl DefMap {
                    None => return ResolvePathResult::empty(ReachedFixedPoint::Yes),
                };
                log::debug!("resolving {:?} in crate root (+ extern prelude)", segment);
-                self.resolve_name_in_crate_root_or_extern_prelude(&segment)
+                self.resolve_name_in_crate_root_or_extern_prelude(db, &segment)
            }
            PathKind::Plain => {
                let (_, segment) = match segments.next() {
@@ -384,24 +398,31 @@ impl DefMap {
                }
            }
        };
-        // Give precedence to names in outer `DefMap`s over the extern prelude; only check prelude
+        let from_extern_prelude = self
-        // from the crate DefMap.
+            .extern_prelude
-        let from_extern_prelude = match self.block {
+            .get(name)
-            Some(_) => PerNs::none(),
+            .map_or(PerNs::none(), |&it| PerNs::types(it, Visibility::Public));
-            None => self
-                .extern_prelude
-                .get(name)
-                .map_or(PerNs::none(), |&it| PerNs::types(it, Visibility::Public)),
-        };
        let from_prelude = self.resolve_in_prelude(db, name);
        from_legacy_macro.or(from_scope_or_builtin).or(from_extern_prelude).or(from_prelude)
    }
-    fn resolve_name_in_crate_root_or_extern_prelude(&self, name: &Name) -> PerNs {
+    fn resolve_name_in_crate_root_or_extern_prelude(
-        let from_crate_root = self[self.root].scope.get(name);
+        &self,
-        let from_extern_prelude = self.resolve_name_in_extern_prelude(name);
+        db: &dyn DefDatabase,
+        name: &Name,
+    ) -> PerNs {
+        let arc;
+        let crate_def_map = match self.block {
+            Some(_) => {
+                arc = self.crate_root(db).def_map(db);
+                &arc
+            }
+            None => self,
+        };
+        let from_crate_root = crate_def_map[crate_def_map.root].scope.get(name);
+        let from_extern_prelude = self.resolve_name_in_extern_prelude(db, name);
        from_crate_root.or(from_extern_prelude)
    }
diff --git a/crates/hir_expand/src/builtin_derive.rs b/crates/hir_expand/src/builtin_derive.rs
index 6ece4b289..537c03028 100644
--- a/crates/hir_expand/src/builtin_derive.rs
+++ b/crates/hir_expand/src/builtin_derive.rs
@@ -269,7 +269,7 @@ mod tests {
    use expect_test::{expect, Expect};
    use name::AsName;
-    use crate::{test_db::TestDB, AstId, MacroCallId, MacroCallKind, MacroCallLoc};
+    use crate::{test_db::TestDB, AstId, AttrId, MacroCallId, MacroCallKind, MacroCallLoc};
    use super::*;
@@ -308,7 +308,7 @@ $0
        let expander = BuiltinDeriveExpander::find_by_name(&name).unwrap();
-        let attr_id = AstId::new(file_id.into(), ast_id_map.ast_id(&items[0]));
+        let ast_id = AstId::new(file_id.into(), ast_id_map.ast_id(&items[0]));
        let loc = MacroCallLoc {
            def: MacroDefId {
@@ -317,7 +317,11 @@ $0
                local_inner: false,
            },
            krate: CrateId(0),
-            kind: MacroCallKind::Derive(attr_id, name.to_string()),
+            kind: MacroCallKind::Derive {
+                ast_id,
+                derive_name: name.to_string(),
+                derive_attr: AttrId(0),
+            },
        };
        let id: MacroCallId = db.intern_macro(loc).into();
diff --git a/crates/hir_expand/src/builtin_macro.rs b/crates/hir_expand/src/builtin_macro.rs
index a7d0f5b1f..80365fc16 100644
--- a/crates/hir_expand/src/builtin_macro.rs
+++ b/crates/hir_expand/src/builtin_macro.rs
@@ -566,10 +566,9 @@ mod tests {
                let loc = MacroCallLoc {
                    def,
                    krate,
-                    kind: MacroCallKind::FnLike(AstId::new(
+                    kind: MacroCallKind::FnLike {
-                        file_id.into(),
+                        ast_id: AstId::new(file_id.into(), ast_id_map.ast_id(&macro_call)),
-                        ast_id_map.ast_id(&macro_call),
+                    },
-                    )),
                };
                let id: MacroCallId = db.intern_macro(loc).into();
diff --git a/crates/hir_expand/src/db.rs b/crates/hir_expand/src/db.rs
index 10fe60821..95dc12744 100644
--- a/crates/hir_expand/src/db.rs
+++ b/crates/hir_expand/src/db.rs
@@ -14,9 +14,9 @@ use syntax::{
 };
 use crate::{
-    ast_id_map::AstIdMap, hygiene::HygieneFrame, BuiltinDeriveExpander, BuiltinFnLikeExpander,
+    ast_id_map::AstIdMap, hygiene::HygieneFrame, input::process_macro_input, BuiltinDeriveExpander,
-    EagerCallLoc, EagerMacroId, HirFileId, HirFileIdRepr, LazyMacroId, MacroCallId, MacroCallLoc,
+    BuiltinFnLikeExpander, EagerCallLoc, EagerMacroId, HirFileId, HirFileIdRepr, LazyMacroId,
-    MacroDefId, MacroDefKind, MacroFile, ProcMacroExpander,
+    MacroCallId, MacroCallLoc, MacroDefId, MacroDefKind, MacroFile, ProcMacroExpander,
 };
 /// Total limit on the number of tokens produced by any macro invocation.
@@ -191,6 +191,7 @@ fn macro_arg_text(db: &dyn AstDatabase, id: MacroCallId) -> Option<GreenNode> {
    };
    let loc = db.lookup_intern_macro(id);
    let arg = loc.kind.arg(db)?;
+    let arg = process_macro_input(db, arg, id);
    Some(arg.green())
 }
diff --git a/crates/hir_expand/src/eager.rs b/crates/hir_expand/src/eager.rs
index 9705526fa..ef126e4ad 100644
--- a/crates/hir_expand/src/eager.rs
+++ b/crates/hir_expand/src/eager.rs
@@ -174,8 +174,9 @@ fn lazy_expand(
 ) -> ExpandResult<Option<InFile<SyntaxNode>>> {
    let ast_id = db.ast_id_map(macro_call.file_id).ast_id(&macro_call.value);
-    let id: MacroCallId =
+    let id: MacroCallId = def
-        def.as_lazy_macro(db, krate, MacroCallKind::FnLike(macro_call.with_value(ast_id))).into();
+        .as_lazy_macro(db, krate, MacroCallKind::FnLike { ast_id: macro_call.with_value(ast_id) })
+        .into();
    let err = db.macro_expand_error(id);
    let value = db.parse_or_expand(id.as_file()).map(|node| InFile::new(id.as_file(), node));
diff --git a/crates/hir_expand/src/input.rs b/crates/hir_expand/src/input.rs
new file mode 100644
index 000000000..d1f22aba4
--- /dev/null
+++ b/crates/hir_expand/src/input.rs
@@ -0,0 +1,95 @@
+//! Macro input conditioning.
+use syntax::{
+    ast::{self, AttrsOwner},
+    AstNode, SyntaxNode,
+};
+use crate::{
+    db::AstDatabase,
+    name::{name, AsName},
+    AttrId, LazyMacroId, MacroCallKind, MacroCallLoc,
+};
+pub(crate) fn process_macro_input(
+    db: &dyn AstDatabase,
+    node: SyntaxNode,
+    id: LazyMacroId,
+) -> SyntaxNode {
+    let loc: MacroCallLoc = db.lookup_intern_macro(id);
+    match loc.kind {
+        MacroCallKind::FnLike { .. } => node,
+        MacroCallKind::Derive { derive_attr, .. } => {
+            let item = match ast::Item::cast(node.clone()) {
+                Some(item) => item,
+                None => return node,
+            };
+            remove_derives_up_to(item, derive_attr).syntax().clone()
+        }
+    }
+}
+/// Removes `#[derive]` attributes from `item`, up to `attr`.
+fn remove_derives_up_to(item: ast::Item, attr: AttrId) -> ast::Item {
+    let item = item.clone_for_update();
+    let idx = attr.0 as usize;
+    for attr in item.attrs().take(idx + 1) {
+        if let Some(name) =
+            attr.path().and_then(|path| path.as_single_segment()).and_then(|seg| seg.name_ref())
+        {
+            if name.as_name() == name![derive] {
+                attr.syntax().detach();
+            }
+        }
+    }
+    item
+}
+#[cfg(test)]
+mod tests {
+    use base_db::fixture::WithFixture;
+    use base_db::SourceDatabase;
+    use expect_test::{expect, Expect};
+    use crate::test_db::TestDB;
+    use super::*;
+    fn test_remove_derives_up_to(attr: AttrId, ra_fixture: &str, expect: Expect) {
+        let (db, file_id) = TestDB::with_single_file(&ra_fixture);
+        let parsed = db.parse(file_id);
+        let mut items: Vec<_> =
+            parsed.syntax_node().descendants().filter_map(ast::Item::cast).collect();
+        assert_eq!(items.len(), 1);
+        let item = remove_derives_up_to(items.pop().unwrap(), attr);
+        expect.assert_eq(&item.to_string());
+    }
+    #[test]
+    fn remove_derive() {
+        test_remove_derives_up_to(
+            AttrId(2),
+            r#"
+#[allow(unused)]
+#[derive(Copy)]
+#[derive(Hello)]
+#[derive(Clone)]
+struct A {
+    bar: u32
+}
+        "#,
+            expect![[r#"
+#[allow(unused)]
+#[derive(Clone)]
+struct A {
+    bar: u32
+}"#]],
+        );
+    }
+}
diff --git a/crates/hir_expand/src/lib.rs b/crates/hir_expand/src/lib.rs
index 3e332ee47..7349fdfe4 100644
--- a/crates/hir_expand/src/lib.rs
+++ b/crates/hir_expand/src/lib.rs
@@ -14,6 +14,7 @@ pub mod builtin_macro;
 pub mod proc_macro;
 pub mod quote;
 pub mod eager;
+mod input;
 use either::Either;
 pub use mbe::{ExpandError, ExpandResult};
@@ -290,22 +291,27 @@ pub struct MacroCallLoc {
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub enum MacroCallKind {
-    FnLike(AstId<ast::MacroCall>),
+    FnLike { ast_id: AstId<ast::MacroCall> },
-    Derive(AstId<ast::Item>, String),
+    Derive { ast_id: AstId<ast::Item>, derive_name: String, derive_attr: AttrId },
 }
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct AttrId(pub u32);
 impl MacroCallKind {
    fn file_id(&self) -> HirFileId {
        match self {
-            MacroCallKind::FnLike(ast_id) => ast_id.file_id,
+            MacroCallKind::FnLike { ast_id, .. } => ast_id.file_id,
-            MacroCallKind::Derive(ast_id, _) => ast_id.file_id,
+            MacroCallKind::Derive { ast_id, .. } => ast_id.file_id,
        }
    }
    fn node(&self, db: &dyn db::AstDatabase) -> InFile<SyntaxNode> {
        match self {
-            MacroCallKind::FnLike(ast_id) => ast_id.with_value(ast_id.to_node(db).syntax().clone()),
+            MacroCallKind::FnLike { ast_id, .. } => {
-            MacroCallKind::Derive(ast_id, _) => {
+                ast_id.with_value(ast_id.to_node(db).syntax().clone())
+            }
+            MacroCallKind::Derive { ast_id, .. } => {
                ast_id.with_value(ast_id.to_node(db).syntax().clone())
            }
        }
@@ -313,10 +319,10 @@ impl MacroCallKind {
    fn arg(&self, db: &dyn db::AstDatabase) -> Option<SyntaxNode> {
        match self {
-            MacroCallKind::FnLike(ast_id) => {
+            MacroCallKind::FnLike { ast_id, .. } => {
                Some(ast_id.to_node(db).token_tree()?.syntax().clone())
            }
-            MacroCallKind::Derive(ast_id, _) => Some(ast_id.to_node(db).syntax().clone()),
+            MacroCallKind::Derive { ast_id, .. } => Some(ast_id.to_node(db).syntax().clone()),
        }
    }
 }
diff --git a/crates/hir_expand/src/proc_macro.rs b/crates/hir_expand/src/proc_macro.rs
index 75e950816..d5643393a 100644
--- a/crates/hir_expand/src/proc_macro.rs
+++ b/crates/hir_expand/src/proc_macro.rs
@@ -2,7 +2,6 @@
 use crate::db::AstDatabase;
 use base_db::{CrateId, ProcMacroId};
-use tt::buffer::{Cursor, TokenBuffer};
 #[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
 pub struct ProcMacroExpander {
@@ -44,9 +43,6 @@ impl ProcMacroExpander {
                    .clone()
                    .ok_or_else(|| err!("No derive macro found."))?;
-                let tt = remove_derive_attrs(tt)
-                    .ok_or_else(|| err!("Fail to remove derive for custom derive"))?;
                // Proc macros have access to the environment variables of the invoking crate.
                let env = &krate_graph[calling_crate].env;
@@ -56,101 +52,3 @@ impl ProcMacroExpander {
        }
    }
 }
-fn eat_punct(cursor: &mut Cursor, c: char) -> bool {
-    if let Some(tt::buffer::TokenTreeRef::Leaf(tt::Leaf::Punct(punct), _)) = cursor.token_tree() {
-        if punct.char == c {
-            *cursor = cursor.bump();
-            return true;
-        }
-    }
-    false
-}
-fn eat_subtree(cursor: &mut Cursor, kind: tt::DelimiterKind) -> bool {
-    if let Some(tt::buffer::TokenTreeRef::Subtree(subtree, _)) = cursor.token_tree() {
-        if Some(kind) == subtree.delimiter_kind() {
-            *cursor = cursor.bump_subtree();
-            return true;
-        }
-    }
-    false
-}
-fn eat_ident(cursor: &mut Cursor, t: &str) -> bool {
-    if let Some(tt::buffer::TokenTreeRef::Leaf(tt::Leaf::Ident(ident), _)) = cursor.token_tree() {
-        if t == ident.text.as_str() {
-            *cursor = cursor.bump();
-            return true;
-        }
-    }
-    false
-}
-fn remove_derive_attrs(tt: &tt::Subtree) -> Option<tt::Subtree> {
-    let buffer = TokenBuffer::from_tokens(&tt.token_trees);
-    let mut p = buffer.begin();
-    let mut result = tt::Subtree::default();
-    while !p.eof() {
-        let curr = p;
-        if eat_punct(&mut p, '#') {
-            eat_punct(&mut p, '!');
-            let parent = p;
-            if eat_subtree(&mut p, tt::DelimiterKind::Bracket) {
-                if eat_ident(&mut p, "derive") {
-                    p = parent.bump();
-                    continue;
-                }
-            }
-        }
-        result.token_trees.push(curr.token_tree()?.cloned());
-        p = curr.bump();
-    }
-    Some(result)
-}
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use test_utils::assert_eq_text;
-    #[test]
-    fn test_remove_derive_attrs() {
-        let tt = mbe::parse_to_token_tree(
-            r#"
-    #[allow(unused)]
-    #[derive(Copy)]
-    #[derive(Hello)]
-    struct A {
-        bar: u32
-    }
-"#,
-        )
-        .unwrap()
-        .0;
-        let result = format!("{:#?}", remove_derive_attrs(&tt).unwrap());
-        assert_eq_text!(
-            r#"
-SUBTREE $
-  PUNCH   # [alone] 0
-  SUBTREE [] 1
-    IDENT   allow 2
-    SUBTREE () 3
-      IDENT   unused 4
-  IDENT   struct 15
-  IDENT   A 16
-  SUBTREE {} 17
-    IDENT   bar 18
-    PUNCH   : [alone] 19
-    IDENT   u32 20
-"#
-            .trim(),
-            &result
-        );
-    }
-}
diff --git a/crates/hir_ty/src/autoderef.rs b/crates/hir_ty/src/autoderef.rs
index f8e9db9ae..71bc436e6 100644
--- a/crates/hir_ty/src/autoderef.rs
+++ b/crates/hir_ty/src/autoderef.rs
@@ -6,14 +6,15 @@
 use std::iter::successors;
 use base_db::CrateId;
-use chalk_ir::cast::Cast;
+use chalk_ir::{cast::Cast, fold::Fold, interner::HasInterner, VariableKind};
 use hir_def::lang_item::LangItemTarget;
 use hir_expand::name::name;
 use log::{info, warn};
 use crate::{
-    db::HirDatabase, AliasEq, AliasTy, BoundVar, Canonical, CanonicalVarKinds, DebruijnIndex,
+    db::HirDatabase, static_lifetime, AliasEq, AliasTy, BoundVar, Canonical, CanonicalVarKinds,
-    InEnvironment, Interner, ProjectionTyExt, Solution, Ty, TyBuilder, TyKind,
+    DebruijnIndex, InEnvironment, Interner, ProjectionTyExt, Solution, Substitution, Ty, TyBuilder,
+    TyKind,
 };
 const AUTODEREF_RECURSION_LIMIT: usize = 10;
@@ -103,7 +104,7 @@ fn deref_by_trait(
        binders: CanonicalVarKinds::from_iter(
            &Interner,
            ty.goal.binders.iter(&Interner).cloned().chain(Some(chalk_ir::WithKind::new(
-                chalk_ir::VariableKind::Ty(chalk_ir::TyVariableKind::General),
+                VariableKind::Ty(chalk_ir::TyVariableKind::General),
                chalk_ir::UniverseIndex::ROOT,
            ))),
        ),
@@ -136,7 +137,9 @@ fn deref_by_trait(
                    return None;
                }
            }
-            Some(Canonical {
+            // FIXME: we remove lifetime variables here since they can confuse
+            // the method resolution code later
+            Some(fixup_lifetime_variables(Canonical {
                value: vars
                    .value
                    .subst
@@ -144,7 +147,7 @@ fn deref_by_trait(
                    .assert_ty_ref(&Interner)
                    .clone(),
                binders: vars.binders.clone(),
-            })
+            }))
        }
        Solution::Ambig(_) => {
            info!("Ambiguous solution for derefing {:?}: {:?}", ty.goal, solution);
@@ -152,3 +155,32 @@ fn deref_by_trait(
        }
    }
 }
+fn fixup_lifetime_variables<T: Fold<Interner, Result = T> + HasInterner<Interner = Interner>>(
+    c: Canonical<T>,
+) -> Canonical<T> {
+    // Removes lifetime variables from the Canonical, replacing them by static lifetimes.
+    let mut i = 0;
+    let subst = Substitution::from_iter(
+        &Interner,
+        c.binders.iter(&Interner).map(|vk| match vk.kind {
+            VariableKind::Ty(_) => {
+                let index = i;
+                i += 1;
+                BoundVar::new(DebruijnIndex::INNERMOST, index).to_ty(&Interner).cast(&Interner)
+            }
+            VariableKind::Lifetime => static_lifetime().cast(&Interner),
+            VariableKind::Const(_) => unimplemented!(),
+        }),
+    );
+    let binders = CanonicalVarKinds::from_iter(
+        &Interner,
+        c.binders.iter(&Interner).filter(|vk| match vk.kind {
+            VariableKind::Ty(_) => true,
+            VariableKind::Lifetime => false,
+            VariableKind::Const(_) => true,
+        }),
+    );
+    let value = subst.apply(c.value, &Interner);
+    Canonical { binders, value }
+}
diff --git a/crates/hir_ty/src/builder.rs b/crates/hir_ty/src/builder.rs
index 09512d1ce..e25ef866d 100644
--- a/crates/hir_ty/src/builder.rs
+++ b/crates/hir_ty/src/builder.rs
@@ -4,6 +4,7 @@ use std::iter;
 use chalk_ir::{
    cast::{Cast, CastTo, Caster},
+    fold::Fold,
    interner::HasInterner,
    AdtId, BoundVar, DebruijnIndex, Safety, Scalar,
 };
@@ -13,7 +14,7 @@ use smallvec::SmallVec;
 use crate::{
    db::HirDatabase, primitive, to_assoc_type_id, to_chalk_trait_id, utils::generics, Binders,
    CallableSig, FnPointer, FnSig, FnSubst, GenericArg, Interner, ProjectionTy, Substitution,
-    TraitRef, Ty, TyDefId, TyExt, TyKind, TypeWalk, ValueTyDefId,
+    TraitRef, Ty, TyDefId, TyExt, TyKind, ValueTyDefId,
 };
 /// This is a builder for `Ty` or anything that needs a `Substitution`.
@@ -32,8 +33,7 @@ impl<D> TyBuilder<D> {
    fn build_internal(self) -> (D, Substitution) {
        assert_eq!(self.vec.len(), self.param_count);
-        // FIXME: would be good to have a way to construct a chalk_ir::Substitution from the interned form
+        let subst = Substitution::from_iter(&Interner, self.vec);
-        let subst = Substitution::intern(self.vec);
        (self.data, subst)
    }
@@ -141,7 +141,7 @@ impl TyBuilder<hir_def::AdtId> {
                self.vec.push(fallback().cast(&Interner));
            } else {
                // each default can depend on the previous parameters
-                let subst_so_far = Substitution::intern(self.vec.clone());
+                let subst_so_far = Substitution::from_iter(&Interner, self.vec.clone());
                self.vec
                    .push(default_ty.clone().substitute(&Interner, &subst_so_far).cast(&Interner));
            }
@@ -196,13 +196,13 @@ impl TyBuilder<TypeAliasId> {
    }
 }
-impl<T: TypeWalk + HasInterner<Interner = Interner>> TyBuilder<Binders<T>> {
+impl<T: HasInterner<Interner = Interner> + Fold<Interner>> TyBuilder<Binders<T>> {
    fn subst_binders(b: Binders<T>) -> Self {
        let param_count = b.binders.len(&Interner);
        TyBuilder::new(b, param_count)
    }
-    pub fn build(self) -> T {
+    pub fn build(self) -> <T as Fold<Interner>>::Result {
        let (b, subst) = self.build_internal();
        b.substitute(&Interner, &subst)
    }
diff --git a/crates/hir_ty/src/chalk_cast.rs b/crates/hir_ty/src/chalk_cast.rs
deleted file mode 100644
index df6492113..000000000
--- a/crates/hir_ty/src/chalk_cast.rs
+++ /dev/null
@@ -1,73 +0,0 @@
-//! Implementations of the Chalk `Cast` trait for our types.
-use chalk_ir::{
-    cast::{Cast, CastTo},
-    interner::HasInterner,
-};
-use crate::{AliasEq, DomainGoal, GenericArg, GenericArgData, Interner, TraitRef, Ty, WhereClause};
-macro_rules! has_interner {
-    ($t:ty) => {
-        impl HasInterner for $t {
-            type Interner = crate::Interner;
-        }
-    };
-}
-has_interner!(WhereClause);
-has_interner!(DomainGoal);
-has_interner!(GenericArg);
-has_interner!(Ty);
-impl CastTo<WhereClause> for TraitRef {
-    fn cast_to(self, _interner: &Interner) -> WhereClause {
-        WhereClause::Implemented(self)
-    }
-}
-impl CastTo<WhereClause> for AliasEq {
-    fn cast_to(self, _interner: &Interner) -> WhereClause {
-        WhereClause::AliasEq(self)
-    }
-}
-impl CastTo<DomainGoal> for WhereClause {
-    fn cast_to(self, _interner: &Interner) -> DomainGoal {
-        DomainGoal::Holds(self)
-    }
-}
-impl CastTo<GenericArg> for Ty {
-    fn cast_to(self, interner: &Interner) -> GenericArg {
-        GenericArg::new(interner, GenericArgData::Ty(self))
-    }
-}
-macro_rules! transitive_impl {
-    ($a:ty, $b:ty, $c:ty) => {
-        impl CastTo<$c> for $a {
-            fn cast_to(self, interner: &Interner) -> $c {
-                self.cast::<$b>(interner).cast(interner)
-            }
-        }
-    };
-}
-// In Chalk, these can be done as blanket impls, but that doesn't work here
-// because of coherence
-transitive_impl!(TraitRef, WhereClause, DomainGoal);
-transitive_impl!(AliasEq, WhereClause, DomainGoal);
-macro_rules! reflexive_impl {
-    ($a:ty) => {
-        impl CastTo<$a> for $a {
-            fn cast_to(self, _interner: &Interner) -> $a {
-                self
-            }
-        }
-    };
-}
-reflexive_impl!(GenericArg);
diff --git a/crates/hir_ty/src/traits/chalk.rs b/crates/hir_ty/src/chalk_db.rs
index 090f6492b..8f054d06b 100644
--- a/crates/hir_ty/src/traits/chalk.rs
+++ b/crates/hir_ty/src/chalk_db.rs
@@ -1,52 +1,47 @@
-//! Conversion code from/to Chalk.
+//! The implementation of `RustIrDatabase` for Chalk, which provides information
+//! about the code that Chalk needs.
 use std::sync::Arc;
 use log::debug;
-use chalk_ir::{fold::shift::Shift, CanonicalVarKinds};
+use chalk_ir::{cast::Cast, fold::shift::Shift, CanonicalVarKinds};
 use chalk_solve::rust_ir::{self, OpaqueTyDatumBound, WellKnownTrait};
-use base_db::{salsa::InternKey, CrateId};
+use base_db::CrateId;
 use hir_def::{
    lang_item::{lang_attr, LangItemTarget},
-    AssocContainerId, AssocItemId, HasModule, Lookup, TypeAliasId,
+    AssocContainerId, AssocItemId, GenericDefId, HasModule, Lookup, TypeAliasId,
 };
 use hir_expand::name::name;
-use super::ChalkContext;
 use crate::{
    db::HirDatabase,
    display::HirDisplay,
-    from_assoc_type_id,
+    from_assoc_type_id, from_chalk_trait_id, make_only_type_binders,
+    mapping::{from_chalk, ToChalk, TypeAliasAsValue},
    method_resolution::{TyFingerprint, ALL_FLOAT_FPS, ALL_INT_FPS},
    to_assoc_type_id, to_chalk_trait_id,
+    traits::ChalkContext,
    utils::generics,
-    AliasEq, AliasTy, BoundVar, CallableDefId, DebruijnIndex, FnDefId, ProjectionTy, Substitution,
+    AliasEq, AliasTy, BoundVar, CallableDefId, DebruijnIndex, FnDefId, Interner, ProjectionTy,
-    TraitRef, TraitRefExt, Ty, TyBuilder, TyExt, TyKind, WhereClause,
+    ProjectionTyExt, QuantifiedWhereClause, Substitution, TraitRef, TraitRefExt, Ty, TyBuilder,
+    TyExt, TyKind, WhereClause,
 };
-use mapping::{
-    convert_where_clauses, generic_predicate_to_inline_bound, make_binders, TypeAliasAsValue,
-};
-pub use self::interner::Interner;
-pub(crate) use self::interner::*;
-pub(super) mod tls;
-mod interner;
-mod mapping;
-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(crate) fn from_chalk<T, ChalkT>(db: &dyn HirDatabase, chalk: ChalkT) -> T
+pub(crate) type AssociatedTyDatum = chalk_solve::rust_ir::AssociatedTyDatum<Interner>;
-where
+pub(crate) type TraitDatum = chalk_solve::rust_ir::TraitDatum<Interner>;
-    T: ToChalk<Chalk = ChalkT>,
+pub(crate) type StructDatum = chalk_solve::rust_ir::AdtDatum<Interner>;
-{
+pub(crate) type ImplDatum = chalk_solve::rust_ir::ImplDatum<Interner>;
-    T::from_chalk(db, chalk)
+pub(crate) type OpaqueTyDatum = chalk_solve::rust_ir::OpaqueTyDatum<Interner>;
-}
+pub(crate) type AssocTypeId = chalk_ir::AssocTypeId<Interner>;
+pub(crate) type TraitId = chalk_ir::TraitId<Interner>;
+pub(crate) type AdtId = chalk_ir::AdtId<Interner>;
+pub(crate) type ImplId = chalk_ir::ImplId<Interner>;
+pub(crate) type AssociatedTyValueId = chalk_solve::rust_ir::AssociatedTyValueId<Interner>;
+pub(crate) type AssociatedTyValue = chalk_solve::rust_ir::AssociatedTyValue<Interner>;
+pub(crate) type FnDefDatum = chalk_solve::rust_ir::FnDefDatum<Interner>;
+pub(crate) type Variances = chalk_ir::Variances<Interner>;
 impl<'a> chalk_solve::RustIrDatabase<Interner> for ChalkContext<'a> {
    fn associated_ty_data(&self, id: AssocTypeId) -> Arc<AssociatedTyDatum> {
@@ -84,9 +79,9 @@ impl<'a> chalk_solve::RustIrDatabase<Interner> for ChalkContext<'a> {
        binders: &CanonicalVarKinds<Interner>,
    ) -> Vec<ImplId> {
        debug!("impls_for_trait {:?}", trait_id);
-        let trait_: hir_def::TraitId = from_chalk(self.db, trait_id);
+        let trait_: hir_def::TraitId = from_chalk_trait_id(trait_id);
-        let ty: Ty = from_chalk(self.db, parameters[0].assert_ty_ref(&Interner).clone());
+        let ty: Ty = parameters[0].assert_ty_ref(&Interner).clone();
        fn binder_kind(
            ty: &Ty,
@@ -103,7 +98,7 @@ impl<'a> chalk_solve::RustIrDatabase<Interner> for ChalkContext<'a> {
            None
        }
-        let self_ty_fp = TyFingerprint::for_impl(&ty);
+        let self_ty_fp = TyFingerprint::for_trait_impl(&ty);
        let fps: &[TyFingerprint] = match binder_kind(&ty, binders) {
            Some(chalk_ir::TyVariableKind::Integer) => &ALL_INT_FPS,
            Some(chalk_ir::TyVariableKind::Float) => &ALL_FLOAT_FPS,
@@ -166,7 +161,7 @@ impl<'a> chalk_solve::RustIrDatabase<Interner> for ChalkContext<'a> {
            Some(LangItemTarget::TraitId(trait_)) => trait_,
            _ => return None,
        };
-        Some(trait_.to_chalk(self.db))
+        Some(to_chalk_trait_id(trait_))
    }
    fn program_clauses_for_env(
@@ -187,16 +182,11 @@ impl<'a> chalk_solve::RustIrDatabase<Interner> for ChalkContext<'a> {
                let (datas, binders) = (*datas).as_ref().into_value_and_skipped_binders();
                let data = &datas.impl_traits[idx as usize];
                let bound = OpaqueTyDatumBound {
-                    bounds: make_binders(
+                    bounds: make_only_type_binders(
-                        data.bounds
-                            .skip_binders()
-                            .iter()
-                            .cloned()
-                            .map(|b| b.to_chalk(self.db))
-                            .collect(),
                        1,
+                        data.bounds.skip_binders().iter().cloned().collect(),
                    ),
-                    where_clauses: make_binders(vec![], 0),
+                    where_clauses: make_only_type_binders(0, vec![]),
                };
                chalk_ir::Binders::new(binders, bound)
            }
@@ -244,25 +234,25 @@ impl<'a> chalk_solve::RustIrDatabase<Interner> for ChalkContext<'a> {
                            .intern(&Interner),
                    });
                    let bound = OpaqueTyDatumBound {
-                        bounds: make_binders(
+                        bounds: make_only_type_binders(
+                            1,
                            vec![
-                                crate::wrap_empty_binders(impl_bound).to_chalk(self.db),
+                                crate::wrap_empty_binders(impl_bound),
-                                crate::wrap_empty_binders(proj_bound).to_chalk(self.db),
+                                crate::wrap_empty_binders(proj_bound),
                            ],
-                            1,
                        ),
-                        where_clauses: make_binders(vec![], 0),
+                        where_clauses: make_only_type_binders(0, vec![]),
                    };
                    // The opaque type has 1 parameter.
-                    make_binders(bound, 1)
+                    make_only_type_binders(1, bound)
                } else {
                    // If failed to find Symbol’s value as variable is void: Future::Output, return empty bounds as fallback.
                    let bound = OpaqueTyDatumBound {
-                        bounds: make_binders(vec![], 0),
+                        bounds: make_only_type_binders(0, vec![]),
-                        where_clauses: make_binders(vec![], 0),
+                        where_clauses: make_only_type_binders(0, vec![]),
                    };
                    // The opaque type has 1 parameter.
-                    make_binders(bound, 1)
+                    make_only_type_binders(1, bound)
                }
            }
        };
@@ -272,7 +262,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
-        TyKind::Error.intern(&Interner).to_chalk(self.db)
+        TyKind::Error.intern(&Interner)
    }
    fn is_object_safe(&self, _trait_id: chalk_ir::TraitId<Interner>) -> bool {
@@ -293,33 +283,32 @@ impl<'a> chalk_solve::RustIrDatabase<Interner> for ChalkContext<'a> {
        _closure_id: chalk_ir::ClosureId<Interner>,
        substs: &chalk_ir::Substitution<Interner>,
    ) -> chalk_ir::Binders<rust_ir::FnDefInputsAndOutputDatum<Interner>> {
-        let sig_ty: Ty =
+        let sig_ty = substs.at(&Interner, 0).assert_ty_ref(&Interner).clone();
-            from_chalk(self.db, substs.at(&Interner, 0).assert_ty_ref(&Interner).clone());
        let sig = &sig_ty.callable_sig(self.db).expect("first closure param should be fn ptr");
        let io = rust_ir::FnDefInputsAndOutputDatum {
-            argument_types: sig.params().iter().map(|ty| ty.clone().to_chalk(self.db)).collect(),
+            argument_types: sig.params().iter().cloned().collect(),
-            return_type: sig.ret().clone().to_chalk(self.db),
+            return_type: sig.ret().clone(),
        };
-        make_binders(io.shifted_in(&Interner), 0)
+        make_only_type_binders(0, io.shifted_in(&Interner))
    }
    fn closure_upvars(
        &self,
        _closure_id: chalk_ir::ClosureId<Interner>,
        _substs: &chalk_ir::Substitution<Interner>,
    ) -> chalk_ir::Binders<chalk_ir::Ty<Interner>> {
-        let ty = TyBuilder::unit().to_chalk(self.db);
+        let ty = TyBuilder::unit();
-        make_binders(ty, 0)
+        make_only_type_binders(0, ty)
    }
    fn closure_fn_substitution(
        &self,
        _closure_id: chalk_ir::ClosureId<Interner>,
        _substs: &chalk_ir::Substitution<Interner>,
    ) -> chalk_ir::Substitution<Interner> {
-        Substitution::empty(&Interner).to_chalk(self.db)
+        Substitution::empty(&Interner)
    }
    fn trait_name(&self, trait_id: chalk_ir::TraitId<Interner>) -> String {
-        let id = from_chalk(self.db, trait_id);
+        let id = from_chalk_trait_id(trait_id);
        self.db.trait_data(id).name.to_string()
    }
    fn adt_name(&self, chalk_ir::AdtId(adt_id): AdtId) -> String {
@@ -410,10 +399,10 @@ pub(crate) fn associated_ty_data_query(
    let where_clauses = convert_where_clauses(db, type_alias.into(), &bound_vars);
    let bound_data = rust_ir::AssociatedTyDatumBound { bounds, where_clauses };
    let datum = AssociatedTyDatum {
-        trait_id: trait_.to_chalk(db),
+        trait_id: to_chalk_trait_id(trait_),
        id,
        name: type_alias,
-        binders: make_binders(bound_data, generic_params.len()),
+        binders: make_only_type_binders(generic_params.len(), bound_data),
    };
    Arc::new(datum)
 }
@@ -424,7 +413,7 @@ pub(crate) fn trait_datum_query(
    trait_id: TraitId,
 ) -> Arc<TraitDatum> {
    debug!("trait_datum {:?}", trait_id);
-    let trait_: hir_def::TraitId = from_chalk(db, trait_id);
+    let trait_ = from_chalk_trait_id(trait_id);
    let trait_data = db.trait_data(trait_);
    debug!("trait {:?} = {:?}", trait_id, trait_data.name);
    let generic_params = generics(db.upcast(), trait_.into());
@@ -446,7 +435,7 @@ pub(crate) fn trait_datum_query(
        lang_attr(db.upcast(), trait_).and_then(|name| well_known_trait_from_lang_attr(&name));
    let trait_datum = TraitDatum {
        id: trait_id,
-        binders: make_binders(trait_datum_bound, bound_vars.len(&Interner)),
+        binders: make_only_type_binders(bound_vars.len(&Interner), trait_datum_bound),
        flags,
        associated_ty_ids,
        well_known,
@@ -515,7 +504,7 @@ pub(crate) fn struct_datum_query(
        // FIXME set ADT kind
        kind: rust_ir::AdtKind::Struct,
        id: struct_id,
-        binders: make_binders(struct_datum_bound, num_params),
+        binders: make_only_type_binders(num_params, struct_datum_bound),
        flags,
    };
    Arc::new(struct_datum)
@@ -563,7 +552,6 @@ fn impl_def_datum(
        trait_ref.display(db),
        where_clauses
    );
-    let trait_ref = trait_ref.to_chalk(db);
    let polarity = if negative { rust_ir::Polarity::Negative } else { rust_ir::Polarity::Positive };
@@ -585,7 +573,7 @@ fn impl_def_datum(
        .collect();
    debug!("impl_datum: {:?}", impl_datum_bound);
    let impl_datum = ImplDatum {
-        binders: make_binders(impl_datum_bound, bound_vars.len(&Interner)),
+        binders: make_only_type_binders(bound_vars.len(&Interner), impl_datum_bound),
        impl_type,
        polarity,
        associated_ty_value_ids,
@@ -624,7 +612,7 @@ fn type_alias_associated_ty_value(
        .associated_type_by_name(&type_alias_data.name)
        .expect("assoc ty value should not exist"); // validated when building the impl data as well
    let (ty, binders) = db.ty(type_alias.into()).into_value_and_skipped_binders();
-    let value_bound = rust_ir::AssociatedTyValueBound { ty: ty.to_chalk(db) };
+    let value_bound = rust_ir::AssociatedTyValueBound { ty };
    let value = rust_ir::AssociatedTyValue {
        impl_id: impl_id.to_chalk(db),
        associated_ty_id: to_assoc_type_id(assoc_ty),
@@ -645,13 +633,13 @@ pub(crate) fn fn_def_datum_query(
    let where_clauses = convert_where_clauses(db, callable_def.into(), &bound_vars);
    let bound = rust_ir::FnDefDatumBound {
        // Note: Chalk doesn't actually use this information yet as far as I am aware, but we provide it anyway
-        inputs_and_output: make_binders(
+        inputs_and_output: make_only_type_binders(
+            0,
            rust_ir::FnDefInputsAndOutputDatum {
-                argument_types: sig.params().iter().map(|ty| ty.clone().to_chalk(db)).collect(),
+                argument_types: sig.params().iter().cloned().collect(),
-                return_type: sig.ret().clone().to_chalk(db),
+                return_type: sig.ret().clone(),
            }
            .shifted_in(&Interner),
-            0,
        ),
        where_clauses,
    };
@@ -688,38 +676,65 @@ pub(crate) fn adt_variance_query(
    )
 }
-impl From<FnDefId> for crate::db::InternedCallableDefId {
+pub(super) fn convert_where_clauses(
-    fn from(fn_def_id: FnDefId) -> Self {
+    db: &dyn HirDatabase,
-        InternKey::from_intern_id(fn_def_id.0)
+    def: GenericDefId,
-    }
+    substs: &Substitution,
-}
+) -> Vec<chalk_ir::QuantifiedWhereClause<Interner>> {
+    let generic_predicates = db.generic_predicates(def);
-impl From<crate::db::InternedCallableDefId> for FnDefId {
+    let mut result = Vec::with_capacity(generic_predicates.len());
-    fn from(callable_def_id: crate::db::InternedCallableDefId) -> Self {
+    for pred in generic_predicates.iter() {
-        chalk_ir::FnDefId(callable_def_id.as_intern_id())
+        result.push(pred.clone().substitute(&Interner, substs));
-    }
+    }
-}
+    result
-impl From<OpaqueTyId> for crate::db::InternedOpaqueTyId {
-    fn from(id: OpaqueTyId) -> Self {
-        InternKey::from_intern_id(id.0)
-    }
-}
-impl From<crate::db::InternedOpaqueTyId> for OpaqueTyId {
-    fn from(id: crate::db::InternedOpaqueTyId) -> Self {
-        chalk_ir::OpaqueTyId(id.as_intern_id())
-    }
-}
-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::InternedClosureId> for chalk_ir::ClosureId<Interner> {
+pub(super) fn generic_predicate_to_inline_bound(
-    fn from(id: crate::db::InternedClosureId) -> Self {
+    db: &dyn HirDatabase,
-        chalk_ir::ClosureId(id.as_intern_id())
+    pred: &QuantifiedWhereClause,
+    self_ty: &Ty,
+) -> Option<chalk_ir::Binders<rust_ir::InlineBound<Interner>>> {
+    // An InlineBound is like a GenericPredicate, except the self type is left out.
+    // We don't have a special type for this, but Chalk does.
+    let self_ty_shifted_in = self_ty.clone().shifted_in_from(&Interner, DebruijnIndex::ONE);
+    let (pred, binders) = pred.as_ref().into_value_and_skipped_binders();
+    match pred {
+        WhereClause::Implemented(trait_ref) => {
+            if trait_ref.self_type_parameter(&Interner) != self_ty_shifted_in {
+                // we can only convert predicates back to type bounds if they
+                // have the expected self type
+                return None;
+            }
+            let args_no_self = trait_ref.substitution.as_slice(&Interner)[1..]
+                .iter()
+                .map(|ty| ty.clone().cast(&Interner))
+                .collect();
+            let trait_bound = rust_ir::TraitBound { trait_id: trait_ref.trait_id, args_no_self };
+            Some(chalk_ir::Binders::new(binders, rust_ir::InlineBound::TraitBound(trait_bound)))
+        }
+        WhereClause::AliasEq(AliasEq { alias: AliasTy::Projection(projection_ty), ty }) => {
+            if projection_ty.self_type_parameter(&Interner) != self_ty_shifted_in {
+                return None;
+            }
+            let trait_ = projection_ty.trait_(db);
+            let args_no_self = projection_ty.substitution.as_slice(&Interner)[1..]
+                .iter()
+                .map(|ty| ty.clone().cast(&Interner))
+                .collect();
+            let alias_eq_bound = rust_ir::AliasEqBound {
+                value: ty.clone(),
+                trait_bound: rust_ir::TraitBound {
+                    trait_id: to_chalk_trait_id(trait_),
+                    args_no_self,
+                },
+                associated_ty_id: projection_ty.associated_ty_id,
+                parameters: Vec::new(), // FIXME we don't support generic associated types yet
+            };
+            Some(chalk_ir::Binders::new(
+                binders,
+                rust_ir::InlineBound::AliasEqBound(alias_eq_bound),
+            ))
+        }
+        _ => None,
    }
 }
diff --git a/crates/hir_ty/src/chalk_ext.rs b/crates/hir_ty/src/chalk_ext.rs
index 28ed3aac6..8c4542956 100644
--- a/crates/hir_ty/src/chalk_ext.rs
+++ b/crates/hir_ty/src/chalk_ext.rs
@@ -75,7 +75,7 @@ impl TyExt for Ty {
    }
    fn as_reference(&self) -> Option<(&Ty, Lifetime, Mutability)> {
        match self.kind(&Interner) {
-            TyKind::Ref(mutability, lifetime, ty) => Some((ty, *lifetime, *mutability)),
+            TyKind::Ref(mutability, lifetime, ty) => Some((ty, lifetime.clone(), *mutability)),
            _ => None,
        }
    }
diff --git a/crates/hir_ty/src/db.rs b/crates/hir_ty/src/db.rs
index 326c20240..1690926ad 100644
--- a/crates/hir_ty/src/db.rs
+++ b/crates/hir_ty/src/db.rs
@@ -1,4 +1,5 @@
-//! FIXME: write short doc here
+//! The home of `HirDatabase`, which is the Salsa database containing all the
+//! type inference-related queries.
 use std::sync::Arc;
@@ -10,9 +11,9 @@ use hir_def::{
 use la_arena::ArenaMap;
 use crate::{
+    chalk_db,
    method_resolution::{InherentImpls, TraitImpls},
-    traits::chalk,
+    Binders, CallableDefId, FnDefId, ImplTraitId, InferenceResult, Interner, PolyFnSig,
-    Binders, CallableDefId, FnDefId, ImplTraitId, InferenceResult, PolyFnSig,
    QuantifiedWhereClause, ReturnTypeImplTraits, TraitRef, Ty, TyDefId, ValueTyDefId,
 };
 use hir_expand::name::Name;
@@ -94,33 +95,38 @@ pub trait HirDatabase: DefDatabase + Upcast<dyn DefDatabase> {
    #[salsa::interned]
    fn intern_closure(&self, id: (DefWithBodyId, ExprId)) -> InternedClosureId;
-    #[salsa::invoke(chalk::associated_ty_data_query)]
+    #[salsa::invoke(chalk_db::associated_ty_data_query)]
-    fn associated_ty_data(&self, id: chalk::AssocTypeId) -> Arc<chalk::AssociatedTyDatum>;
+    fn associated_ty_data(&self, id: chalk_db::AssocTypeId) -> Arc<chalk_db::AssociatedTyDatum>;
-    #[salsa::invoke(chalk::trait_datum_query)]
+    #[salsa::invoke(chalk_db::trait_datum_query)]
-    fn trait_datum(&self, krate: CrateId, trait_id: chalk::TraitId) -> Arc<chalk::TraitDatum>;
+    fn trait_datum(&self, krate: CrateId, trait_id: chalk_db::TraitId)
+        -> Arc<chalk_db::TraitDatum>;
-    #[salsa::invoke(chalk::struct_datum_query)]
+    #[salsa::invoke(chalk_db::struct_datum_query)]
-    fn struct_datum(&self, krate: CrateId, struct_id: chalk::AdtId) -> Arc<chalk::StructDatum>;
+    fn struct_datum(
+        &self,
+        krate: CrateId,
+        struct_id: chalk_db::AdtId,
+    ) -> Arc<chalk_db::StructDatum>;
-    #[salsa::invoke(crate::traits::chalk::impl_datum_query)]
+    #[salsa::invoke(chalk_db::impl_datum_query)]
-    fn impl_datum(&self, krate: CrateId, impl_id: chalk::ImplId) -> Arc<chalk::ImplDatum>;
+    fn impl_datum(&self, krate: CrateId, impl_id: chalk_db::ImplId) -> Arc<chalk_db::ImplDatum>;
-    #[salsa::invoke(crate::traits::chalk::fn_def_datum_query)]
+    #[salsa::invoke(chalk_db::fn_def_datum_query)]
-    fn fn_def_datum(&self, krate: CrateId, fn_def_id: FnDefId) -> Arc<chalk::FnDefDatum>;
+    fn fn_def_datum(&self, krate: CrateId, fn_def_id: FnDefId) -> Arc<chalk_db::FnDefDatum>;
-    #[salsa::invoke(crate::traits::chalk::fn_def_variance_query)]
+    #[salsa::invoke(chalk_db::fn_def_variance_query)]
-    fn fn_def_variance(&self, krate: CrateId, fn_def_id: FnDefId) -> chalk::Variances;
+    fn fn_def_variance(&self, krate: CrateId, fn_def_id: FnDefId) -> chalk_db::Variances;
-    #[salsa::invoke(crate::traits::chalk::adt_variance_query)]
+    #[salsa::invoke(chalk_db::adt_variance_query)]
-    fn adt_variance(&self, krate: CrateId, adt_id: chalk::AdtId) -> chalk::Variances;
+    fn adt_variance(&self, krate: CrateId, adt_id: chalk_db::AdtId) -> chalk_db::Variances;
-    #[salsa::invoke(crate::traits::chalk::associated_ty_value_query)]
+    #[salsa::invoke(chalk_db::associated_ty_value_query)]
    fn associated_ty_value(
        &self,
        krate: CrateId,
-        id: chalk::AssociatedTyValueId,
+        id: chalk_db::AssociatedTyValueId,
-    ) -> Arc<chalk::AssociatedTyValue>;
+    ) -> Arc<chalk_db::AssociatedTyValue>;
    #[salsa::invoke(crate::traits::trait_solve_query)]
    fn trait_solve(
@@ -129,12 +135,12 @@ pub trait HirDatabase: DefDatabase + Upcast<dyn DefDatabase> {
        goal: crate::Canonical<crate::InEnvironment<crate::DomainGoal>>,
    ) -> Option<crate::Solution>;
-    #[salsa::invoke(crate::traits::chalk::program_clauses_for_chalk_env_query)]
+    #[salsa::invoke(chalk_db::program_clauses_for_chalk_env_query)]
    fn program_clauses_for_chalk_env(
        &self,
        krate: CrateId,
-        env: chalk_ir::Environment<chalk::Interner>,
+        env: chalk_ir::Environment<Interner>,
-    ) -> chalk_ir::ProgramClauses<chalk::Interner>;
+    ) -> chalk_ir::ProgramClauses<Interner>;
 }
 fn infer_wait(db: &dyn HirDatabase, def: DefWithBodyId) -> Arc<InferenceResult> {
diff --git a/crates/hir_ty/src/diagnostics.rs b/crates/hir_ty/src/diagnostics.rs
index 86f937e1d..84fc8ce14 100644
--- a/crates/hir_ty/src/diagnostics.rs
+++ b/crates/hir_ty/src/diagnostics.rs
@@ -1,4 +1,4 @@
-//! FIXME: write short doc here
+//! Type inference-based diagnostics.
 mod expr;
 mod match_check;
 mod unsafe_check;
diff --git a/crates/hir_ty/src/display.rs b/crates/hir_ty/src/display.rs
index e0ca96c6d..e7c9dabc2 100644
--- a/crates/hir_ty/src/display.rs
+++ b/crates/hir_ty/src/display.rs
@@ -1,4 +1,6 @@
-//! FIXME: write short doc here
+//! The `HirDisplay` trait, which serves two purposes: Turning various bits from
+//! HIR back into source code, and just displaying them for debugging/testing
+//! purposes.
 use std::{
    array,
@@ -20,11 +22,11 @@ use hir_expand::name::Name;
 use crate::{
    const_from_placeholder_idx, db::HirDatabase, from_assoc_type_id, from_foreign_def_id,
-    from_placeholder_idx, lt_from_placeholder_idx, primitive, subst_prefix, to_assoc_type_id,
+    from_placeholder_idx, lt_from_placeholder_idx, mapping::from_chalk, primitive, subst_prefix,
-    traits::chalk::from_chalk, utils::generics, AdtId, AliasEq, AliasTy, CallableDefId,
+    to_assoc_type_id, utils::generics, AdtId, AliasEq, AliasTy, CallableDefId, CallableSig, Const,
-    CallableSig, Const, ConstValue, DomainGoal, GenericArg, ImplTraitId, Interner, Lifetime,
+    ConstValue, DomainGoal, GenericArg, ImplTraitId, Interner, Lifetime, LifetimeData,
-    LifetimeData, LifetimeOutlives, Mutability, OpaqueTy, ProjectionTy, ProjectionTyExt,
+    LifetimeOutlives, Mutability, OpaqueTy, ProjectionTy, ProjectionTyExt, QuantifiedWhereClause,
-    QuantifiedWhereClause, Scalar, TraitRef, TraitRefExt, Ty, TyExt, TyKind, WhereClause,
+    Scalar, TraitRef, TraitRefExt, Ty, TyExt, TyKind, WhereClause,
 };
 pub struct HirFormatter<'a> {
@@ -265,7 +267,7 @@ impl HirDisplay for ProjectionTy {
        write!(f, " as {}", trait_.name)?;
        if self.substitution.len(&Interner) > 1 {
            write!(f, "<")?;
-            f.write_joined(&self.substitution.interned()[1..], ", ")?;
+            f.write_joined(&self.substitution.as_slice(&Interner)[1..], ", ")?;
            write!(f, ">")?;
        }
        write!(f, ">::{}", f.db.type_alias_data(from_assoc_type_id(self.associated_ty_id)).name)?;
@@ -287,6 +289,8 @@ impl HirDisplay for GenericArg {
    fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
        match self.interned() {
            crate::GenericArgData::Ty(ty) => ty.hir_fmt(f),
+            crate::GenericArgData::Lifetime(lt) => lt.hir_fmt(f),
+            crate::GenericArgData::Const(c) => c.hir_fmt(f),
        }
    }
 }
@@ -414,7 +418,7 @@ impl HirDisplay for Ty {
                    write!(f, ",)")?;
                } else {
                    write!(f, "(")?;
-                    f.write_joined(&*substs.interned(), ", ")?;
+                    f.write_joined(&*substs.as_slice(&Interner), ", ")?;
                    write!(f, ")")?;
                }
            }
@@ -442,7 +446,7 @@ impl HirDisplay for Ty {
                    // We print all params except implicit impl Trait params. Still a bit weird; should we leave out parent and self?
                    if total_len > 0 {
                        write!(f, "<")?;
-                        f.write_joined(&parameters.interned()[..total_len], ", ")?;
+                        f.write_joined(&parameters.as_slice(&Interner)[..total_len], ", ")?;
                        write!(f, ">")?;
                    }
                }
@@ -489,7 +493,7 @@ impl HirDisplay for Ty {
                            .map(|generic_def_id| f.db.generic_defaults(generic_def_id))
                            .filter(|defaults| !defaults.is_empty())
                        {
-                            None => parameters.interned().as_ref(),
+                            None => parameters.as_slice(&Interner),
                            Some(default_parameters) => {
                                let mut default_from = 0;
                                for (i, parameter) in parameters.iter(&Interner).enumerate() {
@@ -513,11 +517,11 @@ impl HirDisplay for Ty {
                                        }
                                    }
                                }
-                                &parameters.interned()[0..default_from]
+                                &parameters.as_slice(&Interner)[0..default_from]
                            }
                        }
                    } else {
-                        parameters.interned().as_ref()
+                        parameters.as_slice(&Interner)
                    };
                    if !parameters_to_write.is_empty() {
                        write!(f, "<")?;
@@ -540,7 +544,7 @@ impl HirDisplay for Ty {
                    write!(f, "{}::{}", trait_.name, type_alias_data.name)?;
                    if parameters.len(&Interner) > 0 {
                        write!(f, "<")?;
-                        f.write_joined(&*parameters.interned(), ", ")?;
+                        f.write_joined(&*parameters.as_slice(&Interner), ", ")?;
                        write!(f, ">")?;
                    }
                } else {
@@ -664,6 +668,8 @@ impl HirDisplay for Ty {
                write!(f, "{{unknown}}")?;
            }
            TyKind::InferenceVar(..) => write!(f, "_")?,
+            TyKind::Generator(..) => write!(f, "{{generator}}")?,
+            TyKind::GeneratorWitness(..) => write!(f, "{{generator witness}}")?,
        }
        Ok(())
    }
@@ -741,17 +747,17 @@ fn write_bounds_like_dyn_trait(
                if !first {
                    write!(f, " + ")?;
                }
-                // We assume that the self type is $0 (i.e. the
+                // We assume that the self type is ^0.0 (i.e. the
                // existential) here, which is the only thing that's
                // possible in actual Rust, and hence don't print it
                write!(f, "{}", f.db.trait_data(trait_).name)?;
-                if let [_, params @ ..] = &*trait_ref.substitution.interned().as_slice() {
+                if let [_, params @ ..] = &*trait_ref.substitution.as_slice(&Interner) {
                    if is_fn_trait {
                        if let Some(args) =
                            params.first().and_then(|it| it.assert_ty_ref(&Interner).as_tuple())
                        {
                            write!(f, "(")?;
-                            f.write_joined(&*args.interned(), ", ")?;
+                            f.write_joined(args.as_slice(&Interner), ", ")?;
                            write!(f, ")")?;
                        }
                    } else if !params.is_empty() {
@@ -783,6 +789,10 @@ fn write_bounds_like_dyn_trait(
                }
                ty.hir_fmt(f)?;
            }
+            // FIXME implement these
+            WhereClause::LifetimeOutlives(_) => {}
+            WhereClause::TypeOutlives(_) => {}
        }
        first = false;
    }
@@ -806,7 +816,7 @@ fn fmt_trait_ref(tr: &TraitRef, f: &mut HirFormatter, use_as: bool) -> Result<()
    write!(f, "{}", f.db.trait_data(tr.hir_trait_id()).name)?;
    if tr.substitution.len(&Interner) > 1 {
        write!(f, "<")?;
-        f.write_joined(&tr.substitution.interned()[1..], ", ")?;
+        f.write_joined(&tr.substitution.as_slice(&Interner)[1..], ", ")?;
        write!(f, ">")?;
    }
    Ok(())
@@ -837,6 +847,10 @@ impl HirDisplay for WhereClause {
                ty.hir_fmt(f)?;
            }
            WhereClause::AliasEq(_) => write!(f, "{{error}}")?,
+            // FIXME implement these
+            WhereClause::TypeOutlives(..) => {}
+            WhereClause::LifetimeOutlives(..) => {}
        }
        Ok(())
    }
@@ -881,9 +895,11 @@ impl HirDisplay for DomainGoal {
            DomainGoal::Holds(wc) => {
                write!(f, "Holds(")?;
                wc.hir_fmt(f)?;
-                write!(f, ")")
+                write!(f, ")")?;
            }
+            _ => write!(f, "?")?,
        }
+        Ok(())
    }
 }
diff --git a/crates/hir_ty/src/infer.rs b/crates/hir_ty/src/infer.rs
index 531159e54..bf2da2d4a 100644
--- a/crates/hir_ty/src/infer.rs
+++ b/crates/hir_ty/src/infer.rs
@@ -18,7 +18,7 @@ use std::mem;
 use std::ops::Index;
 use std::sync::Arc;
-use chalk_ir::{cast::Cast, Mutability};
+use chalk_ir::{cast::Cast, DebruijnIndex, Mutability};
 use hir_def::{
    body::Body,
    data::{ConstData, FunctionData, StaticData},
@@ -38,11 +38,11 @@ use syntax::SmolStr;
 use super::{
    DomainGoal, Guidance, InEnvironment, ProjectionTy, Solution, TraitEnvironment, TraitRef, Ty,
-    TypeWalk,
 };
 use crate::{
-    db::HirDatabase, infer::diagnostics::InferenceDiagnostic, lower::ImplTraitLoweringMode,
+    db::HirDatabase, fold_tys, infer::diagnostics::InferenceDiagnostic,
-    to_assoc_type_id, AliasEq, AliasTy, Canonical, Interner, TyBuilder, TyExt, TyKind,
+    lower::ImplTraitLoweringMode, to_assoc_type_id, AliasEq, AliasTy, Canonical, Interner,
+    TyBuilder, TyExt, TyKind,
 };
 // This lint has a false positive here. See the link below for details.
@@ -323,7 +323,7 @@ impl<'a> InferenceContext<'a> {
    }
    fn insert_type_vars(&mut self, ty: Ty) -> Ty {
-        ty.fold(&mut |ty| self.insert_type_vars_shallow(ty))
+        fold_tys(ty, |ty, _| self.insert_type_vars_shallow(ty), DebruijnIndex::INNERMOST)
    }
    fn resolve_obligations_as_possible(&mut self) {
@@ -434,12 +434,16 @@ 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.kind(&Interner) {
+        fold_tys(
-            TyKind::Alias(AliasTy::Projection(proj_ty)) => {
+            ty,
-                self.normalize_projection_ty(proj_ty.clone())
+            |ty, _| match ty.kind(&Interner) {
-            }
+                TyKind::Alias(AliasTy::Projection(proj_ty)) => {
-            _ => ty,
+                    self.normalize_projection_ty(proj_ty.clone())
-        })
+                }
+                _ => ty,
+            },
+            DebruijnIndex::INNERMOST,
+        )
    }
    fn normalize_projection_ty(&mut self, proj_ty: ProjectionTy) -> Ty {
diff --git a/crates/hir_ty/src/infer/coerce.rs b/crates/hir_ty/src/infer/coerce.rs
index fd679f444..1f463a425 100644
--- a/crates/hir_ty/src/infer/coerce.rs
+++ b/crates/hir_ty/src/infer/coerce.rs
@@ -71,12 +71,14 @@ impl<'a> InferenceContext<'a> {
        }
        // Pointer weakening and function to pointer
-        match (from_ty.interned_mut(), to_ty.kind(&Interner)) {
+        match (from_ty.kind(&Interner), to_ty.kind(&Interner)) {
            // `*mut T` -> `*const T`
+            (TyKind::Raw(_, inner), TyKind::Raw(m2 @ Mutability::Not, ..)) => {
+                from_ty = TyKind::Raw(*m2, inner.clone()).intern(&Interner);
+            }
            // `&mut T` -> `&T`
-            (TyKind::Raw(m1, ..), TyKind::Raw(m2 @ Mutability::Not, ..))
+            (TyKind::Ref(_, lt, inner), TyKind::Ref(m2 @ Mutability::Not, ..)) => {
-            | (TyKind::Ref(m1, ..), TyKind::Ref(m2 @ Mutability::Not, ..)) => {
+                from_ty = TyKind::Ref(*m2, lt.clone(), inner.clone()).intern(&Interner);
-                *m1 = *m2;
            }
            // `&T` -> `*const T`
            // `&mut T` -> `*mut T`/`*const T`
diff --git a/crates/hir_ty/src/infer/expr.rs b/crates/hir_ty/src/infer/expr.rs
index 9841988c5..50497eecb 100644
--- a/crates/hir_ty/src/infer/expr.rs
+++ b/crates/hir_ty/src/infer/expr.rs
@@ -3,7 +3,7 @@
 use std::iter::{repeat, repeat_with};
 use std::{mem, sync::Arc};
-use chalk_ir::{cast::Cast, Mutability, TyVariableKind};
+use chalk_ir::{cast::Cast, fold::Shift, Mutability, TyVariableKind};
 use hir_def::{
    expr::{Array, BinaryOp, Expr, ExprId, Literal, Statement, UnaryOp},
    path::{GenericArg, GenericArgs},
@@ -17,14 +17,14 @@ use syntax::ast::RangeOp;
 use crate::{
    autoderef, dummy_usize_const,
    lower::lower_to_chalk_mutability,
+    mapping::from_chalk,
    method_resolution, op,
    primitive::{self, UintTy},
    static_lifetime, to_chalk_trait_id,
-    traits::{chalk::from_chalk, FnTrait},
+    traits::FnTrait,
    utils::{generics, Generics},
    AdtId, Binders, CallableDefId, FnPointer, FnSig, FnSubst, InEnvironment, Interner,
    ProjectionTyExt, Rawness, Scalar, Substitution, TraitRef, Ty, TyBuilder, TyExt, TyKind,
-    TypeWalk,
 };
 use super::{
@@ -463,7 +463,11 @@ impl<'a> InferenceContext<'a> {
                    };
                    match canonicalized.decanonicalize_ty(derefed_ty.value).kind(&Interner) {
                        TyKind::Tuple(_, substs) => name.as_tuple_index().and_then(|idx| {
-                            substs.interned().get(idx).map(|a| a.assert_ty_ref(&Interner)).cloned()
+                            substs
+                                .as_slice(&Interner)
+                                .get(idx)
+                                .map(|a| a.assert_ty_ref(&Interner))
+                                .cloned()
                        }),
                        TyKind::Adt(AdtId(hir_def::AdtId::StructId(s)), parameters) => {
                            let local_id = self.db.struct_data(*s).variant_data.field(name)?;
diff --git a/crates/hir_ty/src/infer/pat.rs b/crates/hir_ty/src/infer/pat.rs
index a41e8e116..aea354cde 100644
--- a/crates/hir_ty/src/infer/pat.rs
+++ b/crates/hir_ty/src/infer/pat.rs
@@ -122,7 +122,7 @@ impl<'a> InferenceContext<'a> {
        let ty = match &body[pat] {
            &Pat::Tuple { ref args, ellipsis } => {
                let expectations = match expected.as_tuple() {
-                    Some(parameters) => &*parameters.interned().as_slice(),
+                    Some(parameters) => &*parameters.as_slice(&Interner),
                    _ => &[],
                };
@@ -242,7 +242,7 @@ impl<'a> InferenceContext<'a> {
                    let (inner_ty, alloc_ty) = match expected.as_adt() {
                        Some((adt, subst)) if adt == box_adt => (
                            subst.at(&Interner, 0).assert_ty_ref(&Interner).clone(),
-                            subst.interned().get(1).and_then(|a| a.ty(&Interner).cloned()),
+                            subst.as_slice(&Interner).get(1).and_then(|a| a.ty(&Interner).cloned()),
                        ),
                        _ => (self.result.standard_types.unknown.clone(), None),
                    };
diff --git a/crates/hir_ty/src/infer/path.rs b/crates/hir_ty/src/infer/path.rs
index f8955aa32..495282eba 100644
--- a/crates/hir_ty/src/infer/path.rs
+++ b/crates/hir_ty/src/infer/path.rs
@@ -101,7 +101,7 @@ impl<'a> InferenceContext<'a> {
        let substs = ctx.substs_from_path(path, typable, true);
        let ty = TyBuilder::value_ty(self.db, typable)
            .use_parent_substs(&parent_substs)
-            .fill(substs.interned()[parent_substs.len(&Interner)..].iter().cloned())
+            .fill(substs.as_slice(&Interner)[parent_substs.len(&Interner)..].iter().cloned())
            .build();
        Some(ty)
    }
diff --git a/crates/hir_ty/src/infer/unify.rs b/crates/hir_ty/src/infer/unify.rs
index 2ea9dd920..a887e20b0 100644
--- a/crates/hir_ty/src/infer/unify.rs
+++ b/crates/hir_ty/src/infer/unify.rs
@@ -2,14 +2,17 @@
 use std::borrow::Cow;
-use chalk_ir::{FloatTy, IntTy, TyVariableKind, UniverseIndex, VariableKind};
+use chalk_ir::{
+    cast::Cast, fold::Fold, interner::HasInterner, FloatTy, IntTy, TyVariableKind, UniverseIndex,
+    VariableKind,
+};
 use ena::unify::{InPlaceUnificationTable, NoError, UnifyKey, UnifyValue};
 use super::{DomainGoal, InferenceContext};
 use crate::{
-    AliasEq, AliasTy, BoundVar, Canonical, CanonicalVarKinds, DebruijnIndex, FnPointer, FnSubst,
+    fold_tys, static_lifetime, AliasEq, AliasTy, BoundVar, Canonical, CanonicalVarKinds,
-    InEnvironment, InferenceVar, Interner, Scalar, Substitution, Ty, TyExt, TyKind, TypeWalk,
+    DebruijnIndex, FnPointer, FnSubst, InEnvironment, InferenceVar, Interner, Scalar, Substitution,
-    WhereClause,
+    Ty, TyExt, TyKind, WhereClause,
 };
 impl<'a> InferenceContext<'a> {
@@ -34,7 +37,10 @@ where
 }
 #[derive(Debug)]
-pub(super) struct Canonicalized<T> {
+pub(super) struct Canonicalized<T>
+where
+    T: HasInterner<Interner = Interner>,
+{
    pub(super) value: Canonical<T>,
    free_vars: Vec<(InferenceVar, TyVariableKind)>,
 }
@@ -48,9 +54,14 @@ impl<'a, 'b> Canonicalizer<'a, 'b> {
        })
    }
-    fn do_canonicalize<T: TypeWalk>(&mut self, t: T, binders: DebruijnIndex) -> T {
+    fn do_canonicalize<T: Fold<Interner, Result = T> + HasInterner<Interner = Interner>>(
-        t.fold_binders(
+        &mut self,
-            &mut |ty, binders| match ty.kind(&Interner) {
+        t: T,
+        binders: DebruijnIndex,
+    ) -> T {
+        fold_tys(
+            t,
+            |ty, binders| match ty.kind(&Interner) {
                &TyKind::InferenceVar(var, kind) => {
                    let inner = from_inference_var(var);
                    if self.var_stack.contains(&inner) {
@@ -76,7 +87,10 @@ impl<'a, 'b> Canonicalizer<'a, 'b> {
        )
    }
-    fn into_canonicalized<T>(self, result: T) -> Canonicalized<T> {
+    fn into_canonicalized<T: HasInterner<Interner = Interner>>(
+        self,
+        result: T,
+    ) -> Canonicalized<T> {
        let kinds = self
            .free_vars
            .iter()
@@ -103,28 +117,18 @@ impl<'a, 'b> Canonicalizer<'a, 'b> {
            DomainGoal::Holds(wc) => {
                DomainGoal::Holds(self.do_canonicalize(wc, DebruijnIndex::INNERMOST))
            }
+            _ => unimplemented!(),
        };
        self.into_canonicalized(InEnvironment { goal: result, environment: obligation.environment })
    }
 }
-impl<T> Canonicalized<T> {
+impl<T: HasInterner<Interner = Interner>> Canonicalized<T> {
    pub(super) fn decanonicalize_ty(&self, ty: Ty) -> Ty {
-        ty.fold_binders(
+        crate::fold_free_vars(ty, |bound, _binders| {
-            &mut |ty, binders| {
+            let (v, k) = self.free_vars[bound.index];
-                if let TyKind::BoundVar(bound) = ty.kind(&Interner) {
+            TyKind::InferenceVar(v, k).intern(&Interner)
-                    if bound.debruijn >= binders {
+        })
-                        let (v, k) = self.free_vars[bound.index];
-                        TyKind::InferenceVar(v, k).intern(&Interner)
-                    } else {
-                        ty
-                    }
-                } else {
-                    ty
-                }
-            },
-            DebruijnIndex::INNERMOST,
-        )
    }
    pub(super) fn apply_solution(
@@ -136,15 +140,17 @@ impl<T> Canonicalized<T> {
        let new_vars = Substitution::from_iter(
            &Interner,
            solution.binders.iter(&Interner).map(|k| match k.kind {
-                VariableKind::Ty(TyVariableKind::General) => ctx.table.new_type_var(),
+                VariableKind::Ty(TyVariableKind::General) => {
-                VariableKind::Ty(TyVariableKind::Integer) => ctx.table.new_integer_var(),
+                    ctx.table.new_type_var().cast(&Interner)
-                VariableKind::Ty(TyVariableKind::Float) => ctx.table.new_float_var(),
+                }
-                // HACK: Chalk can sometimes return new lifetime variables. We
+                VariableKind::Ty(TyVariableKind::Integer) => {
-                // want to just skip them, but to not mess up the indices of
+                    ctx.table.new_integer_var().cast(&Interner)
-                // other variables, we'll just create a new type variable in
+                }
-                // their place instead. This should not matter (we never see the
+                VariableKind::Ty(TyVariableKind::Float) => {
-                // actual *uses* of the lifetime variable).
+                    ctx.table.new_float_var().cast(&Interner)
-                VariableKind::Lifetime => ctx.table.new_type_var(),
+                }
+                // Chalk can sometimes return new lifetime variables. We just use the static lifetime everywhere
+                VariableKind::Lifetime => static_lifetime().cast(&Interner),
                _ => panic!("const variable in solution"),
            }),
        );
@@ -488,55 +494,63 @@ 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.kind(&Interner) {
+        fold_tys(
-            &TyKind::InferenceVar(tv, kind) => {
+            ty,
-                let inner = from_inference_var(tv);
+            |ty, _| match ty.kind(&Interner) {
-                if tv_stack.contains(&inner) {
+                &TyKind::InferenceVar(tv, kind) => {
-                    cov_mark::hit!(type_var_cycles_resolve_as_possible);
+                    let inner = from_inference_var(tv);
-                    // recursive type
+                    if tv_stack.contains(&inner) {
-                    return self.type_variable_table.fallback_value(tv, kind);
+                        cov_mark::hit!(type_var_cycles_resolve_as_possible);
-                }
+                        // recursive type
-                if let Some(known_ty) =
+                        return self.type_variable_table.fallback_value(tv, kind);
-                    self.var_unification_table.inlined_probe_value(inner).known()
+                    }
-                {
+                    if let Some(known_ty) =
-                    // known_ty may contain other variables that are known by now
+                        self.var_unification_table.inlined_probe_value(inner).known()
-                    tv_stack.push(inner);
+                    {
-                    let result = self.resolve_ty_as_possible_inner(tv_stack, known_ty.clone());
+                        // known_ty may contain other variables that are known by now
-                    tv_stack.pop();
+                        tv_stack.push(inner);
-                    result
+                        let result = self.resolve_ty_as_possible_inner(tv_stack, known_ty.clone());
-                } else {
+                        tv_stack.pop();
-                    ty
+                        result
+                    } else {
+                        ty
+                    }
                }
-            }
+                _ => ty,
-            _ => ty,
+            },
-        })
+            DebruijnIndex::INNERMOST,
+        )
    }
    /// Resolves the type completely; type variables without known type are
    /// 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.kind(&Interner) {
+        fold_tys(
-            &TyKind::InferenceVar(tv, kind) => {
+            ty,
-                let inner = from_inference_var(tv);
+            |ty, _| match ty.kind(&Interner) {
-                if tv_stack.contains(&inner) {
+                &TyKind::InferenceVar(tv, kind) => {
-                    cov_mark::hit!(type_var_cycles_resolve_completely);
+                    let inner = from_inference_var(tv);
-                    // recursive type
+                    if tv_stack.contains(&inner) {
-                    return self.type_variable_table.fallback_value(tv, kind);
+                        cov_mark::hit!(type_var_cycles_resolve_completely);
-                }
+                        // recursive type
-                if let Some(known_ty) =
+                        return self.type_variable_table.fallback_value(tv, kind);
-                    self.var_unification_table.inlined_probe_value(inner).known()
+                    }
-                {
+                    if let Some(known_ty) =
-                    // known_ty may contain other variables that are known by now
+                        self.var_unification_table.inlined_probe_value(inner).known()
-                    tv_stack.push(inner);
+                    {
-                    let result = self.resolve_ty_completely_inner(tv_stack, known_ty.clone());
+                        // known_ty may contain other variables that are known by now
-                    tv_stack.pop();
+                        tv_stack.push(inner);
-                    result
+                        let result = self.resolve_ty_completely_inner(tv_stack, known_ty.clone());
-                } else {
+                        tv_stack.pop();
-                    self.type_variable_table.fallback_value(tv, kind)
+                        result
+                    } else {
+                        self.type_variable_table.fallback_value(tv, kind)
+                    }
                }
-            }
+                _ => ty,
-            _ => ty,
+            },
-        })
+            DebruijnIndex::INNERMOST,
+        )
    }
 }
diff --git a/crates/hir_ty/src/traits/chalk/interner.rs b/crates/hir_ty/src/interner.rs
index bd9395b7e..a1656115d 100644
--- a/crates/hir_ty/src/traits/chalk/interner.rs
+++ b/crates/hir_ty/src/interner.rs
@@ -1,61 +1,83 @@
 //! Implementation of the Chalk `Interner` trait, which allows customizing the
 //! representation of the various objects Chalk deals with (types, goals etc.).
-use super::tls;
+use crate::{chalk_db, tls, GenericArg};
 use base_db::salsa::InternId;
-use chalk_ir::{GenericArg, Goal, GoalData};
+use chalk_ir::{Goal, GoalData};
-use hir_def::TypeAliasId;
+use hir_def::{
+    intern::{impl_internable, InternStorage, Internable, Interned},
+    TypeAliasId,
+};
 use smallvec::SmallVec;
 use std::{fmt, sync::Arc};
 #[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
 pub struct Interner;
-pub(crate) type AssocTypeId = chalk_ir::AssocTypeId<Interner>;
+#[derive(PartialEq, Eq, Hash, Debug)]
-pub(crate) type AssociatedTyDatum = chalk_solve::rust_ir::AssociatedTyDatum<Interner>;
+pub struct InternedWrapper<T>(T);
-pub(crate) type TraitId = chalk_ir::TraitId<Interner>;
-pub(crate) type TraitDatum = chalk_solve::rust_ir::TraitDatum<Interner>;
+impl<T> std::ops::Deref for InternedWrapper<T> {
-pub(crate) type AdtId = chalk_ir::AdtId<Interner>;
+    type Target = T;
-pub(crate) type StructDatum = chalk_solve::rust_ir::AdtDatum<Interner>;
-pub(crate) type ImplId = chalk_ir::ImplId<Interner>;
+    fn deref(&self) -> &Self::Target {
-pub(crate) type ImplDatum = chalk_solve::rust_ir::ImplDatum<Interner>;
+        &self.0
-pub(crate) type AssociatedTyValueId = chalk_solve::rust_ir::AssociatedTyValueId<Interner>;
+    }
-pub(crate) type AssociatedTyValue = chalk_solve::rust_ir::AssociatedTyValue<Interner>;
+}
-pub(crate) type FnDefDatum = chalk_solve::rust_ir::FnDefDatum<Interner>;
-pub(crate) type OpaqueTyId = chalk_ir::OpaqueTyId<Interner>;
+impl_internable!(
-pub(crate) type OpaqueTyDatum = chalk_solve::rust_ir::OpaqueTyDatum<Interner>;
+    InternedWrapper<Vec<chalk_ir::VariableKind<Interner>>>,
-pub(crate) type Variances = chalk_ir::Variances<Interner>;
+    InternedWrapper<SmallVec<[GenericArg; 2]>>,
+    InternedWrapper<chalk_ir::TyData<Interner>>,
+    InternedWrapper<chalk_ir::LifetimeData<Interner>>,
+    InternedWrapper<chalk_ir::ConstData<Interner>>,
+    InternedWrapper<Vec<chalk_ir::CanonicalVarKind<Interner>>>,
+    InternedWrapper<Vec<chalk_ir::ProgramClause<Interner>>>,
+    InternedWrapper<Vec<chalk_ir::QuantifiedWhereClause<Interner>>>,
+    InternedWrapper<Vec<chalk_ir::Variance>>,
+);
 impl chalk_ir::interner::Interner for Interner {
-    type InternedType = Arc<chalk_ir::TyData<Self>>;
+    type InternedType = Interned<InternedWrapper<chalk_ir::TyData<Interner>>>;
-    type InternedLifetime = chalk_ir::LifetimeData<Self>;
+    type InternedLifetime = Interned<InternedWrapper<chalk_ir::LifetimeData<Self>>>;
-    type InternedConst = Arc<chalk_ir::ConstData<Self>>;
+    type InternedConst = Interned<InternedWrapper<chalk_ir::ConstData<Self>>>;
    type InternedConcreteConst = ();
    type InternedGenericArg = chalk_ir::GenericArgData<Self>;
    type InternedGoal = Arc<GoalData<Self>>;
    type InternedGoals = Vec<Goal<Self>>;
-    type InternedSubstitution = SmallVec<[GenericArg<Self>; 2]>;
+    type InternedSubstitution = Interned<InternedWrapper<SmallVec<[GenericArg; 2]>>>;
-    type InternedProgramClause = Arc<chalk_ir::ProgramClauseData<Self>>;
+    type InternedProgramClause = chalk_ir::ProgramClauseData<Self>;
-    type InternedProgramClauses = Arc<[chalk_ir::ProgramClause<Self>]>;
+    type InternedProgramClauses = Interned<InternedWrapper<Vec<chalk_ir::ProgramClause<Self>>>>;
-    type InternedQuantifiedWhereClauses = Vec<chalk_ir::QuantifiedWhereClause<Self>>;
+    type InternedQuantifiedWhereClauses =
-    type InternedVariableKinds = Vec<chalk_ir::VariableKind<Self>>;
+        Interned<InternedWrapper<Vec<chalk_ir::QuantifiedWhereClause<Self>>>>;
-    type InternedCanonicalVarKinds = Vec<chalk_ir::CanonicalVarKind<Self>>;
+    type InternedVariableKinds = Interned<InternedWrapper<Vec<chalk_ir::VariableKind<Interner>>>>;
+    type InternedCanonicalVarKinds =
+        Interned<InternedWrapper<Vec<chalk_ir::CanonicalVarKind<Self>>>>;
    type InternedConstraints = Vec<chalk_ir::InEnvironment<chalk_ir::Constraint<Self>>>;
-    type InternedVariances = Arc<[chalk_ir::Variance]>;
+    type InternedVariances = Interned<InternedWrapper<Vec<chalk_ir::Variance>>>;
    type DefId = InternId;
    type InternedAdtId = hir_def::AdtId;
    type Identifier = TypeAliasId;
    type FnAbi = ();
-    fn debug_adt_id(type_kind_id: AdtId, fmt: &mut fmt::Formatter<'_>) -> Option<fmt::Result> {
+    fn debug_adt_id(
+        type_kind_id: chalk_db::AdtId,
+        fmt: &mut fmt::Formatter<'_>,
+    ) -> Option<fmt::Result> {
        tls::with_current_program(|prog| Some(prog?.debug_struct_id(type_kind_id, fmt)))
    }
-    fn debug_trait_id(type_kind_id: TraitId, fmt: &mut fmt::Formatter<'_>) -> Option<fmt::Result> {
+    fn debug_trait_id(
+        type_kind_id: chalk_db::TraitId,
+        fmt: &mut fmt::Formatter<'_>,
+    ) -> Option<fmt::Result> {
        tls::with_current_program(|prog| Some(prog?.debug_trait_id(type_kind_id, fmt)))
    }
-    fn debug_assoc_type_id(id: AssocTypeId, fmt: &mut fmt::Formatter<'_>) -> Option<fmt::Result> {
+    fn debug_assoc_type_id(
+        id: chalk_db::AssocTypeId,
+        fmt: &mut fmt::Formatter<'_>,
+    ) -> Option<fmt::Result> {
        tls::with_current_program(|prog| Some(prog?.debug_assoc_type_id(id, fmt)))
    }
@@ -99,7 +121,7 @@ impl chalk_ir::interner::Interner for Interner {
    }
    fn debug_generic_arg(
-        parameter: &GenericArg<Interner>,
+        parameter: &GenericArg,
        fmt: &mut fmt::Formatter<'_>,
    ) -> Option<fmt::Result> {
        tls::with_current_program(|prog| Some(prog?.debug_generic_arg(parameter, fmt)))
@@ -194,30 +216,30 @@ impl chalk_ir::interner::Interner for Interner {
    fn intern_ty(&self, kind: chalk_ir::TyKind<Self>) -> Self::InternedType {
        let flags = kind.compute_flags(self);
-        Arc::new(chalk_ir::TyData { kind, flags })
+        Interned::new(InternedWrapper(chalk_ir::TyData { kind, flags }))
    }
    fn ty_data<'a>(&self, ty: &'a Self::InternedType) -> &'a chalk_ir::TyData<Self> {
-        ty
+        &ty.0
    }
    fn intern_lifetime(&self, lifetime: chalk_ir::LifetimeData<Self>) -> Self::InternedLifetime {
-        lifetime
+        Interned::new(InternedWrapper(lifetime))
    }
    fn lifetime_data<'a>(
        &self,
        lifetime: &'a Self::InternedLifetime,
    ) -> &'a chalk_ir::LifetimeData<Self> {
-        lifetime
+        &lifetime.0
    }
    fn intern_const(&self, constant: chalk_ir::ConstData<Self>) -> Self::InternedConst {
-        Arc::new(constant)
+        Interned::new(InternedWrapper(constant))
    }
    fn const_data<'a>(&self, constant: &'a Self::InternedConst) -> &'a chalk_ir::ConstData<Self> {
-        constant
+        &constant.0
    }
    fn const_eq(
@@ -264,23 +286,23 @@ impl chalk_ir::interner::Interner for Interner {
    fn intern_substitution<E>(
        &self,
-        data: impl IntoIterator<Item = Result<GenericArg<Self>, E>>,
+        data: impl IntoIterator<Item = Result<GenericArg, E>>,
    ) -> Result<Self::InternedSubstitution, E> {
-        data.into_iter().collect()
+        Ok(Interned::new(InternedWrapper(data.into_iter().collect::<Result<_, _>>()?)))
    }
    fn substitution_data<'a>(
        &self,
        substitution: &'a Self::InternedSubstitution,
-    ) -> &'a [GenericArg<Self>] {
+    ) -> &'a [GenericArg] {
-        substitution
+        &substitution.as_ref().0
    }
    fn intern_program_clause(
        &self,
        data: chalk_ir::ProgramClauseData<Self>,
    ) -> Self::InternedProgramClause {
-        Arc::new(data)
+        data
    }
    fn program_clause_data<'a>(
@@ -294,7 +316,7 @@ impl chalk_ir::interner::Interner for Interner {
        &self,
        data: impl IntoIterator<Item = Result<chalk_ir::ProgramClause<Self>, E>>,
    ) -> Result<Self::InternedProgramClauses, E> {
-        data.into_iter().collect()
+        Ok(Interned::new(InternedWrapper(data.into_iter().collect::<Result<_, _>>()?)))
    }
    fn program_clauses_data<'a>(
@@ -308,7 +330,7 @@ impl chalk_ir::interner::Interner for Interner {
        &self,
        data: impl IntoIterator<Item = Result<chalk_ir::QuantifiedWhereClause<Self>, E>>,
    ) -> Result<Self::InternedQuantifiedWhereClauses, E> {
-        data.into_iter().collect()
+        Ok(Interned::new(InternedWrapper(data.into_iter().collect::<Result<_, _>>()?)))
    }
    fn quantified_where_clauses_data<'a>(
@@ -322,21 +344,21 @@ impl chalk_ir::interner::Interner for Interner {
        &self,
        data: impl IntoIterator<Item = Result<chalk_ir::VariableKind<Self>, E>>,
    ) -> Result<Self::InternedVariableKinds, E> {
-        data.into_iter().collect()
+        Ok(Interned::new(InternedWrapper(data.into_iter().collect::<Result<_, _>>()?)))
    }
    fn variable_kinds_data<'a>(
        &self,
        parameter_kinds: &'a Self::InternedVariableKinds,
    ) -> &'a [chalk_ir::VariableKind<Self>] {
-        &parameter_kinds
+        &parameter_kinds.as_ref().0
    }
    fn intern_canonical_var_kinds<E>(
        &self,
        data: impl IntoIterator<Item = Result<chalk_ir::CanonicalVarKind<Self>, E>>,
    ) -> Result<Self::InternedCanonicalVarKinds, E> {
-        data.into_iter().collect()
+        Ok(Interned::new(InternedWrapper(data.into_iter().collect::<Result<_, _>>()?)))
    }
    fn canonical_var_kinds_data<'a>(
@@ -376,7 +398,7 @@ impl chalk_ir::interner::Interner for Interner {
        &self,
        data: impl IntoIterator<Item = Result<chalk_ir::Variance, E>>,
    ) -> Result<Self::InternedVariances, E> {
-        data.into_iter().collect()
+        Ok(Interned::new(InternedWrapper(data.into_iter().collect::<Result<_, _>>()?)))
    }
    fn variances_data<'a>(
@@ -390,3 +412,12 @@ impl chalk_ir::interner::Interner for Interner {
 impl chalk_ir::interner::HasInterner for Interner {
    type Interner = Self;
 }
+#[macro_export]
+macro_rules! has_interner {
+    ($t:ty) => {
+        impl HasInterner for $t {
+            type Interner = crate::Interner;
+        }
+    };
+}
diff --git a/crates/hir_ty/src/lib.rs b/crates/hir_ty/src/lib.rs
index 87f10e9d5..113234fa4 100644
--- a/crates/hir_ty/src/lib.rs
+++ b/crates/hir_ty/src/lib.rs
@@ -1,27 +1,29 @@
 //! The type system. We currently use this to infer types for completion, hover
 //! information and various assists.
 #[allow(unused)]
 macro_rules! eprintln {
    ($($tt:tt)*) => { stdx::eprintln!($($tt)*) };
 }
 mod autoderef;
-pub mod primitive;
-pub mod traits;
-pub mod method_resolution;
-mod op;
-mod lower;
-pub(crate) mod infer;
-pub(crate) mod utils;
-mod chalk_cast;
-mod chalk_ext;
 mod builder;
+mod chalk_db;
+mod chalk_ext;
+mod infer;
+mod interner;
+mod lower;
+mod mapping;
+mod op;
+mod tls;
+mod utils;
 mod walk;
-mod types;
-pub mod display;
 pub mod db;
 pub mod diagnostics;
+pub mod display;
+pub mod method_resolution;
+pub mod primitive;
+pub mod traits;
 #[cfg(test)]
 mod tests;
@@ -30,12 +32,12 @@ mod test_db;
 use std::sync::Arc;
-use base_db::salsa;
+use chalk_ir::{
-use chalk_ir::UintTy;
+    fold::{Fold, Shift},
-use hir_def::{
+    interner::HasInterner,
-    expr::ExprId, type_ref::Rawness, ConstParamId, LifetimeParamId, TraitId, TypeAliasId,
+    UintTy,
-    TypeParamId,
 };
+use hir_def::{expr::ExprId, type_ref::Rawness, TypeParamId};
 use crate::{db::HirDatabase, display::HirDisplay, utils::generics};
@@ -43,12 +45,17 @@ pub use autoderef::autoderef;
 pub use builder::TyBuilder;
 pub use chalk_ext::*;
 pub use infer::{could_unify, InferenceResult};
+pub use interner::Interner;
 pub use lower::{
    associated_type_shorthand_candidates, callable_item_sig, CallableDefId, ImplTraitLoweringMode,
    TyDefId, TyLoweringContext, ValueTyDefId,
 };
-pub use traits::{chalk::Interner, TraitEnvironment};
+pub use mapping::{
-pub use types::*;
+    const_from_placeholder_idx, from_assoc_type_id, from_chalk_trait_id, from_foreign_def_id,
+    from_placeholder_idx, lt_from_placeholder_idx, to_assoc_type_id, to_chalk_trait_id,
+    to_foreign_def_id, to_placeholder_idx,
+};
+pub use traits::TraitEnvironment;
 pub use walk::TypeWalk;
 pub use chalk_ir::{
@@ -65,6 +72,21 @@ pub type PlaceholderIndex = chalk_ir::PlaceholderIndex;
 pub type VariableKind = chalk_ir::VariableKind<Interner>;
 pub type VariableKinds = chalk_ir::VariableKinds<Interner>;
 pub type CanonicalVarKinds = chalk_ir::CanonicalVarKinds<Interner>;
+pub type Binders<T> = chalk_ir::Binders<T>;
+pub type Substitution = chalk_ir::Substitution<Interner>;
+pub type GenericArg = chalk_ir::GenericArg<Interner>;
+pub type GenericArgData = chalk_ir::GenericArgData<Interner>;
+pub type Ty = chalk_ir::Ty<Interner>;
+pub type TyKind = chalk_ir::TyKind<Interner>;
+pub type DynTy = chalk_ir::DynTy<Interner>;
+pub type FnPointer = chalk_ir::FnPointer<Interner>;
+// pub type FnSubst = chalk_ir::FnSubst<Interner>;
+pub use chalk_ir::FnSubst;
+pub type ProjectionTy = chalk_ir::ProjectionTy<Interner>;
+pub type AliasTy = chalk_ir::AliasTy<Interner>;
+pub type OpaqueTy = chalk_ir::OpaqueTy<Interner>;
+pub type InferenceVar = chalk_ir::InferenceVar;
 pub type Lifetime = chalk_ir::Lifetime<Interner>;
 pub type LifetimeData = chalk_ir::LifetimeData<Interner>;
@@ -76,12 +98,27 @@ pub type ConstValue = chalk_ir::ConstValue<Interner>;
 pub type ConcreteConst = chalk_ir::ConcreteConst<Interner>;
 pub type ChalkTraitId = chalk_ir::TraitId<Interner>;
+pub type TraitRef = chalk_ir::TraitRef<Interner>;
+pub type QuantifiedWhereClause = Binders<WhereClause>;
+pub type QuantifiedWhereClauses = chalk_ir::QuantifiedWhereClauses<Interner>;
+pub type Canonical<T> = chalk_ir::Canonical<T>;
 pub type FnSig = chalk_ir::FnSig<Interner>;
+pub type InEnvironment<T> = chalk_ir::InEnvironment<T>;
+pub type DomainGoal = chalk_ir::DomainGoal<Interner>;
+pub type AliasEq = chalk_ir::AliasEq<Interner>;
+pub type Solution = chalk_solve::Solution<Interner>;
+pub type ConstrainedSubst = chalk_ir::ConstrainedSubst<Interner>;
+pub type Guidance = chalk_solve::Guidance<Interner>;
+pub type WhereClause = chalk_ir::WhereClause<Interner>;
 // FIXME: get rid of this
 pub fn subst_prefix(s: &Substitution, n: usize) -> Substitution {
-    Substitution::intern(s.interned()[..std::cmp::min(s.len(&Interner), n)].into())
+    Substitution::from_iter(
+        &Interner,
+        s.as_slice(&Interner)[..std::cmp::min(s.len(&Interner), n)].iter().cloned(),
+    )
 }
 /// Return an index of a parameter in the generic type parameter list by it's id.
@@ -89,14 +126,17 @@ pub fn param_idx(db: &dyn HirDatabase, id: TypeParamId) -> Option<usize> {
    generics(db.upcast(), id.parent).param_idx(id)
 }
-pub fn wrap_empty_binders<T>(value: T) -> Binders<T>
+pub(crate) fn wrap_empty_binders<T>(value: T) -> Binders<T>
 where
-    T: TypeWalk,
+    T: Fold<Interner, Result = T> + HasInterner<Interner = Interner>,
 {
-    Binders::empty(&Interner, value.shifted_in_from(DebruijnIndex::ONE))
+    Binders::empty(&Interner, value.shifted_in_from(&Interner, DebruijnIndex::ONE))
 }
-pub fn make_only_type_binders<T>(num_vars: usize, value: T) -> Binders<T> {
+pub(crate) fn make_only_type_binders<T: HasInterner<Interner = Interner>>(
+    num_vars: usize,
+    value: T,
+) -> Binders<T> {
    Binders::new(
        VariableKinds::from_iter(
            &Interner,
@@ -108,7 +148,7 @@ pub fn make_only_type_binders<T>(num_vars: usize, value: T) -> Binders<T> {
 }
 // FIXME: get rid of this
-pub fn make_canonical<T>(
+pub fn make_canonical<T: HasInterner<Interner = Interner>>(
    value: T,
    kinds: impl IntoIterator<Item = TyVariableKind>,
 ) -> Canonical<T> {
@@ -129,6 +169,8 @@ pub struct CallableSig {
    is_varargs: bool,
 }
+has_interner!(CallableSig);
 /// A polymorphic function signature.
 pub type PolyFnSig = Binders<CallableSig>;
@@ -144,10 +186,10 @@ impl CallableSig {
            params_and_return: fn_ptr
                .substitution
                .clone()
-                .shifted_out_to(DebruijnIndex::ONE)
+                .shifted_out_to(&Interner, DebruijnIndex::ONE)
                .expect("unexpected lifetime vars in fn ptr")
                .0
-                .interned()
+                .as_slice(&Interner)
                .iter()
                .map(|arg| arg.assert_ty_ref(&Interner).clone())
                .collect(),
@@ -164,7 +206,22 @@ impl CallableSig {
    }
 }
-impl Ty {}
+impl Fold<Interner> for CallableSig {
+    type Result = CallableSig;
+    fn fold_with<'i>(
+        self,
+        folder: &mut dyn chalk_ir::fold::Folder<'i, Interner>,
+        outer_binder: DebruijnIndex,
+    ) -> chalk_ir::Fallible<Self::Result>
+    where
+        Interner: 'i,
+    {
+        let vec = self.params_and_return.to_vec();
+        let folded = vec.fold_with(folder, outer_binder)?;
+        Ok(CallableSig { params_and_return: folded.into(), is_varargs: self.is_varargs })
+    }
+}
 #[derive(Copy, Clone, PartialEq, Eq, Debug, Hash)]
 pub enum ImplTraitId {
@@ -177,70 +234,75 @@ pub struct ReturnTypeImplTraits {
    pub(crate) impl_traits: Vec<ReturnTypeImplTrait>,
 }
+has_interner!(ReturnTypeImplTraits);
 #[derive(Clone, PartialEq, Eq, Debug, Hash)]
 pub(crate) struct ReturnTypeImplTrait {
    pub(crate) bounds: Binders<Vec<QuantifiedWhereClause>>,
 }
-pub fn to_foreign_def_id(id: TypeAliasId) -> ForeignDefId {
+pub fn static_lifetime() -> Lifetime {
-    chalk_ir::ForeignDefId(salsa::InternKey::as_intern_id(&id))
+    LifetimeData::Static.intern(&Interner)
-}
-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 {
+pub fn dummy_usize_const() -> Const {
-    let interned_id = db.intern_type_param_id(id);
+    let usize_ty = chalk_ir::TyKind::Scalar(Scalar::Uint(UintTy::Usize)).intern(&Interner);
-    PlaceholderIndex {
+    chalk_ir::ConstData {
-        ui: chalk_ir::UniverseIndex::ROOT,
+        ty: usize_ty,
-        idx: salsa::InternKey::as_intern_id(&interned_id).as_usize(),
+        value: chalk_ir::ConstValue::Concrete(chalk_ir::ConcreteConst { interned: () }),
    }
+    .intern(&Interner)
 }
-pub fn lt_from_placeholder_idx(db: &dyn HirDatabase, idx: PlaceholderIndex) -> LifetimeParamId {
+pub(crate) fn fold_free_vars<T: HasInterner<Interner = Interner> + Fold<Interner>>(
-    assert_eq!(idx.ui, chalk_ir::UniverseIndex::ROOT);
+    t: T,
-    let interned_id = salsa::InternKey::from_intern_id(salsa::InternId::from(idx.idx));
+    f: impl FnMut(BoundVar, DebruijnIndex) -> Ty,
-    db.lookup_intern_lifetime_param_id(interned_id)
+) -> T::Result {
-}
+    use chalk_ir::{fold::Folder, Fallible};
+    struct FreeVarFolder<F>(F);
+    impl<'i, F: FnMut(BoundVar, D