79 files changed, 2738 insertions, 1659 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/crates/hir/src/lib.rs b/crates/hir/src/lib.rs
index 817a01db1..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,
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/body/lower.rs b/crates/hir_def/src/body/lower.rs
index bfb75a8a5..ed07d6928 100644
--- a/crates/hir_def/src/body/lower.rs
+++ b/crates/hir_def/src/body/lower.rs
@@ -531,8 +531,9 @@ impl ExprCollector<'_> {
                }
            }
            ast::Expr::MacroCall(e) => {
+                let macro_ptr = AstPtr::new(&e);
                let mut ids = vec![];
-                self.collect_macro_call(e, syntax_ptr.clone(), true, |this, expansion| {
+                self.collect_macro_call(e, macro_ptr, true, |this, expansion| {
                    ids.push(match expansion {
                        Some(it) => this.collect_expr(it),
                        None => this.alloc_expr(Expr::Missing, syntax_ptr.clone()),
@@ -555,7 +556,7 @@ impl ExprCollector<'_> {
    fn collect_macro_call<F: FnMut(&mut Self, Option<T>), T: ast::AstNode>(
        &mut self,
        e: ast::MacroCall,
-        syntax_ptr: AstPtr<ast::Expr>,
+        syntax_ptr: AstPtr<ast::MacroCall>,
        is_error_recoverable: bool,
        mut collector: F,
    ) {
@@ -643,10 +644,14 @@ impl ExprCollector<'_> {
                // Note that macro could be expended to multiple statements
                if let Some(ast::Expr::MacroCall(m)) = stmt.expr() {
+                    let macro_ptr = AstPtr::new(&m);
                    let syntax_ptr = AstPtr::new(&stmt.expr().unwrap());
-                    self.collect_macro_call(m, syntax_ptr.clone(), false, |this, expansion| {
+                    self.collect_macro_call(
-                        match expansion {
+                        m,
+                        macro_ptr,
+                        false,
+                        |this, expansion| match expansion {
                            Some(expansion) => {
                                let statements: ast::MacroStmts = expansion;
@@ -660,8 +665,8 @@ impl ExprCollector<'_> {
                                let expr = this.alloc_expr(Expr::Missing, syntax_ptr.clone());
                                this.statements_in_scope.push(Statement::Expr(expr));
                            }
-                        }
+                        },
-                    });
+                    );
                } else {
                    let expr = self.collect_expr_opt(stmt.expr());
                    self.statements_in_scope.push(Statement::Expr(expr));
@@ -848,8 +853,23 @@ impl ExprCollector<'_> {
                    Pat::Missing
                }
            }
+            ast::Pat::MacroPat(mac) => match mac.macro_call() {
+                Some(call) => {
+                    let macro_ptr = AstPtr::new(&call);
+                    let mut pat = None;
+                    self.collect_macro_call(call, macro_ptr, true, |this, expanded_pat| {
+                        pat = Some(this.collect_pat_opt(expanded_pat));
+                    });
+                    match pat {
+                        Some(pat) => return pat,
+                        None => Pat::Missing,
+                    }
+                }
+                None => Pat::Missing,
+            },
            // FIXME: implement
-            ast::Pat::RangePat(_) | ast::Pat::MacroPat(_) => Pat::Missing,
+            ast::Pat::RangePat(_) => Pat::Missing,
        };
        let ptr = AstPtr::new(&pat);
        self.alloc_pat(pattern, Either::Left(ptr))
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/item_tree.rs b/crates/hir_def/src/item_tree.rs
index 240662486..94e08f835 100644
--- a/crates/hir_def/src/item_tree.rs
+++ b/crates/hir_def/src/item_tree.rs
@@ -99,6 +99,11 @@ impl ItemTree {
                    // items.
                    ctx.lower_macro_stmts(stmts)
                },
+                ast::Pat(_pat) => {
+                    // FIXME: This occurs because macros in pattern position are treated as inner
+                    // items and expanded during block DefMap computation
+                    return Default::default();
+                },
                ast::Expr(e) => {
                    // Macros can expand to expressions. We return an empty item tree in this case, but
                    // still need to collect inner items.
diff --git a/crates/hir_def/src/item_tree/lower.rs b/crates/hir_def/src/item_tree/lower.rs
index c5629af24..45b099cf3 100644
--- a/crates/hir_def/src/item_tree/lower.rs
+++ b/crates/hir_def/src/item_tree/lower.rs
@@ -189,7 +189,7 @@ impl Ctx {
                                block_stack.push(self.source_ast_id_map.ast_id(&block));
                            },
                            ast::Item(item) => {
-                                // FIXME: This triggers for macro calls in expression position
+                                // FIXME: This triggers for macro calls in expression/pattern/type position
                                let mod_items = self.lower_mod_item(&item, true);
                                let current_block = block_stack.last();
                                if let (Some(mod_items), Some(block)) = (mod_items, current_block) {
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 6dbbe2d05..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,10 +832,14 @@ 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, directive.depth));
                            res = ReachedFixedPoint::No;
@@ -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..ca705ee9d 100644
--- a/crates/hir_expand/src/db.rs
+++ b/crates/hir_expand/src/db.rs
@@ -439,6 +439,7 @@ fn to_fragment_kind(db: &dyn AstDatabase, id: MacroCallId) -> FragmentKind {
    match parent.kind() {
        MACRO_ITEMS | SOURCE_FILE => FragmentKind::Items,
        MACRO_STMTS => FragmentKind::Statements,
+        MACRO_PAT => FragmentKind::Pattern,
        ITEM_LIST => FragmentKind::Items,
        LET_STMT => {
            // FIXME: Handle LHS Pattern
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/lib.rs b/crates/hir_expand/src/lib.rs
index 3e332ee47..a0e6aec62 100644
--- a/crates/hir_expand/src/lib.rs
+++ b/crates/hir_expand/src/lib.rs
@@ -290,22 +290,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 +318,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_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/chalk_cast.rs b/crates/hir_ty/src/chalk_cast.rs
deleted file mode 100644
index f27dee3fd..000000000
--- a/crates/hir_ty/src/chalk_cast.rs
+++ /dev/null
@@ -1,16 +0,0 @@
-//! Implementations of the Chalk `Cast` trait for our types.
-use chalk_ir::interner::HasInterner;
-use crate::{CallableSig, ReturnTypeImplTraits};
-macro_rules! has_interner {
-    ($t:ty) => {
-        impl HasInterner for $t {
-            type Interner = crate::Interner;
-        }
-    };
-}
-has_interner!(CallableSig);
-has_interner!(ReturnTypeImplTraits);
diff --git a/crates/hir_ty/src/traits/chalk.rs b/crates/hir_ty/src/chalk_db.rs
index b8c390b2e..8f054d06b 100644
--- a/crates/hir_ty/src/traits/chalk.rs
+++ b/crates/hir_ty/src/chalk_db.rs
@@ -1,50 +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, make_only_type_binders,
+    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, TypeAliasAsValue};
-pub use self::interner::Interner;
+pub(crate) type AssociatedTyDatum = chalk_solve::rust_ir::AssociatedTyDatum<Interner>;
-pub(crate) use self::interner::*;
+pub(crate) type TraitDatum = chalk_solve::rust_ir::TraitDatum<Interner>;
+pub(crate) type StructDatum = chalk_solve::rust_ir::AdtDatum<Interner>;
-pub(super) mod tls;
+pub(crate) type ImplDatum = chalk_solve::rust_ir::ImplDatum<Interner>;
-mod interner;
+pub(crate) type OpaqueTyDatum = chalk_solve::rust_ir::OpaqueTyDatum<Interner>;
-mod mapping;
+pub(crate) type AssocTypeId = chalk_ir::AssocTypeId<Interner>;
-pub(crate) trait ToChalk {
+pub(crate) type TraitId = chalk_ir::TraitId<Interner>;
-    type Chalk;
+pub(crate) type AdtId = chalk_ir::AdtId<Interner>;
-    fn to_chalk(self, db: &dyn HirDatabase) -> Self::Chalk;
+pub(crate) type ImplId = chalk_ir::ImplId<Interner>;
-    fn from_chalk(db: &dyn HirDatabase, chalk: Self::Chalk) -> Self;
+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) fn from_chalk<T, ChalkT>(db: &dyn HirDatabase, chalk: ChalkT) -> T
+pub(crate) type Variances = chalk_ir::Variances<Interner>;
-where
-    T: ToChalk<Chalk = ChalkT>,
-{
-    T::from_chalk(db, chalk)
-}
 impl<'a> chalk_solve::RustIrDatabase<Interner> for ChalkContext<'a> {
    fn associated_ty_data(&self, id: AssocTypeId) -> Arc<AssociatedTyDatum> {
@@ -82,7 +79,7 @@ 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 = parameters[0].assert_ty_ref(&Interner).clone();
@@ -101,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,
@@ -164,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(
@@ -311,7 +308,7 @@ impl<'a> chalk_solve::RustIrDatabase<Interner> for ChalkContext<'a> {
    }
    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 {
@@ -416,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());
@@ -679,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 d7a3977e5..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)?;
@@ -416,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, ")")?;
                }
            }
@@ -444,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, ">")?;
                    }
                }
@@ -491,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() {
@@ -515,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, "<")?;
@@ -542,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 {
@@ -749,13 +751,13 @@ fn write_bounds_like_dyn_trait(
                // 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() {
@@ -814,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(())
diff --git a/crates/hir_ty/src/infer/expr.rs b/crates/hir_ty/src/infer/expr.rs
index cbbfa8b5c..50497eecb 100644
--- a/crates/hir_ty/src/infer/expr.rs
+++ b/crates/hir_ty/src/infer/expr.rs
@@ -17,10 +17,11 @@ 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,
@@ -462,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/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 874c95411..113234fa4 100644
--- a/crates/hir_ty/src/lib.rs
+++ b/crates/hir_ty/src/lib.rs
@@ -7,21 +7,23 @@ macro_rules! eprintln {
 }
 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;
-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,16 +32,12 @@ mod test_db;
 use std::sync::Arc;
-use base_db::salsa;
 use chalk_ir::{
    fold::{Fold, Shift},
    interner::HasInterner,
    UintTy,
 };
-use hir_def::{
+use hir_def::{expr::ExprId, type_ref::Rawness, TypeParamId};
-    expr::ExprId, type_ref::Rawness, ConstParamId, LifetimeParamId, TraitId, TypeAliasId,
-    TypeParamId,
-};
 use crate::{db::HirDatabase, display::HirDisplay, utils::generics};
@@ -47,11 +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::{
+    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::{
@@ -94,6 +98,10 @@ 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>;
@@ -109,7 +117,7 @@ pub type WhereClause = chalk_ir::WhereClause<Interner>;
 pub fn subst_prefix(s: &Substitution, n: usize) -> Substitution {
    Substitution::from_iter(
        &Interner,
-        s.interned()[..std::cmp::min(s.len(&Interner), n)].iter().cloned(),
+        s.as_slice(&Interner)[..std::cmp::min(s.len(&Interner), n)].iter().cloned(),
    )
 }
@@ -118,14 +126,14 @@ 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: Fold<Interner, Result = T> + HasInterner<Interner = Interner>,
 {
    Binders::empty(&Interner, value.shifted_in_from(&Interner, DebruijnIndex::ONE))
 }
-pub fn make_only_type_binders<T: HasInterner<Interner = Interner>>(
+pub(crate) fn make_only_type_binders<T: HasInterner<Interner = Interner>>(
    num_vars: usize,
    value: T,
 ) -> Binders<T> {
@@ -153,14 +161,6 @@ pub fn make_canonical<T: HasInterner<Interner = Interner>>(
    Canonical { value, binders: chalk_ir::CanonicalVarKinds::from_iter(&Interner, kinds) }
 }
-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>;
 /// A function signature as seen by type inference: Several parameter types and
 /// one return type.
 #[derive(Clone, PartialEq, Eq, Debug)]
@@ -169,6 +169,8 @@ pub struct CallableSig {
    is_varargs: bool,
 }
+has_interner!(CallableSig);
 /// A polymorphic function signature.
 pub type PolyFnSig = Binders<CallableSig>;
@@ -187,7 +189,7 @@ impl CallableSig {
                .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(),
@@ -232,61 +234,13 @@ 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 {
-    chalk_ir::ForeignDefId(salsa::InternKey::as_intern_id(&id))
-}
-pub fn from_foreign_def_id(id: ForeignDefId) -> TypeAliasId {
-    salsa::InternKey::from_intern_id(id.0)
-}
-pub fn to_assoc_type_id(id: TypeAliasId) -> AssocTypeId {
-    chalk_ir::AssocTypeId(salsa::InternKey::as_intern_id(&id))
-}
-pub fn from_assoc_type_id(id: AssocTypeId) -> TypeAliasId {
-    salsa::InternKey::from_intern_id(id.0)
-}
-pub fn from_placeholder_idx(db: &dyn HirDatabase, idx: PlaceholderIndex) -> TypeParamId {
-    assert_eq!(idx.ui, chalk_ir::UniverseIndex::ROOT);
-    let interned_id = salsa::InternKey::from_intern_id(salsa::InternId::from(idx.idx));
-    db.lookup_intern_type_param_id(interned_id)
-}
-pub fn to_placeholder_idx(db: &dyn HirDatabase, id: TypeParamId) -> PlaceholderIndex {
-    let interned_id = db.intern_type_param_id(id);
-    PlaceholderIndex {
-        ui: chalk_ir::UniverseIndex::ROOT,
-        idx: salsa::InternKey::as_intern_id(&interned_id).as_usize(),
-    }
-}
-pub fn lt_from_placeholder_idx(db: &dyn HirDatabase, idx: PlaceholderIndex) -> LifetimeParamId {
-    assert_eq!(idx.ui, chalk_ir::UniverseIndex::ROOT);
-    let interned_id = salsa::InternKey::from_intern_id(salsa::InternId::from(idx.idx));
-    db.lookup_intern_lifetime_param_id(interned_id)
-}
-pub fn const_from_placeholder_idx(db: &dyn HirDatabase, idx: PlaceholderIndex) -> ConstParamId {
-    assert_eq!(idx.ui, chalk_ir::UniverseIndex::ROOT);
-    let interned_id = salsa::InternKey::from_intern_id(salsa::InternId::from(idx.idx));
-    db.lookup_intern_const_param_id(interned_id)
-}
-pub fn to_chalk_trait_id(id: TraitId) -> ChalkTraitId {
-    chalk_ir::TraitId(salsa::InternKey::as_intern_id(&id))
-}
-pub fn from_chalk_trait_id(id: ChalkTraitId) -> TraitId {
-    salsa::InternKey::from_intern_id(id.0)
-}
 pub fn static_lifetime() -> Lifetime {
    LifetimeData::Static.intern(&Interner)
 }
diff --git a/crates/hir_ty/src/lower.rs b/crates/hir_ty/src/lower.rs
index 8a22d9ea3..a035686bc 100644
--- a/crates/hir_ty/src/lower.rs
+++ b/crates/hir_ty/src/lower.rs
@@ -27,13 +27,14 @@ use stdx::impl_from;
 use crate::{
    db::HirDatabase,
-    dummy_usize_const, static_lifetime, to_assoc_type_id, to_chalk_trait_id, to_placeholder_idx,
+    dummy_usize_const,
-    traits::chalk::{Interner, ToChalk},
+    mapping::ToChalk,
+    static_lifetime, to_assoc_type_id, to_chalk_trait_id, to_placeholder_idx,
    utils::{
        all_super_trait_refs, associated_type_by_name_including_super_traits, generics, Generics,
    },
    AliasEq, AliasTy, Binders, BoundVar, CallableSig, DebruijnIndex, DynTy, FnPointer, FnSig,
-    FnSubst, ImplTraitId, OpaqueTy, PolyFnSig, ProjectionTy, QuantifiedWhereClause,
+    FnSubst, ImplTraitId, Interner, OpaqueTy, PolyFnSig, ProjectionTy, QuantifiedWhereClause,
    QuantifiedWhereClauses, ReturnTypeImplTrait, ReturnTypeImplTraits, Substitution,
    TraitEnvironment, TraitRef, TraitRefExt, Ty, TyBuilder, TyKind, WhereClause,
 };
diff --git a/crates/hir_ty/src/mapping.rs b/crates/hir_ty/src/mapping.rs
new file mode 100644
index 000000000..5e86fafe5
--- /dev/null
+++ b/crates/hir_ty/src/mapping.rs
@@ -0,0 +1,154 @@
+//! This module contains the implementations of the `ToChalk` trait, which
+//! handles conversion between our data types and their corresponding types in
+//! Chalk (in both directions); plus some helper functions for more specialized
+//! conversions.
+use chalk_solve::rust_ir;
+use base_db::salsa::{self, InternKey};
+use hir_def::{ConstParamId, LifetimeParamId, TraitId, TypeAliasId, TypeParamId};
+use crate::{
+    chalk_db, db::HirDatabase, AssocTypeId, CallableDefId, ChalkTraitId, FnDefId, ForeignDefId,
+    Interner, OpaqueTyId, PlaceholderIndex,
+};
+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
+where
+    T: ToChalk<Chalk = ChalkT>,
+{
+    T::from_chalk(db, chalk)
+}
+impl ToChalk for hir_def::ImplId {
+    type Chalk = chalk_db::ImplId;
+    fn to_chalk(self, _db: &dyn HirDatabase) -> chalk_db::ImplId {
+        chalk_ir::ImplId(self.as_intern_id())
+    }
+    fn from_chalk(_db: &dyn HirDatabase, impl_id: chalk_db::ImplId) -> hir_def::ImplId {
+        InternKey::from_intern_id(impl_id.0)
+    }
+}
+impl ToChalk for CallableDefId {
+    type Chalk = FnDefId;
+    fn to_chalk(self, db: &dyn HirDatabase) -> FnDefId {
+        db.intern_callable_def(self).into()
+    }
+    fn from_chalk(db: &dyn HirDatabase, fn_def_id: FnDefId) -> CallableDefId {
+        db.lookup_intern_callable_def(fn_def_id.into())
+    }
+}
+pub(crate) struct TypeAliasAsValue(pub(crate) TypeAliasId);
+impl ToChalk for TypeAliasAsValue {
+    type Chalk = chalk_db::AssociatedTyValueId;
+    fn to_chalk(self, _db: &dyn HirDatabase) -> chalk_db::AssociatedTyValueId {
+        rust_ir::AssociatedTyValueId(self.0.as_intern_id())
+    }
+    fn from_chalk(
+        _db: &dyn HirDatabase,
+        assoc_ty_value_id: chalk_db::AssociatedTyValueId,
+    ) -> TypeAliasAsValue {
+        TypeAliasAsValue(TypeAliasId::from_intern_id(assoc_ty_value_id.0))
+    }
+}
+impl From<FnDefId> for crate::db::InternedCallableDefId {
+    fn from(fn_def_id: FnDefId) -> Self {
+        InternKey::from_intern_id(fn_def_id.0)
+    }
+}
+impl From<crate::db::InternedCallableDefId> for FnDefId {
+    fn from(callable_def_id: crate::db::InternedCallableDefId) -> Self {
+        chalk_ir::FnDefId(callable_def_id.as_intern_id())
+    }
+}
+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> {
+    fn from(id: crate::db::InternedClosureId) -> Self {
+        chalk_ir::ClosureId(id.as_intern_id())
+    }
+}
+pub fn to_foreign_def_id(id: TypeAliasId) -> ForeignDefId {
+    chalk_ir::ForeignDefId(salsa::InternKey::as_intern_id(&id))
+}
+pub fn from_foreign_def_id(id: ForeignDefId) -> TypeAliasId {
+    salsa::InternKey::from_intern_id(id.0)
+}
+pub fn to_assoc_type_id(id: TypeAliasId) -> AssocTypeId {
+    chalk_ir::AssocTypeId(salsa::InternKey::as_intern_id(&id))
+}
+pub fn from_assoc_type_id(id: AssocTypeId) -> TypeAliasId {
+    salsa::InternKey::from_intern_id(id.0)
+}
+pub fn from_placeholder_idx(db: &dyn HirDatabase, idx: PlaceholderIndex) -> TypeParamId {
+    assert_eq!(idx.ui, chalk_ir::UniverseIndex::ROOT);
+    let interned_id = salsa::InternKey::from_intern_id(salsa::InternId::from(idx.idx));
+    db.lookup_intern_type_param_id(interned_id)
+}
+pub fn to_placeholder_idx(db: &dyn HirDatabase, id: TypeParamId) -> PlaceholderIndex {
+    let interned_id = db.intern_type_param_id(id);
+    PlaceholderIndex {
+        ui: chalk_ir::UniverseIndex::ROOT,
+        idx: salsa::InternKey::as_intern_id(&interned_id).as_usize(),
+    }
+}
+pub fn lt_from_placeholder_idx(db: &dyn HirDatabase, idx: PlaceholderIndex) -> LifetimeParamId {
+    assert_eq!(idx.ui, chalk_ir::UniverseIndex::ROOT);
+    let interned_id = salsa::InternKey::from_intern_id(salsa::InternId::from(idx.idx));
+    db.lookup_intern_lifetime_param_id(interned_id)
+}
+pub fn const_from_placeholder_idx(db: &dyn HirDatabase, idx: PlaceholderIndex) -> ConstParamId {
+    assert_eq!(idx.ui, chalk_ir::UniverseIndex::ROOT);
+    let interned_id = salsa::InternKey::from_intern_id(salsa::InternId::from(idx.idx));
+    db.lookup_intern_const_param_id(interned_id)
+}
+pub fn to_chalk_trait_id(id: TraitId) -> ChalkTraitId {
+    chalk_ir::TraitId(salsa::InternKey::as_intern_id(&id))
+}
+pub fn from_chalk_trait_id(id: ChalkTraitId) -> TraitId {
+    salsa::InternKey::from_intern_id(id.0)
+}
diff --git a/crates/hir_ty/src/method_resolution.rs b/crates/hir_ty/src/method_resolution.rs
index be3e4f09a..3693e3284 100644
--- a/crates/hir_ty/src/method_resolution.rs
+++ b/crates/hir_ty/src/method_resolution.rs
@@ -21,32 +21,36 @@ use crate::{
    primitive::{self, FloatTy, IntTy, UintTy},
    static_lifetime,
    utils::all_super_traits,
-    AdtId, Canonical, CanonicalVarKinds, DebruijnIndex, FnPointer, FnSig, ForeignDefId,
+    AdtId, Canonical, CanonicalVarKinds, DebruijnIndex, ForeignDefId, InEnvironment, Interner,
-    InEnvironment, Interner, Scalar, Substitution, TraitEnvironment, TraitRefExt, Ty, TyBuilder,
+    Scalar, Substitution, TraitEnvironment, TraitRefExt, Ty, TyBuilder, TyExt, TyKind,
-    TyExt, TyKind,
 };
 /// This is used as a key for indexing impls.
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 pub enum TyFingerprint {
+    // These are lang item impls:
    Str,
    Slice,
    Array,
    Never,
    RawPtr(Mutability),
    Scalar(Scalar),
+    // These can have user-defined impls:
    Adt(hir_def::AdtId),
    Dyn(TraitId),
-    Tuple(usize),
    ForeignType(ForeignDefId),
-    FnPtr(usize, FnSig),
+    // These only exist for trait impls
+    Unit,
+    Unnameable,
+    Function(u32),
 }
 impl TyFingerprint {
-    /// Creates a TyFingerprint for looking up an impl. Only certain types can
+    /// Creates a TyFingerprint for looking up an inherent impl. Only certain
-    /// have impls: if we have some `struct S`, we can have an `impl S`, but not
+    /// types can have inherent impls: if we have some `struct S`, we can have
-    /// `impl &S`. Hence, this will return `None` for reference types and such.
+    /// an `impl S`, but not `impl &S`. Hence, this will return `None` for
-    pub fn for_impl(ty: &Ty) -> Option<TyFingerprint> {
+    /// reference types and such.
+    pub fn for_inherent_impl(ty: &Ty) -> Option<TyFingerprint> {
        let fp = match ty.kind(&Interner) {
            TyKind::Str => TyFingerprint::Str,
            TyKind::Never => TyFingerprint::Never,
@@ -54,17 +58,52 @@ impl TyFingerprint {
            TyKind::Array(..) => TyFingerprint::Array,
            TyKind::Scalar(scalar) => TyFingerprint::Scalar(*scalar),
            TyKind::Adt(AdtId(adt), _) => TyFingerprint::Adt(*adt),
-            TyKind::Tuple(cardinality, _) => TyFingerprint::Tuple(*cardinality),
            TyKind::Raw(mutability, ..) => TyFingerprint::RawPtr(*mutability),
            TyKind::Foreign(alias_id, ..) => TyFingerprint::ForeignType(*alias_id),
-            TyKind::Function(FnPointer { sig, substitution: substs, .. }) => {
-                TyFingerprint::FnPtr(substs.0.len(&Interner) - 1, *sig)
-            }
            TyKind::Dyn(_) => ty.dyn_trait().map(|trait_| TyFingerprint::Dyn(trait_))?,
            _ => return None,
        };
        Some(fp)
    }
+    /// Creates a TyFingerprint for looking up a trait impl.
+    pub fn for_trait_impl(ty: &Ty) -> Option<TyFingerprint> {
+        let fp = match ty.kind(&Interner) {
+            TyKind::Str => TyFingerprint::Str,
+            TyKind::Never => TyFingerprint::Never,
+            TyKind::Slice(..) => TyFingerprint::Slice,
+            TyKind::Array(..) => TyFingerprint::Array,
+            TyKind::Scalar(scalar) => TyFingerprint::Scalar(*scalar),
+            TyKind::Adt(AdtId(adt), _) => TyFingerprint::Adt(*adt),
+            TyKind::Raw(mutability, ..) => TyFingerprint::RawPtr(*mutability),
+            TyKind::Foreign(alias_id, ..) => TyFingerprint::ForeignType(*alias_id),
+            TyKind::Dyn(_) => ty.dyn_trait().map(|trait_| TyFingerprint::Dyn(trait_))?,
+            TyKind::Ref(_, _, ty) => return TyFingerprint::for_trait_impl(ty),
+            TyKind::Tuple(_, subst) => {
+                let first_ty = subst.interned().get(0).map(|arg| arg.assert_ty_ref(&Interner));
+                if let Some(ty) = first_ty {
+                    return TyFingerprint::for_trait_impl(ty);
+                } else {
+                    TyFingerprint::Unit
+                }
+            }
+            TyKind::AssociatedType(_, _)
+            | TyKind::OpaqueType(_, _)
+            | TyKind::FnDef(_, _)
+            | TyKind::Closure(_, _)
+            | TyKind::Generator(..)
+            | TyKind::GeneratorWitness(..) => TyFingerprint::Unnameable,
+            TyKind::Function(fn_ptr) => {
+                TyFingerprint::Function(fn_ptr.substitution.0.len(&Interner) as u32)
+            }
+            TyKind::Alias(_)
+            | TyKind::Placeholder(_)
+            | TyKind::BoundVar(_)
+            | TyKind::InferenceVar(_, _)
+            | TyKind::Error => return None,
+        };
+        Some(fp)
+    }
 }
 pub(crate) const ALL_INT_FPS: [TyFingerprint; 12] = [
@@ -112,7 +151,7 @@ impl TraitImpls {
                        None => continue,
                    };
                    let self_ty = db.impl_self_ty(impl_id);
-                    let self_ty_fp = TyFingerprint::for_impl(self_ty.skip_binders());
+                    let self_ty_fp = TyFingerprint::for_trait_impl(self_ty.skip_binders());
                    impls
                        .map
                        .entry(target_trait)
@@ -157,10 +196,13 @@ impl TraitImpls {
    }
    /// Queries all trait impls for the given type.
-    pub fn for_self_ty(&self, fp: TyFingerprint) -> impl Iterator<Item = ImplId> + '_ {
+    pub fn for_self_ty_without_blanket_impls(
+        &self,
+        fp: TyFingerprint,
+    ) -> impl Iterator<Item = ImplId> + '_ {
        self.map
            .values()
-            .flat_map(move |impls| impls.get(&None).into_iter().chain(impls.get(&Some(fp))))
+            .flat_map(move |impls| impls.get(&Some(fp)).into_iter())
            .flat_map(|it| it.iter().copied())
    }
@@ -215,9 +257,11 @@ impl InherentImpls {
                }
                let self_ty = db.impl_self_ty(impl_id);
-                if let Some(fp) = TyFingerprint::for_impl(self_ty.skip_binders()) {
+                let fp = TyFingerprint::for_inherent_impl(self_ty.skip_binders());
+                if let Some(fp) = fp {
                    map.entry(fp).or_default().push(impl_id);
                }
+                // `fp` should only be `None` in error cases (either erroneous code or incomplete name resolution)
            }
        }
@@ -228,7 +272,7 @@ impl InherentImpls {
    }
    pub fn for_self_ty(&self, self_ty: &Ty) -> &[ImplId] {
-        match TyFingerprint::for_impl(self_ty) {
+        match TyFingerprint::for_inherent_impl(self_ty) {
            Some(fp) => self.map.get(&fp).map(|vec| vec.as_ref()).unwrap_or(&[]),
            None => &[],
        }
@@ -609,6 +653,7 @@ fn iterate_trait_method_candidates(
                }
            }
            known_implemented = true;
+            // FIXME: we shouldn't be ignoring the binders here
            if callback(&self_ty.value, *item) {
                return true;
            }
diff --git a/crates/hir_ty/src/op.rs b/crates/hir_ty/src/op.rs
index 0491c5cb4..0222de2bc 100644
--- a/crates/hir_ty/src/op.rs
+++ b/crates/hir_ty/src/op.rs
@@ -9,21 +9,55 @@ pub(super) fn binary_op_return_ty(op: BinaryOp, lhs_ty: Ty, rhs_ty: Ty) -> Ty {
        BinaryOp::LogicOp(_) | BinaryOp::CmpOp(_) => TyKind::Scalar(Scalar::Bool).intern(&Interner),
        BinaryOp::Assignment { .. } => TyBuilder::unit(),
        BinaryOp::ArithOp(ArithOp::Shl) | BinaryOp::ArithOp(ArithOp::Shr) => {
-            match lhs_ty.kind(&Interner) {
+            // all integer combinations are valid here
+            if matches!(
+                lhs_ty.kind(&Interner),
                TyKind::Scalar(Scalar::Int(_))
-                | TyKind::Scalar(Scalar::Uint(_))
+                    | TyKind::Scalar(Scalar::Uint(_))
-                | TyKind::Scalar(Scalar::Float(_)) => lhs_ty,
+                    | TyKind::InferenceVar(_, TyVariableKind::Integer)
-                TyKind::InferenceVar(_, TyVariableKind::Integer)
+            ) && matches!(
-                | TyKind::InferenceVar(_, TyVariableKind::Float) => lhs_ty,
+                rhs_ty.kind(&Interner),
-                _ => TyKind::Error.intern(&Interner),
+                TyKind::Scalar(Scalar::Int(_))
+                    | TyKind::Scalar(Scalar::Uint(_))
+                    | TyKind::InferenceVar(_, TyVariableKind::Integer)
+            ) {
+                lhs_ty
+            } else {
+                TyKind::Error.intern(&Interner)
            }
        }
-        BinaryOp::ArithOp(_) => match rhs_ty.kind(&Interner) {
+        BinaryOp::ArithOp(_) => match (lhs_ty.kind(&Interner), rhs_ty.kind(&Interner)) {
-            TyKind::Scalar(Scalar::Int(_))
+            // (int, int) | (uint, uint) | (float, float)
-            | TyKind::Scalar(Scalar::Uint(_))
+            (TyKind::Scalar(Scalar::Int(_)), TyKind::Scalar(Scalar::Int(_)))
-            | TyKind::Scalar(Scalar::Float(_)) => rhs_ty,
+            | (TyKind::Scalar(Scalar::Uint(_)), TyKind::Scalar(Scalar::Uint(_)))
-            TyKind::InferenceVar(_, TyVariableKind::Integer)
+            | (TyKind::Scalar(Scalar::Float(_)), TyKind::Scalar(Scalar::Float(_))) => rhs_ty,
-            | TyKind::InferenceVar(_, TyVariableKind::Float) => rhs_ty,
+            // ({int}, int) | ({int}, uint)
+            (TyKind::InferenceVar(_, TyVariableKind::Integer), TyKind::Scalar(Scalar::Int(_)))
+            | (TyKind::InferenceVar(_, TyVariableKind::Integer), TyKind::Scalar(Scalar::Uint(_))) => {
+                rhs_ty
+            }
+            // (int, {int}) | (uint, {int})
+            (TyKind::Scalar(Scalar::Int(_)), TyKind::InferenceVar(_, TyVariableKind::Integer))
+            | (TyKind::Scalar(Scalar::Uint(_)), TyKind::InferenceVar(_, TyVariableKind::Integer)) => {
+                lhs_ty
+            }
+            // ({float} | float)
+            (TyKind::InferenceVar(_, TyVariableKind::Float), TyKind::Scalar(Scalar::Float(_))) => {
+                rhs_ty
+            }
+            // (float, {float})
+            (TyKind::Scalar(Scalar::Float(_)), TyKind::InferenceVar(_, TyVariableKind::Float)) => {
+                lhs_ty
+            }
+            // ({int}, {int}) | ({float}, {float})
+            (
+                TyKind::InferenceVar(_, TyVariableKind::Integer),
+                TyKind::InferenceVar(_, TyVariableKind::Integer),
+            )
+            | (
+                TyKind::InferenceVar(_, TyVariableKind::Float),
+                TyKind::InferenceVar(_, TyVariableKind::Float),
+            ) => rhs_ty,
            _ => TyKind::Error.intern(&Interner),
        },
    }
diff --git a/crates/hir_ty/src/primitive.rs b/crates/hir_ty/src/primitive.rs
index 2449addfb..d7f48c69a 100644
--- a/crates/hir_ty/src/primitive.rs
+++ b/crates/hir_ty/src/primitive.rs
@@ -1,7 +1,4 @@
-//! Defines primitive types, which have a couple of peculiarities:
+//! A few helper functions for dealing with primitives.
-//!
-//! * during type inference, they can be uncertain (ie, `let x = 92;`)
-//! * they don't belong to any particular crate.
 pub use chalk_ir::{FloatTy, IntTy, UintTy};
 pub use hir_def::builtin_type::{BuiltinFloat, BuiltinInt, BuiltinUint};
diff --git a/crates/hir_ty/src/tests/macros.rs b/crates/hir_ty/src/tests/macros.rs
index 86e3d8b86..b8e373ed8 100644
--- a/crates/hir_ty/src/tests/macros.rs
+++ b/crates/hir_ty/src/tests/macros.rs
@@ -1065,11 +1065,11 @@ fn macro_in_arm() {
        }
        "#,
        expect![[r#"
+            !0..2 '()': ()
            51..110 '{     ...  }; }': ()
            61..62 'x': u32
            65..107 'match ...     }': u32
            71..73 '()': ()
-            84..91 'unit!()': ()
            95..100 '92u32': u32
        "#]],
    );
diff --git a/crates/hir_ty/src/tests/patterns.rs b/crates/hir_ty/src/tests/patterns.rs
index 85a28e76b..f514b3efe 100644
--- a/crates/hir_ty/src/tests/patterns.rs
+++ b/crates/hir_ty/src/tests/patterns.rs
@@ -1,6 +1,6 @@
 use expect_test::expect;
-use super::{check_infer, check_infer_with_mismatches};
+use super::{check_infer, check_infer_with_mismatches, check_types};
 #[test]
 fn infer_pattern() {
@@ -825,3 +825,29 @@ fn foo(foo: Foo) {
        "#]],
    );
 }
+#[test]
+fn macro_pat() {
+    check_types(
+        r#"
+macro_rules! pat {
+    ($name:ident) => { Enum::Variant1($name) }
+}
+enum Enum {
+    Variant1(u8),
+    Variant2,
+}
+fn f(e: Enum) {
+    match e {
+        pat!(bind) => {
+            bind;
+          //^^^^ u8
+        }
+        Enum::Variant2 => {}
+    }
+}
+    "#,
+    )
+}
diff --git a/crates/hir_ty/src/tests/regression.rs b/crates/hir_ty/src/tests/regression.rs
index b69f86050..9cd9f473d 100644
--- a/crates/hir_ty/src/tests/regression.rs
+++ b/crates/hir_ty/src/tests/regression.rs
@@ -974,3 +974,41 @@ fn param_overrides_fn() {
        "#,
    )
 }
+#[test]
+fn lifetime_from_chalk_during_deref() {
+    check_types(
+        r#"
+        #[lang = "deref"]
+        pub trait Deref {
+            type Target;
+        }
+        struct Box<T: ?Sized> {}
+        impl<T> Deref for Box<T> {
+            type Target = T;
+            fn deref(&self) -> &Self::Target {
+                loop {}
+            }
+        }
+        trait Iterator {
+            type Item;
+        }
+        pub struct Iter<'a, T: 'a> {
+            inner: Box<dyn IterTrait<'a, T, Item = &'a T> + 'a>,
+        }
+        trait IterTrait<'a, T: 'a>: Iterator<Item = &'a T> {
+            fn clone_box(&self);
+        }
+        fn clone_iter<T>(s: Iter<T>) {
+            s.inner.clone_box();
+          //^^^^^^^^^^^^^^^^^^^ ()
+        }
+        "#,
+    )
+}
diff --git a/crates/hir_ty/src/tests/traits.rs b/crates/hir_ty/src/tests/traits.rs
index 65b71fdfa..ffc7c8ef4 100644
--- a/crates/hir_ty/src/tests/traits.rs
+++ b/crates/hir_ty/src/tests/traits.rs
@@ -263,15 +263,14 @@ mod ops {
 fn infer_from_bound_1() {
    check_infer(
        r#"
-        trait Trait<T> {}
+trait Trait<T> {}
-        struct S<T>(T);
+struct S<T>(T);
-        impl<U> Trait<U> for S<U> {}
+impl<U> Trait<U> for S<U> {}
-        fn foo<T: Trait<u32>>(t: T) {}
+fn foo<T: Trait<u32>>(t: T) {}
-        fn test() {
+fn test() {
-            let s = S(unknown);
+    let s = S(unknown);
-            foo(s);
+    foo(s);
-        }
+}"#,
-        "#,
        expect![[r#"
            85..86 't': T
            91..93 '{}': ()
@@ -291,15 +290,14 @@ fn infer_from_bound_1() {
 fn infer_from_bound_2() {
    check_infer(
        r#"
-        trait Trait<T> {}
+trait Trait<T> {}
-        struct S<T>(T);
+struct S<T>(T);
-        impl<U> Trait<U> for S<U> {}
+impl<U> Trait<U> for S<U> {}
-        fn foo<U, T: Trait<U>>(t: T) -> U {}
+fn foo<U, T: Trait<U>>(t: T) -> U {}
-        fn test() {
+fn test() {
-            let s = S(unknown);
+    let s = S(unknown);
-            let x: u32 = foo(s);
+    let x: u32 = foo(s);
-        }
+}"#,
-        "#,
        expect![[r#"
            86..87 't': T
            97..99 '{}': ()
@@ -321,13 +319,12 @@ fn trait_default_method_self_bound_implements_trait() {
    cov_mark::check!(trait_self_implements_self);
    check_infer(
        r#"
-        trait Trait {
+trait Trait {
-            fn foo(&self) -> i64;
+    fn foo(&self) -> i64;
-            fn bar(&self) -> {
+    fn bar(&self) -> {
-                let x = self.foo();
+        let x = self.foo();
-            }
+    }
-        }
+}"#,
-        "#,
        expect![[r#"
            26..30 'self': &Self
            52..56 'self': &Self
@@ -343,15 +340,14 @@ fn trait_default_method_self_bound_implements_trait() {
 fn trait_default_method_self_bound_implements_super_trait() {
    check_infer(
        r#"
-        trait SuperTrait {
+trait SuperTrait {
-            fn foo(&self) -> i64;
+    fn foo(&self) -> i64;
-        }
+}
-        trait Trait: SuperTrait {
+trait Trait: SuperTrait {
-            fn bar(&self) -> {
+    fn bar(&self) -> {
-                let x = self.foo();
+        let x = self.foo();
-            }
+    }
-        }
+}"#,
-        "#,
        expect![[r#"
            31..35 'self': &Self
            85..89 'self': &Self
@@ -367,18 +363,17 @@ fn trait_default_method_self_bound_implements_super_trait() {
 fn infer_project_associated_type() {
    check_infer(
        r#"
-        trait Iterable {
+trait Iterable {
-            type Item;
+    type Item;
-        }
+}
-        struct S;
+struct S;
-        impl Iterable for S { type Item = u32; }
+impl Iterable for S { type Item = u32; }
-        fn test<T: Iterable>() {
+fn test<T: Iterable>() {
-            let x: <S as Iterable>::Item = 1;
+    let x: <S as Iterable>::Item = 1;
-            let y: <T as Iterable>::Item = no_matter;
+    let y: <T as Iterable>::Item = no_matter;
-            let z: T::Item = no_matter;
+    let z: T::Item = no_matter;
-            let a: <T>::Item = no_matter;
+    let a: <T>::Item = no_matter;
-        }
+}"#,
-        "#,
        expect![[r#"
            108..261 '{     ...ter; }': ()
            118..119 'x': u32
@@ -397,20 +392,19 @@ fn infer_project_associated_type() {
 fn infer_return_associated_type() {
    check_infer(
        r#"
-        trait Iterable {
+trait Iterable {
-            type Item;
+    type Item;
-        }
+}
-        struct S;
+struct S;
-        impl Iterable for S { type Item = u32; }
+impl Iterable for S { type Item = u32; }
-        fn foo1<T: Iterable>(t: T) -> T::Item {}
+fn foo1<T: Iterable>(t: T) -> T::Item {}
-        fn foo2<T: Iterable>(t: T) -> <T as Iterable>::Item {}
+fn foo2<T: Iterable>(t: T) -> <T as Iterable>::Item {}
-        fn foo3<T: Iterable>(t: T) -> <T>::Item {}
+fn foo3<T: Iterable>(t: T) -> <T>::Item {}
-        fn test() {
+fn test() {
-            let x = foo1(S);
+    let x = foo1(S);
-            let y = foo2(S);
+    let y = foo2(S);
-            let z = foo3(S);
+    let z = foo3(S);
-        }
+}"#,
-        "#,
        expect![[r#"
            106..107 't': T
            123..125 '{}': ()
@@ -439,13 +433,12 @@ fn infer_return_associated_type() {
 fn infer_associated_type_bound() {
    check_infer(
        r#"
-        trait Iterable {
+trait Iterable {
-            type Item;
+    type Item;
-        }
+}
-        fn test<T: Iterable<Item=u32>>() {
+fn test<T: Iterable<Item=u32>>() {
-            let y: T::Item = unknown;
+    let y: T::Item = unknown;
-        }
+}"#,
-        "#,
        expect![[r#"
            67..100 '{     ...own; }': ()
            77..78 'y': u32
@@ -458,9 +451,8 @@ fn infer_associated_type_bound() {
 fn infer_const_body() {
    check_infer(
        r#"
-        const A: u32 = 1 + 1;
+const A: u32 = 1 + 1;
-        static B: u64 = { let x = 1; x };
+static B: u64 = { let x = 1; x };"#,
-        "#,
        expect![[r#"
            15..16 '1': u32
            15..20 '1 + 1': u32
@@ -477,13 +469,12 @@ fn infer_const_body() {
 fn tuple_struct_fields() {
    check_infer(
        r#"
-        struct S(i32, u64);
+struct S(i32, u64);
-        fn test() -> u64 {
+fn test() -> u64 {
-            let a = S(4, 6);
+    let a = S(4, 6);
-            let b = a.0;
+    let b = a.0;
-            a.1
+    a.1
-        }
+}"#,
-        "#,
        expect![[r#"
            37..86 '{     ... a.1 }': u64
            47..48 'a': S
@@ -504,13 +495,12 @@ fn tuple_struct_fields() {
 fn tuple_struct_with_fn() {
    check_infer(
        r#"
-        struct S(fn(u32) -> u64);
+struct S(fn(u32) -> u64);
-        fn test() -> u64 {
+fn test() -> u64 {
-            let a = S(|i| 2*i);
+    let a = S(|i| 2*i);
-            let b = a.0(4);
+    let b = a.0(4);
-            a.0(2)
+    a.0(2)
-        }
+}"#,
-        "#,
        expect![[r#"
            43..101 '{     ...0(2) }': u64
            53..54 'a': S
@@ -949,27 +939,26 @@ fn test<T: ApplyL>(t: T) {
 fn argument_impl_trait() {
    check_infer_with_mismatches(
        r#"
-        trait Trait<T> {
+trait Trait<T> {
-            fn foo(&self) -> T;
+    fn foo(&self) -> T;
-            fn foo2(&self) -> i64;
+    fn foo2(&self) -> i64;
-        }
+}
-        fn bar(x: impl Trait<u16>) {}
+fn bar(x: impl Trait<u16>) {}
-        struct S<T>(T);
+struct S<T>(T);
-        impl<T> Trait<T> for S<T> {}
+impl<T> Trait<T> for S<T> {}
-        fn test(x: impl Trait<u64>, y: &impl Trait<u32>) {
+fn test(x: impl Trait<u64>, y: &impl Trait<u32>) {
-            x;
+    x;
-            y;
+    y;
-            let z = S(1);
+    let z = S(1);
-            bar(z);
+    bar(z);
-            x.foo();
+    x.foo();
-            y.foo();
+    y.foo();
-            z.foo();
+    z.foo();
-            x.foo2();
+    x.foo2();
-            y.foo2();
+    y.foo2();
-            z.foo2();
+    z.foo2();
-        }
+}"#,
-        "#,
        expect![[r#"
            29..33 'self': &Self
            54..58 'self': &Self
@@ -1007,30 +996,29 @@ fn argument_impl_trait() {
 fn argument_impl_trait_type_args_1() {
    check_infer_with_mismatches(
        r#"
-        trait Trait {}
+trait Trait {}
-        trait Foo {
+trait Foo {
-            // this function has an implicit Self param, an explicit type param,
+    // this function has an implicit Self param, an explicit type param,
-            // and an implicit impl Trait param!
+    // and an implicit impl Trait param!
-            fn bar<T>(x: impl Trait) -> T { loop {} }
+    fn bar<T>(x: impl Trait) -> T { loop {} }
-        }
+}
-        fn foo<T>(x: impl Trait) -> T { loop {} }
+fn foo<T>(x: impl Trait) -> T { loop {} }
-        struct S;
+struct S;
-        impl Trait for S {}
+impl Trait for S {}
-        struct F;
+struct F;
-        impl Foo for F {}
+impl Foo for F {}
-        fn test() {
+fn test() {
-            Foo::bar(S);
+    Foo::bar(S);
-            <F as Foo>::bar(S);
+    <F as Foo>::bar(S);
-            F::bar(S);
+    F::bar(S);
-            Foo::bar::<u32>(S);
+    Foo::bar::<u32>(S);
-            <F as Foo>::bar::<u32>(S);
+    <F as Foo>::bar::<u32>(S);
-            foo(S);
+    foo(S);
-            foo::<u32>(S);
+    foo::<u32>(S);
-            foo::<u32, i32>(S); // we should ignore the extraneous i32
+    foo::<u32, i32>(S); // we should ignore the extraneous i32
-        }
+}"#,
-        "#,
        expect![[r#"
            155..156 'x': impl Trait
            175..186 '{ loop {} }': T
@@ -1073,21 +1061,20 @@ fn argument_impl_trait_type_args_1() {
 fn argument_impl_trait_type_args_2() {
    check_infer_with_mismatches(
        r#"
-        trait Trait {}
+trait Trait {}
-        struct S;
+struct S;
-        impl Trait for S {}
+impl Trait for S {}
-        struct F<T>;
+struct F<T>;
-        impl<T> F<T> {
+impl<T> F<T> {
-            fn foo<U>(self, x: impl Trait) -> (T, U) { loop {} }
+    fn foo<U>(self, x: impl Trait) -> (T, U) { loop {} }
-        }
+}
-        fn test() {
+fn test() {
-            F.foo(S);
+    F.foo(S);
-            F::<u32>.foo(S);
+    F::<u32>.foo(S);
-            F::<u32>.foo::<i32>(S);
+    F::<u32>.foo::<i32>(S);
-            F::<u32>.foo::<i32, u32>(S); // extraneous argument should be ignored
+    F::<u32>.foo::<i32, u32>(S); // extraneous argument should be ignored
-        }
+}"#,
-        "#,
        expect![[r#"
            87..91 'self': F<T>
            93..94 'x': impl Trait
@@ -1115,15 +1102,14 @@ fn argument_impl_trait_type_args_2() {
 fn argument_impl_trait_to_fn_pointer() {
    check_infer_with_mismatches(
        r#"
-        trait Trait {}
+trait Trait {}
-        fn foo(x: impl Trait) { loop {} }
+fn foo(x: impl Trait) { loop {} }
-        struct S;
+struct S;
-        impl Trait for S {}
+impl Trait for S {}
-        fn test() {
+fn test() {
-            let f: fn(S) -> () = foo;
+    let f: fn(S) -> () = foo;
-        }
+}"#,
-        "#,
        expect![[r#"
            22..23 'x': impl Trait
            37..48 '{ loop {} }': ()
@@ -1140,24 +1126,23 @@ fn argument_impl_trait_to_fn_pointer() {
 fn impl_trait() {
    check_infer(
        r#"
-        trait Trait<T> {
+trait Trait<T> {
-            fn foo(&self) -> T;
+    fn foo(&self) -> T;
-            fn foo2(&self) -> i64;
+    fn foo2(&self) -> i64;
-        }
+}
-        fn bar() -> impl Trait<u64> {}
+fn bar() -> impl Trait<u64> {}
-        fn test(x: impl Trait<u64>, y: &impl Trait<u64>) {
+fn test(x: impl Trait<u64>, y: &impl Trait<u64>) {
-            x;
+    x;
-            y;
+    y;
-            let z = bar();
+    let z = bar();
-            x.foo();
+    x.foo();
-            y.foo();
+    y.foo();
-            z.foo();
+    z.foo();
-            x.foo2();
+    x.foo2();
-            y.foo2();
+    y.foo2();
-            z.foo2();
+    z.foo2();
-        }
+}"#,
-        "#,
        expect![[r#"
            29..33 'self': &Self
            54..58 'self': &Self
@@ -1191,16 +1176,15 @@ fn simple_return_pos_impl_trait() {
    cov_mark::check!(lower_rpit);
    check_infer(
        r#"
-        trait Trait<T> {
+trait Trait<T> {
-            fn foo(&self) -> T;
+    fn foo(&self) -> T;
-        }
+}
-        fn bar() -> impl Trait<u64> { loop {} }
+fn bar() -> impl Trait<u64> { loop {} }
-        fn test() {
+fn test() {
-            let a = bar();
+    let a = bar();
-            a.foo();
+    a.foo();
-        }
+}"#,
-        "#,
        expect![[r#"
            29..33 'self': &Self
            71..82 '{ loop {} }': !
@@ -1220,25 +1204,24 @@ fn simple_return_pos_impl_trait() {
 fn more_return_pos_impl_trait() {
    check_infer(
        r#"
-        trait Iterator {
+trait Iterator {
-            type Item;
+    type Item;
-            fn next(&mut self) -> Self::Item;
+    fn next(&mut self) -> Self::Item;
-        }
+}
-        trait Trait<T> {
+trait Trait<T> {
-            fn foo(&self) -> T;
+    fn foo(&self) -> T;
-        }
+}
-        fn bar() -> (impl Iterator<Item = impl Trait<u32>>, impl Trait<u64>) { loop {} }
+fn bar() -> (impl Iterator<Item = impl Trait<u32>>, impl Trait<u64>) { loop {} }
-        fn baz<T>(t: T) -> (impl Iterator<Item = impl Trait<T>>, impl Trait<T>) { loop {} }
+fn baz<T>(t: T) -> (impl Iterator<Item = impl Trait<T>>, impl Trait<T>) { loop {} }
-        fn test() {
+fn test() {
-            let (a, b) = bar();
+    let (a, b) = bar();
-            a.next().foo();
+    a.next().foo();
-            b.foo();
+    b.foo();
-            let (c, d) = baz(1u128);
+    let (c, d) = baz(1u128);
-            c.next().foo();
+    c.next().foo();
-            d.foo();
+    d.foo();
-        }
+}"#,
-        "#,
        expect![[r#"
            49..53 'self': &mut Self
            101..105 'self': &Self
@@ -1279,24 +1262,23 @@ fn more_return_pos_impl_trait() {
 fn dyn_trait() {
    check_infer(
        r#"
-        trait Trait<T> {
+trait Trait<T> {
-            fn foo(&self) -> T;
+    fn foo(&self) -> T;
-            fn foo2(&self) -> i64;
+    fn foo2(&self) -> i64;
-        }
+}
-        fn bar() -> dyn Trait<u64> {}
+fn bar() -> dyn Trait<u64> {}
-        fn test(x: dyn Trait<u64>, y: &dyn Trait<u64>) {
+fn test(x: dyn Trait<u64>, y: &dyn Trait<u64>) {
-            x;
+    x;
-            y;
+    y;
-            let z = bar();
+    let z = bar();
-            x.foo();
+    x.foo();
-            y.foo();
+    y.foo();
-            z.foo();
+    z.foo();
-            x.foo2();
+    x.foo2();
-            y.foo2();
+    y.foo2();
-            z.foo2();
+    z.foo2();
-        }
+}"#,
-        "#,
        expect![[r#"
            29..33 'self': &Self
            54..58 'self': &Self
@@ -1329,22 +1311,21 @@ fn dyn_trait() {
 fn dyn_trait_in_impl() {
    check_infer(
        r#"
-        trait Trait<T, U> {
+trait Trait<T, U> {
-            fn foo(&self) -> (T, U);
+    fn foo(&self) -> (T, U);
-        }
+}
-        struct S<T, U> {}
+struct S<T, U> {}
-        impl<T, U> S<T, U> {
+impl<T, U> S<T, U> {
-            fn bar(&self) -> &dyn Trait<T, U> { loop {} }
+    fn bar(&self) -> &dyn Trait<T, U> { loop {} }
-        }
+}
-        trait Trait2<T, U> {
+trait Trait2<T, U> {
-            fn baz(&self) -> (T, U);
+    fn baz(&self) -> (T, U);
-        }
+}
-        impl<T, U> Trait2<T, U> for dyn Trait<T, U> { }
+impl<T, U> Trait2<T, U> for dyn Trait<T, U> { }
-        fn test(s: S<u32, i32>) {
+fn test(s: S<u32, i32>) {
-            s.bar().baz();
+    s.bar().baz();
-        }
+}"#,
-        "#,
        expect![[r#"
            32..36 'self': &Self
            102..106 'self': &S<T, U>
@@ -1365,20 +1346,19 @@ fn dyn_trait_in_impl() {
 fn dyn_trait_bare() {
    check_infer(
        r#"
-        trait Trait {
+trait Trait {
-            fn foo(&self) -> u64;
+    fn foo(&self) -> u64;
-        }
+}
-        fn bar() -> Trait {}
+fn bar() -> Trait {}
-        fn test(x: Trait, y: &Trait) -> u64 {
+fn test(x: Trait, y: &Trait) -> u64 {