94 files changed, 3174 insertions, 3218 deletions
diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index 1850068a3..0f68b234c 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -76,7 +76,7 @@ jobs:
      run: cargo test --no-run --locked
    - name: Test
-      run: cargo test
+      run: cargo test -- --nocapture
    - name: Prepare cache
      run: cargo xtask pre-cache
diff --git a/Cargo.lock b/Cargo.lock
index bcb1cbd9f..d7e6d3ac8 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -852,9 +852,9 @@ dependencies = [
 [[package]]
 name = "lsp-types"
-version = "0.88.0"
+version = "0.89.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d8e8e042772e4e10b3785822f63c82399d0dd233825de44d2596f7fa86e023e0"
+checksum = "07731ecd4ee0654728359a5b95e2a254c857876c04b85225496a35d60345daa7"
 dependencies = [
 "bitflags",
 "serde",
@@ -1577,9 +1577,9 @@ dependencies = [
 [[package]]
 name = "syn"
-version = "1.0.68"
+version = "1.0.69"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3ce15dd3ed8aa2f8eeac4716d6ef5ab58b6b9256db41d7e1a0224c2788e8fd87"
+checksum = "48fe99c6bd8b1cc636890bcc071842de909d902c81ac7dab53ba33c421ab8ffb"
 dependencies = [
 "proc-macro2",
 "quote",
diff --git a/crates/hir/src/lib.rs b/crates/hir/src/lib.rs
index 0afc06906..eba46a056 100644
--- a/crates/hir/src/lib.rs
+++ b/crates/hir/src/lib.rs
@@ -1580,11 +1580,24 @@ impl Impl {
            ty.equals_ctor(rref.as_ref().map_or(&self_ty.ty, |it| &it.ty))
        };
+        let fp = TyFingerprint::for_inherent_impl(&ty);
+        let fp = if let Some(fp) = fp {
+            fp
+        } else {
+            return Vec::new();
+        };
        let mut all = Vec::new();
        def_crates.iter().for_each(|&id| {
-            all.extend(db.inherent_impls_in_crate(id).all_impls().map(Self::from).filter(filter))
+            all.extend(
+                db.inherent_impls_in_crate(id)
+                    .for_self_ty(&ty)
+                    .into_iter()
+                    .cloned()
+                    .map(Self::from)
+                    .filter(filter),
+            )
        });
-        let fp = TyFingerprint::for_impl(&ty);
        for id in def_crates
            .iter()
            .flat_map(|&id| Crate { id }.transitive_reverse_dependencies(db))
@@ -1592,13 +1605,12 @@ impl Impl {
            .chain(def_crates.iter().copied())
            .unique()
        {
-            match fp {
+            all.extend(
-                Some(fp) => all.extend(
+                db.trait_impls_in_crate(id)
-                    db.trait_impls_in_crate(id).for_self_ty(fp).map(Self::from).filter(filter),
+                    .for_self_ty_without_blanket_impls(fp)
-                ),
+                    .map(Self::from)
-                None => all
+                    .filter(filter),
-                    .extend(db.trait_impls_in_crate(id).all_impls().map(Self::from).filter(filter)),
+            );
-            }
        }
        all
    }
@@ -1825,7 +1837,7 @@ impl Type {
            Solution::Unique(s) => s
                .value
                .subst
-                .interned()
+                .as_slice(&Interner)
                .first()
                .map(|ty| self.derived(ty.assert_ty_ref(&Interner).clone())),
            Solution::Ambig(_) => None,
@@ -1903,7 +1915,9 @@ impl Type {
                | TyKind::Dyn(_)
                | TyKind::Function(_)
                | TyKind::Alias(_)
-                | TyKind::Foreign(_) => false,
+                | TyKind::Foreign(_)
+                | TyKind::Generator(..)
+                | TyKind::GeneratorWitness(..) => false,
            }
        }
    }
diff --git a/crates/hir_def/src/attr.rs b/crates/hir_def/src/attr.rs
index d9df7564d..786fad6e1 100644
--- a/crates/hir_def/src/attr.rs
+++ b/crates/hir_def/src/attr.rs
@@ -9,7 +9,7 @@ use std::{
 use base_db::CrateId;
 use cfg::{CfgExpr, CfgOptions};
 use either::Either;
-use hir_expand::{hygiene::Hygiene, name::AsName, AstId, InFile};
+use hir_expand::{hygiene::Hygiene, name::AsName, AstId, AttrId, InFile};
 use itertools::Itertools;
 use la_arena::ArenaMap;
 use mbe::ast_to_token_tree;
@@ -98,13 +98,16 @@ impl RawAttrs {
    pub(crate) fn new(owner: &dyn ast::AttrsOwner, hygiene: &Hygiene) -> Self {
        let entries = collect_attrs(owner)
            .enumerate()
-            .flat_map(|(i, attr)| match attr {
+            .flat_map(|(i, attr)| {
-                Either::Left(attr) => Attr::from_src(attr, hygiene, i as u32),
+                let index = AttrId(i as u32);
-                Either::Right(comment) => comment.doc_comment().map(|doc| Attr {
+                match attr {
-                    index: i as u32,
+                    Either::Left(attr) => Attr::from_src(attr, hygiene, index),
-                    input: Some(AttrInput::Literal(SmolStr::new(doc))),
+                    Either::Right(comment) => comment.doc_comment().map(|doc| Attr {
-                    path: Interned::new(ModPath::from(hir_expand::name!(doc))),
+                        id: index,
-                }),
+                        input: Some(AttrInput::Literal(SmolStr::new(doc))),
+                        path: Interned::new(ModPath::from(hir_expand::name!(doc))),
+                    }),
+                }
            })
            .collect::<Arc<_>>();
@@ -161,7 +164,7 @@ impl RawAttrs {
                let cfg = parts.next().unwrap();
                let cfg = Subtree { delimiter: subtree.delimiter, token_trees: cfg.to_vec() };
                let cfg = CfgExpr::parse(&cfg);
-                let index = attr.index;
+                let index = attr.id;
                let attrs = parts.filter(|a| !a.is_empty()).filter_map(|attr| {
                    let tree = Subtree { delimiter: None, token_trees: attr.to_vec() };
                    let attr = ast::Attr::parse(&format!("#[{}]", tree)).ok()?;
@@ -468,7 +471,7 @@ impl AttrsWithOwner {
    ) -> Option<(Documentation, DocsRangeMap)> {
        // FIXME: code duplication in `docs` above
        let docs = self.by_key("doc").attrs().flat_map(|attr| match attr.input.as_ref()? {
-            AttrInput::Literal(s) => Some((s, attr.index)),
+            AttrInput::Literal(s) => Some((s, attr.id)),
            AttrInput::TokenTree(_) => None,
        });
        let indent = docs
@@ -560,8 +563,8 @@ impl AttrSourceMap {
    /// the attribute represented by `Attr`.
    pub fn source_of(&self, attr: &Attr) -> InFile<&Either<ast::Attr, ast::Comment>> {
        self.attrs
-            .get(attr.index as usize)
+            .get(attr.id.0 as usize)
-            .unwrap_or_else(|| panic!("cannot find `Attr` at index {}", attr.index))
+            .unwrap_or_else(|| panic!("cannot find `Attr` at index {:?}", attr.id))
            .as_ref()
    }
 }
@@ -572,7 +575,7 @@ pub struct DocsRangeMap {
    // (docstring-line-range, attr_index, attr-string-range)
    // a mapping from the text range of a line of the [`Documentation`] to the attribute index and
    // the original (untrimmed) syntax doc line
-    mapping: Vec<(TextRange, u32, TextRange)>,
+    mapping: Vec<(TextRange, AttrId, TextRange)>,
 }
 impl DocsRangeMap {
@@ -585,7 +588,7 @@ impl DocsRangeMap {
        let relative_range = range - line_docs_range.start();
-        let &InFile { file_id, value: ref source } = &self.source[idx as usize];
+        let &InFile { file_id, value: ref source } = &self.source[idx.0 as usize];
        match source {
            Either::Left(_) => None, // FIXME, figure out a nice way to handle doc attributes here
            // as well as for whats done in syntax highlight doc injection
@@ -606,7 +609,7 @@ impl DocsRangeMap {
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Attr {
-    index: u32,
+    pub(crate) id: AttrId,
    pub(crate) path: Interned<ModPath>,
    pub(crate) input: Option<AttrInput>,
 }
@@ -620,7 +623,7 @@ pub enum AttrInput {
 }
 impl Attr {
-    fn from_src(ast: ast::Attr, hygiene: &Hygiene, index: u32) -> Option<Attr> {
+    fn from_src(ast: ast::Attr, hygiene: &Hygiene, id: AttrId) -> Option<Attr> {
        let path = Interned::new(ModPath::from_src(ast.path()?, hygiene)?);
        let input = if let Some(ast::Expr::Literal(lit)) = ast.expr() {
            let value = match lit.kind() {
@@ -633,7 +636,7 @@ impl Attr {
        } else {
            None
        };
-        Some(Attr { index, path, input })
+        Some(Attr { id, path, input })
    }
    /// Parses this attribute as a `#[derive]`, returns an iterator that yields all contained paths
@@ -748,9 +751,7 @@ fn collect_attrs(
        .chain(inner_docs.into_iter().flatten())
        .map(|docs_text| (docs_text.syntax().text_range().start(), Either::Right(docs_text)));
    // sort here by syntax node offset because the source can have doc attributes and doc strings be interleaved
-    let attrs: Vec<_> = docs.chain(attrs).sorted_by_key(|&(offset, _)| offset).collect();
+    docs.chain(attrs).sorted_by_key(|&(offset, _)| offset).map(|(_, attr)| attr)
-    attrs.into_iter().map(|(_, attr)| attr)
 }
 pub(crate) fn variants_attrs_source_map(
diff --git a/crates/hir_def/src/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 eefc75706..ffee05500 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;
@@ -700,13 +700,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>,
@@ -717,7 +720,11 @@ fn derive_macro_as_call_id(
        .as_lazy_macro(
            db.upcast(),
            krate,
-            MacroCallKind::Derive(item_attr.ast_id, last_segment.to_string()),
+            MacroCallKind::Derive {
+                ast_id: item_attr.ast_id,
+                derive_name: last_segment.to_string(),
+                derive_attr,
+            },
        )
        .into();
    Ok(res)
diff --git a/crates/hir_def/src/nameres.rs b/crates/hir_def/src/nameres.rs
index 7dd68219f..9e181751c 100644
--- a/crates/hir_def/src/nameres.rs
+++ b/crates/hir_def/src/nameres.rs
@@ -613,12 +613,12 @@ mod diagnostics {
                DiagnosticKind::UnresolvedProcMacro { ast } => {
                    let mut precise_location = None;
                    let (file, ast, name) = match ast {
-                        MacroCallKind::FnLike(ast) => {
+                        MacroCallKind::FnLike { ast_id } => {
-                            let node = ast.to_node(db.upcast());
+                            let node = ast_id.to_node(db.upcast());
-                            (ast.file_id, SyntaxNodePtr::from(AstPtr::new(&node)), None)
+                            (ast_id.file_id, SyntaxNodePtr::from(AstPtr::new(&node)), None)
                        }
-                        MacroCallKind::Derive(ast, name) => {
+                        MacroCallKind::Derive { ast_id, derive_name, .. } => {
-                            let node = ast.to_node(db.upcast());
+                            let node = ast_id.to_node(db.upcast());
                            // Compute the precise location of the macro name's token in the derive
                            // list.
@@ -639,7 +639,7 @@ mod diagnostics {
                                    });
                                for token in tokens {
                                    if token.kind() == SyntaxKind::IDENT
-                                        && token.text() == name.as_str()
+                                        && token.text() == derive_name.as_str()
                                    {
                                        precise_location = Some(token.text_range());
                                        break 'outer;
@@ -648,9 +648,9 @@ mod diagnostics {
                            }
                            (
-                                ast.file_id,
+                                ast_id.file_id,
                                SyntaxNodePtr::from(AstPtr::new(&node)),
-                                Some(name.clone()),
+                                Some(derive_name.clone()),
                            )
                        }
                    };
@@ -669,13 +669,13 @@ mod diagnostics {
                DiagnosticKind::MacroError { ast, message } => {
                    let (file, ast) = match ast {
-                        MacroCallKind::FnLike(ast) => {
+                        MacroCallKind::FnLike { ast_id, .. } => {
-                            let node = ast.to_node(db.upcast());
+                            let node = ast_id.to_node(db.upcast());
-                            (ast.file_id, SyntaxNodePtr::from(AstPtr::new(&node)))
+                            (ast_id.file_id, SyntaxNodePtr::from(AstPtr::new(&node)))
                        }
-                        MacroCallKind::Derive(ast, _) => {
+                        MacroCallKind::Derive { ast_id, .. } => {
-                            let node = ast.to_node(db.upcast());
+                            let node = ast_id.to_node(db.upcast());
-                            (ast.file_id, SyntaxNodePtr::from(AstPtr::new(&node)))
+                            (ast_id.file_id, SyntaxNodePtr::from(AstPtr::new(&node)))
                        }
                    };
                    sink.push(MacroError { file, node: ast, message: message.clone() });
diff --git a/crates/hir_def/src/nameres/collector.rs b/crates/hir_def/src/nameres/collector.rs
index 492d8c71f..fb4ddff5e 100644
--- a/crates/hir_def/src/nameres/collector.rs
+++ b/crates/hir_def/src/nameres/collector.rs
@@ -13,7 +13,7 @@ use hir_expand::{
    builtin_macro::find_builtin_macro,
    name::{AsName, Name},
    proc_macro::ProcMacroExpander,
-    HirFileId, MacroCallId, MacroCallKind, MacroDefId, MacroDefKind,
+    AttrId, HirFileId, MacroCallId, MacroCallKind, MacroDefId, MacroDefKind,
 };
 use hir_expand::{InFile, MacroCallLoc};
 use rustc_hash::{FxHashMap, FxHashSet};
@@ -216,7 +216,7 @@ struct MacroDirective {
 #[derive(Clone, Debug, Eq, PartialEq)]
 enum MacroDirectiveKind {
    FnLike { ast_id: AstIdWithPath<ast::MacroCall> },
-    Derive { ast_id: AstIdWithPath<ast::Item> },
+    Derive { ast_id: AstIdWithPath<ast::Item>, derive_attr: AttrId },
 }
 struct DefData<'a> {
@@ -478,7 +478,7 @@ impl DefCollector<'_> {
            self.def_map.edition,
        );
-        let res = self.def_map.resolve_name_in_extern_prelude(&extern_crate.name);
+        let res = self.def_map.resolve_name_in_extern_prelude(self.db, &extern_crate.name);
        if let Some(ModuleDefId::ModuleId(m)) = res.take_types() {
            cov_mark::hit!(macro_rules_from_other_crates_are_visible_with_macro_use);
@@ -534,6 +534,7 @@ impl DefCollector<'_> {
        log::debug!("resolving import: {:?} ({:?})", import, self.def_map.edition);
        if import.is_extern_crate {
            let res = self.def_map.resolve_name_in_extern_prelude(
+                self.db,
                &import
                    .path
                    .as_ident()
@@ -831,12 +832,16 @@ impl DefCollector<'_> {
                        Err(UnresolvedMacro) | Ok(Err(_)) => {}
                    }
                }
-                MacroDirectiveKind::Derive { ast_id } => {
+                MacroDirectiveKind::Derive { ast_id, derive_attr } => {
-                    match derive_macro_as_call_id(ast_id, self.db, self.def_map.krate, |path| {
+                    match derive_macro_as_call_id(
-                        self.resolve_derive_macro(directive.module_id, &path)
+                        ast_id,
-                    }) {
+                        *derive_attr,
+                        self.db,
+                        self.def_map.krate,
+                        |path| self.resolve_derive_macro(directive.module_id, &path),
+                    ) {
                        Ok(call_id) => {
-                            resolved.push((directive.module_id, call_id, 0));
+                            resolved.push((directive.module_id, call_id, directive.depth));
                            res = ReachedFixedPoint::No;
                            return false;
                        }
@@ -1368,7 +1373,7 @@ impl ModCollector<'_, '_> {
                        self.def_collector.unexpanded_macros.push(MacroDirective {
                            module_id: self.module_id,
                            depth: self.macro_depth + 1,
-                            kind: MacroDirectiveKind::Derive { ast_id },
+                            kind: MacroDirectiveKind::Derive { ast_id, derive_attr: derive.id },
                        });
                    }
                }
@@ -1520,7 +1525,7 @@ impl ModCollector<'_, '_> {
                // Built-in macro failed eager expansion.
                self.def_collector.def_map.diagnostics.push(DefDiagnostic::macro_error(
                    self.module_id,
-                    MacroCallKind::FnLike(ast_id.ast_id),
+                    MacroCallKind::FnLike { ast_id: ast_id.ast_id },
                    error.unwrap().to_string(),
                ));
                return;
diff --git a/crates/hir_def/src/nameres/path_resolution.rs b/crates/hir_def/src/nameres/path_resolution.rs
index 60471937c..ccc9f22eb 100644
--- a/crates/hir_def/src/nameres/path_resolution.rs
+++ b/crates/hir_def/src/nameres/path_resolution.rs
@@ -60,12 +60,26 @@ impl ResolvePathResult {
 }
 impl DefMap {
-    pub(super) fn resolve_name_in_extern_prelude(&self, name: &Name) -> PerNs {
+    pub(super) fn resolve_name_in_extern_prelude(
+        &self,
+        db: &dyn DefDatabase,
+        name: &Name,
+    ) -> PerNs {
        if name == &name!(self) {
            cov_mark::hit!(extern_crate_self_as);
            return PerNs::types(self.module_id(self.root).into(), Visibility::Public);
        }
-        self.extern_prelude
+        let arc;
+        let root = match self.block {
+            Some(_) => {
+                arc = self.crate_root(db).def_map(db);
+                &*arc
+            }
+            None => self,
+        };
+        root.extern_prelude
            .get(name)
            .map_or(PerNs::none(), |&it| PerNs::types(it, Visibility::Public))
    }
@@ -191,7 +205,7 @@ impl DefMap {
                    None => return ResolvePathResult::empty(ReachedFixedPoint::Yes),
                };
                log::debug!("resolving {:?} in crate root (+ extern prelude)", segment);
-                self.resolve_name_in_crate_root_or_extern_prelude(&segment)
+                self.resolve_name_in_crate_root_or_extern_prelude(db, &segment)
            }
            PathKind::Plain => {
                let (_, segment) = match segments.next() {
@@ -384,24 +398,31 @@ impl DefMap {
                }
            }
        };
-        // Give precedence to names in outer `DefMap`s over the extern prelude; only check prelude
+        let from_extern_prelude = self
-        // from the crate DefMap.
+            .extern_prelude
-        let from_extern_prelude = match self.block {
+            .get(name)
-            Some(_) => PerNs::none(),
+            .map_or(PerNs::none(), |&it| PerNs::types(it, Visibility::Public));
-            None => self
-                .extern_prelude
-                .get(name)
-                .map_or(PerNs::none(), |&it| PerNs::types(it, Visibility::Public)),
-        };
        let from_prelude = self.resolve_in_prelude(db, name);
        from_legacy_macro.or(from_scope_or_builtin).or(from_extern_prelude).or(from_prelude)
    }
-    fn resolve_name_in_crate_root_or_extern_prelude(&self, name: &Name) -> PerNs {
+    fn resolve_name_in_crate_root_or_extern_prelude(
-        let from_crate_root = self[self.root].scope.get(name);
+        &self,
-        let from_extern_prelude = self.resolve_name_in_extern_prelude(name);
+        db: &dyn DefDatabase,
+        name: &Name,
+    ) -> PerNs {
+        let arc;
+        let crate_def_map = match self.block {
+            Some(_) => {
+                arc = self.crate_root(db).def_map(db);
+                &arc
+            }
+            None => self,
+        };
+        let from_crate_root = crate_def_map[crate_def_map.root].scope.get(name);
+        let from_extern_prelude = self.resolve_name_in_extern_prelude(db, name);
        from_crate_root.or(from_extern_prelude)
    }
diff --git a/crates/hir_expand/src/builtin_derive.rs b/crates/hir_expand/src/builtin_derive.rs
index 6ece4b289..537c03028 100644
--- a/crates/hir_expand/src/builtin_derive.rs
+++ b/crates/hir_expand/src/builtin_derive.rs
@@ -269,7 +269,7 @@ mod tests {
    use expect_test::{expect, Expect};
    use name::AsName;
-    use crate::{test_db::TestDB, AstId, MacroCallId, MacroCallKind, MacroCallLoc};
+    use crate::{test_db::TestDB, AstId, AttrId, MacroCallId, MacroCallKind, MacroCallLoc};
    use super::*;
@@ -308,7 +308,7 @@ $0
        let expander = BuiltinDeriveExpander::find_by_name(&name).unwrap();
-        let attr_id = AstId::new(file_id.into(), ast_id_map.ast_id(&items[0]));
+        let ast_id = AstId::new(file_id.into(), ast_id_map.ast_id(&items[0]));
        let loc = MacroCallLoc {
            def: MacroDefId {
@@ -317,7 +317,11 @@ $0
                local_inner: false,
            },
            krate: CrateId(0),
-            kind: MacroCallKind::Derive(attr_id, name.to_string()),
+            kind: MacroCallKind::Derive {
+                ast_id,
+                derive_name: name.to_string(),
+                derive_attr: AttrId(0),
+            },
        };
        let id: MacroCallId = db.intern_macro(loc).into();
diff --git a/crates/hir_expand/src/builtin_macro.rs b/crates/hir_expand/src/builtin_macro.rs
index a7d0f5b1f..80365fc16 100644
--- a/crates/hir_expand/src/builtin_macro.rs
+++ b/crates/hir_expand/src/builtin_macro.rs
@@ -566,10 +566,9 @@ mod tests {
                let loc = MacroCallLoc {
                    def,
                    krate,
-                    kind: MacroCallKind::FnLike(AstId::new(
+                    kind: MacroCallKind::FnLike {
-                        file_id.into(),
+                        ast_id: AstId::new(file_id.into(), ast_id_map.ast_id(&macro_call)),
-                        ast_id_map.ast_id(&macro_call),
+                    },
-                    )),
                };
                let id: MacroCallId = db.intern_macro(loc).into();
diff --git a/crates/hir_expand/src/db.rs b/crates/hir_expand/src/db.rs
index 10fe60821..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/builder.rs b/crates/hir_ty/src/builder.rs
index 09512d1ce..e25ef866d 100644
--- a/crates/hir_ty/src/builder.rs
+++ b/crates/hir_ty/src/builder.rs
@@ -4,6 +4,7 @@ use std::iter;
 use chalk_ir::{
    cast::{Cast, CastTo, Caster},
+    fold::Fold,
    interner::HasInterner,
    AdtId, BoundVar, DebruijnIndex, Safety, Scalar,
 };
@@ -13,7 +14,7 @@ use smallvec::SmallVec;
 use crate::{
    db::HirDatabase, primitive, to_assoc_type_id, to_chalk_trait_id, utils::generics, Binders,
    CallableSig, FnPointer, FnSig, FnSubst, GenericArg, Interner, ProjectionTy, Substitution,
-    TraitRef, Ty, TyDefId, TyExt, TyKind, TypeWalk, ValueTyDefId,
+    TraitRef, Ty, TyDefId, TyExt, TyKind, ValueTyDefId,
 };
 /// This is a builder for `Ty` or anything that needs a `Substitution`.
@@ -32,8 +33,7 @@ impl<D> TyBuilder<D> {
    fn build_internal(self) -> (D, Substitution) {
        assert_eq!(self.vec.len(), self.param_count);
-        // FIXME: would be good to have a way to construct a chalk_ir::Substitution from the interned form
+        let subst = Substitution::from_iter(&Interner, self.vec);
-        let subst = Substitution::intern(self.vec);
        (self.data, subst)
    }
@@ -141,7 +141,7 @@ impl TyBuilder<hir_def::AdtId> {
                self.vec.push(fallback().cast(&Interner));
            } else {
                // each default can depend on the previous parameters
-                let subst_so_far = Substitution::intern(self.vec.clone());
+                let subst_so_far = Substitution::from_iter(&Interner, self.vec.clone());
                self.vec
                    .push(default_ty.clone().substitute(&Interner, &subst_so_far).cast(&Interner));
            }
@@ -196,13 +196,13 @@ impl TyBuilder<TypeAliasId> {
    }
 }
-impl<T: TypeWalk + HasInterner<Interner = Interner>> TyBuilder<Binders<T>> {
+impl<T: HasInterner<Interner = Interner> + Fold<Interner>> TyBuilder<Binders<T>> {
    fn subst_binders(b: Binders<T>) -> Self {
        let param_count = b.binders.len(&Interner);
        TyBuilder::new(b, param_count)
    }
-    pub fn build(self) -> T {
+    pub fn build(self) -> <T as Fold<Interner>>::Result {
        let (b, subst) = self.build_internal();
        b.substitute(&Interner, &subst)
    }
diff --git a/crates/hir_ty/src/chalk_cast.rs b/crates/hir_ty/src/chalk_cast.rs
deleted file mode 100644
index df6492113..000000000
--- a/crates/hir_ty/src/chalk_cast.rs
+++ /dev/null
@@ -1,73 +0,0 @@
-//! Implementations of the Chalk `Cast` trait for our types.
-use chalk_ir::{
-    cast::{Cast, CastTo},
-    interner::HasInterner,
-};
-use crate::{AliasEq, DomainGoal, GenericArg, GenericArgData, Interner, TraitRef, Ty, WhereClause};
-macro_rules! has_interner {
-    ($t:ty) => {
-        impl HasInterner for $t {
-            type Interner = crate::Interner;
-        }
-    };
-}
-has_interner!(WhereClause);
-has_interner!(DomainGoal);
-has_interner!(GenericArg);
-has_interner!(Ty);
-impl CastTo<WhereClause> for TraitRef {
-    fn cast_to(self, _interner: &Interner) -> WhereClause {
-        WhereClause::Implemented(self)
-    }
-}
-impl CastTo<WhereClause> for AliasEq {
-    fn cast_to(self, _interner: &Interner) -> WhereClause {
-        WhereClause::AliasEq(self)
-    }
-}
-impl CastTo<DomainGoal> for WhereClause {
-    fn cast_to(self, _interner: &Interner) -> DomainGoal {
-        DomainGoal::Holds(self)
-    }
-}
-impl CastTo<GenericArg> for Ty {
-    fn cast_to(self, interner: &Interner) -> GenericArg {
-        GenericArg::new(interner, GenericArgData::Ty(self))
-    }
-}
-macro_rules! transitive_impl {
-    ($a:ty, $b:ty, $c:ty) => {
-        impl CastTo<$c> for $a {
-            fn cast_to(self, interner: &Interner) -> $c {
-                self.cast::<$b>(interner).cast(interner)
-            }
-        }
-    };
-}
-// In Chalk, these can be done as blanket impls, but that doesn't work here
-// because of coherence
-transitive_impl!(TraitRef, WhereClause, DomainGoal);
-transitive_impl!(AliasEq, WhereClause, DomainGoal);
-macro_rules! reflexive_impl {
-    ($a:ty) => {
-        impl CastTo<$a> for $a {
-            fn cast_to(self, _interner: &Interner) -> $a {
-                self
-            }
-        }
-    };
-}
-reflexive_impl!(GenericArg);
diff --git a/crates/hir_ty/src/traits/chalk.rs b/crates/hir_ty/src/chalk_db.rs
index 090f6492b..8f054d06b 100644
--- a/crates/hir_ty/src/traits/chalk.rs
+++ b/crates/hir_ty/src/chalk_db.rs
@@ -1,52 +1,47 @@
-//! Conversion code from/to Chalk.
+//! The implementation of `RustIrDatabase` for Chalk, which provides information
+//! about the code that Chalk needs.
 use std::sync::Arc;
 use log::debug;
-use chalk_ir::{fold::shift::Shift, CanonicalVarKinds};
+use chalk_ir::{cast::Cast, fold::shift::Shift, CanonicalVarKinds};
 use chalk_solve::rust_ir::{self, OpaqueTyDatumBound, WellKnownTrait};
-use base_db::{salsa::InternKey, CrateId};
+use base_db::CrateId;
 use hir_def::{
    lang_item::{lang_attr, LangItemTarget},
-    AssocContainerId, AssocItemId, HasModule, Lookup, TypeAliasId,
+    AssocContainerId, AssocItemId, GenericDefId, HasModule, Lookup, TypeAliasId,
 };
 use hir_expand::name::name;
-use super::ChalkContext;
 use crate::{
    db::HirDatabase,
    display::HirDisplay,
-    from_assoc_type_id,
+    from_assoc_type_id, from_chalk_trait_id, make_only_type_binders,
+    mapping::{from_chalk, ToChalk, TypeAliasAsValue},
    method_resolution::{TyFingerprint, ALL_FLOAT_FPS, ALL_INT_FPS},
    to_assoc_type_id, to_chalk_trait_id,
+    traits::ChalkContext,
    utils::generics,
-    AliasEq, AliasTy, BoundVar, CallableDefId, DebruijnIndex, FnDefId, ProjectionTy, Substitution,
+    AliasEq, AliasTy, BoundVar, CallableDefId, DebruijnIndex, FnDefId, Interner, ProjectionTy,
-    TraitRef, TraitRefExt, Ty, TyBuilder, TyExt, TyKind, WhereClause,
+    ProjectionTyExt, QuantifiedWhereClause, Substitution, TraitRef, TraitRefExt, Ty, TyBuilder,
+    TyExt, TyKind, WhereClause,
 };
-use mapping::{
-    convert_where_clauses, generic_predicate_to_inline_bound, make_binders, TypeAliasAsValue,
-};
-pub use self::interner::Interner;
-pub(crate) use self::interner::*;
-pub(super) mod tls;
-mod interner;
-mod mapping;
-pub(crate) trait ToChalk {
-    type Chalk;
-    fn to_chalk(self, db: &dyn HirDatabase) -> Self::Chalk;
-    fn from_chalk(db: &dyn HirDatabase, chalk: Self::Chalk) -> Self;
-}
-pub(crate) fn from_chalk<T, ChalkT>(db: &dyn HirDatabase, chalk: ChalkT) -> T
+pub(crate) type AssociatedTyDatum = chalk_solve::rust_ir::AssociatedTyDatum<Interner>;
-where
+pub(crate) type TraitDatum = chalk_solve::rust_ir::TraitDatum<Interner>;
-    T: ToChalk<Chalk = ChalkT>,
+pub(crate) type StructDatum = chalk_solve::rust_ir::AdtDatum<Interner>;
-{
+pub(crate) type ImplDatum = chalk_solve::rust_ir::ImplDatum<Interner>;
-    T::from_chalk(db, chalk)
+pub(crate) type OpaqueTyDatum = chalk_solve::rust_ir::OpaqueTyDatum<Interner>;
-}
+pub(crate) type AssocTypeId = chalk_ir::AssocTypeId<Interner>;
+pub(crate) type TraitId = chalk_ir::TraitId<Interner>;
+pub(crate) type AdtId = chalk_ir::AdtId<Interner>;
+pub(crate) type ImplId = chalk_ir::ImplId<Interner>;
+pub(crate) type AssociatedTyValueId = chalk_solve::rust_ir::AssociatedTyValueId<Interner>;
+pub(crate) type AssociatedTyValue = chalk_solve::rust_ir::AssociatedTyValue<Interner>;
+pub(crate) type FnDefDatum = chalk_solve::rust_ir::FnDefDatum<Interner>;
+pub(crate) type Variances = chalk_ir::Variances<Interner>;
 impl<'a> chalk_solve::RustIrDatabase<Interner> for ChalkContext<'a> {
    fn associated_ty_data(&self, id: AssocTypeId) -> Arc<AssociatedTyDatum> {
@@ -84,9 +79,9 @@ impl<'a> chalk_solve::RustIrDatabase<Interner> for ChalkContext<'a> {
        binders: &CanonicalVarKinds<Interner>,
    ) -> Vec<ImplId> {
        debug!("impls_for_trait {:?}", trait_id);
-        let trait_: hir_def::TraitId = from_chalk(self.db, trait_id);
+        let trait_: hir_def::TraitId = from_chalk_trait_id(trait_id);
-        let ty: Ty = from_chalk(self.db, parameters[0].assert_ty_ref(&Interner).clone());
+        let ty: Ty = parameters[0].assert_ty_ref(&Interner).clone();
        fn binder_kind(
            ty: &Ty,
@@ -103,7 +98,7 @@ impl<'a> chalk_solve::RustIrDatabase<Interner> for ChalkContext<'a> {
            None
        }
-        let self_ty_fp = TyFingerprint::for_impl(&ty);
+        let self_ty_fp = TyFingerprint::for_trait_impl(&ty);
        let fps: &[TyFingerprint] = match binder_kind(&ty, binders) {
            Some(chalk_ir::TyVariableKind::Integer) => &ALL_INT_FPS,
            Some(chalk_ir::TyVariableKind::Float) => &ALL_FLOAT_FPS,
@@ -166,7 +161,7 @@ impl<'a> chalk_solve::RustIrDatabase<Interner> for ChalkContext<'a> {
            Some(LangItemTarget::TraitId(trait_)) => trait_,
            _ => return None,
        };
-        Some(trait_.to_chalk(self.db))
+        Some(to_chalk_trait_id(trait_))
    }
    fn program_clauses_for_env(
@@ -187,16 +182,11 @@ impl<'a> chalk_solve::RustIrDatabase<Interner> for ChalkContext<'a> {
                let (datas, binders) = (*datas).as_ref().into_value_and_skipped_binders();
                let data = &datas.impl_traits[idx as usize];
                let bound = OpaqueTyDatumBound {
-                    bounds: make_binders(
+                    bounds: make_only_type_binders(
-                        data.bounds
-                            .skip_binders()
-                            .iter()
-                            .cloned()
-                            .map(|b| b.to_chalk(self.db))
-                            .collect(),
                        1,
+                        data.bounds.skip_binders().iter().cloned().collect(),
                    ),
-                    where_clauses: make_binders(vec![], 0),
+                    where_clauses: make_only_type_binders(0, vec![]),
                };
                chalk_ir::Binders::new(binders, bound)
            }
@@ -244,25 +234,25 @@ impl<'a> chalk_solve::RustIrDatabase<Interner> for ChalkContext<'a> {
                            .intern(&Interner),
                    });
                    let bound = OpaqueTyDatumBound {
-                        bounds: make_binders(
+                        bounds: make_only_type_binders(
+                            1,
                            vec![
-                                crate::wrap_empty_binders(impl_bound).to_chalk(self.db),
+                                crate::wrap_empty_binders(impl_bound),
-                                crate::wrap_empty_binders(proj_bound).to_chalk(self.db),
+                                crate::wrap_empty_binders(proj_bound),
                            ],
-                            1,
                        ),
-                        where_clauses: make_binders(vec![], 0),
+                        where_clauses: make_only_type_binders(0, vec![]),
                    };
                    // The opaque type has 1 parameter.
-                    make_binders(bound, 1)
+                    make_only_type_binders(1, bound)
                } else {
                    // If failed to find Symbol’s value as variable is void: Future::Output, return empty bounds as fallback.
                    let bound = OpaqueTyDatumBound {
-                        bounds: make_binders(vec![], 0),
+                        bounds: make_only_type_binders(0, vec![]),
-                        where_clauses: make_binders(vec![], 0),
+                        where_clauses: make_only_type_binders(0, vec![]),
                    };
                    // The opaque type has 1 parameter.
-                    make_binders(bound, 1)
+                    make_only_type_binders(1, bound)
                }
            }
        };
@@ -272,7 +262,7 @@ impl<'a> chalk_solve::RustIrDatabase<Interner> for ChalkContext<'a> {
    fn hidden_opaque_type(&self, _id: chalk_ir::OpaqueTyId<Interner>) -> chalk_ir::Ty<Interner> {
        // FIXME: actually provide the hidden type; it is relevant for auto traits
-        TyKind::Error.intern(&Interner).to_chalk(self.db)
+        TyKind::Error.intern(&Interner)
    }
    fn is_object_safe(&self, _trait_id: chalk_ir::TraitId<Interner>) -> bool {
@@ -293,33 +283,32 @@ impl<'a> chalk_solve::RustIrDatabase<Interner> for ChalkContext<'a> {
        _closure_id: chalk_ir::ClosureId<Interner>,
        substs: &chalk_ir::Substitution<Interner>,
    ) -> chalk_ir::Binders<rust_ir::FnDefInputsAndOutputDatum<Interner>> {
-        let sig_ty: Ty =
+        let sig_ty = substs.at(&Interner, 0).assert_ty_ref(&Interner).clone();
-            from_chalk(self.db, substs.at(&Interner, 0).assert_ty_ref(&Interner).clone());
        let sig = &sig_ty.callable_sig(self.db).expect("first closure param should be fn ptr");
        let io = rust_ir::FnDefInputsAndOutputDatum {
-            argument_types: sig.params().iter().map(|ty| ty.clone().to_chalk(self.db)).collect(),
+            argument_types: sig.params().iter().cloned().collect(),
-            return_type: sig.ret().clone().to_chalk(self.db),
+            return_type: sig.ret().clone(),
        };
-        make_binders(io.shifted_in(&Interner), 0)
+        make_only_type_binders(0, io.shifted_in(&Interner))
    }
    fn closure_upvars(
        &self,
        _closure_id: chalk_ir::ClosureId<Interner>,
        _substs: &chalk_ir::Substitution<Interner>,
    ) -> chalk_ir::Binders<chalk_ir::Ty<Interner>> {
-        let ty = TyBuilder::unit().to_chalk(self.db);
+        let ty = TyBuilder::unit();
-        make_binders(ty, 0)
+        make_only_type_binders(0, ty)
    }
    fn closure_fn_substitution(
        &self,
        _closure_id: chalk_ir::ClosureId<Interner>,
        _substs: &chalk_ir::Substitution<Interner>,
    ) -> chalk_ir::Substitution<Interner> {
-        Substitution::empty(&Interner).to_chalk(self.db)
+        Substitution::empty(&Interner)
    }
    fn trait_name(&self, trait_id: chalk_ir::TraitId<Interner>) -> String {
-        let id = from_chalk(self.db, trait_id);
+        let id = from_chalk_trait_id(trait_id);
        self.db.trait_data(id).name.to_string()
    }
    fn adt_name(&self, chalk_ir::AdtId(adt_id): AdtId) -> String {
@@ -410,10 +399,10 @@ pub(crate) fn associated_ty_data_query(
    let where_clauses = convert_where_clauses(db, type_alias.into(), &bound_vars);
    let bound_data = rust_ir::AssociatedTyDatumBound { bounds, where_clauses };
    let datum = AssociatedTyDatum {
-        trait_id: trait_.to_chalk(db),
+        trait_id: to_chalk_trait_id(trait_),
        id,
        name: type_alias,
-        binders: make_binders(bound_data, generic_params.len()),
+        binders: make_only_type_binders(generic_params.len(), bound_data),
    };
    Arc::new(datum)
 }
@@ -424,7 +413,7 @@ pub(crate) fn trait_datum_query(
    trait_id: TraitId,
 ) -> Arc<TraitDatum> {
    debug!("trait_datum {:?}", trait_id);
-    let trait_: hir_def::TraitId = from_chalk(db, trait_id);
+    let trait_ = from_chalk_trait_id(trait_id);
    let trait_data = db.trait_data(trait_);
    debug!("trait {:?} = {:?}", trait_id, trait_data.name);
    let generic_params = generics(db.upcast(), trait_.into());
@@ -446,7 +435,7 @@ pub(crate) fn trait_datum_query(
        lang_attr(db.upcast(), trait_).and_then(|name| well_known_trait_from_lang_attr(&name));
    let trait_datum = TraitDatum {
        id: trait_id,
-        binders: make_binders(trait_datum_bound, bound_vars.len(&Interner)),
+        binders: make_only_type_binders(bound_vars.len(&Interner), trait_datum_bound),
        flags,
        associated_ty_ids,
        well_known,
@@ -515,7 +504,7 @@ pub(crate) fn struct_datum_query(
        // FIXME set ADT kind
        kind: rust_ir::AdtKind::Struct,
        id: struct_id,
-        binders: make_binders(struct_datum_bound, num_params),
+        binders: make_only_type_binders(num_params, struct_datum_bound),
        flags,
    };
    Arc::new(struct_datum)
@@ -563,7 +552,6 @@ fn impl_def_datum(
        trait_ref.display(db),
        where_clauses
    );
-    let trait_ref = trait_ref.to_chalk(db);
    let polarity = if negative { rust_ir::Polarity::Negative } else { rust_ir::Polarity::Positive };
@@ -585,7 +573,7 @@ fn impl_def_datum(
        .collect();
    debug!("impl_datum: {:?}", impl_datum_bound);
    let impl_datum = ImplDatum {
-        binders: make_binders(impl_datum_bound, bound_vars.len(&Interner)),
+        binders: make_only_type_binders(bound_vars.len(&Interner), impl_datum_bound),
        impl_type,
        polarity,
        associated_ty_value_ids,
@@ -624,7 +612,7 @@ fn type_alias_associated_ty_value(
        .associated_type_by_name(&type_alias_data.name)
        .expect("assoc ty value should not exist"); // validated when building the impl data as well
    let (ty, binders) = db.ty(type_alias.into()).into_value_and_skipped_binders();
-    let value_bound = rust_ir::AssociatedTyValueBound { ty: ty.to_chalk(db) };
+    let value_bound = rust_ir::AssociatedTyValueBound { ty };
    let value = rust_ir::AssociatedTyValue {
        impl_id: impl_id.to_chalk(db),
        associated_ty_id: to_assoc_type_id(assoc_ty),
@@ -645,13 +633,13 @@ pub(crate) fn fn_def_datum_query(
    let where_clauses = convert_where_clauses(db, callable_def.into(), &bound_vars);
    let bound = rust_ir::FnDefDatumBound {
        // Note: Chalk doesn't actually use this information yet as far as I am aware, but we provide it anyway
-        inputs_and_output: make_binders(
+        inputs_and_output: make_only_type_binders(
+            0,
            rust_ir::FnDefInputsAndOutputDatum {
-                argument_types: sig.params().iter().map(|ty| ty.clone().to_chalk(db)).collect(),
+                argument_types: sig.params().iter().cloned().collect(),
-                return_type: sig.ret().clone().to_chalk(db),
+                return_type: sig.ret().clone(),
            }
            .shifted_in(&Interner),
-            0,
        ),
        where_clauses,
    };
@@ -688,38 +676,65 @@ pub(crate) fn adt_variance_query(
    )
 }
-impl From<FnDefId> for crate::db::InternedCallableDefId {
+pub(super) fn convert_where_clauses(
-    fn from(fn_def_id: FnDefId) -> Self {
+    db: &dyn HirDatabase,
-        InternKey::from_intern_id(fn_def_id.0)
+    def: GenericDefId,
-    }
+    substs: &Substitution,
-}
+) -> Vec<chalk_ir::QuantifiedWhereClause<Interner>> {
+    let generic_predicates = db.generic_predicates(def);
-impl From<crate::db::InternedCallableDefId> for FnDefId {
+    let mut result = Vec::with_capacity(generic_predicates.len());
-    fn from(callable_def_id: crate::db::InternedCallableDefId) -> Self {
+    for pred in generic_predicates.iter() {
-        chalk_ir::FnDefId(callable_def_id.as_intern_id())
+        result.push(pred.clone().substitute(&Interner, substs));
-    }
+    }
-}
+    result
-impl From<OpaqueTyId> for crate::db::InternedOpaqueTyId {
-    fn from(id: OpaqueTyId) -> Self {
-        InternKey::from_intern_id(id.0)
-    }
-}
-impl From<crate::db::InternedOpaqueTyId> for OpaqueTyId {
-    fn from(id: crate::db::InternedOpaqueTyId) -> Self {
-        chalk_ir::OpaqueTyId(id.as_intern_id())
-    }
-}
-impl From<chalk_ir::ClosureId<Interner>> for crate::db::InternedClosureId {
-    fn from(id: chalk_ir::ClosureId<Interner>) -> Self {
-        Self::from_intern_id(id.0)
-    }
 }
-impl From<crate::db::InternedClosureId> for chalk_ir::ClosureId<Interner> {
+pub(super) fn generic_predicate_to_inline_bound(
-    fn from(id: crate::db::InternedClosureId) -> Self {
+    db: &dyn HirDatabase,
-        chalk_ir::ClosureId(id.as_intern_id())
+    pred: &QuantifiedWhereClause,
+    self_ty: &Ty,
+) -> Option<chalk_ir::Binders<rust_ir::InlineBound<Interner>>> {
+    // An InlineBound is like a GenericPredicate, except the self type is left out.
+    // We don't have a special type for this, but Chalk does.
+    let self_ty_shifted_in = self_ty.clone().shifted_in_from(&Interner, DebruijnIndex::ONE);
+    let (pred, binders) = pred.as_ref().into_value_and_skipped_binders();
+    match pred {
+        WhereClause::Implemented(trait_ref) => {
+            if trait_ref.self_type_parameter(&Interner) != self_ty_shifted_in {
+                // we can only convert predicates back to type bounds if they
+                // have the expected self type
+                return None;
+            }
+            let args_no_self = trait_ref.substitution.as_slice(&Interner)[1..]
+                .iter()
+                .map(|ty| ty.clone().cast(&Interner))
+                .collect();
+            let trait_bound = rust_ir::TraitBound { trait_id: trait_ref.trait_id, args_no_self };
+            Some(chalk_ir::Binders::new(binders, rust_ir::InlineBound::TraitBound(trait_bound)))
+        }
+        WhereClause::AliasEq(AliasEq { alias: AliasTy::Projection(projection_ty), ty }) => {
+            if projection_ty.self_type_parameter(&Interner) != self_ty_shifted_in {
+                return None;
+            }
+            let trait_ = projection_ty.trait_(db);
+            let args_no_self = projection_ty.substitution.as_slice(&Interner)[1..]
+                .iter()
+                .map(|ty| ty.clone().cast(&Interner))
+                .collect();
+            let alias_eq_bound = rust_ir::AliasEqBound {
+                value: ty.clone(),
+                trait_bound: rust_ir::TraitBound {
+                    trait_id: to_chalk_trait_id(trait_),
+                    args_no_self,
+                },
+                associated_ty_id: projection_ty.associated_ty_id,
+                parameters: Vec::new(), // FIXME we don't support generic associated types yet
+            };
+            Some(chalk_ir::Binders::new(
+                binders,
+                rust_ir::InlineBound::AliasEqBound(alias_eq_bound),
+            ))
+        }
+        _ => None,
    }
 }
diff --git a/crates/hir_ty/src/chalk_ext.rs b/crates/hir_ty/src/chalk_ext.rs
index 28ed3aac6..8c4542956 100644
--- a/crates/hir_ty/src/chalk_ext.rs
+++ b/crates/hir_ty/src/chalk_ext.rs
@@ -75,7 +75,7 @@ impl TyExt for Ty {
    }
    fn as_reference(&self) -> Option<(&Ty, Lifetime, Mutability)> {
        match self.kind(&Interner) {
-            TyKind::Ref(mutability, lifetime, ty) => Some((ty, *lifetime, *mutability)),
+            TyKind::Ref(mutability, lifetime, ty) => Some((ty, lifetime.clone(), *mutability)),
            _ => None,
        }
    }
diff --git a/crates/hir_ty/src/db.rs b/crates/hir_ty/src/db.rs
index 326c20240..1690926ad 100644
--- a/crates/hir_ty/src/db.rs
+++ b/crates/hir_ty/src/db.rs
@@ -1,4 +1,5 @@
-//! FIXME: write short doc here
+//! The home of `HirDatabase`, which is the Salsa database containing all the
+//! type inference-related queries.
 use std::sync::Arc;
@@ -10,9 +11,9 @@ use hir_def::{
 use la_arena::ArenaMap;
 use crate::{
+    chalk_db,
    method_resolution::{InherentImpls, TraitImpls},
-    traits::chalk,
+    Binders, CallableDefId, FnDefId, ImplTraitId, InferenceResult, Interner, PolyFnSig,
-    Binders, CallableDefId, FnDefId, ImplTraitId, InferenceResult, PolyFnSig,
    QuantifiedWhereClause, ReturnTypeImplTraits, TraitRef, Ty, TyDefId, ValueTyDefId,
 };
 use hir_expand::name::Name;
@@ -94,33 +95,38 @@ pub trait HirDatabase: DefDatabase + Upcast<dyn DefDatabase> {
    #[salsa::interned]
    fn intern_closure(&self, id: (DefWithBodyId, ExprId)) -> InternedClosureId;
-    #[salsa::invoke(chalk::associated_ty_data_query)]
+    #[salsa::invoke(chalk_db::associated_ty_data_query)]
-    fn associated_ty_data(&self, id: chalk::AssocTypeId) -> Arc<chalk::AssociatedTyDatum>;
+    fn associated_ty_data(&self, id: chalk_db::AssocTypeId) -> Arc<chalk_db::AssociatedTyDatum>;
-    #[salsa::invoke(chalk::trait_datum_query)]
+    #[salsa::invoke(chalk_db::trait_datum_query)]
-    fn trait_datum(&self, krate: CrateId, trait_id: chalk::TraitId) -> Arc<chalk::TraitDatum>;
+    fn trait_datum(&self, krate: CrateId, trait_id: chalk_db::TraitId)
+        -> Arc<chalk_db::TraitDatum>;
-    #[salsa::invoke(chalk::struct_datum_query)]
+    #[salsa::invoke(chalk_db::struct_datum_query)]
-    fn struct_datum(&self, krate: CrateId, struct_id: chalk::AdtId) -> Arc<chalk::StructDatum>;
+    fn struct_datum(
+        &self,
+        krate: CrateId,
+        struct_id: chalk_db::AdtId,
+    ) -> Arc<chalk_db::StructDatum>;
-    #[salsa::invoke(crate::traits::chalk::impl_datum_query)]
+    #[salsa::invoke(chalk_db::impl_datum_query)]
-    fn impl_datum(&self, krate: CrateId, impl_id: chalk::ImplId) -> Arc<chalk::ImplDatum>;
+    fn impl_datum(&self, krate: CrateId, impl_id: chalk_db::ImplId) -> Arc<chalk_db::ImplDatum>;
-    #[salsa::invoke(crate::traits::chalk::fn_def_datum_query)]
+    #[salsa::invoke(chalk_db::fn_def_datum_query)]
-    fn fn_def_datum(&self, krate: CrateId, fn_def_id: FnDefId) -> Arc<chalk::FnDefDatum>;
+    fn fn_def_datum(&self, krate: CrateId, fn_def_id: FnDefId) -> Arc<chalk_db::FnDefDatum>;
-    #[salsa::invoke(crate::traits::chalk::fn_def_variance_query)]
+    #[salsa::invoke(chalk_db::fn_def_variance_query)]
-    fn fn_def_variance(&self, krate: CrateId, fn_def_id: FnDefId) -> chalk::Variances;
+    fn fn_def_variance(&self, krate: CrateId, fn_def_id: FnDefId) -> chalk_db::Variances;
-    #[salsa::invoke(crate::traits::chalk::adt_variance_query)]
+    #[salsa::invoke(chalk_db::adt_variance_query)]
-    fn adt_variance(&self, krate: CrateId, adt_id: chalk::AdtId) -> chalk::Variances;
+    fn adt_variance(&self, krate: CrateId, adt_id: chalk_db::AdtId) -> chalk_db::Variances;
-    #[salsa::invoke(crate::traits::chalk::associated_ty_value_query)]
+    #[salsa::invoke(chalk_db::associated_ty_value_query)]
    fn associated_ty_value(
        &self,
        krate: CrateId,
-        id: chalk::AssociatedTyValueId,
+        id: chalk_db::AssociatedTyValueId,
-    ) -> Arc<chalk::AssociatedTyValue>;
+    ) -> Arc<chalk_db::AssociatedTyValue>;
    #[salsa::invoke(crate::traits::trait_solve_query)]
    fn trait_solve(
@@ -129,12 +135,12 @@ pub trait HirDatabase: DefDatabase + Upcast<dyn DefDatabase> {
        goal: crate::Canonical<crate::InEnvironment<crate::DomainGoal>>,
    ) -> Option<crate::Solution>;
-    #[salsa::invoke(crate::traits::chalk::program_clauses_for_chalk_env_query)]
+    #[salsa::invoke(chalk_db::program_clauses_for_chalk_env_query)]
    fn program_clauses_for_chalk_env(
        &self,
        krate: CrateId,
-        env: chalk_ir::Environment<chalk::Interner>,
+        env: chalk_ir::Environment<Interner>,
-    ) -> chalk_ir::ProgramClauses<chalk::Interner>;
+    ) -> chalk_ir::ProgramClauses<Interner>;
 }
 fn infer_wait(db: &dyn HirDatabase, def: DefWithBodyId) -> Arc<InferenceResult> {
diff --git a/crates/hir_ty/src/diagnostics.rs b/crates/hir_ty/src/diagnostics.rs
index 86f937e1d..84fc8ce14 100644
--- a/crates/hir_ty/src/diagnostics.rs
+++ b/crates/hir_ty/src/diagnostics.rs
@@ -1,4 +1,4 @@
-//! FIXME: write short doc here
+//! Type inference-based diagnostics.
 mod expr;
 mod match_check;
 mod unsafe_check;
diff --git a/crates/hir_ty/src/display.rs b/crates/hir_ty/src/display.rs
index e0ca96c6d..e7c9dabc2 100644
--- a/crates/hir_ty/src/display.rs
+++ b/crates/hir_ty/src/display.rs
@@ -1,4 +1,6 @@
-//! FIXME: write short doc here
+//! The `HirDisplay` trait, which serves two purposes: Turning various bits from
+//! HIR back into source code, and just displaying them for debugging/testing
+//! purposes.
 use std::{
    array,
@@ -20,11 +22,11 @@ use hir_expand::name::Name;
 use crate::{
    const_from_placeholder_idx, db::HirDatabase, from_assoc_type_id, from_foreign_def_id,
-    from_placeholder_idx, lt_from_placeholder_idx, primitive, subst_prefix, to_assoc_type_id,
+    from_placeholder_idx, lt_from_placeholder_idx, mapping::from_chalk, primitive, subst_prefix,
-    traits::chalk::from_chalk, utils::generics, AdtId, AliasEq, AliasTy, CallableDefId,
+    to_assoc_type_id, utils::generics, AdtId, AliasEq, AliasTy, CallableDefId, CallableSig, Const,
-    CallableSig, Const, ConstValue, DomainGoal, GenericArg, ImplTraitId, Interner, Lifetime,
+    ConstValue, DomainGoal, GenericArg, ImplTraitId, Interner, Lifetime, LifetimeData,
-    LifetimeData, LifetimeOutlives, Mutability, OpaqueTy, ProjectionTy, ProjectionTyExt,
+    LifetimeOutlives, Mutability, OpaqueTy, ProjectionTy, ProjectionTyExt, QuantifiedWhereClause,
-    QuantifiedWhereClause, Scalar, TraitRef, TraitRefExt, Ty, TyExt, TyKind, WhereClause,
+    Scalar, TraitRef, TraitRefExt, Ty, TyExt, TyKind, WhereClause,
 };
 pub struct HirFormatter<'a> {
@@ -265,7 +267,7 @@ impl HirDisplay for ProjectionTy {
        write!(f, " as {}", trait_.name)?;
        if self.substitution.len(&Interner) > 1 {
            write!(f, "<")?;
-            f.write_joined(&self.substitution.interned()[1..], ", ")?;
+            f.write_joined(&self.substitution.as_slice(&Interner)[1..], ", ")?;
            write!(f, ">")?;
        }
        write!(f, ">::{}", f.db.type_alias_data(from_assoc_type_id(self.associated_ty_id)).name)?;
@@ -287,6 +289,8 @@ impl HirDisplay for GenericArg {
    fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
        match self.interned() {
            crate::GenericArgData::Ty(ty) => ty.hir_fmt(f),
+            crate::GenericArgData::Lifetime(lt) => lt.hir_fmt(f),
+            crate::GenericArgData::Const(c) => c.hir_fmt(f),
        }
    }
 }
@@ -414,7 +418,7 @@ impl HirDisplay for Ty {
                    write!(f, ",)")?;
                } else {
                    write!(f, "(")?;
-                    f.write_joined(&*substs.interned(), ", ")?;
+                    f.write_joined(&*substs.as_slice(&Interner), ", ")?;
                    write!(f, ")")?;
                }
            }
@@ -442,7 +446,7 @@ impl HirDisplay for Ty {
                    // We print all params except implicit impl Trait params. Still a bit weird; should we leave out parent and self?
                    if total_len > 0 {
                        write!(f, "<")?;
-                        f.write_joined(&parameters.interned()[..total_len], ", ")?;
+                        f.write_joined(&parameters.as_slice(&Interner)[..total_len], ", ")?;
                        write!(f, ">")?;
                    }
                }
@@ -489,7 +493,7 @@ impl HirDisplay for Ty {
                            .map(|generic_def_id| f.db.generic_defaults(generic_def_id))
                            .filter(|defaults| !defaults.is_empty())
                        {
-                            None => parameters.interned().as_ref(),
+                            None => parameters.as_slice(&Interner),
                            Some(default_parameters) => {
                                let mut default_from = 0;
                                for (i, parameter) in parameters.iter(&Interner).enumerate() {
@@ -513,11 +517,11 @@ impl HirDisplay for Ty {
                                        }
                                    }
                                }
-                                &parameters.interned()[0..default_from]
+                                &parameters.as_slice(&Interner)[0..default_from]
                            }
                        }
                    } else {
-                        parameters.interned().as_ref()
+                        parameters.as_slice(&Interner)
                    };
                    if !parameters_to_write.is_empty() {
                        write!(f, "<")?;
@@ -540,7 +544,7 @@ impl HirDisplay for Ty {
                    write!(f, "{}::{}", trait_.name, type_alias_data.name)?;
                    if parameters.len(&Interner) > 0 {
                        write!(f, "<")?;
-                        f.write_joined(&*parameters.interned(), ", ")?;
+                        f.write_joined(&*parameters.as_slice(&Interner), ", ")?;
                        write!(f, ">")?;
                    }
                } else {
@@ -664,6 +668,8 @@ impl HirDisplay for Ty {
                write!(f, "{{unknown}}")?;
            }
            TyKind::InferenceVar(..) => write!(f, "_")?,
+            TyKind::Generator(..) => write!(f, "{{generator}}")?,
+            TyKind::GeneratorWitness(..) => write!(f, "{{generator witness}}")?,
        }
        Ok(())
    }
@@ -741,17 +747,17 @@ fn write_bounds_like_dyn_trait(
                if !first {
                    write!(f, " + ")?;
                }
-                // We assume that the self type is $0 (i.e. the
+                // We assume that the self type is ^0.0 (i.e. the
                // existential) here, which is the only thing that's
                // possible in actual Rust, and hence don't print it
                write!(f, "{}", f.db.trait_data(trait_).name)?;
-                if let [_, params @ ..] = &*trait_ref.substitution.interned().as_slice() {
+                if let [_, params @ ..] = &*trait_ref.substitution.as_slice(&Interner) {
                    if is_fn_trait {
                        if let Some(args) =
                            params.first().and_then(|it| it.assert_ty_ref(&Interner).as_tuple())
                        {
                            write!(f, "(")?;
-                            f.write_joined(&*args.interned(), ", ")?;
+                            f.write_joined(args.as_slice(&Interner), ", ")?;
                            write!(f, ")")?;
                        }
                    } else if !params.is_empty() {
@@ -783,6 +789,10 @@ fn write_bounds_like_dyn_trait(
                }
                ty.hir_fmt(f)?;
            }
+            // FIXME implement these
+            WhereClause::LifetimeOutlives(_) => {}
+            WhereClause::TypeOutlives(_) => {}
        }
        first = false;
    }
@@ -806,7 +816,7 @@ fn fmt_trait_ref(tr: &TraitRef, f: &mut HirFormatter, use_as: bool) -> Result<()
    write!(f, "{}", f.db.trait_data(tr.hir_trait_id()).name)?;
    if tr.substitution.len(&Interner) > 1 {
        write!(f, "<")?;
-        f.write_joined(&tr.substitution.interned()[1..], ", ")?;
+        f.write_joined(&tr.substitution.as_slice(&Interner)[1..], ", ")?;
        write!(f, ">")?;
    }
    Ok(())
@@ -837,6 +847,10 @@ impl HirDisplay for WhereClause {
                ty.hir_fmt(f)?;
            }
            WhereClause::AliasEq(_) => write!(f, "{{error}}")?,
+            // FIXME implement these
+            WhereClause::TypeOutlives(..) => {}
+            WhereClause::LifetimeOutlives(..) => {}
        }
        Ok(())
    }
@@ -881,9 +895,11 @@ impl HirDisplay for DomainGoal {
            DomainGoal::Holds(wc) => {
                write!(f, "Holds(")?;
                wc.hir_fmt(f)?;
-                write!(f, ")")
+                write!(f, ")")?;
            }
+            _ => write!(f, "?")?,
        }
+        Ok(())
    }
 }
diff --git a/crates/hir_ty/src/infer.rs b/crates/hir_ty/src/infer.rs
index 531159e54..bf2da2d4a 100644
--- a/crates/hir_ty/src/infer.rs
+++ b/crates/hir_ty/src/infer.rs
@@ -18,7 +18,7 @@ use std::mem;
 use std::ops::Index;
 use std::sync::Arc;
-use chalk_ir::{cast::Cast, Mutability};
+use chalk_ir::{cast::Cast, DebruijnIndex, Mutability};
 use hir_def::{
    body::Body,
    data::{ConstData, FunctionData, StaticData},
@@ -38,11 +38,11 @@ use syntax::SmolStr;
 use super::{
    DomainGoal, Guidance, InEnvironment, ProjectionTy, Solution, TraitEnvironment, TraitRef, Ty,
-    TypeWalk,
 };
 use crate::{
-    db::HirDatabase, infer::diagnostics::InferenceDiagnostic, lower::ImplTraitLoweringMode,
+    db::HirDatabase, fold_tys, infer::diagnostics::InferenceDiagnostic,
-    to_assoc_type_id, AliasEq, AliasTy, Canonical, Interner, TyBuilder, TyExt, TyKind,
+    lower::ImplTraitLoweringMode, to_assoc_type_id, AliasEq, AliasTy, Canonical, Interner,
+    TyBuilder, TyExt, TyKind,
 };
 // This lint has a false positive here. See the link below for details.
@@ -323,7 +323,7 @@ impl<'a> InferenceContext<'a> {
    }
    fn insert_type_vars(&mut self, ty: Ty) -> Ty {
-        ty.fold(&mut |ty| self.insert_type_vars_shallow(ty))
+        fold_tys(ty, |ty, _| self.insert_type_vars_shallow(ty), DebruijnIndex::INNERMOST)
    }
    fn resolve_obligations_as_possible(&mut self) {
@@ -434,12 +434,16 @@ impl<'a> InferenceContext<'a> {
    /// to do it as well.
    fn normalize_associated_types_in(&mut self, ty: Ty) -> Ty {
        let ty = self.resolve_ty_as_possible(ty);
-        ty.fold(&mut |ty| match ty.kind(&Interner) {
+        fold_tys(
-            TyKind::Alias(AliasTy::Projection(proj_ty)) => {
+            ty,
-                self.normalize_projection_ty(proj_ty.clone())
+            |ty, _| match ty.kind(&Interner) {
-            }
+                TyKind::Alias(AliasTy::Projection(proj_ty)) => {
-            _ => ty,
+                    self.normalize_projection_ty(proj_ty.clone())
-        })
+                }
+                _ => ty,
+            },
+            DebruijnIndex::INNERMOST,
+        )
    }
    fn normalize_projection_ty(&mut self, proj_ty: ProjectionTy) -> Ty {
diff --git a/crates/hir_ty/src/infer/coerce.rs b/crates/hir_ty/src/infer/coerce.rs
index fd679f444..1f463a425 100644
--- a/crates/hir_ty/src/infer/coerce.rs
+++ b/crates/hir_ty/src/infer/coerce.rs
@@ -71,12 +71,14 @@ impl<'a> InferenceContext<'a> {
        }
        // Pointer weakening and function to pointer
-        match (from_ty.interned_mut(), to_ty.kind(&Interner)) {
+        match (from_ty.kind(&Interner), to_ty.kind(&Interner)) {
            // `*mut T` -> `*const T`
+            (TyKind::Raw(_, inner), TyKind::Raw(m2 @ Mutability::Not, ..)) => {
+                from_ty = TyKind::Raw(*m2, inner.clone()).intern(&Interner);
+            }
            // `&mut T` -> `&T`
-            (TyKind::Raw(m1, ..), TyKind::Raw(m2 @ Mutability::Not, ..))
+            (TyKind::Ref(_, lt, inner), TyKind::Ref(m2 @ Mutability::Not, ..)) => {
-            | (TyKind::Ref(m1, ..), TyKind::Ref(m2 @ Mutability::Not, ..)) => {
+                from_ty = TyKind::Ref(*m2, lt.clone(), inner.clone()).intern(&Interner);
-                *m1 = *m2;
            }
            // `&T` -> `*const T`
            // `&mut T` -> `*mut T`/`*const T`
diff --git a/crates/hir_ty/src/infer/expr.rs b/crates/hir_ty/src/infer/expr.rs
index 9841988c5..50497eecb 100644
--- a/crates/hir_ty/src/infer/expr.rs
+++ b/crates/hir_ty/src/infer/expr.rs
@@ -3,7 +3,7 @@
 use std::iter::{repeat, repeat_with};
 use std::{mem, sync::Arc};
-use chalk_ir::{cast::Cast, Mutability, TyVariableKind};
+use chalk_ir::{cast::Cast, fold::Shift, Mutability, TyVariableKind};
 use hir_def::{
    expr::{Array, BinaryOp, Expr, ExprId, Literal, Statement, UnaryOp},
    path::{GenericArg, GenericArgs},
@@ -17,14 +17,14 @@ use syntax::ast::RangeOp;
 use crate::{
    autoderef, dummy_usize_const,
    lower::lower_to_chalk_mutability,
+    mapping::from_chalk,
    method_resolution, op,
    primitive::{self, UintTy},
    static_lifetime, to_chalk_trait_id,
-    traits::{chalk::from_chalk, FnTrait},
+    traits::FnTrait,
    utils::{generics, Generics},
    AdtId, Binders, CallableDefId, FnPointer, FnSig, FnSubst, InEnvironment, Interner,
    ProjectionTyExt, Rawness, Scalar, Substitution, TraitRef, Ty, TyBuilder, TyExt, TyKind,
-    TypeWalk,
 };
 use super::{
@@ -463,7 +463,11 @@ impl<'a> InferenceContext<'a> {
                    };
                    match canonicalized.decanonicalize_ty(derefed_ty.value).kind(&Interner) {
                        TyKind::Tuple(_, substs) => name.as_tuple_index().and_then(|idx| {
-                            substs.interned().get(idx).map(|a| a.assert_ty_ref(&Interner)).cloned()
+                            substs
+                                .as_slice(&Interner)
+                                .get(idx)
+                                .map(|a| a.assert_ty_ref(&Interner))
+                                .cloned()
                        }),
                        TyKind::Adt(AdtId(hir_def::AdtId::StructId(s)), parameters) => {
                            let local_id = self.db.struct_data(*s).variant_data.field(name)?;
diff --git a/crates/hir_ty/src/infer/pat.rs b/crates/hir_ty/src/infer/pat.rs
index a41e8e116..aea354cde 100644
--- a/crates/hir_ty/src/infer/pat.rs
+++ b/crates/hir_ty/src/infer/pat.rs
@@ -122,7 +122,7 @@ impl<'a> InferenceContext<'a> {
        let ty = match &body[pat] {
            &Pat::Tuple { ref args, ellipsis } => {
                let expectations = match expected.as_tuple() {
-                    Some(parameters) => &*parameters.interned().as_slice(),
+                    Some(parameters) => &*parameters.as_slice(&Interner),
                    _ => &[],
                };
@@ -242,7 +242,7 @@ impl<'a> InferenceContext<'a> {
                    let (inner_ty, alloc_ty) = match expected.as_adt() {
                        Some((adt, subst)) if adt == box_adt => (
                            subst.at(&Interner, 0).assert_ty_ref(&Interner).clone(),
-                            subst.interned().get(1).and_then(|a| a.ty(&Interner).cloned()),
+                            subst.as_slice(&Interner).get(1).and_then(|a| a.ty(&Interner).cloned()),
                        ),
                        _ => (self.result.standard_types.unknown.clone(), None),
                    };
diff --git a/crates/hir_ty/src/infer/path.rs b/crates/hir_ty/src/infer/path.rs
index f8955aa32..495282eba 100644
--- a/crates/hir_ty/src/infer/path.rs
+++ b/crates/hir_ty/src/infer/path.rs
@@ -101,7 +101,7 @@ impl<'a> InferenceContext<'a> {
        let substs = ctx.substs_from_path(path, typable, true);
        let ty = TyBuilder::value_ty(self.db, typable)
            .use_parent_substs(&parent_substs)
-            .fill(substs.interned()[parent_substs.len(&Interner)..].iter().cloned())
+            .fill(substs.as_slice(&Interner)[parent_substs.len(&Interner)..].iter().cloned())
            .build();
        Some(ty)
    }
diff --git a/crates/hir_ty/src/infer/unify.rs b/crates/hir_ty/src/infer/unify.rs
index 2ea9dd920..a887e20b0 100644
--- a/crates/hir_ty/src/infer/unify.rs
+++ b/crates/hir_ty/src/infer/unify.rs
@@ -2,14 +2,17 @@
 use std::borrow::Cow;
-use chalk_ir::{FloatTy, IntTy, TyVariableKind, UniverseIndex, VariableKind};
+use chalk_ir::{
+    cast::Cast, fold::Fold, interner::HasInterner, FloatTy, IntTy, TyVariableKind, UniverseIndex,
+    VariableKind,
+};
 use ena::unify::{InPlaceUnificationTable, NoError, UnifyKey, UnifyValue};
 use super::{DomainGoal, InferenceContext};
 use crate::{
-    AliasEq, AliasTy, BoundVar, Canonical, CanonicalVarKinds, DebruijnIndex, FnPointer, FnSubst,
+    fold_tys, static_lifetime, AliasEq, AliasTy, BoundVar, Canonical, CanonicalVarKinds,
-    InEnvironment, InferenceVar, Interner, Scalar, Substitution, Ty, TyExt, TyKind, TypeWalk,
+    DebruijnIndex, FnPointer, FnSubst, InEnvironment, InferenceVar, Interner, Scalar, Substitution,
-    WhereClause,
+    Ty, TyExt, TyKind, WhereClause,
 };
 impl<'a> InferenceContext<'a> {
@@ -34,7 +37,10 @@ where
 }
 #[derive(Debug)]
-pub(super) struct Canonicalized<T> {
+pub(super) struct Canonicalized<T>
+where
+    T: HasInterner<Interner = Interner>,
+{
    pub(super) value: Canonical<T>,
    free_vars: Vec<(InferenceVar, TyVariableKind)>,
 }
@@ -48,9 +54,14 @@ impl<'a, 'b> Canonicalizer<'a, 'b> {
        })
    }
-    fn do_canonicalize<T: TypeWalk>(&mut self, t: T, binders: DebruijnIndex) -> T {
+    fn do_canonicalize<T: Fold<Interner, Result = T> + HasInterner<Interner = Interner>>(
-        t.fold_binders(
+        &mut self,
-            &mut |ty, binders| match ty.kind(&Interner) {
+        t: T,
+        binders: DebruijnIndex,
+    ) -> T {
+        fold_tys(
+            t,
+            |ty, binders| match ty.kind(&Interner) {
                &TyKind::InferenceVar(var, kind) => {
                    let inner = from_inference_var(var);
                    if self.var_stack.contains(&inner) {
@@ -76,7 +87,10 @@ impl<'a, 'b> Canonicalizer<'a, 'b> {
        )
    }
-    fn into_canonicalized<T>(self, result: T) -> Canonicalized<T> {
+    fn into_canonicalized<T: HasInterner<Interner = Interner>>(
+        self,
+        result: T,
+    ) -> Canonicalized<T> {
        let kinds = self
            .free_vars
            .iter()
@@ -103,28 +117,18 @@ impl<'a, 'b> Canonicalizer<'a, 'b> {
            DomainGoal::Holds(wc) => {
                DomainGoal::Holds(self.do_canonicalize(wc, DebruijnIndex::INNERMOST))
            }
+            _ => unimplemented!(),
        };
        self.into_canonicalized(InEnvironment { goal: result, environment: obligation.environment })
    }
 }
-impl<T> Canonicalized<T> {
+impl<T: HasInterner<Interner = Interner>> Canonicalized<T> {
    pub(super) fn decanonicalize_ty(&self, ty: Ty) -> Ty {
-        ty.fold_binders(
+        crate::fold_free_vars(ty, |bound, _binders| {
-            &mut |ty, binders| {
+            let (v, k) = self.free_vars[bound.index];
-                if let TyKind::BoundVar(bound) = ty.kind(&Interner) {
+            TyKind::InferenceVar(v, k).intern(&Interner)
-                    if bound.debruijn >= binders {
+        })
-                        let (v, k) = self.free_vars[bound.index];
-                        TyKind::InferenceVar(v, k).intern(&Interner)
-                    } else {
-                        ty
-                    }
-                } else {
-                    ty
-                }
-            },
-            DebruijnIndex::INNERMOST,
-        )
    }
    pub(super) fn apply_solution(
@@ -136,15 +140,17 @@ impl<T> Canonicalized<T> {
        let new_vars = Substitution::from_iter(
            &Interner,
            solution.binders.iter(&Interner).map(|k| match k.kind {
-                VariableKind::Ty(TyVariableKind::General) => ctx.table.new_type_var(),
+                VariableKind::Ty(TyVariableKind::General) => {
-                VariableKind::Ty(TyVariableKind::Integer) => ctx.table.new_integer_var(),
+                    ctx.table.new_type_var().cast(&Interner)
-                VariableKind::Ty(TyVariableKind::Float) => ctx.table.new_float_var(),
+                }
-                // HACK: Chalk can sometimes return new lifetime variables. We
+                VariableKind::Ty(TyVariableKind::Integer) => {
-                // want to just skip them, but to not mess up the indices of
+                    ctx.table.new_integer_var().cast(&Interner)
-                // other variables, we'll just create a new type variable in
+                }
-                // their place instead. This should not matter (we never see the
+                VariableKind::Ty(TyVariableKind::Float) => {
-                // actual *uses* of the lifetime variable).
+                    ctx.table.new_float_var().cast(&Interner)
-                VariableKind::Lifetime => ctx.table.new_type_var(),
+                }
+                // Chalk can sometimes return new lifetime variables. We just use the static lifetime everywhere
+                VariableKind::Lifetime => static_lifetime().cast(&Interner),
                _ => panic!("const variable in solution"),
            }),
        );
@@ -488,55 +494,63 @@ impl InferenceTable {
    /// be resolved as far as possible, i.e. contain no type variables with
    /// known type.
    fn resolve_ty_as_possible_inner(&mut self, tv_stack: &mut Vec<TypeVarId>, ty: Ty) -> Ty {
-        ty.fold(&mut |ty| match ty.kind(&Interner) {
+        fold_tys(
-            &TyKind::InferenceVar(tv, kind) => {
+            ty,
-                let inner = from_inference_var(tv);
+            |ty, _| match ty.kind(&Interner) {
-                if tv_stack.contains(&inner) {
+                &TyKind::InferenceVar(tv, kind) => {
-                    cov_mark::hit!(type_var_cycles_resolve_as_possible);
+                    let inner = from_inference_var(tv);
-                    // recursive type
+                    if tv_stack.contains(&inner) {
-                    return self.type_variable_table.fallback_value(tv, kind);
+                        cov_mark::hit!(type_var_cycles_resolve_as_possible);
-                }
+                        // recursive type
-                if let Some(known_ty) =
+                        return self.type_variable_table.fallback_value(tv, kind);
-                    self.var_unification_table.inlined_probe_value(inner).known()
+                    }
-                {
+                    if let Some(known_ty) =
-                    // known_ty may contain other variables that are known by now
+                        self.var_unification_table.inlined_probe_value(inner).known()
-                    tv_stack.push(inner);
+                    {
-                    let result = self.resolve_ty_as_possible_inner(tv_stack, known_ty.clone());
+                        // known_ty may contain other variables that are known by now
-                    tv_stack.pop();
+                        tv_stack.push(inner);
-                    result
+                        let result = self.resolve_ty_as_possible_inner(tv_stack, known_ty.clone());
-                } else {
+                        tv_stack.pop();
-                    ty
+                        result
+                    } else {
+                        ty
+                    }
                }
-            }
+                _ => ty,
-            _ => ty,
+            },
-        })
+            DebruijnIndex::INNERMOST,
+        )
    }
    /// Resolves the type completely; type variables without known type are
    /// replaced by TyKind::Unknown.
    fn resolve_ty_completely_inner(&mut self, tv_stack: &mut Vec<TypeVarId>, ty: Ty) -> Ty {
-        ty.fold(&mut |ty| match ty.kind(&Interner) {
+        fold_tys(
-            &TyKind::InferenceVar(tv, kind) => {
+            ty,
-                let inner = from_inference_var(tv);
+            |ty, _| match ty.kind(&Interner) {
-                if tv_stack.contains(&inner) {
+                &TyKind::InferenceVar(tv, kind) => {
-                    cov_mark::hit!(type_var_cycles_resolve_completely);
+                    let inner = from_inference_var(tv);
-                    // recursive type
+                    if tv_stack.contains(&inner) {
-                    return self.type_variable_table.fallback_value(tv, kind);
+                        cov_mark::hit!(type_var_cycles_resolve_completely);
-                }
+                        // recursive type
-                if let Some(known_ty) =
+                        return self.type_variable_table.fallback_value(tv, kind);
-                    self.var_unification_table.inlined_probe_value(inner).known()
+                    }
-                {
+                    if let Some(known_ty) =
-                    // known_ty may contain other variables that are known by now
+                        self.var_unification_table.inlined_probe_value(inner).known()
-                    tv_stack.push(inner);
+                    {
-                    let result = self.resolve_ty_completely_inner(tv_stack, known_ty.clone());
+                        // known_ty may contain other variables that are known by now
-                    tv_stack.pop();
+                        tv_stack.push(inner);
-                    result
+                        let result = self.resolve_ty_completely_inner(tv_stack, known_ty.clone());
-                } else {
+                        tv_stack.pop();
-                    self.type_variable_table.fallback_value(tv, kind)
+                        result
+                    } else {
+                        self.type_variable_table.fallback_value(tv, kind)
+                    }
                }
-            }
+                _ => ty,
-            _ => ty,
+            },
-        })
+            DebruijnIndex::INNERMOST,
+        )
    }
 }
diff --git a/crates/hir_ty/src/traits/chalk/interner.rs b/crates/hir_ty/src/interner.rs
index bd9395b7e..a1656115d 100644
--- a/crates/hir_ty/src/traits/chalk/interner.rs
+++ b/crates/hir_ty/src/interner.rs
@@ -1,61 +1,83 @@
 //! Implementation of the Chalk `Interner` trait, which allows customizing the
 //! representation of the various objects Chalk deals with (types, goals etc.).
-use super::tls;
+use crate::{chalk_db, tls, GenericArg};
 use base_db::salsa::InternId;
-use chalk_ir::{GenericArg, Goal, GoalData};
+use chalk_ir::{Goal, GoalData};
-use hir_def::TypeAliasId;
+use hir_def::{
+    intern::{impl_internable, InternStorage, Internable, Interned},
+    TypeAliasId,
+};
 use smallvec::SmallVec;
 use std::{fmt, sync::Arc};
 #[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
 pub struct Interner;
-pub(crate) type AssocTypeId = chalk_ir::AssocTypeId<Interner>;
+#[derive(PartialEq, Eq, Hash, Debug)]
-pub(crate) type AssociatedTyDatum = chalk_solve::rust_ir::AssociatedTyDatum<Interner>;
+pub struct InternedWrapper<T>(T);
-pub(crate) type TraitId = chalk_ir::TraitId<Interner>;
-pub(crate) type TraitDatum = chalk_solve::rust_ir::TraitDatum<Interner>;
+impl<T> std::ops::Deref for InternedWrapper<T> {
-pub(crate) type AdtId = chalk_ir::AdtId<Interner>;
+    type Target = T;
-pub(crate) type StructDatum = chalk_solve::rust_ir::AdtDatum<Interner>;
-pub(crate) type ImplId = chalk_ir::ImplId<Interner>;
+    fn deref(&self) -> &Self::Target {
-pub(crate) type ImplDatum = chalk_solve::rust_ir::ImplDatum<Interner>;
+        &self.0
-pub(crate) type AssociatedTyValueId = chalk_solve::rust_ir::AssociatedTyValueId<Interner>;
+    }
-pub(crate) type AssociatedTyValue = chalk_solve::rust_ir::AssociatedTyValue<Interner>;
+}
-pub(crate) type FnDefDatum = chalk_solve::rust_ir::FnDefDatum<Interner>;
-pub(crate) type OpaqueTyId = chalk_ir::OpaqueTyId<Interner>;
+impl_internable!(
-pub(crate) type OpaqueTyDatum = chalk_solve::rust_ir::OpaqueTyDatum<Interner>;
+    InternedWrapper<Vec<chalk_ir::VariableKind<Interner>>>,
-pub(crate) type Variances = chalk_ir::Variances<Interner>;
+    InternedWrapper<SmallVec<[GenericArg; 2]>>,
+    InternedWrapper<chalk_ir::TyData<Interner>>,
+    InternedWrapper<chalk_ir::LifetimeData<Interner>>,
+    InternedWrapper<chalk_ir::ConstData<Interner>>,
+    InternedWrapper<Vec<chalk_ir::CanonicalVarKind<Interner>>>,
+    InternedWrapper<Vec<chalk_ir::ProgramClause<Interner>>>,
+    InternedWrapper<Vec<chalk_ir::QuantifiedWhereClause<Interner>>>,
+    InternedWrapper<Vec<chalk_ir::Variance>>,
+);
 impl chalk_ir::interner::Interner for Interner {
-    type InternedType = Arc<chalk_ir::TyData<Self>>;
+    type InternedType = Interned<InternedWrapper<chalk_ir::TyData<Interner>>>;
-    type InternedLifetime = chalk_ir::LifetimeData<Self>;
+    type InternedLifetime = Interned<InternedWrapper<chalk_ir::LifetimeData<Self>>>;
-    type InternedConst = Arc<chalk_ir::ConstData<Self>>;
+    type InternedConst = Interned<InternedWrapper<chalk_ir::ConstData<Self>>>;
    type InternedConcreteConst = ();
    type InternedGenericArg = chalk_ir::GenericArgData<Self>;
    type InternedGoal = Arc<GoalData<Self>>;
    type InternedGoals = Vec<Goal<Self>>;
-    type InternedSubstitution = SmallVec<[GenericArg<Self>; 2]>;
+    type InternedSubstitution = Interned<InternedWrapper<SmallVec<[GenericArg; 2]>>>;
-    type InternedProgramClause = Arc<chalk_ir::ProgramClauseData<Self>>;
+    type InternedProgramClause = chalk_ir::ProgramClauseData<Self>;
-    type InternedProgramClauses = Arc<[chalk_ir::ProgramClause<Self>]>;
+    type InternedProgramClauses = Interned<InternedWrapper<Vec<chalk_ir::ProgramClause<Self>>>>;
-    type InternedQuantifiedWhereClauses = Vec<chalk_ir::QuantifiedWhereClause<Self>>;
+    type InternedQuantifiedWhereClauses =
-    type InternedVariableKinds = Vec<chalk_ir::VariableKind<Self>>;
+        Interned<InternedWrapper<Vec<chalk_ir::QuantifiedWhereClause<Self>>>>;
-    type InternedCanonicalVarKinds = Vec<chalk_ir::CanonicalVarKind<Self>>;
+    type InternedVariableKinds = Interned<InternedWrapper<Vec<chalk_ir::VariableKind<Interner>>>>;
+    type InternedCanonicalVarKinds =
+        Interned<InternedWrapper<Vec<chalk_ir::CanonicalVarKind<Self>>>>;
    type InternedConstraints = Vec<chalk_ir::InEnvironment<chalk_ir::Constraint<Self>>>;
-    type InternedVariances = Arc<[chalk_ir::Variance]>;
+    type InternedVariances = Interned<InternedWrapper<Vec<chalk_ir::Variance>>>;
    type DefId = InternId;
    type InternedAdtId = hir_def::AdtId;
    type Identifier = TypeAliasId;
    type FnAbi = ();
-    fn debug_adt_id(type_kind_id: AdtId, fmt: &mut fmt::Formatter<'_>) -> Option<fmt::Result> {
+    fn debug_adt_id(
+        type_kind_id: chalk_db::AdtId,
+        fmt: &mut fmt::Formatter<'_>,
+    ) -> Option<fmt::Result> {
        tls::with_current_program(|prog| Some(prog?.debug_struct_id(type_kind_id, fmt)))
    }
-    fn debug_trait_id(type_kind_id: TraitId, fmt: &mut fmt::Formatter<'_>) -> Option<fmt::Result> {
+    fn debug_trait_id(
+        type_kind_id: chalk_db::TraitId,
+        fmt: &mut fmt::Formatter<'_>,
+    ) -> Option<fmt::Result> {
        tls::with_current_program(|prog| Some(prog?.debug_trait_id(type_kind_id, fmt)))
    }
-    fn debug_assoc_type_id(id: AssocTypeId, fmt: &mut fmt::Formatter<'_>) -> Option<fmt::Result> {
+    fn debug_assoc_type_id(
+        id: chalk_db::AssocTypeId,
+        fmt: &mut fmt::Formatter<'_>,
+    ) -> Option<fmt::Result> {
        tls::with_current_program(|prog| Some(prog?.debug_assoc_type_id(id, fmt)))
    }
@@ -99,7 +121,7 @@ impl chalk_ir::interner::Interner for Interner {
    }
    fn debug_generic_arg(
-        parameter: &GenericArg<Interner>,
+        parameter: &GenericArg,
        fmt: &mut fmt::Formatter<'_>,
    ) -> Option<fmt::Result> {
        tls::with_current_program(|prog| Some(prog?.debug_generic_arg(parameter, fmt)))
@@ -194,30 +216,30 @@ impl chalk_ir::interner::Interner for Interner {
    fn intern_ty(&self, kind: chalk_ir::TyKind<Self>) -> Self::InternedType {
        let flags = kind.compute_flags(self);
-        Arc::new(chalk_ir::TyData { kind, flags })
+        Interned::new(InternedWrapper(chalk_ir::TyData { kind, flags }))
    }
    fn ty_data<'a>(&self, ty: &'a Self::InternedType) -> &'a chalk_ir::TyData<Self> {
-        ty
+        &ty.0
    }
    fn intern_lifetime(&self, lifetime: chalk_ir::LifetimeData<Self>) -> Self::InternedLifetime {
-        lifetime
+        Interned::new(InternedWrapper(lifetime))
    }
    fn lifetime_data<'a>(
        &self,
        lifetime: &'a Self::InternedLifetime,
    ) -> &'a chalk_ir::LifetimeData<Self> {
-        lifetime
+        &lifetime.0
    }
    fn intern_const(&self, constant: chalk_ir::ConstData<Self>) -> Self::InternedConst {
-        Arc::new(constant)
+        Interned::new(InternedWrapper(constant))
    }
    fn const_data<'a>(&self, constant: &'a Self::InternedConst) -> &'a chalk_ir::ConstData<Self> {
-        constant
+        &constant.0
    }
    fn const_eq(
@@ -264,23 +286,23 @@ impl chalk_ir::interner::Interner for Interner {
    fn intern_substitution<E>(
        &self,
-        data: impl IntoIterator<Item = Result<GenericArg<Self>, E>>,
+        data: impl IntoIterator<Item = Result<GenericArg, E>>,
    ) -> Result<Self::InternedSubstitution, E> {
-        data.into_iter().collect()
+        Ok(Interned::new(InternedWrapper(data.into_iter().collect::<Result<_, _>>()?)))
    }
    fn substitution_data<'a>(
        &self,
        substitution: &'a Self::InternedSubstitution,
-    ) -> &'a [GenericArg<Self>] {
+    ) -> &'a [GenericArg] {
-        substitution
+        &substitution.as_ref().0
    }
    fn intern_program_clause(
        &self,
        data: chalk_ir::ProgramClauseData<Self>,
    ) -> Self::InternedProgramClause {
-        Arc::new(data)
+        data
    }
    fn program_clause_data<'a>(
@@ -294,7 +316,7 @@ impl chalk_ir::interner::Interner for Interner {
        &self,
        data: impl IntoIterator<Item = Result<chalk_ir::ProgramClause<Self>, E>>,
    ) -> Result<Self::InternedProgramClauses, E> {
-        data.into_iter().collect()
+        Ok(Interned::new(InternedWrapper(data.into_iter().collect::<Result<_, _>>()?)))
    }
    fn program_clauses_data<'a>(
@@ -308,7 +330,7 @@ impl chalk_ir::interner::Interner for Interner {
        &self,
        data: impl IntoIterator<Item = Result<chalk_ir::QuantifiedWhereClause<Self>, E>>,
    ) -> Result<Self::InternedQuantifiedWhereClauses, E> {
-        data.into_iter().collect()
+        Ok(Interned::new(InternedWrapper(data.into_iter().collect::<Result<_, _>>()?)))
    }
    fn quantified_where_clauses_data<'a>(
@@ -322,21 +344,21 @@ impl chalk_ir::interner::Interner for Interner {
        &self,
        data: impl IntoIterator<Item = Result<chalk_ir::VariableKind<Self>, E>>,
    ) -> Result<Self::InternedVariableKinds, E> {
-        data.into_iter().collect()
+        Ok(Interned::new(InternedWrapper(data.into_iter().collect::<Result<_, _>>()?)))
    }
    fn variable_kinds_data<'a>(
        &self,
        parameter_kinds: &'a Self::InternedVariableKinds,
    ) -> &'a [chalk_ir::VariableKind<Self>] {
-        &parameter_kinds
+        &parameter_kinds.as_ref().0
    }
    fn intern_canonical_var_kinds<E>(
        &self,
        data: impl IntoIterator<Item = Result<chalk_ir::CanonicalVarKind<Self>, E>>,
    ) -> Result<Self::InternedCanonicalVarKinds, E> {
-        data.into_iter().collect()
+        Ok(Interned::new(InternedWrapper(data.into_iter().collect::<Result<_, _>>()?)))
    }
    fn canonical_var_kinds_data<'a>(
@@ -376,7 +398,7 @@ impl chalk_ir::interner::Interner for Interner {
        &self,
        data: impl IntoIterator<Item = Result<chalk_ir::Variance, E>>,
    ) -> Result<Self::InternedVariances, E> {
-        data.into_iter().collect()
+        Ok(Interned::new(InternedWrapper(data.into_iter().collect::<Result<_, _>>()?)))
    }
    fn variances_data<'a>(
@@ -390,3 +412,12 @@ impl chalk_ir::interner::Interner for Interner {
 impl chalk_ir::interner::HasInterner for Interner {
    type Interner = Self;
 }
+#[macro_export]
+macro_rules! has_interner {
+    ($t:ty) => {
+        impl HasInterner for $t {
+            type Interner = crate::Interner;
+        }
+    };
+}
diff --git a/crates/hir_ty/src/lib.rs b/crates/hir_ty/src/lib.rs
index 87f10e9d5..113234fa4 100644
--- a/crates/hir_ty/src/lib.rs
+++ b/crates/hir_ty/src/lib.rs
@@ -1,27 +1,29 @@
 //! The type system. We currently use this to infer types for completion, hover
 //! information and various assists.
 #[allow(unused)]
 macro_rules! eprintln {
    ($($tt:tt)*) => { stdx::eprintln!($($tt)*) };
 }
 mod autoderef;
-pub mod primitive;
-pub mod traits;
-pub mod method_resolution;
-mod op;
-mod lower;
-pub(crate) mod infer;
-pub(crate) mod utils;
-mod chalk_cast;
-mod chalk_ext;
 mod builder;
+mod chalk_db;
+mod chalk_ext;
+mod infer;
+mod interner;
+mod lower;
+mod mapping;
+mod op;
+mod tls;
+mod utils;
 mod walk;
-mod types;
-pub mod display;
 pub mod db;
 pub mod diagnostics;
+pub mod display;
+pub mod method_resolution;
+pub mod primitive;
+pub mod traits;
 #[cfg(test)]
 mod tests;
@@ -30,12 +32,12 @@ mod test_db;
 use std::sync::Arc;
-use base_db::salsa;
+use chalk_ir::{
-use chalk_ir::UintTy;
+    fold::{Fold, Shift},
-use hir_def::{
+    interner::HasInterner,
-    expr::ExprId, type_ref::Rawness, ConstParamId, LifetimeParamId, TraitId, TypeAliasId,
+    UintTy,
-    TypeParamId,
 };
+use hir_def::{expr::ExprId, type_ref::Rawness, TypeParamId};
 use crate::{db::HirDatabase, display::HirDisplay, utils::generics};
@@ -43,12 +45,17 @@ pub use autoderef::autoderef;
 pub use builder::TyBuilder;
 pub use chalk_ext::*;
 pub use infer::{could_unify, InferenceResult};
+pub use interner::Interner;
 pub use lower::{
    associated_type_shorthand_candidates, callable_item_sig, CallableDefId, ImplTraitLoweringMode,
    TyDefId, TyLoweringContext, ValueTyDefId,
 };
-pub use traits::{chalk::Interner, TraitEnvironment};
+pub use mapping::{
-pub use types::*;
+    const_from_placeholder_idx, from_assoc_type_id, from_chalk_trait_id, from_foreign_def_id,
+    from_placeholder_idx, lt_from_placeholder_idx, to_assoc_type_id, to_chalk_trait_id,
+    to_foreign_def_id, to_placeholder_idx,
+};
+pub use traits::TraitEnvironment;
 pub use walk::TypeWalk;
 pub use chalk_ir::{
@@ -65,6 +72,21 @@ pub type PlaceholderIndex = chalk_ir::PlaceholderIndex;
 pub type VariableKind = chalk_ir::VariableKind<Interner>;
 pub type VariableKinds = chalk_ir::VariableKinds<Interner>;
 pub type CanonicalVarKinds = chalk_ir::CanonicalVarKinds<Interner>;
+pub type Binders<T> = chalk_ir::Binders<T>;
+pub type Substitution = chalk_ir::Substitution<Interner>;
+pub type GenericArg = chalk_ir::GenericArg<Interner>;
+pub type GenericArgData = chalk_ir::GenericArgData<Interner>;
+pub type Ty = chalk_ir::Ty<Interner>;
+pub type TyKind = chalk_ir::TyKind<Interner>;
+pub type DynTy = chalk_ir::DynTy<Interner>;
+pub type FnPointer = chalk_ir::FnPointer<Interner>;
+// pub type FnSubst = chalk_ir::FnSubst<Interner>;
+pub use chalk_ir::FnSubst;
+pub type ProjectionTy = chalk_ir::ProjectionTy<Interner>;
+pub type AliasTy = chalk_ir::AliasTy<Interner>;
+pub type OpaqueTy = chalk_ir::OpaqueTy<Interner>;
+pub type InferenceVar = chalk_ir::InferenceVar;
 pub type Lifetime = chalk_ir::Lifetime<Interner>;
 pub type LifetimeData = chalk_ir::LifetimeData<Interner>;
@@ -76,12 +98,27 @@ pub type ConstValue = chalk_ir::ConstValue<Interner>;
 pub type ConcreteConst = chalk_ir::ConcreteConst<Interner>;
 pub type ChalkTraitId = chalk_ir::TraitId<Interner>;
+pub type TraitRef = chalk_ir::TraitRef<Interner>;
+pub type QuantifiedWhereClause = Binders<WhereClause>;
+pub type QuantifiedWhereClauses = chalk_ir::QuantifiedWhereClauses<Interner>;
+pub type Canonical<T> = chalk_ir::Canonical<T>;
 pub type FnSig = chalk_ir::FnSig<Interner>;
+pub type InEnvironment<T> = chalk_ir::InEnvironment<T>;
+pub type DomainGoal = chalk_ir::DomainGoal<Interner>;
+pub type AliasEq = chalk_ir::AliasEq<Interner>;
+pub type Solution = chalk_solve::Solution<Interner>;
+pub type ConstrainedSubst = chalk_ir::ConstrainedSubst<Interner>;
+pub type Guidance = chalk_solve::Guidance<Interner>;
+pub type WhereClause = chalk_ir::WhereClause<Interner>;
 // FIXME: get rid of this
 pub fn subst_prefix(s: &Substitution, n: usize) -> Substitution {
-    Substitution::intern(s.interned()[..std::cmp::min(s.len(&Interner), n)].into())
+    Substitution::from_iter(
+        &Interner,
+        s.as_slice(&Interner)[..std::cmp::min(s.len(&Interner), n)].iter().cloned(),
+    )
 }
 /// Return an index of a parameter in the generic type parameter list by it's id.
@@ -89,14 +126,17 @@ pub fn param_idx(db: &dyn HirDatabase, id: TypeParamId) -> Option<usize> {
    generics(db.upcast(), id.parent).param_idx(id)
 }
-pub fn wrap_empty_binders<T>(value: T) -> Binders<T>
+pub(crate) fn wrap_empty_binders<T>(value: T) -> Binders<T>
 where
-    T: TypeWalk,
+    T: Fold<Interner, Result = T> + HasInterner<Interner = Interner>,
 {
-    Binders::empty(&Interner, value.shifted_in_from(DebruijnIndex::ONE))
+    Binders::empty(&Interner, value.shifted_in_from(&Interner, DebruijnIndex::ONE))
 }
-pub fn make_only_type_binders<T>(num_vars: usize, value: T) -> Binders<T> {
+pub(crate) fn make_only_type_binders<T: HasInterner<Interner = Interner>>(
+    num_vars: usize,
+    value: T,
+) -> Binders<T> {
    Binders::new(
        VariableKinds::from_iter(
            &Interner,
@@ -108,7 +148,7 @@ pub fn make_only_type_binders<T>(num_vars: usize, value: T) -> Binders<T> {
 }
 // FIXME: get rid of this
-pub fn make_canonical<T>(
+pub fn make_canonical<T: HasInterner<Interner = Interner>>(
    value: T,
    kinds: impl IntoIterator<Item = TyVariableKind>,
 ) -> Canonical<T> {
@@ -129,6 +169,8 @@ pub struct CallableSig {
    is_varargs: bool,
 }
+has_interner!(CallableSig);
 /// A polymorphic function signature.
 pub type PolyFnSig = Binders<CallableSig>;
@@ -144,10 +186,10 @@ impl CallableSig {
            params_and_return: fn_ptr
                .substitution
                .clone()
-                .shifted_out_to(DebruijnIndex::ONE)
+                .shifted_out_to(&Interner, DebruijnIndex::ONE)
                .expect("unexpected lifetime vars in fn ptr")
                .0
-                .interned()
+                .as_slice(&Interner)
                .iter()
                .map(|arg| arg.assert_ty_ref(&Interner).clone())
                .collect(),
@@ -164,7 +206,22 @@ impl CallableSig {
    }
 }
-impl Ty {}
+impl Fold<Interner> for CallableSig {
+    type Result = CallableSig;
+    fn fold_with<'i>(
+        self,
+        folder: &mut dyn chalk_ir::fold::Folder<'i, Interner>,
+        outer_binder: DebruijnIndex,
+    ) -> chalk_ir::Fallible<Self::Result>
+    where
+        Interner: 'i,
+    {
+        let vec = self.params_and_return.to_vec();
+        let folded = vec.fold_with(folder, outer_binder)?;
+        Ok(CallableSig { params_and_return: folded.into(), is_varargs: self.is_varargs })
+    }
+}
 #[derive(Copy, Clone, PartialEq, Eq, Debug, Hash)]
 pub enum ImplTraitId {
@@ -177,70 +234,75 @@ pub struct ReturnTypeImplTraits {
    pub(crate) impl_traits: Vec<ReturnTypeImplTrait>,
 }
+has_interner!(ReturnTypeImplTraits);
 #[derive(Clone, PartialEq, Eq, Debug, Hash)]
 pub(crate) struct ReturnTypeImplTrait {
    pub(crate) bounds: Binders<Vec<QuantifiedWhereClause>>,
 }
-pub fn to_foreign_def_id(id: TypeAliasId) -> ForeignDefId {
+pub fn static_lifetime() -> Lifetime {
-    chalk_ir::ForeignDefId(salsa::InternKey::as_intern_id(&id))
+    LifetimeData::Static.intern(&Interner)
-}
-pub fn from_foreign_def_id(id: ForeignDefId) -> TypeAliasId {
-    salsa::InternKey::from_intern_id(id.0)
-}
-pub fn to_assoc_type_id(id: TypeAliasId) -> AssocTypeId {
-    chalk_ir::AssocTypeId(salsa::InternKey::as_intern_id(&id))
-}
-pub fn from_assoc_type_id(id: AssocTypeId) -> TypeAliasId {
-    salsa::InternKey::from_intern_id(id.0)
-}
-pub fn from_placeholder_idx(db: &dyn HirDatabase, idx: PlaceholderIndex) -> TypeParamId {
-    assert_eq!(idx.ui, chalk_ir::UniverseIndex::ROOT);
-    let interned_id = salsa::InternKey::from_intern_id(salsa::InternId::from(idx.idx));
-    db.lookup_intern_type_param_id(interned_id)
 }
-pub fn to_placeholder_idx(db: &dyn HirDatabase, id: TypeParamId) -> PlaceholderIndex {
+pub fn dummy_usize_const() -> Const {
-    let interned_id = db.intern_type_param_id(id);
+    let usize_ty = chalk_ir::TyKind::Scalar(Scalar::Uint(UintTy::Usize)).intern(&Interner);
-    PlaceholderIndex {
+    chalk_ir::ConstData {
-        ui: chalk_ir::UniverseIndex::ROOT,
+        ty: usize_ty,
-        idx: salsa::InternKey::as_intern_id(&interned_id).as_usize(),
+        value: chalk_ir::ConstValue::Concrete(chalk_ir::ConcreteConst { interned: () }),
    }
+    .intern(&Interner)
 }
-pub fn lt_from_placeholder_idx(db: &dyn HirDatabase, idx: PlaceholderIndex) -> LifetimeParamId {
+pub(crate) fn fold_free_vars<T: HasInterner<Interner = Interner> + Fold<Interner>>(
-    assert_eq!(idx.ui, chalk_ir::UniverseIndex::ROOT);
+    t: T,
-    let interned_id = salsa::InternKey::from_intern_id(salsa::InternId::from(idx.idx));
+    f: impl FnMut(BoundVar, DebruijnIndex) -> Ty,
-    db.lookup_intern_lifetime_param_id(interned_id)
+) -> T::Result {
-}
+    use chalk_ir::{fold::Folder, Fallible};
+    struct FreeVarFolder<F>(F);
+    impl<'i, F: FnMut(BoundVar, DebruijnIndex) -> Ty + 'i> Folder<'i, Interner> for FreeVarFolder<F> {
+        fn as_dyn(&mut self) -> &mut dyn Folder<'i, Interner> {
+            self
+        }
-pub fn const_from_placeholder_idx(db: &dyn HirDatabase, idx: PlaceholderIndex) -> ConstParamId {
+        fn interner(&self) -> &'i Interner {
-    assert_eq!(idx.ui, chalk_ir::UniverseIndex::ROOT);
+            &Interner
-    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 {
+        fn fold_free_var_ty(
-    chalk_ir::TraitId(salsa::InternKey::as_intern_id(&id))
+            &mut self,
+            bound_var: BoundVar,
+            outer_binder: DebruijnIndex,
+        ) -> Fallible<Ty> {
+            Ok(self.0(bound_var, outer_binder))
+        }
+    }
+    t.fold_with(&mut FreeVarFolder(f), DebruijnIndex::INNERMOST).expect("fold failed unexpectedly")
 }
-pub fn from_chalk_trait_id(id: ChalkTraitId) -> TraitId {
+pub(crate) fn fold_tys<T: HasInterner<Interner = Interner> + Fold<Interner>>(
-    salsa::InternKey::from_intern_id(id.0)
+    t: T,
-}
+    f: impl FnMut(Ty, DebruijnIndex) -> Ty,
+    binders: DebruijnIndex,
+) -> T::Result {
+    use chalk_ir::{
+        fold::{Folder, SuperFold},
+        Fallible,
+    };
+    struct TyFolder<F>(F);
+    impl<'i, F: FnMut(Ty, DebruijnIndex) -> Ty + 'i> Folder<'i, Interner> for TyFolder<F> {
+        fn as_dyn(&mut self) -> &mut dyn Folder<'i, Interner> {
+            self
+        }
-pub fn static_lifetime() -> Lifetime {
+        fn interner(&self) -> &'i Interner {
-    LifetimeData::Static.intern(&Interner)
+            &Interner
-}
+        }
-pub fn dummy_usize_const() -> Const {
+        fn fold_ty(&mut self, ty: Ty, outer_binder: DebruijnIndex) -> Fallible<Ty> {
-    let usize_ty = chalk_ir::TyKind::Scalar(Scalar::Uint(UintTy::Usize)).intern(&Interner);
+            let ty = ty.super_fold_with(self.as_dyn(), outer_binder)?;
-    chalk_ir::ConstData {
+            Ok(self.0(ty, outer_binder))
-        ty: usize_ty,
+        }
-        value: chalk_ir::ConstValue::Concrete(chalk_ir::ConcreteConst { interned: () }),
    }
-    .intern(&Interner)
+    t.fold_with(&mut TyFolder(f), binders).expect("fold failed unexpectedly")
 }
diff --git a/crates/hir_ty/src/lower.rs b/crates/hir_ty/src/lower.rs
index e6903e189..a035686bc 100644
--- a/crates/hir_ty/src/lower.rs
+++ b/crates/hir_ty/src/lower.rs
@@ -8,7 +8,7 @@
 use std::{iter, sync::Arc};
 use base_db::CrateId;
-use chalk_ir::{cast::Cast, Mutability, Safety};
+use chalk_ir::{cast::Cast, fold::Shift, interner::HasInterner, Mutability, Safety};
 use hir_def::{
    adt::StructKind,
    builtin_type::BuiltinType,
@@ -27,15 +27,16 @@ 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, TypeWalk, WhereClause,
+    TraitEnvironment, TraitRef, TraitRefExt, Ty, TyBuilder, TyKind, WhereClause,
 };
 #[derive(Debug)]
@@ -488,7 +489,7 @@ impl<'a> TyLoweringContext<'a> {
                        };
                        // We need to shift in the bound vars, since
                        // associated_type_shorthand_candidates does not do that
-                        let substs = substs.shifted_in_from(self.in_binders);
+                        let substs = substs.shifted_in_from(&Interner, self.in_binders);
                        // FIXME handle type parameters on the segment
                        return Some(
                            TyKind::Alias(AliasTy::Projection(ProjectionTy {
@@ -847,7 +848,7 @@ pub fn associated_type_shorthand_candidates<R>(
                // FIXME: how to correctly handle higher-ranked bounds here?
                WhereClause::Implemented(tr) => search(
                    tr.clone()
-                        .shifted_out_to(DebruijnIndex::ONE)
+                        .shifted_out_to(&Interner, DebruijnIndex::ONE)
                        .expect("FIXME unexpected higher-ranked trait bound"),
                ),
                _ => None,
@@ -950,8 +951,7 @@ pub(crate) fn trait_environment_query(
                traits_in_scope
                    .push((tr.self_type_parameter(&Interner).clone(), tr.hir_trait_id()));
            }
-            let program_clause: chalk_ir::ProgramClause<Interner> =
+            let program_clause: chalk_ir::ProgramClause<Interner> = pred.clone().cast(&Interner);
-                pred.clone().to_chalk(db).cast(&Interner);
            clauses.push(program_clause.into_from_env_clause(&Interner));
        }
    }
@@ -974,7 +974,7 @@ pub(crate) fn trait_environment_query(
        let substs = TyBuilder::type_params_subst(db, trait_id);
        let trait_ref = TraitRef { trait_id: to_chalk_trait_id(trait_id), substitution: substs };
        let pred = WhereClause::Implemented(trait_ref);
-        let program_clause: chalk_ir::ProgramClause<Interner> = pred.to_chalk(db).cast(&Interner);
+        let program_clause: chalk_ir::ProgramClause<Interner> = pred.cast(&Interner);
        clauses.push(program_clause.into_from_env_clause(&Interner));
    }
@@ -1016,22 +1016,16 @@ pub(crate) fn generic_defaults_query(
                p.default.as_ref().map_or(TyKind::Error.intern(&Interner), |t| ctx.lower_ty(t));
            // Each default can only refer to previous parameters.
-            ty = ty.fold_binders(
+            ty = crate::fold_free_vars(ty, |bound, binders| {
-                &mut |ty, binders| match ty.kind(&Interner) {
+                if bound.index >= idx && bound.debruijn == DebruijnIndex::INNERMOST {
-                    TyKind::BoundVar(BoundVar { debruijn, index }) if *debruijn == binders => {
+                    // type variable default referring to parameter coming
-                        if *index >= idx {
+                    // after it. This is forbidden (FIXME: report
-                            // type variable default referring to parameter coming
+                    // diagnostic)
-                            // after it. This is forbidden (FIXME: report
+                    TyKind::Error.intern(&Interner)
-                            // diagnostic)
+                } else {
-                            TyKind::Error.intern(&Interner)
+                    bound.shifted_in_from(binders).to_ty(&Interner)
-                        } else {
+                }
-                            ty
+            });
-                        }
-                    }
-                    _ => ty,
-                },
-                DebruijnIndex::INNERMOST,
-            );
            crate::make_only_type_binders(idx, ty)
        })
@@ -1307,6 +1301,6 @@ pub(crate) fn lower_to_chalk_mutability(m: hir_def::type_ref::Mutability) -> Mut
    }
 }
-fn make_binders<T>(generics: &Generics, value: T) -> Binders<T> {
+fn make_binders<T: HasInterner<Interner = Interner>>(generics: &Generics, value: T) -> Binders<T> {
    crate::make_only_type_binders(generics.len(), value)
 }
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 7e09a1539..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, TypeWalk,
 };
 /// 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;
            }
@@ -757,20 +802,13 @@ pub(crate) fn inherent_impl_substs(
 /// This replaces any 'free' Bound vars in `s` (i.e. those with indices past
 /// num_vars_to_keep) by `TyKind::Unknown`.
 fn fallback_bound_vars(s: Substitution, num_vars_to_keep: usize) -> Substitution {
-    s.fold_binders(
+    crate::fold_free_vars(s, |bound, binders| {
-        &mut |ty, binders| {
+        if bound.index >= num_vars_to_keep && bound.debruijn == DebruijnIndex::INNERMOST {
-            if let TyKind::BoundVar(bound) = ty.kind(&Interner) {
+            TyKind::Error.intern(&Interner)
-                if bound.index >= num_vars_to_keep && bound.debruijn >= binders {
+        } else {
-                    TyKind::Error.intern(&Interner)
+            bound.shifted_in_from(binders).to_ty(&Interner)
-                } else {
+        }
-                    ty
+    })
-                }
-            } else {
-                ty
-            }
-        },
-        DebruijnIndex::INNERMOST,
-    )
 }
 fn transform_receiver_ty(
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 {
-            x;
+    x;
-            y;
+    y;
-            let z = bar();
+    let z = bar();
-            x.foo();
+    x.foo();
-            y.foo();
+    y.foo();
-            z.foo();
+    z.foo();
-        }
+}"#,
-        "#,
        expect![[r#"
            26..30 'self': &Self
            60..62 '{}': ()
@@ -1404,17 +1384,24 @@ fn dyn_trait_bare() {
 fn weird_bounds() {
    check_infer(
        r#"
-        trait Trait {}
+trait Trait {}
-        fn test(a: impl Trait + 'lifetime, b: impl 'lifetime, c: impl (Trait), d: impl ('lifetime), e: impl ?Sized, f: impl Trait + ?Sized) {}
+fn test(
-        "#,
+    a: impl Trait + 'lifetime,
+    b: impl 'lifetime,
+    c: impl (Trait),
+    d: impl ('lifetime),
+    e: impl ?Sized,
+    f: impl Trait + ?Sized
+) {}
+"#,
        expect![[r#"
-            23..24 'a': impl Trait
+            28..29 'a': impl Trait
-            50..51 'b': impl
+            59..60 'b': impl
-            69..70 'c': impl Trait
+            82..83 'c': impl Trait
-            86..87 'd': impl
+            103..104 'd': impl
-            107..108 'e': impl
+            128..129 'e': impl
-            123..124 'f': impl Trait
+            148..149 'f': impl Trait
-            147..149 '{}': ()
+            173..175 '{}': ()
        "#]],
    );
 }
@@ -1439,27 +1426,26 @@ fn test(x: (impl Trait + UnknownTrait)) {
 fn assoc_type_bindings() {
    check_infer(
        r#"
-        trait Trait {
+trait Trait {
-            type Type;
+    type Type;
-        }
+}
-        fn get<T: Trait>(t: T) -> <T as Trait>::Type {}
+fn get<T: Trait>(t: T) -> <T as Trait>::Type {}
-        fn get2<U, T: Trait<Type = U>>(t: T) -> U {}
+fn get2<U, T: Trait<Type = U>>(t: T) -> U {}
-        fn set<T: Trait<Type = u64>>(t: T) -> T {t}
+fn set<T: Trait<Type = u64>>(t: T) -> T {t}
-        struct S<T>;
+struct S<T>;
-        impl<T> Trait for S<T> { type Type = T; }
+impl<T> Trait for S<T> { type Type = T; }
-        fn test<T: Trait<Type = u32>>(x: T, y: impl Trait<Type = i64>) {
+fn test<T: Trait<Type = u32>>(x: T, y: impl Trait<Type = i64>) {
-            get(x);
+    get(x);
-            get2(x);
+    get2(x);
-            get(y);
+    get(y);
-            get2(y);
+    get2(y);
-            get(set(S));
+    get(set(S));
-            get2(set(S));
+    get2(set(S));
-            get2(S::<str>);
+    get2(S::<str>);
-        }
+}"#,
-        "#,
        expect![[r#"
            49..50 't': T
            77..79 '{}': ()
@@ -1546,18 +1532,17 @@ mod iter {
 fn projection_eq_within_chalk() {
    check_infer(
        r#"
-        trait Trait1 {
+trait Trait1 {
-            type Type;
+    type Type;
-        }
+}
-        trait Trait2<T> {
+trait Trait2<T> {
-            fn foo(self) -> T;
+    fn foo(self) -> T;
-        }
+}
-        impl<T, U> Trait2<T> for U where U: Trait1<Type = T> {}
+impl<T, U> Trait2<T> for U where U: Trait1<Type = T> {}
-        fn test<T: Trait1<Type = u32>>(x: T) {
+fn test<T: Trait1<Type = u32>>(x: T) {
-            x.foo();
+    x.foo();
-        }
+}"#,
-        "#,
        expect![[r#"
            61..65 'self': Self
            163..164 'x': T
@@ -1589,19 +1574,18 @@ fn test<T: foo::Trait>(x: T) {
 fn super_trait_method_resolution() {
    check_infer(
        r#"
-        mod foo {
+mod foo {
-            trait SuperTrait {
+    trait SuperTrait {
-                fn foo(&self) -> u32 {}
+        fn foo(&self) -> u32 {}
-            }
+    }
-        }
+}
-        trait Trait1: foo::SuperTrait {}
+trait Trait1: foo::SuperTrait {}
-        trait Trait2 where Self: foo::SuperTrait {}
+trait Trait2 where Self: foo::SuperTrait {}
-        fn test<T: Trait1, U: Trait2>(x: T, y: U) {
+fn test<T: Trait1, U: Trait2>(x: T, y: U) {
-            x.foo();
+    x.foo();
-            y.foo();
+    y.foo();
-        }
+}"#,
-        "#,
        expect![[r#"
            49..53 'self': &Self
            62..64 '{}': ()
@@ -1620,17 +1604,16 @@ fn super_trait_method_resolution() {
 fn super_trait_impl_trait_method_resolution() {
    check_infer(
        r#"
-        mod foo {
+mod foo {
-            trait SuperTrait {
+    trait SuperTrait {
-                fn foo(&self) -> u32 {}
+        fn foo(&self) -> u32 {}
-            }
+    }
-        }
+}
-        trait Trait1: foo::SuperTrait {}
+trait Trait1: foo::SuperTrait {}
-        fn test(x: &impl Trait1) {
+fn test(x: &impl Trait1) {
-            x.foo();
+    x.foo();
-        }
+}"#,
-        "#,
        expect![[r#"
            49..53 'self': &Self
            62..64 '{}': ()
@@ -1667,20 +1650,19 @@ fn super_trait_cycle() {
 fn super_trait_assoc_type_bounds() {
    check_infer(
        r#"
-        trait SuperTrait { type Type; }
+trait SuperTrait { type Type; }
-        trait Trait where Self: SuperTrait {}
+trait Trait where Self: SuperTrait {}
-        fn get2<U, T: Trait<Type = U>>(t: T) -> U {}
+fn get2<U, T: Trait<Type = U>>(t: T) -> U {}
-        fn set<T: Trait<Type = u64>>(t: T) -> T {t}
+fn set<T: Trait<Type = u64>>(t: T) -> T {t}
-        struct S<T>;
+struct S<T>;
-        impl<T> SuperTrait for S<T> { type Type = T; }
+impl<T> SuperTrait for S<T> { type Type = T; }
-        impl<T> Trait for S<T> {}
+impl<T> Trait for S<T> {}
-        fn test() {
+fn test() {
-            get2(set(S));
+    get2(set(S));
-        }
+}"#,
-        "#,
        expect![[r#"
            102..103 't': T
            113..115 '{}': ()
@@ -1701,16 +1683,15 @@ fn super_trait_assoc_type_bounds() {
 fn fn_trait() {
    check_infer_with_mismatches(
        r#"
-        trait FnOnce<Args> {
+trait FnOnce<Args> {
-            type Output;
+    type Output;
-            fn call_once(self, args: Args) -> <Self as FnOnce<Args>>::Output;
+    fn call_once(self, args: Args) -> <Self as FnOnce<Args>>::Output;
-        }
+}
-        fn test<F: FnOnce(u32, u64) -> u128>(f: F) {
+fn test<F: FnOnce(u32, u64) -> u128>(f: F) {
-            f.call_once((1, 2));
+    f.call_once((1, 2));
-        }
+}"#,
-        "#,
        expect![[r#"
            56..60 'self': Self
            62..66 'args': Args
@@ -1729,37 +1710,36 @@ fn fn_trait() {
 fn fn_ptr_and_item() {
    check_infer_with_mismatches(
        r#"
-        #[lang="fn_once"]
+#[lang="fn_once"]
-        trait FnOnce<Args> {
+trait FnOnce<Args> {
-            type Output;
+    type Output;
-            fn call_once(self, args: Args) -> Self::Output;
+    fn call_once(self, args: Args) -> Self::Output;
-        }
+}
-        trait Foo<T> {
+trait Foo<T> {
-            fn foo(&self) -> T;
+    fn foo(&self) -> T;
-        }
+}
-        struct Bar<T>(T);
+struct Bar<T>(T);
-        impl<A1, R, F: FnOnce(A1) -> R> Foo<(A1, R)> for Bar<F> {
+impl<A1, R, F: FnOnce(A1) -> R> Foo<(A1, R)> for Bar<F> {
-            fn foo(&self) -> (A1, R) { loop {} }
+    fn foo(&self) -> (A1, R) { loop {} }
-        }
+}
-        enum Opt<T> { None, Some(T) }
+enum Opt<T> { None, Some(T) }
-        impl<T> Opt<T> {
+impl<T> Opt<T> {
-            fn map<U, F: FnOnce(T) -> U>(self, f: F) -> Opt<U> { loop {} }
+    fn map<U, F: FnOnce(T) -> U>(self, f: F) -> Opt<U> { loop {} }
-        }
+}
-        fn test() {
+fn test() {
-            let bar: Bar<fn(u8) -> u32>;
+    let bar: Bar<fn(u8) -> u32>;
-            bar.foo();
+    bar.foo();
-            let opt: Opt<u8>;
+    let opt: Opt<u8>;
-            let f: fn(u8) -> u32;
+    let f: fn(u8) -> u32;
-            opt.map(f);
+    opt.map(f);
-        }
+}"#,
-        "#,
        expect![[r#"
            74..78 'self': Self
            80..84 'args': Args
@@ -1790,46 +1770,45 @@ fn fn_ptr_and_item() {
 fn fn_trait_deref_with_ty_default() {
    check_infer(
        r#"
-        #[lang = "deref"]
+#[lang = "deref"]
-        trait Deref {
+trait Deref {
-            type Target;
+    type Target;
-            fn deref(&self) -> &Self::Target;
+    fn deref(&self) -> &Self::Target;
-        }
+}
-        #[lang="fn_once"]
+#[lang="fn_once"]
-        trait FnOnce<Args> {
+trait FnOnce<Args> {
-            type Output;
+    type Output;
-            fn call_once(self, args: Args) -> Self::Output;
+    fn call_once(self, args: Args) -> Self::Output;
-        }
+}
-        struct Foo;
+struct Foo;
-        impl Foo {
+impl Foo {
-            fn foo(&self) -> usize {}
+    fn foo(&self) -> usize {}
-        }
+}
-        struct Lazy<T, F = fn() -> T>(F);
+struct Lazy<T, F = fn() -> T>(F);
-        impl<T, F> Lazy<T, F> {
+impl<T, F> Lazy<T, F> {
-            pub fn new(f: F) -> Lazy<T, F> {}
+    pub fn new(f: F) -> Lazy<T, F> {}
-        }
+}
-        impl<T, F: FnOnce() -> T> Deref for Lazy<T, F> {
+impl<T, F: FnOnce() -> T> Deref for Lazy<T, F> {
-            type Target = T;
+    type Target = T;
-        }
+}
-        fn test() {
+fn test() {
-            let lazy1: Lazy<Foo, _> = Lazy::new(|| Foo);
+    let lazy1: Lazy<Foo, _> = Lazy::new(|| Foo);
-            let r1 = lazy1.foo();
+    let r1 = lazy1.foo();
-            fn make_foo_fn() -> Foo {}
+    fn make_foo_fn() -> Foo {}
-            let make_foo_fn_ptr: fn() -> Foo = make_foo_fn;
+    let make_foo_fn_ptr: fn() -> Foo = make_foo_fn;
-            let lazy2: Lazy<Foo, _> = Lazy::new(make_foo_fn_ptr);
+    let lazy2: Lazy<Foo, _> = Lazy::new(make_foo_fn_ptr);
-            let r2 = lazy2.foo();
+    let r2 = lazy2.foo();
-        }
+}"#,
-        "#,
        expect![[r#"
            64..68 'self': &Self
            165..169 'self': Self
@@ -1865,23 +1844,22 @@ fn fn_trait_deref_with_ty_default() {
 fn closure_1() {
    check_infer_with_mismatches(
        r#"
-        #[lang = "fn_once"]
+#[lang = "fn_once"]
-        trait FnOnce<Args> {
+trait FnOnce<Args> {
-            type Output;
+    type Output;
-        }
+}
-        enum Option<T> { Some(T), None }
+enum Option<T> { Some(T), None }
-        impl<T> Option<T> {
+impl<T> Option<T> {
-            fn map<U, F: FnOnce(T) -> U>(self, f: F) -> Option<U> { loop {} }
+    fn map<U, F: FnOnce(T) -> U>(self, f: F) -> Option<U> { loop {} }
-        }
+}
-        fn test() {
+fn test() {
-            let x = Option::Some(1u32);
+    let x = Option::Some(1u32);
-            x.map(|v| v + 1);
+    x.map(|v| v + 1);
-            x.map(|_v| 1u64);
+    x.map(|_v| 1u64);
-            let y: Option<i64> = x.map(|_v| 1);
+    let y: Option<i64> = x.map(|_v| 1);
-        }
+}"#,
-        "#,
        expect![[r#"
            147..151 'self': Option<T>
            153..154 'f': F
@@ -1919,38 +1897,63 @@ fn closure_1() {
 fn closure_2() {
    check_infer_with_mismatches(
        r#"
-        trait FnOnce<Args> {
+#[lang = "add"]
-            type Output;
+pub trait Add<Rhs = Self> {
-        }
+    type Output;
+    fn add(self, rhs: Rhs) -> Self::Output;
+}
-        fn test<F: FnOnce(u32) -> u64>(f: F) {
+trait FnOnce<Args> {
-            f(1);
+    type Output;
-            let g = |v| v + 1;
+}
-            g(1u64);
-            let h = |v| 1u128 + v;
+impl Add for u64 {
-        }
+    type Output = Self;
-        "#,
+    fn add(self, rhs: u64) -> Self::Output {0}
+}
+impl Add for u128 {
+    type Output = Self;
+    fn add(self, rhs: u128) -> Self::Output {0}
+}
+fn test<F: FnOnce(u32) -> u64>(f: F) {
+    f(1);
+    let g = |v| v + 1;
+    g(1u64);
+    let h = |v| 1u128 + v;
+}"#,
        expect![[r#"
-            72..73 'f': F
+            72..76 'self': Self
-            78..154 '{     ...+ v; }': ()
+            78..81 'rhs': Rhs
-            84..85 'f': F
+            203..207 'self': u64
-            84..88 'f(1)': {unknown}
+            209..212 'rhs': u64
-            86..87 '1': i32
+            235..238 '{0}': u64
-            98..99 'g': |u64| -> i32
+            236..237 '0': u64
-            102..111 '|v| v + 1': |u64| -> i32
+            297..301 'self': u128
-            103..104 'v': u64
+            303..306 'rhs': u128
-            106..107 'v': u64
+            330..333 '{0}': u128
-            106..111 'v + 1': i32
+            331..332 '0': u128
-            110..111 '1': i32
+            368..369 'f': F
-            117..118 'g': |u64| -> i32
+            374..450 '{     ...+ v; }': ()
-            117..124 'g(1u64)': i32
+            380..381 'f': F
-            119..123 '1u64': u64
+            380..384 'f(1)': {unknown}
-            134..135 'h': |u128| -> u128
+            382..383 '1': i32
-            138..151 '|v| 1u128 + v': |u128| -> u128
+            394..395 'g': |u64| -> u64
-            139..140 'v': u128
+            398..407 '|v| v + 1': |u64| -> u64
-            142..147 '1u128': u128
+            399..400 'v': u64
-            142..151 '1u128 + v': u128
+            402..403 'v': u64
-            150..151 'v': u128
+            402..407 'v + 1': u64
+            406..407 '1': u64
+            413..414 'g': |u64| -> u64
+            413..420 'g(1u64)': u64
+            415..419 '1u64': u64
+            430..431 'h': |u128| -> u128
+            434..447 '|v| 1u128 + v': |u128| -> u128
+            435..436 'v': u128
+            438..443 '1u128': u128
+            438..447 '1u128 + v': u128
+            446..447 'v': u128
        "#]],
    );
 }
@@ -1959,29 +1962,28 @@ fn closure_2() {
 fn closure_as_argument_inference_order() {
    check_infer_with_mismatches(
        r#"
-        #[lang = "fn_once"]
+#[lang = "fn_once"]
-        trait FnOnce<Args> {
+trait FnOnce<Args> {
-            type Output;
+    type Output;
-        }
+}
-        fn foo1<T, U, F: FnOnce(T) -> U>(x: T, f: F) -> U { loop {} }
+fn foo1<T, U, F: FnOnce(T) -> U>(x: T, f: F) -> U { loop {} }
-        fn foo2<T, U, F: FnOnce(T) -> U>(f: F, x: T) -> U { loop {} }
+fn foo2<T, U, F: FnOnce(T) -> U>(f: F, x: T) -> U { loop {} }
-        struct S;
+struct S;
-        impl S {
+impl S {
-            fn method(self) -> u64;
+    fn method(self) -> u64;
-            fn foo1<T, U, F: FnOnce(T) -> U>(self, x: T, f: F) -> U { loop {} }
+    fn foo1<T, U, F: FnOnce(T) -> U>(self, x: T, f: F) -> U { loop {} }
-            fn foo2<T, U, F: FnOnce(T) -> U>(self, f: F, x: T) -> U { loop {} }
+    fn foo2<T, U, F: FnOnce(T) -> U>(self, f: F, x: T) -> U { loop {} }
-        }
+}
-        fn test() {
+fn test() {
-            let x1 = foo1(S, |s| s.method());
+    let x1 = foo1(S, |s| s.method());
-            let x2 = foo2(|s| s.method(), S);
+    let x2 = foo2(|s| s.method(), S);
-            let x3 = S.foo1(S, |s| s.method());
+    let x3 = S.foo1(S, |s| s.method());
-            let x4 = S.foo2(|s| s.method(), S);
+    let x4 = S.foo2(|s| s.method(), S);
-        }
+}"#,
-        "#,
        expect![[r#"
            94..95 'x': T
            100..101 'f': F
@@ -2110,27 +2112,26 @@ fn test<T, U>() where T::Item: Trait2, T: Trait<U::Item>, U: Trait<()> {
 fn unselected_projection_on_impl_self() {
    check_infer(
        r#"
-        //- /main.rs
+//- /main.rs
-        trait Trait {
+trait Trait {
-            type Item;
+    type Item;
-            fn f(&self, x: Self::Item);
+    fn f(&self, x: Self::Item);
-        }
+}
-        struct S;
+struct S;
-        impl Trait for S {
+impl Trait for S {
-            type Item = u32;
+    type Item = u32;
-            fn f(&self, x: Self::Item) { let y = x; }
+    fn f(&self, x: Self::Item) { let y = x; }
-        }
+}
-        struct S2;
+struct S2;
-        impl Trait for S2 {
+impl Trait for S2 {
-            type Item = i32;
+    type Item = i32;
-            fn f(&self, x: <Self>::Item) { let y = x; }
+    fn f(&self, x: <Self>::Item) { let y = x; }
-        }
+}"#,
-        "#,
        expect![[r#"
            40..44 'self': &Self
            46..47 'x': Trait::Item<Self>
@@ -2366,58 +2367,57 @@ fn test<I: Iterator<Item: Iterator<Item = u32>>>() {
 fn proc_macro_server_types() {
    check_infer(
        r#"
-        macro_rules! with_api {
+macro_rules! with_api {
-            ($S:ident, $self:ident, $m:ident) => {
+    ($S:ident, $self:ident, $m:ident) => {
-                $m! {
+        $m! {
-                    TokenStream {
+            TokenStream {
-                        fn new() -> $S::TokenStream;
+                fn new() -> $S::TokenStream;
-                    },
+            },
-                    Group {
+            Group {
-                    },
+            },
-                }
-            };
        }
-        macro_rules! associated_item {
+    };
-            (type TokenStream) =>
+}
-                (type TokenStream: 'static;);
+macro_rules! associated_item {
-            (type Group) =>
+    (type TokenStream) =>
-                (type Group: 'static;);
+        (type TokenStream: 'static;);
-            ($($item:tt)*) => ($($item)*;)
+    (type Group) =>
-        }
+        (type Group: 'static;);
-        macro_rules! declare_server_traits {
+    ($($item:tt)*) => ($($item)*;)
-            ($($name:ident {
+}
-                $(fn $method:ident($($arg:ident: $arg_ty:ty),* $(,)?) $(-> $ret_ty:ty)?;)*
+macro_rules! declare_server_traits {
-            }),* $(,)?) => {
+    ($($name:ident {
-                pub trait Types {
+        $(fn $method:ident($($arg:ident: $arg_ty:ty),* $(,)?) $(-> $ret_ty:ty)?;)*
-                    $(associated_item!(type $name);)*
+    }),* $(,)?) => {
-                }
+        pub trait Types {
+            $(associated_item!(type $name);)*
-                $(pub trait $name: Types {
-                    $(associated_item!(fn $method($($arg: $arg_ty),*) $(-> $ret_ty)?);)*
-                })*
-                pub trait Server: Types $(+ $name)* {}
-                impl<S: Types $(+ $name)*> Server for S {}
-            }
        }
-        with_api!(Self, self_, declare_server_traits);
+        $(pub trait $name: Types {
-        struct G {}
+            $(associated_item!(fn $method($($arg: $arg_ty),*) $(-> $ret_ty)?);)*
-        struct T {}
+        })*
-        struct Rustc;
-        impl Types for Rustc {
-            type TokenStream = T;
-            type Group = G;
-        }
-        fn make<T>() -> T { loop {} }
+        pub trait Server: Types $(+ $name)* {}
-        impl TokenStream for Rustc {
+        impl<S: Types $(+ $name)*> Server for S {}
-            fn new() -> Self::TokenStream {
+    }
-                let group: Self::Group = make();
+}
-                make()
-            }
+with_api!(Self, self_, declare_server_traits);
-        }
+struct G {}
-        "#,
+struct T {}
+struct Rustc;
+impl Types for Rustc {
+    type TokenStream = T;
+    type Group = G;
+}
+fn make<T>() -> T { loop {} }
+impl TokenStream for Rustc {
+    fn new() -> Self::TokenStream {
+        let group: Self::Group = make();
+        make()
+    }
+}"#,
        expect![[r#"
            1061..1072 '{ loop {} }': T
            1063..1070 'loop {}': !
@@ -2436,23 +2436,22 @@ fn proc_macro_server_types() {
 fn unify_impl_trait() {
    check_infer_with_mismatches(
        r#"
-        trait Trait<T> {}
+trait Trait<T> {}
-        fn foo(x: impl Trait<u32>) { loop {} }
+fn foo(x: impl Trait<u32>) { loop {} }
-        fn bar<T>(x: impl Trait<T>) -> T { loop {} }
+fn bar<T>(x: impl Trait<T>) -> T { loop {} }
-        struct S<T>(T);
+struct S<T>(T);
-        impl<T> Trait<T> for S<T> {}
+impl<T> Trait<T> for S<T> {}
-        fn default<T>() -> T { loop {} }
+fn default<T>() -> T { loop {} }
-        fn test() -> impl Trait<i32> {
+fn test() -> impl Trait<i32> {
-            let s1 = S(default());
+    let s1 = S(default());
-            foo(s1);
+    foo(s1);
-            let x: i32 = bar(S(default()));
+    let x: i32 = bar(S(default()));
-            S(default())
+    S(default())
-        }
+}"#,
-        "#,
        expect![[r#"
            26..27 'x': impl Trait<u32>
            46..57 '{ loop {} }': ()
@@ -2493,30 +2492,29 @@ fn unify_impl_trait() {
 fn assoc_types_from_bounds() {
    check_infer(
        r#"
-        //- /main.rs
+//- /main.rs
-        #[lang = "fn_once"]
+#[lang = "fn_once"]
-        trait FnOnce<Args> {
+trait FnOnce<Args> {
-            type Output;
+    type Output;
-        }
+}
-        trait T {
+trait T {
-            type O;
+    type O;
-        }
+}
-        impl T for () {
+impl T for () {
-            type O = ();
+    type O = ();
-        }
+}
-        fn f<X, F>(_v: F)
+fn f<X, F>(_v: F)
-        where
+where
-            X: T,
+    X: T,
-            F: FnOnce(&X::O),
+    F: FnOnce(&X::O),
-        { }
+{ }
-        fn main() {
+fn main() {
-            f::<(), _>(|z| { z; });
+    f::<(), _>(|z| { z; });
-        }
+}"#,
-        "#,
        expect![[r#"
            133..135 '_v': F
            178..181 '{ }': ()
@@ -2602,76 +2600,75 @@ fn test() {
 fn iterator_chain() {
    check_infer_with_mismatches(
        r#"
-        //- /main.rs
+//- /main.rs
-        #[lang = "fn_once"]
+#[lang = "fn_once"]
-        trait FnOnce<Args> {
+trait FnOnce<Args> {
-            type Output;
+    type Output;
-        }
+}
-        #[lang = "fn_mut"]
+#[lang = "fn_mut"]
-        trait FnMut<Args>: FnOnce<Args> { }
+trait FnMut<Args>: FnOnce<Args> { }
-        enum Option<T> { Some(T), None }
+enum Option<T> { Some(T), None }
-        use Option::*;
+use Option::*;
-        pub trait Iterator {
+pub trait Iterator {
-            type Item;
+    type Item;
-            fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
+    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
-            where
+    where
-                F: FnMut(Self::Item) -> Option<B>,
+        F: FnMut(Self::Item) -> Option<B>,
-            { loop {} }
+    { loop {} }
-            fn for_each<F>(self, f: F)
+    fn for_each<F>(self, f: F)
-            where
+    where
-                F: FnMut(Self::Item),
+        F: FnMut(Self::Item),
-            { loop {} }
+    { loop {} }
-        }
+}
-        pub trait IntoIterator {
+pub trait IntoIterator {
-            type Item;
+    type Item;
-            type IntoIter: Iterator<Item = Self::Item>;
+    type IntoIter: Iterator<Item = Self::Item>;
-            fn into_iter(self) -> Self::IntoIter;
+    fn into_iter(self) -> Self::IntoIter;
-        }
+}
-        pub struct FilterMap<I, F> { }
+pub struct FilterMap<I, F> { }
-        impl<B, I: Iterator, F> Iterator for FilterMap<I, F>
+impl<B, I: Iterator, F> Iterator for FilterMap<I, F>
-        where
+where
-            F: FnMut(I::Item) -> Option<B>,
+    F: FnMut(I::Item) -> Option<B>,
-        {
+{
-            type Item = B;
+    type Item = B;
-        }
+}
-        #[stable(feature = "rust1", since = "1.0.0")]
+#[stable(feature = "rust1", since = "1.0.0")]
-        impl<I: Iterator> IntoIterator for I {
+impl<I: Iterator> IntoIterator for I {
-            type Item = I::Item;
+    type Item = I::Item;
-            type IntoIter = I;
+    type IntoIter = I;
-            fn into_iter(self) -> I {
+    fn into_iter(self) -> I {
-                self
+        self
-            }
+    }
-        }
+}
-        struct Vec<T> {}
+struct Vec<T> {}
-        impl<T> Vec<T> {
+impl<T> Vec<T> {
-            fn new() -> Self { loop {} }
+    fn new() -> Self { loop {} }
-        }
+}
-        impl<T> IntoIterator for Vec<T> {
+impl<T> IntoIterator for Vec<T> {
-            type Item = T;
+    type Item = T;
-            type IntoIter = IntoIter<T>;
+    type IntoIter = IntoIter<T>;
-        }
+}
-        pub struct IntoIter<T> { }
+pub struct IntoIter<T> { }
-        impl<T> Iterator for IntoIter<T> {
+impl<T> Iterator for IntoIter<T> {
-            type Item = T;
+    type Item = T;
-        }
+}
-        fn main() {
+fn main() {
-            Vec::<i32>::new().into_iter()
+    Vec::<i32>::new().into_iter()
-            .filter_map(|x| if x > 0 { Some(x as u32) } else { None })
+    .filter_map(|x| if x > 0 { Some(x as u32) } else { None })
-            .for_each(|y| { y; });
+    .for_each(|y| { y; });
-        }
+}"#,
-        "#,
        expect![[r#"
            226..230 'self': Self
            232..233 'f': F
@@ -2753,14 +2750,13 @@ fn main() {
 fn trait_object_no_coercion() {
    check_infer_with_mismatches(
        r#"
-        trait Foo {}
+trait Foo {}
-        fn foo(x: &dyn Foo) {}
+fn foo(x: &dyn Foo) {}
-        fn test(x: &dyn Foo) {
+fn test(x: &dyn Foo) {
-            foo(x);
+    foo(x);
-        }
+}"#,
-        "#,
        expect![[r#"
            21..22 'x': &dyn Foo
            34..36 '{}': ()
@@ -2777,23 +2773,22 @@ fn trait_object_no_coercion() {
 fn builtin_copy() {
    check_infer_with_mismatches(
        r#"
-        #[lang = "copy"]
+#[lang = "copy"]
-        trait Copy {}
+trait Copy {}
-        struct IsCopy;
+struct IsCopy;
-        impl Copy for IsCopy {}
+impl Copy for IsCopy {}
-        struct NotCopy;
+struct NotCopy;
-        trait Test { fn test(&self) -> bool; }
+trait Test { fn test(&self) -> bool; }
-        impl<T: Copy> Test for T {}
+impl<T: Copy> Test for T {}
-        fn test() {
+fn test() {
-            IsCopy.test();
+    IsCopy.test();
-            NotCopy.test();
+    NotCopy.test();
-            (IsCopy, IsCopy).test();
+    (IsCopy, IsCopy).test();
-            (IsCopy, NotCopy).test();
+    (IsCopy, NotCopy).test();
-        }
+}"#,
-        "#,
        expect![[r#"
            110..114 'self': &Self
            166..267 '{     ...t(); }': ()
@@ -2817,24 +2812,23 @@ fn builtin_copy() {
 fn builtin_fn_def_copy() {
    check_infer_with_mismatches(
        r#"
-        #[lang = "copy"]
+#[lang = "copy"]
-        trait Copy {}
+trait Copy {}
-        fn foo() {}
+fn foo() {}
-        fn bar<T: Copy>(T) -> T {}
+fn bar<T: Copy>(T) -> T {}
-        struct Struct(usize);
+struct Struct(usize);
-        enum Enum { Variant(usize) }
+enum Enum { Variant(usize) }
-        trait Test { fn test(&self) -> bool; }
+trait Test { fn test(&self) -> bool; }
-        impl<T: Copy> Test for T {}
+impl<T: Copy> Test for T {}
-        fn test() {
+fn test() {
-            foo.test();
+    foo.test();
-            bar.test();
+    bar.test();
-            Struct.test();
+    Struct.test();
-            Enum::Variant.test();
+    Enum::Variant.test();
-        }
+}"#,
-        "#,
        expect![[r#"
            41..43 '{}': ()
            60..61 'T': {unknown}
@@ -2858,18 +2852,17 @@ fn builtin_fn_def_copy() {
 fn builtin_fn_ptr_copy() {
    check_infer_with_mismatches(
        r#"
-        #[lang = "copy"]
+#[lang = "copy"]
-        trait Copy {}
+trait Copy {}
-        trait Test { fn test(&self) -> bool; }
+trait Test { fn test(&self) -> bool; }
-        impl<T: Copy> Test for T {}
+impl<T: Copy> Test for T {}
-        fn test(f1: fn(), f2: fn(usize) -> u8, f3: fn(u8, u8) -> &u8) {
+fn test(f1: fn(), f2: fn(usize) -> u8, f3: fn(u8, u8) -> &u8) {
-            f1.test();
+    f1.test();
-            f2.test();
+    f2.test();
-            f3.test();
+    f3.test();
-        }
+}"#,
-        "#,
        expect![[r#"
            54..58 'self': &Self
            108..110 'f1': fn()
@@ -2890,19 +2883,18 @@ fn builtin_fn_ptr_copy() {
 fn builtin_sized() {
    check_infer_with_mismatches(
        r#"
-        #[lang = "sized"]
+#[lang = "sized"]
-        trait Sized {}
+trait Sized {}
-        trait Test { fn test(&self) -> bool; }
+trait Test { fn test(&self) -> bool; }
-        impl<T: Sized> Test for T {}
+impl<T: Sized> Test for T {}
-        fn test() {
+fn test() {
-            1u8.test();
+    1u8.test();
-            (*"foo").test(); // not Sized
+    (*"foo").test(); // not Sized
-            (1u8, 1u8).test();
+    (1u8, 1u8).test();
-            (1u8, *"foo").test(); // not Sized
+    (1u8, *"foo").test(); // not Sized
-        }
+}"#,
-        "#,
        expect![[r#"
            56..60 'self': &Self
            113..228 '{     ...ized }': ()
@@ -2972,19 +2964,18 @@ impl<A: Step> iter::Iterator for ops::Range<A> {
 fn infer_closure_arg() {
    check_infer(
        r#"
-        //- /lib.rs
+//- /lib.rs
-        enum Option<T> {
+enum Option<T> {
-            None,
+    None,
-            Some(T)
+    Some(T)
-        }
+}
-        fn foo() {
+fn foo() {
-            let s = Option::None;
+    let s = Option::None;
-            let f = |x: Option<i32>| {};
+    let f = |x: Option<i32>| {};
-            (&f)(s)
+    (&f)(s)
-        }
+}"#,
-        "#,
        expect![[r#"
            52..126 '{     ...)(s) }': ()
            62..63 's': Option<i32>
@@ -3053,46 +3044,45 @@ fn infer_box_fn_arg() {
    // The type mismatch is a bug
    check_infer_with_mismatches(
        r#"
-        //- /lib.rs deps:std
+//- /lib.rs deps:std
-        #[lang = "fn_once"]
+#[lang = "fn_once"]
-        pub trait FnOnce<Args> {
+pub trait FnOnce<Args> {
-            type Output;
+    type Output;
-            extern "rust-call" fn call_once(self, args: Args) -> Self::Output;
+    extern "rust-call" fn call_once(self, args: Args) -> Self::Output;
-        }
+}
-        #[lang = "deref"]
+#[lang = "deref"]
-        pub trait Deref {
+pub trait Deref {
-            type Target: ?Sized;
+    type Target: ?Sized;
-            fn deref(&self) -> &Self::Target;
+    fn deref(&self) -> &Self::Target;
-        }
+}
-        #[lang = "owned_box"]
+#[lang = "owned_box"]
-        pub struct Box<T: ?Sized> {
+pub struct Box<T: ?Sized> {
-            inner: *mut T,
+    inner: *mut T,
-        }
+}
-        impl<T: ?Sized> Deref for Box<T> {
+impl<T: ?Sized> Deref for Box<T> {
-            type Target = T;
+    type Target = T;
-            fn deref(&self) -> &T {
+    fn deref(&self) -> &T {
-                &self.inner
+        &self.inner
-            }
+    }
-        }
+}
-        enum Option<T> {
+enum Option<T> {
-            None,
+    None,
-            Some(T)
+    Some(T)
-        }
+}
-        fn foo() {
+fn foo() {
-            let s = Option::None;
+    let s = Option::None;
-            let f: Box<dyn FnOnce(&Option<i32>)> = box (|ps| {});
+    let f: Box<dyn FnOnce(&Option<i32>)> = box (|ps| {});
-            f(&s);
+    f(&s);
-        }
+}"#,
-        "#,
        expect![[r#"
            100..104 'self': Self
            106..110 'args': Args
@@ -3258,8 +3248,7 @@ fn f() {
        ().method();
      //^^^^^^^^^^^ u8
    }
-}
+}"#,
-        "#,
        expect![[r#"
            46..50 'self': &Self
            58..63 '{ 0 }': u8
@@ -3313,8 +3302,7 @@ fn f() {
    fn inner() -> S {
        let s = inner();
    }
-}
+}"#,
-        "#,
        expect![[r#"
            17..73 '{     ...   } }': ()
            39..71 '{     ...     }': ()
@@ -3349,8 +3337,7 @@ fn test() {
    let x = A;
    let y = A;
    let r = x.do_op(y);
-}
+}"#,
-        "#,
        expect![[r#"
            63..67 'self': Self
            69..72 'rhs': RHS
@@ -3399,9 +3386,7 @@ impl foo::Bar for F {
 fn foo() {
    use foo::Bar;
    let x = <F as Bar>::boo();
-}
+}"#,
-        "#,
        expect![[r#"
            132..163 '{     ...     }': Bar::Output<Self>
            146..153 'loop {}': !
@@ -3413,3 +3398,79 @@ fn foo() {
        "#]],
    );
 }
+#[test]
+fn renamed_extern_crate_in_block() {
+    check_types(
+        r#"
+//- /lib.rs crate:lib deps:serde
+use serde::Deserialize;
+struct Foo {}
+const _ : () = {
+    extern crate serde as _serde;
+    impl _serde::Deserialize for Foo {
+        fn deserialize() -> u8 { 0 }
+    }
+};
+fn foo() {
+    Foo::deserialize();
+  //^^^^^^^^^^^^^^^^^^ u8
+}
+//- /serde.rs crate:serde
+pub trait Deserialize {
+    fn deserialize() -> u8;
+}"#,
+    );
+}
+#[test]
+fn bin_op_adt_with_rhs_primitive() {
+    check_infer_with_mismatches(
+        r#"
+#[lang = "add"]
+pub trait Add<Rhs = Self> {
+    type Output;
+    fn add(self, rhs: Rhs) -> Self::Output;
+}
+struct Wrapper(u32);
+impl Add<u32> for Wrapper {
+    type Output = Self;
+    fn add(self, rhs: u32) -> Wrapper {
+        Wrapper(rhs)
+    }
+}
+fn main(){
+    let wrapped = Wrapper(10);
+    let num: u32 = 2;
+    let res = wrapped + num;
+}"#,
+        expect![[r#"
+            72..76 'self': Self
+            78..81 'rhs': Rhs
+            192..196 'self': Wrapper
+            198..201 'rhs': u32
+            219..247 '{     ...     }': Wrapper
+            229..236 'Wrapper': Wrapper(u32) -> Wrapper
+            229..241 'Wrapper(rhs)': Wrapper
+            237..240 'rhs': u32
+            259..345 '{     ...um;  }': ()
+            269..276 'wrapped': Wrapper
+            279..286 'Wrapper': Wrapper(u32) -> Wrapper
+            279..290 'Wrapper(10)': Wrapper
+            287..289 '10': u32
+            300..303 'num': u32
+            311..312 '2': u32
+            322..325 'res': Wrapper
+            328..335 'wrapped': Wrapper
+            328..341 'wrapped + num': Wrapper
+            338..341 'num': u32
+        "#]],
+    )
+}
diff --git a/crates/hir_ty/src/traits/chalk/tls.rs b/crates/hir_ty/src/tls.rs
index 8892a63a9..87c671a42 100644
--- a/crates/hir_ty/src/traits/chalk/tls.rs
+++ b/crates/hir_ty/src/tls.rs
@@ -4,8 +4,10 @@ use std::fmt;
 use chalk_ir::{AliasTy, GenericArg, Goal, Goals, Lifetime, ProgramClauseImplication};
 use itertools::Itertools;
-use super::{from_chalk, Interner};
+use crate::{
-use crate::{db::HirDatabase, from_assoc_type_id, CallableDefId};
+    chalk_db, db::HirDatabase, from_assoc_type_id, from_chalk_trait_id, mapping::from_chalk,
+    CallableDefId, Interner,
+};
 use hir_def::{AdtId, AssocContainerId, Lookup, TypeAliasId};
 pub(crate) use unsafe_tls::{set_current_program, with_current_program};
@@ -15,7 +17,7 @@ pub(crate) struct DebugContext<'a>(&'a dyn HirDatabase);
 impl DebugContext<'_> {
    pub(crate) fn debug_struct_id(
        &self,
-        id: super::AdtId,
+        id: chalk_db::AdtId,
        f: &mut fmt::Formatter<'_>,
    ) -> Result<(), fmt::Error> {
        let name = match id.0 {
@@ -28,17 +30,17 @@ impl DebugContext<'_> {
    pub(crate) fn debug_trait_id(
        &self,
-        id: super::TraitId,
+        id: chalk_db::TraitId,
        fmt: &mut fmt::Formatter<'_>,
    ) -> Result<(), fmt::Error> {
-        let trait_: hir_def::TraitId = from_chalk(self.0, id);
+        let trait_: hir_def::TraitId = from_chalk_trait_id(id);
        let trait_data = self.0.trait_data(trait_);
        write!(fmt, "{}", trait_data.name)
    }
    pub(crate) fn debug_assoc_type_id(
        &self,
-        id: super::AssocTypeId,
+        id: chalk_db::AssocTypeId,
        fmt: &mut fmt::Formatter<'_>,
    ) -> Result<(), fmt::Error> {
        let type_alias: TypeAliasId = from_assoc_type_id(id);
diff --git a/crates/hir_ty/src/traits.rs b/crates/hir_ty/src/traits.rs
index 7d87741b8..9936d0803 100644
--- a/crates/hir_ty/src/traits.rs
+++ b/crates/hir_ty/src/traits.rs
@@ -1,28 +1,26 @@
 //! Trait solving using Chalk.
 use std::env::var;
-use base_db::CrateId;
 use chalk_ir::cast::Cast;
 use chalk_solve::{logging_db::LoggingRustIrDatabase, Solver};
+use base_db::CrateId;
 use hir_def::{lang_item::LangItemTarget, TraitId};
 use stdx::panic_context;
 use crate::{
    db::HirDatabase, AliasEq, AliasTy, Canonical, DomainGoal, Guidance, HirDisplay, InEnvironment,
-    Solution, TraitRefExt, Ty, TyKind, WhereClause,
+    Interner, Solution, TraitRefExt, Ty, TyKind, WhereClause,
 };
-use self::chalk::{from_chalk, Interner, ToChalk};
-pub(crate) mod chalk;
 /// This controls how much 'time' we give the Chalk solver before giving up.
 const CHALK_SOLVER_FUEL: i32 = 100;
 #[derive(Debug, Copy, Clone)]
-struct ChalkContext<'a> {
+pub(crate) struct ChalkContext<'a> {
-    db: &'a dyn HirDatabase,
+    pub(crate) db: &'a dyn HirDatabase,
-    krate: CrateId,
+    pub(crate) krate: CrateId,
 }
 fn create_chalk_solver() -> chalk_recursive::RecursiveSolver<Interner> {
@@ -81,6 +79,7 @@ pub(crate) fn trait_solve_query(
            db.trait_data(it.hir_trait_id()).name.to_string()
        }
        DomainGoal::Holds(WhereClause::AliasEq(_)) => "alias_eq".to_string(),
+        _ => "??".to_string(),
    });
    log::info!("trait_solve_query({})", goal.value.goal.display(db));
@@ -95,13 +94,12 @@ pub(crate) fn trait_solve_query(
        }
    }
-    let canonical = goal.to_chalk(db).cast(&Interner);
+    let canonical = goal.cast(&Interner);
    // We currently don't deal with universes (I think / hope they're not yet
    // relevant for our use cases?)
    let u_canonical = chalk_ir::UCanonical { canonical, universes: 1 };
-    let solution = solve(db, krate, &u_canonical);
+    solve(db, krate, &u_canonical)
-    solution.map(|solution| solution_from_chalk(db, solution))
 }
 fn solve(
@@ -148,7 +146,7 @@ fn solve(
    // don't set the TLS for Chalk unless Chalk debugging is active, to make
    // extra sure we only use it for debugging
    let solution =
-        if is_chalk_debug() { chalk::tls::set_current_program(db, solve) } else { solve() };
+        if is_chalk_debug() { crate::tls::set_current_program(db, solve) } else { solve() };
    solution
 }
@@ -169,26 +167,6 @@ fn is_chalk_print() -> bool {
    std::env::var("CHALK_PRINT").is_ok()
 }
-fn solution_from_chalk(
-    db: &dyn HirDatabase,
-    solution: chalk_solve::Solution<Interner>,
-) -> Solution {
-    match solution {
-        chalk_solve::Solution::Unique(constr_subst) => {
-            Solution::Unique(from_chalk(db, constr_subst))
-        }
-        chalk_solve::Solution::Ambig(chalk_solve::Guidance::Definite(subst)) => {
-            Solution::Ambig(Guidance::Definite(from_chalk(db, subst)))
-        }
-        chalk_solve::Solution::Ambig(chalk_solve::Guidance::Suggested(subst)) => {
-            Solution::Ambig(Guidance::Suggested(from_chalk(db, subst)))
-        }
-        chalk_solve::Solution::Ambig(chalk_solve::Guidance::Unknown) => {
-            Solution::Ambig(Guidance::Unknown)
-        }
-    }
-}
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 pub enum FnTrait {
    FnOnce,
diff --git a/crates/hir_ty/src/traits/chalk/mapping.rs b/crates/hir_ty/src/traits/chalk/mapping.rs
deleted file mode 100644
index 701359e6f..000000000
--- a/crates/hir_ty/src/traits/chalk/mapping.rs
+++ /dev/null
@@ -1,546 +0,0 @@
-//! 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_ir::{cast::Cast, interner::HasInterner};
-use chalk_solve::rust_ir;
-use base_db::salsa::InternKey;
-use hir_def::{GenericDefId, TypeAliasId};
-use crate::{
-    db::HirDatabase, static_lifetime, AliasTy, CallableDefId, Canonical, ConstrainedSubst,
-    DomainGoal, FnPointer, GenericArg, InEnvironment, OpaqueTy, ProjectionTy, ProjectionTyExt,
-    QuantifiedWhereClause, Substitution, TraitRef, Ty, TypeWalk, WhereClause,
-};
-use super::interner::*;
-use super::*;
-impl ToChalk for Ty {
-    type Chalk = chalk_ir::Ty<Interner>;
-    fn to_chalk(self, db: &dyn HirDatabase) -> chalk_ir::Ty<Interner> {
-        match self.into_inner() {
-            TyKind::Ref(m, lt, ty) => {
-                chalk_ir::TyKind::Ref(m, lt, ty.to_chalk(db)).intern(&Interner)
-            }
-            TyKind::Array(ty, size) => {
-                chalk_ir::TyKind::Array(ty.to_chalk(db), size).intern(&Interner)
-            }
-            TyKind::Function(FnPointer { sig, substitution: substs, num_binders }) => {
-                let substitution = chalk_ir::FnSubst(substs.0.to_chalk(db));
-                chalk_ir::TyKind::Function(chalk_ir::FnPointer { num_binders, sig, substitution })
-                    .intern(&Interner)
-            }
-            TyKind::AssociatedType(assoc_type_id, substs) => {
-                let substitution = substs.to_chalk(db);
-                chalk_ir::TyKind::AssociatedType(assoc_type_id, substitution).intern(&Interner)
-            }
-            TyKind::OpaqueType(id, substs) => {
-                let substitution = substs.to_chalk(db);
-                chalk_ir::TyKind::OpaqueType(id, substitution).intern(&Interner)
-            }
-            TyKind::Foreign(id) => chalk_ir::TyKind::Foreign(id).intern(&Interner),
-            TyKind::Scalar(scalar) => chalk_ir::TyKind::Scalar(scalar).intern(&Interner),
-            TyKind::Tuple(cardinality, substs) => {
-                let substitution = substs.to_chalk(db);
-                chalk_ir::TyKind::Tuple(cardinality, substitution).intern(&Interner)
-            }
-            TyKind::Raw(mutability, ty) => {
-                let ty = ty.to_chalk(db);
-                chalk_ir::TyKind::Raw(mutability, ty).intern(&Interner)
-            }
-            TyKind::Slice(ty) => chalk_ir::TyKind::Slice(ty.to_chalk(db)).intern(&Interner),
-            TyKind::Str => chalk_ir::TyKind::Str.intern(&Interner),
-            TyKind::FnDef(id, substs) => {
-                let substitution = substs.to_chalk(db);
-                chalk_ir::TyKind::FnDef(id, substitution).intern(&Interner)
-            }
-            TyKind::Never => chalk_ir::TyKind::Never.intern(&Interner),
-            TyKind::Closure(closure_id, substs) => {
-                let substitution = substs.to_chalk(db);
-                chalk_ir::TyKind::Closure(closure_id, substitution).intern(&Interner)
-            }
-            TyKind::Adt(adt_id, substs) => {
-                let substitution = substs.to_chalk(db);
-                chalk_ir::TyKind::Adt(adt_id, substitution).intern(&Interner)
-            }
-            TyKind::Alias(AliasTy::Projection(proj_ty)) => {
-                chalk_ir::AliasTy::Projection(proj_ty.to_chalk(db))
-                    .cast(&Interner)
-                    .intern(&Interner)
-            }
-            TyKind::Alias(AliasTy::Opaque(opaque_ty)) => {
-                chalk_ir::AliasTy::Opaque(opaque_ty.to_chalk(db)).cast(&Interner).intern(&Interner)
-            }
-            TyKind::Placeholder(idx) => idx.to_ty::<Interner>(&Interner),
-            TyKind::BoundVar(idx) => chalk_ir::TyKind::BoundVar(idx).intern(&Interner),
-            TyKind::InferenceVar(..) => panic!("uncanonicalized infer ty"),
-            TyKind::Dyn(dyn_ty) => {
-                let (bounds, binders) = dyn_ty.bounds.into_value_and_skipped_binders();
-                let where_clauses = chalk_ir::QuantifiedWhereClauses::from_iter(
-                    &Interner,
-                    bounds.interned().iter().cloned().map(|p| p.to_chalk(db)),
-                );
-                let bounded_ty = chalk_ir::DynTy {
-                    bounds: chalk_ir::Binders::new(binders, where_clauses),
-                    lifetime: dyn_ty.lifetime,
-                };
-                chalk_ir::TyKind::Dyn(bounded_ty).intern(&Interner)
-            }
-            TyKind::Error => chalk_ir::TyKind::Error.intern(&Interner),
-        }
-    }
-    fn from_chalk(db: &dyn HirDatabase, chalk: chalk_ir::Ty<Interner>) -> Self {
-        match chalk.data(&Interner).kind.clone() {
-            chalk_ir::TyKind::Error => TyKind::Error,
-            chalk_ir::TyKind::Array(ty, size) => TyKind::Array(from_chalk(db, ty), size),
-            chalk_ir::TyKind::Placeholder(idx) => TyKind::Placeholder(idx),
-            chalk_ir::TyKind::Alias(chalk_ir::AliasTy::Projection(proj)) => {
-                TyKind::Alias(AliasTy::Projection(from_chalk(db, proj)))
-            }
-            chalk_ir::TyKind::Alias(chalk_ir::AliasTy::Opaque(opaque_ty)) => {
-                TyKind::Alias(AliasTy::Opaque(from_chalk(db, opaque_ty)))
-            }
-            chalk_ir::TyKind::Function(chalk_ir::FnPointer {
-                num_binders,
-                sig,
-                substitution,
-                ..
-            }) => {
-                assert_eq!(num_binders, 0);
-                let substs = crate::FnSubst(from_chalk(db, substitution.0));
-                TyKind::Function(FnPointer { num_binders, sig, substitution: substs })
-            }
-            chalk_ir::TyKind::BoundVar(idx) => TyKind::BoundVar(idx),
-            chalk_ir::TyKind::InferenceVar(_iv, _kind) => TyKind::Error,
-            chalk_ir::TyKind::Dyn(dyn_ty) => {
-                assert_eq!(dyn_ty.bounds.binders.len(&Interner), 1);
-                let (bounds, binders) = dyn_ty.bounds.into_value_and_skipped_binders();
-                let where_clauses = crate::QuantifiedWhereClauses::from_iter(
-                    &Interner,
-                    bounds.interned().iter().cloned().map(|p| from_chalk(db, p)),
-                );
-                TyKind::Dyn(crate::DynTy {
-                    bounds: crate::Binders::new(binders, where_clauses),
-                    // HACK: we sometimes get lifetime variables back in solutions
-                    // from Chalk, and don't have the infrastructure to substitute
-                    // them yet. So for now we just turn them into 'static right
-                    // when we get them
-                    lifetime: static_lifetime(),
-                })
-            }
-            chalk_ir::TyKind::Adt(adt_id, subst) => TyKind::Adt(adt_id, from_chalk(db, subst)),
-            chalk_ir::TyKind::AssociatedType(type_id, subst) => {
-                TyKind::AssociatedType(type_id, from_chalk(db, subst))
-            }
-            chalk_ir::TyKind::OpaqueType(opaque_type_id, subst) => {
-                TyKind::OpaqueType(opaque_type_id, from_chalk(db, subst))
-            }
-            chalk_ir::TyKind::Scalar(scalar) => TyKind::Scalar(scalar),
-            chalk_ir::TyKind::Tuple(cardinality, subst) => {
-                TyKind::Tuple(cardinality, from_chalk(db, subst))
-            }
-            chalk_ir::TyKind::Raw(mutability, ty) => TyKind::Raw(mutability, from_chalk(db, ty)),
-            chalk_ir::TyKind::Slice(ty) => TyKind::Slice(from_chalk(db, ty)),
-            chalk_ir::TyKind::Ref(mutability, _lifetime, ty) => {
-                // HACK: we sometimes get lifetime variables back in solutions
-                // from Chalk, and don't have the infrastructure to substitute
-                // them yet. So for now we just turn them into 'static right
-                // when we get them
-                TyKind::Ref(mutability, static_lifetime(), from_chalk(db, ty))
-            }
-            chalk_ir::TyKind::Str => TyKind::Str,
-            chalk_ir::TyKind::Never => TyKind::Never,
-            chalk_ir::TyKind::FnDef(fn_def_id, subst) => {
-                TyKind::FnDef(fn_def_id, from_chalk(db, subst))
-            }
-            chalk_ir::TyKind::Closure(id, subst) => TyKind::Closure(id, from_chalk(db, subst)),
-            chalk_ir::TyKind::Foreign(foreign_def_id) => TyKind::Foreign(foreign_def_id),
-            chalk_ir::TyKind::Generator(_, _) => unimplemented!(), // FIXME
-            chalk_ir::TyKind::GeneratorWitness(_, _) => unimplemented!(), // FIXME
-        }
-        .intern(&Interner)
-    }
-}
-impl ToChalk for GenericArg {
-    type Chalk = chalk_ir::GenericArg<Interner>;
-    fn to_chalk(self, db: &dyn HirDatabase) -> Self::Chalk {
-        match self.interned() {
-            crate::GenericArgData::Ty(ty) => ty.clone().to_chalk(db).cast(&Interner),
-        }
-    }
-    fn from_chalk(db: &dyn HirDatabase, chalk: Self::Chalk) -> Self {
-        match chalk.interned() {
-            chalk_ir::GenericArgData::Ty(ty) => Ty::from_chalk(db, ty.clone()).cast(&Interner),
-            chalk_ir::GenericArgData::Lifetime(_) => unimplemented!(),
-            chalk_ir::GenericArgData::Const(_) => unimplemented!(),
-        }
-    }
-}
-impl ToChalk for Substitution {
-    type Chalk = chalk_ir::Substitution<Interner>;
-    fn to_chalk(self, db: &dyn HirDatabase) -> chalk_ir::Substitution<Interner> {
-        chalk_ir::Substitution::from_iter(
-            &Interner,
-            self.iter(&Interner).map(|ty| ty.clone().to_chalk(db)),
-        )
-    }
-    fn from_chalk(
-        db: &dyn HirDatabase,
-        parameters: chalk_ir::Substitution<Interner>,
-    ) -> Substitution {
-        let tys = parameters.iter(&Interner).map(|p| from_chalk(db, p.clone())).collect();
-        Substitution::intern(tys)
-    }
-}
-impl ToChalk for TraitRef {
-    type Chalk = chalk_ir::TraitRef<Interner>;
-    fn to_chalk(self: TraitRef, db: &dyn HirDatabase) -> chalk_ir::TraitRef<Interner> {
-        let trait_id = self.trait_id;
-        let substitution = self.substitution.to_chalk(db);
-        chalk_ir::TraitRef { trait_id, substitution }
-    }
-    fn from_chalk(db: &dyn HirDatabase, trait_ref: chalk_ir::TraitRef<Interner>) -> Self {
-        let trait_id = trait_ref.trait_id;
-        let substs = from_chalk(db, trait_ref.substitution);
-        TraitRef { trait_id, substitution: substs }
-    }
-}
-impl ToChalk for hir_def::TraitId {
-    type Chalk = TraitId;
-    fn to_chalk(self, _db: &dyn HirDatabase) -> TraitId {
-        chalk_ir::TraitId(self.as_intern_id())
-    }
-    fn from_chalk(_db: &dyn HirDatabase, trait_id: TraitId) -> hir_def::TraitId {
-        InternKey::from_intern_id(trait_id.0)
-    }
-}
-impl ToChalk for hir_def::ImplId {
-    type Chalk = ImplId;
-    fn to_chalk(self, _db: &dyn HirDatabase) -> ImplId {
-        chalk_ir::ImplId(self.as_intern_id())
-    }
-    fn from_chalk(_db: &dyn HirDatabase, impl_id: 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 = AssociatedTyValueId;
-    fn to_chalk(self, _db: &dyn HirDatabase) -> AssociatedTyValueId {
-        rust_ir::AssociatedTyValueId(self.0.as_intern_id())
-    }
-    fn from_chalk(
-        _db: &dyn HirDatabase,
-        assoc_ty_value_id: AssociatedTyValueId,
-    ) -> TypeAliasAsValue {
-        TypeAliasAsValue(TypeAliasId::from_intern_id(assoc_ty_value_id.0))
-    }
-}
-impl ToChalk for WhereClause {
-    type Chalk = chalk_ir::WhereClause<Interner>;
-    fn to_chalk(self, db: &dyn HirDatabase) -> chalk_ir::WhereClause<Interner> {
-        match self {
-            WhereClause::Implemented(trait_ref) => {
-                chalk_ir::WhereClause::Implemented(trait_ref.to_chalk(db))
-            }
-            WhereClause::AliasEq(alias_eq) => chalk_ir::WhereClause::AliasEq(alias_eq.to_chalk(db)),
-        }
-    }
-    fn from_chalk(
-        db: &dyn HirDatabase,
-        where_clause: chalk_ir::WhereClause<Interner>,
-    ) -> WhereClause {
-        match where_clause {
-            chalk_ir::WhereClause::Implemented(tr) => WhereClause::Implemented(from_chalk(db, tr)),
-            chalk_ir::WhereClause::AliasEq(alias_eq) => {
-                WhereClause::AliasEq(from_chalk(db, alias_eq))
-            }
-            chalk_ir::WhereClause::LifetimeOutlives(_) => {
-                // we shouldn't get these from Chalk
-                panic!("encountered LifetimeOutlives from Chalk")
-            }
-            chalk_ir::WhereClause::TypeOutlives(_) => {
-                // we shouldn't get these from Chalk
-                panic!("encountered TypeOutlives from Chalk")
-            }
-        }
-    }
-}
-impl ToChalk for ProjectionTy {
-    type Chalk = chalk_ir::ProjectionTy<Interner>;
-    fn to_chalk(self, db: &dyn HirDatabase) -> chalk_ir::ProjectionTy<Interner> {
-        chalk_ir::ProjectionTy {
-            associated_ty_id: self.associated_ty_id,
-            substitution: self.substitution.to_chalk(db),
-        }
-    }
-    fn from_chalk(
-        db: &dyn HirDatabase,
-        projection_ty: chalk_ir::ProjectionTy<Interner>,
-    ) -> ProjectionTy {
-        ProjectionTy {
-            associated_ty_id: projection_ty.associated_ty_id,
-            substitution: from_chalk(db, projection_ty.substitution),
-        }
-    }
-}
-impl ToChalk for OpaqueTy {
-    type Chalk = chalk_ir::OpaqueTy<Interner>;
-    fn to_chalk(self, db: &dyn HirDatabase) -> Self::Chalk {
-        chalk_ir::OpaqueTy {
-            opaque_ty_id: self.opaque_ty_id,
-            substitution: self.substitution.to_chalk(db),
-        }
-    }
-    fn from_chalk(db: &dyn HirDatabase, chalk: Self::Chalk) -> Self {
-        OpaqueTy {
-            opaque_ty_id: chalk.opaque_ty_id,
-            substitution: from_chalk(db, chalk.substitution),
-        }
-    }
-}
-impl ToChalk for AliasTy {
-    type Chalk = chalk_ir::AliasTy<Interner>;
-    fn to_chalk(self, db: &dyn HirDatabase) -> Self::Chalk {
-        match self {
-            AliasTy::Projection(projection_ty) => {
-                chalk_ir::AliasTy::Projection(projection_ty.to_chalk(db))
-            }
-            AliasTy::Opaque(opaque_ty) => chalk_ir::AliasTy::Opaque(opaque_ty.to_chalk(db)),
-        }
-    }
-    fn from_chalk(db: &dyn HirDatabase, chalk: Self::Chalk) -> Self {
-        match chalk {
-            chalk_ir::AliasTy::Projection(projection_ty) => {
-                AliasTy::Projection(from_chalk(db, projection_ty))
-            }
-            chalk_ir::AliasTy::Opaque(opaque_ty) => AliasTy::Opaque(from_chalk(db, opaque_ty)),
-        }
-    }
-}
-impl ToChalk for AliasEq {
-    type Chalk = chalk_ir::AliasEq<Interner>;
-    fn to_chalk(self, db: &dyn HirDatabase) -> chalk_ir::AliasEq<Interner> {
-        chalk_ir::AliasEq { alias: self.alias.to_chalk(db), ty: self.ty.to_chalk(db) }
-    }
-    fn from_chalk(db: &dyn HirDatabase, alias_eq: chalk_ir::AliasEq<Interner>) -> Self {
-        AliasEq { alias: from_chalk(db, alias_eq.alias), ty: from_chalk(db, alias_eq.ty) }
-    }
-}
-impl ToChalk for DomainGoal {
-    type Chalk = chalk_ir::DomainGoal<Interner>;
-    fn to_chalk(self, db: &dyn HirDatabase) -> chalk_ir::DomainGoal<Interner> {
-        match self {
-            DomainGoal::Holds(WhereClause::Implemented(tr)) => tr.to_chalk(db).cast(&Interner),
-            DomainGoal::Holds(WhereClause::AliasEq(alias_eq)) => {
-                alias_eq.to_chalk(db).cast(&Interner)
-            }
-        }
-    }
-    fn from_chalk(_db: &dyn HirDatabase, _goal: chalk_ir::DomainGoal<Interner>) -> Self {
-        unimplemented!()
-    }
-}
-impl<T> ToChalk for Canonical<T>
-where
-    T: ToChalk,
-    T::Chalk: HasInterner<Interner = Interner>,
-{
-    type Chalk = chalk_ir::Canonical<T::Chalk>;
-    fn to_chalk(self, db: &dyn HirDatabase) -> chalk_ir::Canonical<T::Chalk> {
-        let value = self.value.to_chalk(db);
-        chalk_ir::Canonical { value, binders: self.binders }
-    }
-    fn from_chalk(db: &dyn HirDatabase, canonical: chalk_ir::Canonical<T::Chalk>) -> Canonical<T> {
-        Canonical { binders: canonical.binders, value: from_chalk(db, canonical.value) }
-    }
-}
-impl<T: ToChalk> ToChalk for InEnvironment<T>
-where
-    T::Chalk: chalk_ir::interner::HasInterner<Interner = Interner>,
-{
-    type Chalk = chalk_ir::InEnvironment<T::Chalk>;
-    fn to_chalk(self, db: &dyn HirDatabase) -> chalk_ir::InEnvironment<T::Chalk> {
-        chalk_ir::InEnvironment { environment: self.environment, goal: self.goal.to_chalk(db) }
-    }
-    fn from_chalk(
-        _db: &dyn HirDatabase,
-        _in_env: chalk_ir::InEnvironment<T::Chalk>,
-    ) -> InEnvironment<T> {
-        unimplemented!()
-    }
-}
-impl<T: ToChalk> ToChalk for crate::Binders<T>
-where
-    T::Chalk: chalk_ir::interner::HasInterner<Interner = Interner>,
-{
-    type Chalk = chalk_ir::Binders<T::Chalk>;
-    fn to_chalk(self, db: &dyn HirDatabase) -> chalk_ir::Binders<T::Chalk> {
-        let (value, binders) = self.into_value_and_skipped_binders();
-        chalk_ir::Binders::new(binders, value.to_chalk(db))
-    }
-    fn from_chalk(db: &dyn HirDatabase, binders: chalk_ir::Binders<T::Chalk>) -> crate::Binders<T> {
-        let (v, b) = binders.into_value_and_skipped_binders();
-        crate::Binders::new(b, from_chalk(db, v))
-    }
-}
-impl ToChalk for crate::ConstrainedSubst {
-    type Chalk = chalk_ir::ConstrainedSubst<Interner>;
-    fn to_chalk(self, _db: &dyn HirDatabase) -> Self::Chalk {
-        unimplemented!()
-    }
-    fn from_chalk(db: &dyn HirDatabase, chalk: Self::Chalk) -> Self {
-        ConstrainedSubst { subst: from_chalk(db, chalk.subst) }
-    }
-}
-pub(super) fn make_binders<T>(value: T, num_vars: usize) -> chalk_ir::Binders<T>
-where
-    T: HasInterner<Interner = Interner>,
-{
-    chalk_ir::Binders::new(
-        chalk_ir::VariableKinds::from_iter(
-            &Interner,
-            std::iter::repeat(chalk_ir::VariableKind::Ty(chalk_ir::TyVariableKind::General))
-                .take(num_vars),
-        ),
-        value,
-    )
-}
-pub(super) fn convert_where_clauses(
-    db: &dyn HirDatabase,
-    def: GenericDefId,
-    substs: &Substitution,
-) -> Vec<chalk_ir::QuantifiedWhereClause<Interner>> {
-    let generic_predicates = db.generic_predicates(def);
-    let mut result = Vec::with_capacity(generic_predicates.len());
-    for pred in generic_predicates.iter() {
-        result.push(pred.clone().substitute(&Interner, substs).to_chalk(db));
-    }
-    result
-}
-pub(super) fn generic_predicate_to_inline_bound(
-    db: &dyn HirDatabase,
-    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(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.interned()[1..]
-                .iter()
-                .map(|ty| ty.clone().to_chalk(db).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.interned()[1..]
-                .iter()
-                .map(|ty| ty.clone().to_chalk(db).cast(&Interner))
-                .collect();
-            let alias_eq_bound = rust_ir::AliasEqBound {
-                value: ty.clone().to_chalk(db),
-                trait_bound: rust_ir::TraitBound { trait_id: trait_.to_chalk(db), 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/types.rs b/crates/hir_ty/src/types.rs
deleted file mode 100644
index 89adad108..000000000
--- a/crates/hir_ty/src/types.rs
+++ /dev/null
@@ -1,549 +0,0 @@
-//! This is the home of `Ty` etc. until they get replaced by their chalk_ir
-//! equivalents.
-use std::sync::Arc;
-use chalk_ir::{
-    cast::{Cast, CastTo, Caster},
-    BoundVar, Mutability, Scalar, TyVariableKind,
-};
-use smallvec::SmallVec;
-use crate::{
-    AssocTypeId, CanonicalVarKinds, ChalkTraitId, ClosureId, Const, FnDefId, FnSig, ForeignDefId,
-    Interner, Lifetime, OpaqueTyId, PlaceholderIndex, TypeWalk, VariableKind, VariableKinds,
-};
-#[derive(Clone, PartialEq, Eq, Debug, Hash)]
-pub struct OpaqueTy {
-    pub opaque_ty_id: OpaqueTyId,
-    pub substitution: Substitution,
-}
-/// A "projection" type corresponds to an (unnormalized)
-/// projection like `<P0 as Trait<P1..Pn>>::Foo`. Note that the
-/// trait and all its parameters are fully known.
-#[derive(Clone, PartialEq, Eq, Debug, Hash)]
-pub struct ProjectionTy {
-    pub associated_ty_id: AssocTypeId,
-    pub substitution: Substitution,
-}
-impl ProjectionTy {
-    pub fn self_type_parameter(&self, interner: &Interner) -> Ty {
-        self.substitution.interned()[0].assert_ty_ref(interner).clone()
-    }
-}
-#[derive(Clone, PartialEq, Eq, Debug, Hash)]
-pub struct DynTy {
-    /// The unknown self type.
-    pub bounds: Binders<QuantifiedWhereClauses>,
-    pub lifetime: Lifetime,
-}
-#[derive(Clone, PartialEq, Eq, Debug, Hash)]
-pub struct FnPointer {
-    pub num_binders: usize,
-    pub sig: FnSig,
-    pub substitution: FnSubst,
-}
-/// A wrapper for the substs on a Fn.
-#[derive(Clone, PartialEq, Eq, Debug, Hash)]
-pub struct FnSubst(pub Substitution);
-impl FnPointer {
-    /// Represent the current `Fn` as if it was wrapped in `Binders`
-    pub fn into_binders(self, interner: &Interner) -> Binders<FnSubst> {
-        Binders::new(
-            VariableKinds::from_iter(
-                interner,
-                (0..self.num_binders).map(|_| VariableKind::Lifetime),
-            ),
-            self.substitution,
-        )
-    }
-    /// Represent the current `Fn` as if it was wrapped in `Binders`
-    pub fn as_binders(&self, interner: &Interner) -> Binders<&FnSubst> {
-        Binders::new(
-            VariableKinds::from_iter(
-                interner,
-                (0..self.num_binders).map(|_| VariableKind::Lifetime),
-            ),
-            &self.substitution,
-        )
-    }
-}
-#[derive(Clone, PartialEq, Eq, Debug, Hash)]
-pub enum AliasTy {
-    /// A "projection" type corresponds to an (unnormalized)
-    /// projection like `<P0 as Trait<P1..Pn>>::Foo`. Note that the
-    /// trait and all its parameters are fully known.
-    Projection(ProjectionTy),
-    /// An opaque type (`impl Trait`).
-    ///
-    /// This is currently only used for return type impl trait; each instance of
-    /// `impl Trait` in a return type gets its own ID.
-    Opaque(OpaqueTy),
-}
-/// A type.
-///
-/// See also the `TyKind` enum in rustc (librustc/ty/sty.rs), which represents
-/// the same thing (but in a different way).
-///
-/// This should be cheap to clone.
-#[derive(Clone, PartialEq, Eq, Debug, Hash)]
-pub enum TyKind {
-    /// Structures, enumerations and unions.
-    Adt(chalk_ir::AdtId<Interner>, Substitution),
-    /// Represents an associated item like `Iterator::Item`.  This is used
-    /// when we have tried to normalize a projection like `T::Item` but
-    /// couldn't find a better representation.  In that case, we generate
-    /// an **application type** like `(Iterator::Item)<T>`.
-    AssociatedType(AssocTypeId, Substitution),
-    /// a scalar type like `bool` or `u32`
-    Scalar(Scalar),
-    /// A tuple type.  For example, `(i32, bool)`.
-    Tuple(usize, Substitution),
-    /// An array with the given length. Written as `[T; n]`.
-    Array(Ty, Const),
-    /// The pointee of an array slice.  Written as `[T]`.
-    Slice(Ty),
-    /// A raw pointer. Written as `*mut T` or `*const T`
-    Raw(Mutability, Ty),
-    /// A reference; a pointer with an associated lifetime. Written as
-    /// `&'a mut T` or `&'a T`.
-    Ref(Mutability, Lifetime, Ty),
-    /// This represents a placeholder for an opaque type in situations where we
-    /// don't know the hidden type (i.e. currently almost always). This is
-    /// analogous to the `AssociatedType` type constructor.
-    /// It is also used as the type of async block, with one type parameter
-    /// representing the Future::Output type.
-    OpaqueType(OpaqueTyId, Substitution),
-    /// The anonymous type of a function declaration/definition. Each
-    /// function has a unique type, which is output (for a function
-    /// named `foo` returning an `i32`) as `fn() -> i32 {foo}`.
-    ///
-    /// This includes tuple struct / enum variant constructors as well.
-    ///
-    /// For example the type of `bar` here:
-    ///
-    /// ```
-    /// fn foo() -> i32 { 1 }
-    /// let bar = foo; // bar: fn() -> i32 {foo}
-    /// ```
-    FnDef(FnDefId, Substitution),
-    /// The pointee of a string slice. Written as `str`.
-    Str,
-    /// The never type `!`.
-    Never,
-    /// The type of a specific closure.
-    ///
-    /// The closure signature is stored in a `FnPtr` type in the first type
-    /// parameter.
-    Closure(ClosureId, Substitution),
-    /// Represents a foreign type declared in external blocks.
-    Foreign(ForeignDefId),
-    /// A pointer to a function.  Written as `fn() -> i32`.
-    ///
-    /// For example the type of `bar` here:
-    ///
-    /// ```
-    /// fn foo() -> i32 { 1 }
-    /// let bar: fn() -> i32 = foo;
-    /// ```
-    Function(FnPointer),
-    /// An "alias" type represents some form of type alias, such as:
-    /// - An associated type projection like `<T as Iterator>::Item`
-    /// - `impl Trait` types
-    /// - Named type aliases like `type Foo<X> = Vec<X>`
-    Alias(AliasTy),
-    /// A placeholder for a type parameter; for example, `T` in `fn f<T>(x: T)
-    /// {}` when we're type-checking the body of that function. In this
-    /// situation, we know this stands for *some* type, but don't know the exact
-    /// type.
-    Placeholder(PlaceholderIndex),
-    /// A bound type variable. This is used in various places: when representing
-    /// some polymorphic type like the type of function `fn f<T>`, the type
-    /// parameters get turned into variables; during trait resolution, inference
-    /// variables get turned into bound variables and back; and in `Dyn` the
-    /// `Self` type is represented with a bound variable as well.
-    BoundVar(BoundVar),
-    /// A type variable used during type checking.
-    InferenceVar(InferenceVar, TyVariableKind),
-    /// A trait object (`dyn Trait` or bare `Trait` in pre-2018 Rust).
-    ///
-    /// The predicates are quantified over the `Self` type, i.e. `Ty::Bound(0)`
-    /// represents the `Self` type inside the bounds. This is currently
-    /// implicit; Chalk has the `Binders` struct to make it explicit, but it
-    /// didn't seem worth the overhead yet.
-    Dyn(DynTy),
-    /// A placeholder for a type which could not be computed; this is propagated
-    /// to avoid useless error messages. Doubles as a placeholder where type
-    /// variables are inserted before type checking, since we want to try to
-    /// infer a better type here anyway -- for the IDE use case, we want to try
-    /// to infer as much as possible even in the presence of type errors.
-    Error,
-}
-#[derive(Clone, PartialEq, Eq, Debug, Hash)]
-pub struct Ty(Arc<TyKind>);
-impl TyKind {
-    pub fn intern(self, _interner: &Interner) -> Ty {
-        Ty(Arc::new(self))
-    }
-}
-impl Ty {
-    pub fn kind(&self, _interner: &Interner) -> &TyKind {
-        &self.0
-    }
-    pub fn interned_mut(&mut self) -> &mut TyKind {
-        Arc::make_mut(&mut self.0)
-    }
-    pub fn into_inner(self) -> TyKind {
-        Arc::try_unwrap(self.0).unwrap_or_else(|a| (*a).clone())
-    }
-}
-#[derive(Clone, PartialEq, Eq, Debug, Hash)]
-pub struct GenericArg {
-    interned: GenericArgData,
-}
-#[derive(Clone, PartialEq, Eq, Debug, Hash)]
-pub enum GenericArgData {
-    Ty(Ty),
-}
-impl GenericArg {
-    /// Constructs a generic argument using `GenericArgData`.
-    pub fn new(_interner: &Interner, data: GenericArgData) -> Self {
-        GenericArg { interned: data }
-    }
-    /// Gets the interned value.
-    pub fn interned(&self) -> &GenericArgData {
-        &self.interned
-    }
-    /// Asserts that this is a type argument.
-    pub fn assert_ty_ref(&self, interner: &Interner) -> &Ty {
-        self.ty(interner).unwrap()
-    }
-    /// Checks whether the generic argument is a type.
-    pub fn is_ty(&self, _interner: &Interner) -> bool {
-        match self.interned() {
-            GenericArgData::Ty(_) => true,
-        }
-    }
-    /// Returns the type if it is one, `None` otherwise.
-    pub fn ty(&self, _interner: &Interner) -> Option<&Ty> {
-        match self.interned() {
-            GenericArgData::Ty(t) => Some(t),
-        }
-    }
-    pub fn interned_mut(&mut self) -> &mut GenericArgData {
-        &mut self.interned
-    }
-}
-/// A list of substitutions for generic parameters.
-#[derive(Clone, PartialEq, Eq, Debug, Hash)]
-pub struct Substitution(SmallVec<[GenericArg; 2]>);
-impl Substitution {
-    pub fn interned(&self) -> &SmallVec<[GenericArg; 2]> {
-        &self.0
-    }
-    pub fn len(&self, _: &Interner) -> usize {
-        self.0.len()
-    }
-    pub fn is_empty(&self, _: &Interner) -> bool {
-        self.0.is_empty()
-    }
-    pub fn at(&self, _: &Interner, i: usize) -> &GenericArg {
-        &self.0[i]
-    }
-    pub fn empty(_: &Interner) -> Substitution {
-        Substitution(SmallVec::new())
-    }
-    pub fn iter(&self, _: &Interner) -> std::slice::Iter<'_, GenericArg> {
-        self.0.iter()
-    }
-    pub fn from1(_interner: &Interner, ty: Ty) -> Substitution {
-        Substitution::intern({
-            let mut v = SmallVec::new();
-            v.push(ty.cast(&Interner));
-            v
-        })
-    }
-    pub fn from_iter(
-        interner: &Interner,
-        elements: impl IntoIterator<Item = impl CastTo<GenericArg>>,
-    ) -> Self {
-        Substitution(elements.into_iter().casted(interner).collect())
-    }
-    pub fn apply<T: TypeWalk>(&self, value: T, _interner: &Interner) -> T {
-        value.subst_bound_vars(self)
-    }
-    // Temporary helper functions, to be removed
-    pub fn intern(interned: SmallVec<[GenericArg; 2]>) -> Substitution {
-        Substitution(interned)
-    }
-    pub fn interned_mut(&mut self) -> &mut SmallVec<[GenericArg; 2]> {
-        &mut self.0
-    }
-}
-#[derive(Clone, PartialEq, Eq, Hash)]
-pub struct Binders<T> {
-    /// The binders that quantify over the value.
-    pub binders: VariableKinds,
-    value: T,
-}
-impl<T> Binders<T> {
-    pub fn new(binders: VariableKinds, value: T) -> Self {
-        Self { binders, value }
-    }
-    pub fn empty(_interner: &Interner, value: T) -> Self {
-        crate::make_only_type_binders(0, value)
-    }
-    pub fn as_ref(&self) -> Binders<&T> {
-        Binders { binders: self.binders.clone(), value: &self.value }
-    }
-    pub fn map<U>(self, f: impl FnOnce(T) -> U) -> Binders<U> {
-        Binders { binders: self.binders, value: f(self.value) }
-    }
-    pub fn filter_map<U>(self, f: impl FnOnce(T) -> Option<U>) -> Option<Binders<U>> {
-        Some(Binders { binders: self.binders, value: f(self.value)? })
-    }
-    pub fn skip_binders(&self) -> &T {
-        &self.value
-    }
-    pub fn into_value_and_skipped_binders(self) -> (T, VariableKinds) {
-        (self.value, self.binders)
-    }
-    /// Returns the number of binders.
-    pub fn len(&self, interner: &Interner) -> usize {
-        self.binders.len(interner)
-    }
-    // Temporary helper function, to be removed
-    pub fn skip_binders_mut(&mut self) -> &mut T {
-        &mut self.value
-    }
-}
-impl<T: Clone> Binders<&T> {
-    pub fn cloned(&self) -> Binders<T> {
-        Binders::new(self.binders.clone(), self.value.clone())
-    }
-}
-impl<T: TypeWalk> Binders<T> {
-    /// Substitutes all variables.
-    pub fn substitute(self, interner: &Interner, subst: &Substitution) -> T {
-        let (value, binders) = self.into_value_and_skipped_binders();
-        assert_eq!(subst.len(interner), binders.len(interner));
-        value.subst_bound_vars(subst)
-    }
-}
-impl<T: std::fmt::Debug> std::fmt::Debug for Binders<T> {
-    fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
-        let Binders { ref binders, ref value } = *self;
-        write!(fmt, "for{:?} ", binders.inner_debug(&Interner))?;
-        std::fmt::Debug::fmt(value, fmt)
-    }
-}
-/// A trait with type parameters. This includes the `Self`, so this represents a concrete type implementing the trait.
-#[derive(Clone, PartialEq, Eq, Debug, Hash)]
-pub struct TraitRef {
-    pub trait_id: ChalkTraitId,
-    pub substitution: Substitution,
-}
-impl TraitRef {
-    pub fn self_type_parameter(&self, interner: &Interner) -> Ty {
-        self.substitution.at(interner, 0).assert_ty_ref(interner).clone()
-    }
-}
-/// Like `generics::WherePredicate`, but with resolved types: A condition on the
-/// parameters of a generic item.
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub enum WhereClause {
-    /// The given trait needs to be implemented for its type parameters.
-    Implemented(TraitRef),
-    /// An associated type bindings like in `Iterator<Item = T>`.
-    AliasEq(AliasEq),
-}
-pub type QuantifiedWhereClause = Binders<WhereClause>;
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct QuantifiedWhereClauses(Arc<[QuantifiedWhereClause]>);
-impl QuantifiedWhereClauses {
-    pub fn from_iter(
-        _interner: &Interner,
-        elements: impl IntoIterator<Item = QuantifiedWhereClause>,
-    ) -> Self {
-        QuantifiedWhereClauses(elements.into_iter().collect())
-    }
-    pub fn interned(&self) -> &Arc<[QuantifiedWhereClause]> {
-        &self.0
-    }
-    pub fn interned_mut(&mut self) -> &mut Arc<[QuantifiedWhereClause]> {
-        &mut self.0
-    }
-}
-/// Basically a claim (currently not validated / checked) that the contained
-/// type / trait ref contains no inference variables; any inference variables it
-/// contained have been replaced by bound variables, and `kinds` tells us how
-/// many there are and whether they were normal or float/int variables. This is
-/// used to erase irrelevant differences between types before using them in
-/// queries.
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Canonical<T> {
-    pub value: T,
-    pub binders: CanonicalVarKinds,
-}
-/// Something (usually a goal), along with an environment.
-#[derive(Clone, Debug, PartialEq, Eq, Hash)]
-pub struct InEnvironment<T> {
-    pub environment: chalk_ir::Environment<Interner>,
-    pub goal: T,
-}
-impl<T> InEnvironment<T> {
-    pub fn new(environment: &chalk_ir::Environment<Interner>, value: T) -> InEnvironment<T> {
-        InEnvironment { environment: environment.clone(), goal: value }
-    }
-}
-/// Something that needs to be proven (by Chalk) during type checking, e.g. that
-/// a certain type implements a certain trait. Proving the Obligation might
-/// result in additional information about inference variables.
-#[derive(Clone, Debug, PartialEq, Eq, Hash)]
-pub enum DomainGoal {
-    Holds(WhereClause),
-}
-#[derive(Clone, Debug, PartialEq, Eq, Hash)]
-pub struct AliasEq {
-    pub alias: AliasTy,
-    pub ty: Ty,
-}
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct ConstrainedSubst {
-    pub subst: Substitution,
-}
-#[derive(Clone, Debug, PartialEq, Eq)]
-/// A (possible) solution for a proposed goal.
-pub enum Solution {
-    /// The goal indeed holds, and there is a unique value for all existential
-    /// variables.
-    Unique(Canonical<ConstrainedSubst>),
-    /// The goal may be provable in multiple ways, but regardless we may have some guidance
-    /// for type inference. In this case, we don't return any lifetime
-    /// constraints, since we have not "committed" to any particular solution
-    /// yet.
-    Ambig(Guidance),
-}
-#[derive(Clone, Debug, PartialEq, Eq)]
-/// When a goal holds ambiguously (e.g., because there are multiple possible
-/// solutions), we issue a set of *guidance* back to type inference.
-pub enum Guidance {
-    /// The existential variables *must* have the given values if the goal is
-    /// ever to hold, but that alone isn't enough to guarantee the goal will
-    /// actually hold.
-    Definite(Canonical<Substitution>),
-    /// There are multiple plausible values for the existentials, but the ones
-    /// here are suggested as the preferred choice heuristically. These should
-    /// be used for inference fallback only.
-    Suggested(Canonical<Substitution>),
-    /// There's no useful information to feed back to type inference
-    Unknown,
-}
-/// The kinds of placeholders we need during type inference. There's separate
-/// values for general types, and for integer and float variables. The latter
-/// two are used for inference of literal values (e.g. `100` could be one of
-/// several integer types).
-#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
-pub struct InferenceVar {
-    index: u32,
-}
-impl From<u32> for InferenceVar {
-    fn from(index: u32) -> InferenceVar {
-        InferenceVar { index }
-    }
-}
-impl InferenceVar {
-    /// Gets the underlying index value.
-    pub fn index(self) -> u32 {
-        self.index
-    }
-}
diff --git a/crates/hir_ty/src/utils.rs b/crates/hir_ty/src/utils.rs
index 8d5d5cd73..5f6cb052a 100644
--- a/crates/hir_ty/src/utils.rs
+++ b/crates/hir_ty/src/utils.rs
@@ -1,8 +1,7 @@
 //! Helper functions for working with def, which don't need to be a separate
 //! query, but can't be computed directly from `*Data` (ie, which need a `db`).
-use std::sync::Arc;
-use chalk_ir::{BoundVar, DebruijnIndex};
+use chalk_ir::{fold::Shift, BoundVar, DebruijnIndex};
 use hir_def::{
    db::DefDatabase,
    generics::{
@@ -16,9 +15,7 @@ use hir_def::{
 };
 use hir_expand::name::{name, Name};
-use crate::{
+use crate::{db::HirDatabase, Interner, Substitution, TraitRef, TraitRefExt, TyKind, WhereClause};
-    db::HirDatabase, Interner, Substitution, TraitRef, TraitRefExt, TyKind, TypeWalk, WhereClause,
-};
 fn direct_super_traits(db: &dyn DefDatabase, trait_: TraitId) -> Vec<TraitId> {
    let resolver = trait_.resolver(db);
@@ -69,7 +66,7 @@ fn direct_super_trait_refs(db: &dyn HirDatabase, trait_ref: &TraitRef) -> Vec<Tr
                // FIXME: how to correctly handle higher-ranked bounds here?
                WhereClause::Implemented(tr) => Some(
                    tr.clone()
-                        .shifted_out_to(DebruijnIndex::ONE)
+                        .shifted_out_to(&Interner, DebruijnIndex::ONE)
                        .expect("FIXME unexpected higher-ranked trait bound"),
                ),
                _ => None,
@@ -137,15 +134,6 @@ pub(super) fn associated_type_by_name_including_super_traits(
    })
 }
-/// Helper for mutating `Arc<[T]>` (i.e. `Arc::make_mut` for Arc slices).
-/// The underlying values are cloned if there are other strong references.
-pub(crate) fn make_mut_slice<T: Clone>(a: &mut Arc<[T]>) -> &mut [T] {
-    if Arc::get_mut(a).is_none() {
-        *a = a.iter().cloned().collect();
-    }
-    Arc::get_mut(a).unwrap()
-}
 pub(crate) fn generics(db: &dyn DefDatabase, def: GenericDefId) -> Generics {
    let parent_generics = parent_generic_def(db, def).map(|def| Box::new(generics(db, def)));
    Generics { def, params: db.generic_params(def), parent_generics }
diff --git a/crates/hir_ty/src/walk.rs b/crates/hir_ty/src/walk.rs
index 91116dcda..6ef1d5336 100644
--- a/crates/hir_ty/src/walk.rs
+++ b/crates/hir_ty/src/walk.rs
@@ -1,138 +1,17 @@
 //! The `TypeWalk` trait (probably to be replaced by Chalk's `Fold` and
 //! `Visit`).
-use std::mem;
+use chalk_ir::interner::HasInterner;
-use chalk_ir::DebruijnIndex;
 use crate::{
-    utils::make_mut_slice, AliasEq, AliasTy, Binders, CallableSig, FnSubst, GenericArg,
+    AliasEq, AliasTy, Binders, CallableSig, FnSubst, GenericArg, GenericArgData, Interner,
-    GenericArgData, Interner, OpaqueTy, ProjectionTy, Substitution, TraitRef, Ty, TyKind,
+    OpaqueTy, ProjectionTy, Substitution, TraitRef, Ty, TyKind, WhereClause,
-    WhereClause,
 };
 /// This allows walking structures that contain types to do something with those
 /// types, similar to Chalk's `Fold` trait.
 pub trait TypeWalk {
    fn walk(&self, f: &mut impl FnMut(&Ty));
-    fn walk_mut(&mut self, f: &mut impl FnMut(&mut Ty)) {
-        self.walk_mut_binders(&mut |ty, _binders| f(ty), DebruijnIndex::INNERMOST);
-    }
-    /// Walk the type, counting entered binders.
-    ///
-    /// `TyKind::Bound` variables use DeBruijn indexing, which means that 0 refers
-    /// to the innermost binder, 1 to the next, etc.. So when we want to
-    /// substitute a certain bound variable, we can't just walk the whole type
-    /// and blindly replace each instance of a certain index; when we 'enter'
-    /// things that introduce new bound variables, we have to keep track of
-    /// that. Currently, the only thing that introduces bound variables on our
-    /// side are `TyKind::Dyn` and `TyKind::Opaque`, which each introduce a bound
-    /// variable for the self type.
-    fn walk_mut_binders(
-        &mut self,
-        f: &mut impl FnMut(&mut Ty, DebruijnIndex),
-        binders: DebruijnIndex,
-    );
-    fn fold_binders(
-        mut self,
-        f: &mut impl FnMut(Ty, DebruijnIndex) -> Ty,
-        binders: DebruijnIndex,
-    ) -> Self
-    where
-        Self: Sized,
-    {
-        self.walk_mut_binders(
-            &mut |ty_mut, binders| {
-                let ty = mem::replace(ty_mut, TyKind::Error.intern(&Interner));
-                *ty_mut = f(ty, binders);
-            },
-            binders,
-        );
-        self
-    }
-    fn fold(mut self, f: &mut impl FnMut(Ty) -> Ty) -> Self
-    where
-        Self: Sized,
-    {
-        self.walk_mut(&mut |ty_mut| {
-            let ty = mem::replace(ty_mut, TyKind::Error.intern(&Interner));
-            *ty_mut = f(ty);
-        });
-        self
-    }
-    /// Substitutes `TyKind::Bound` vars with the given substitution.
-    fn subst_bound_vars(self, substs: &Substitution) -> Self
-    where
-        Self: Sized,
-    {
-        self.subst_bound_vars_at_depth(substs, DebruijnIndex::INNERMOST)
-    }
-    /// Substitutes `TyKind::Bound` vars with the given substitution.
-    fn subst_bound_vars_at_depth(mut self, substs: &Substitution, depth: DebruijnIndex) -> Self
-    where
-        Self: Sized,
-    {
-        self.walk_mut_binders(
-            &mut |ty, binders| {
-                if let &mut TyKind::BoundVar(bound) = ty.interned_mut() {
-                    if bound.debruijn >= binders {
-                        *ty = substs.interned()[bound.index]
-                            .assert_ty_ref(&Interner)
-                            .clone()
-                            .shifted_in_from(binders);
-                    }
-                }
-            },
-            depth,
-        );
-        self
-    }
-    fn shifted_in(self, _interner: &Interner) -> Self
-    where
-        Self: Sized,
-    {
-        self.shifted_in_from(DebruijnIndex::ONE)
-    }
-    /// Shifts up debruijn indices of `TyKind::Bound` vars by `n`.
-    fn shifted_in_from(self, n: DebruijnIndex) -> Self
-    where
-        Self: Sized,
-    {
-        self.fold_binders(
-            &mut |ty, binders| match ty.kind(&Interner) {
-                TyKind::BoundVar(bound) if bound.debruijn >= binders => {
-                    TyKind::BoundVar(bound.shifted_in_from(n)).intern(&Interner)
-                }
-                _ => ty,
-            },
-            DebruijnIndex::INNERMOST,
-        )
-    }
-    /// Shifts debruijn indices of `TyKind::Bound` vars out (down) by `n`.
-    fn shifted_out_to(self, n: DebruijnIndex) -> Option<Self>
-    where
-        Self: Sized + std::fmt::Debug,
-    {
-        Some(self.fold_binders(
-            &mut |ty, binders| {
-                match ty.kind(&Interner) {
-                    TyKind::BoundVar(bound) if bound.debruijn >= binders => {
-                        TyKind::BoundVar(bound.shifted_out_to(n).unwrap_or(bound.clone()))
-                            .intern(&Interner)
-                    }
-                    _ => ty,
-                }
-            },
-            DebruijnIndex::INNERMOST,
-        ))
-    }
 }
 impl TypeWalk for Ty {
@@ -174,45 +53,6 @@ impl TypeWalk for Ty {
        }
        f(self);
    }
-    fn walk_mut_binders(
-        &mut self,
-        f: &mut impl FnMut(&mut Ty, DebruijnIndex),
-        binders: DebruijnIndex,
-    ) {
-        match self.interned_mut() {
-            TyKind::Alias(AliasTy::Projection(p_ty)) => {
-                p_ty.substitution.walk_mut_binders(f, binders);
-            }
-            TyKind::Dyn(dyn_ty) => {
-                for p in make_mut_slice(dyn_ty.bounds.skip_binders_mut().interned_mut()) {
-                    p.walk_mut_binders(f, binders.shifted_in());
-                }
-            }
-            TyKind::Alias(AliasTy::Opaque(o_ty)) => {
-                o_ty.substitution.walk_mut_binders(f, binders);
-            }
-            TyKind::Slice(ty)
-            | TyKind::Array(ty, _)
-            | TyKind::Ref(_, _, ty)
-            | TyKind::Raw(_, ty) => {
-                ty.walk_mut_binders(f, binders);
-            }
-            TyKind::Function(fn_pointer) => {
-                fn_pointer.substitution.0.walk_mut_binders(f, binders.shifted_in());
-            }
-            TyKind::Adt(_, substs)
-            | TyKind::FnDef(_, substs)
-            | TyKind::Tuple(_, substs)
-            | TyKind::OpaqueType(_, substs)
-            | TyKind::AssociatedType(_, substs)
-            | TyKind::Closure(.., substs) => {
-                substs.walk_mut_binders(f, binders);
-            }
-            _ => {}
-        }
-        f(self, binders);
-    }
 }
 impl<T: TypeWalk> TypeWalk for Vec<T> {
@@ -221,43 +61,18 @@ impl<T: TypeWalk> TypeWalk for Vec<T> {
            t.walk(f);
        }
    }
-    fn walk_mut_binders(
-        &mut self,
-        f: &mut impl FnMut(&mut Ty, DebruijnIndex),
-        binders: DebruijnIndex,
-    ) {
-        for t in self {
-            t.walk_mut_binders(f, binders);
-        }
-    }
 }
 impl TypeWalk for OpaqueTy {
    fn walk(&self, f: &mut impl FnMut(&Ty)) {
        self.substitution.walk(f);
    }
-    fn walk_mut_binders(
-        &mut self,
-        f: &mut impl FnMut(&mut Ty, DebruijnIndex),
-        binders: DebruijnIndex,
-    ) {
-        self.substitution.walk_mut_binders(f, binders);
-    }
 }
 impl TypeWalk for ProjectionTy {
    fn walk(&self, f: &mut impl FnMut(&Ty)) {
        self.substitution.walk(f);
    }
-    fn walk_mut_binders(
-        &mut self,
-        f: &mut impl FnMut(&mut Ty, DebruijnIndex),
-        binders: DebruijnIndex,
-    ) {
-        self.substitution.walk_mut_binders(f, binders);
-    }
 }
 impl TypeWalk for AliasTy {
@@ -267,17 +82,6 @@ impl TypeWalk for AliasTy {
            AliasTy::Opaque(it) => it.walk(f),
        }
    }
-    fn walk_mut_binders(
-        &mut self,
-        f: &mut impl FnMut(&mut Ty, DebruijnIndex),
-        binders: DebruijnIndex,
-    ) {
-        match self {
-            AliasTy::Projection(it) => it.walk_mut_binders(f, binders),
-            AliasTy::Opaque(it) => it.walk_mut_binders(f, binders),
-        }
-    }
 }
 impl TypeWalk for GenericArg {
@@ -286,18 +90,7 @@ impl TypeWalk for GenericArg {
            GenericArgData::Ty(ty) => {
                ty.walk(f);
            }
-        }
+            _ => {}
-    }
-    fn walk_mut_binders(
-        &mut self,
-        f: &mut impl FnMut(&mut Ty, DebruijnIndex),
-        binders: DebruijnIndex,
-    ) {
-        match self.interned_mut() {
-            GenericArgData::Ty(ty) => {
-                ty.walk_mut_binders(f, binders);
-            }
        }
    }
 }
@@ -308,44 +101,18 @@ impl TypeWalk for Substitution {
            t.walk(f);
        }
    }
-    fn walk_mut_binders(
-        &mut self,
-        f: &mut impl FnMut(&mut Ty, DebruijnIndex),
-        binders: DebruijnIndex,
-    ) {
-        for t in self.interned_mut() {
-            t.walk_mut_binders(f, binders);
-        }
-    }
 }
-impl<T: TypeWalk> TypeWalk for Binders<T> {
+impl<T: TypeWalk + HasInterner<Interner = Interner>> TypeWalk for Binders<T> {
    fn walk(&self, f: &mut impl FnMut(&Ty)) {
        self.skip_binders().walk(f);
    }
-    fn walk_mut_binders(
-        &mut self,
-        f: &mut impl FnMut(&mut Ty, DebruijnIndex),
-        binders: DebruijnIndex,
-    ) {
-        self.skip_binders_mut().walk_mut_binders(f, binders.shifted_in())
-    }
 }
 impl TypeWalk for TraitRef {
    fn walk(&self, f: &mut impl FnMut(&Ty)) {
        self.substitution.walk(f);
    }
-    fn walk_mut_binders(
-        &mut self,
-        f: &mut impl FnMut(&mut Ty, DebruijnIndex),
-        binders: DebruijnIndex,
-    ) {
-        self.substitution.walk_mut_binders(f, binders);
-    }
 }
 impl TypeWalk for WhereClause {
@@ -353,17 +120,7 @@ impl TypeWalk for WhereClause {
        match self {
            WhereClause::Implemented(trait_ref) => trait_ref.walk(f),
            WhereClause::AliasEq(alias_eq) => alias_eq.walk(f),
-        }
+            _ => {}
-    }
-    fn walk_mut_binders(
-        &mut self,
-        f: &mut impl FnMut(&mut Ty, DebruijnIndex),
-        binders: DebruijnIndex,
-    ) {
-        match self {
-            WhereClause::Implemented(trait_ref) => trait_ref.walk_mut_binders(f, binders),
-            WhereClause::AliasEq(alias_eq) => alias_eq.walk_mut_binders(f, binders),
        }
    }
 }
@@ -374,16 +131,6 @@ impl TypeWalk for CallableSig {
            t.walk(f);
        }
    }
-    fn walk_mut_binders(
-        &mut self,
-        f: &mut impl FnMut(&mut Ty, DebruijnIndex),
-        binders: DebruijnIndex,
-    ) {
-        for t in make_mut_slice(&mut self.params_and_return) {
-            t.walk_mut_binders(f, binders);
-        }
-    }
 }
 impl TypeWalk for AliasEq {
@@ -394,30 +141,10 @@ impl TypeWalk for AliasEq {
            AliasTy::Opaque(opaque) => opaque.walk(f),
        }
    }
-    fn walk_mut_binders(
-        &mut self,
-        f: &mut impl FnMut(&mut Ty, DebruijnIndex),
-        binders: DebruijnIndex,
-    ) {
-        self.ty.walk_mut_binders(f, binders);
-        match &mut self.alias {
-            AliasTy::Projection(projection_ty) => projection_ty.walk_mut_binders(f, binders),
-            AliasTy::Opaque(opaque) => opaque.walk_mut_binders(f, binders),
-        }
-    }
 }
-impl TypeWalk for FnSubst {
+impl TypeWalk for FnSubst<Interner> {
    fn walk(&self, f: &mut impl FnMut(&Ty)) {
        self.0.walk(f)
    }
-    fn walk_mut_binders(
-        &mut self,
-        f: &mut impl FnMut(&mut Ty, DebruijnIndex),
-        binders: DebruijnIndex,
-    ) {
-        self.0.walk_mut_binders(f, binders)
-    }
 }
diff --git a/crates/ide/src/diagnostics.rs b/crates/ide/src/diagnostics.rs
index dd42116a7..9a883acb9 100644
--- a/crates/ide/src/diagnostics.rs
+++ b/crates/ide/src/diagnostics.rs
@@ -20,12 +20,12 @@ use itertools::Itertools;
 use rustc_hash::FxHashSet;
 use syntax::{
    ast::{self, AstNode},
-    SyntaxNode, SyntaxNodePtr, TextRange,
+    SyntaxNode, SyntaxNodePtr, TextRange, TextSize,
 };
 use text_edit::TextEdit;
 use unlinked_file::UnlinkedFile;
-use crate::{FileId, Label, SourceChange};
+use crate::{Assist, AssistId, AssistKind, FileId, Label, SourceChange};
 use self::fixes::DiagnosticWithFix;
@@ -35,7 +35,7 @@ pub struct Diagnostic {
    pub message: String,
    pub range: TextRange,
    pub severity: Severity,
-    pub fix: Option<Fix>,
+    pub fix: Option<Assist>,
    pub unused: bool,
    pub code: Option<DiagnosticCode>,
 }
@@ -56,7 +56,7 @@ impl Diagnostic {
        }
    }
-    fn with_fix(self, fix: Option<Fix>) -> Self {
+    fn with_fix(self, fix: Option<Assist>) -> Self {
        Self { fix, ..self }
    }
@@ -69,21 +69,6 @@ impl Diagnostic {
    }
 }
-#[derive(Debug)]
-pub struct Fix {
-    pub label: Label,
-    pub source_change: SourceChange,
-    /// Allows to trigger the fix only when the caret is in the range given
-    pub fix_trigger_range: TextRange,
-}
-impl Fix {
-    fn new(label: &str, source_change: SourceChange, fix_trigger_range: TextRange) -> Self {
-        let label = Label::new(label);
-        Self { label, source_change, fix_trigger_range }
-    }
-}
 #[derive(Debug, Copy, Clone)]
 pub enum Severity {
    Error,
@@ -99,6 +84,7 @@ pub struct DiagnosticsConfig {
 pub(crate) fn diagnostics(
    db: &RootDatabase,
    config: &DiagnosticsConfig,
+    resolve: bool,
    file_id: FileId,
 ) -> Vec<Diagnostic> {
    let _p = profile::span("diagnostics");
@@ -122,25 +108,25 @@ pub(crate) fn diagnostics(
    let res = RefCell::new(res);
    let sink_builder = DiagnosticSinkBuilder::new()
        .on::<hir::diagnostics::UnresolvedModule, _>(|d| {
-            res.borrow_mut().push(diagnostic_with_fix(d, &sema));
+            res.borrow_mut().push(diagnostic_with_fix(d, &sema, resolve));
        })
        .on::<hir::diagnostics::MissingFields, _>(|d| {
-            res.borrow_mut().push(diagnostic_with_fix(d, &sema));
+            res.borrow_mut().push(diagnostic_with_fix(d, &sema, resolve));
        })
        .on::<hir::diagnostics::MissingOkOrSomeInTailExpr, _>(|d| {
-            res.borrow_mut().push(diagnostic_with_fix(d, &sema));
+            res.borrow_mut().push(diagnostic_with_fix(d, &sema, resolve));
        })
        .on::<hir::diagnostics::NoSuchField, _>(|d| {
-            res.borrow_mut().push(diagnostic_with_fix(d, &sema));
+            res.borrow_mut().push(diagnostic_with_fix(d, &sema, resolve));
        })
        .on::<hir::diagnostics::RemoveThisSemicolon, _>(|d| {
-            res.borrow_mut().push(diagnostic_with_fix(d, &sema));
+            res.borrow_mut().push(diagnostic_with_fix(d, &sema, resolve));
        })
        .on::<hir::diagnostics::IncorrectCase, _>(|d| {
-            res.borrow_mut().push(warning_with_fix(d, &sema));
+            res.borrow_mut().push(warning_with_fix(d, &sema, resolve));
        })
        .on::<hir::diagnostics::ReplaceFilterMapNextWithFindMap, _>(|d| {
-            res.borrow_mut().push(warning_with_fix(d, &sema));
+            res.borrow_mut().push(warning_with_fix(d, &sema, resolve));
        })
        .on::<hir::diagnostics::InactiveCode, _>(|d| {
            // If there's inactive code somewhere in a macro, don't propagate to the call-site.
@@ -159,14 +145,16 @@ pub(crate) fn diagnostics(
            );
        })
        .on::<UnlinkedFile, _>(|d| {
+            // Limit diagnostic to the first few characters in the file. This matches how VS Code
+            // renders it with the full span, but on other editors, and is less invasive.
+            let range = sema.diagnostics_display_range(d.display_source()).range;
+            let range = range.intersect(TextRange::up_to(TextSize::of("..."))).unwrap_or(range);
            // Override severity and mark as unused.
            res.borrow_mut().push(
-                Diagnostic::hint(
+                Diagnostic::hint(range, d.message())
-                    sema.diagnostics_display_range(d.display_source()).range,
+                    .with_fix(d.fix(&sema, resolve))
-                    d.message(),
+                    .with_code(Some(d.code())),
-                )
-                .with_fix(d.fix(&sema))
-                .with_code(Some(d.code())),
            );
        })
        .on::<hir::diagnostics::UnresolvedProcMacro, _>(|d| {
@@ -221,15 +209,23 @@ pub(crate) fn diagnostics(
    res.into_inner()
 }
-fn diagnostic_with_fix<D: DiagnosticWithFix>(d: &D, sema: &Semantics<RootDatabase>) -> Diagnostic {
+fn diagnostic_with_fix<D: DiagnosticWithFix>(
+    d: &D,
+    sema: &Semantics<RootDatabase>,
+    resolve: bool,
+) -> Diagnostic {
    Diagnostic::error(sema.diagnostics_display_range(d.display_source()).range, d.message())
-        .with_fix(d.fix(&sema))
+        .with_fix(d.fix(&sema, resolve))
        .with_code(Some(d.code()))
 }
-fn warning_with_fix<D: DiagnosticWithFix>(d: &D, sema: &Semantics<RootDatabase>) -> Diagnostic {
+fn warning_with_fix<D: DiagnosticWithFix>(
+    d: &D,
+    sema: &Semantics<RootDatabase>,
+    resolve: bool,
+) -> Diagnostic {
    Diagnostic::hint(sema.diagnostics_display_range(d.display_source()).range, d.message())
-        .with_fix(d.fix(&sema))
+        .with_fix(d.fix(&sema, resolve))
        .with_code(Some(d.code()))
 }
@@ -259,7 +255,8 @@ fn check_unnecessary_braces_in_use_statement(
        acc.push(
            Diagnostic::hint(use_range, "Unnecessary braces in use statement".to_string())
-                .with_fix(Some(Fix::new(
+                .with_fix(Some(fix(
+                    "remove_braces",
                    "Remove unnecessary braces",
                    SourceChange::from_text_edit(file_id, edit),
                    use_range,
@@ -282,6 +279,23 @@ fn text_edit_for_remove_unnecessary_braces_with_self_in_use_statement(
    None
 }
+fn fix(id: &'static str, label: &str, source_change: SourceChange, target: TextRange) -> Assist {
+    let mut res = unresolved_fix(id, label, target);
+    res.source_change = Some(source_change);
+    res
+}
+fn unresolved_fix(id: &'static str, label: &str, target: TextRange) -> Assist {
+    assert!(!id.contains(' '));
+    Assist {
+        id: AssistId(id, AssistKind::QuickFix),
+        label: Label::new(label),
+        group: None,
+        target,
+        source_change: None,
+    }
+}
 #[cfg(test)]
 mod tests {
    use expect_test::{expect, Expect};
@@ -300,16 +314,17 @@ mod tests {
        let (analysis, file_position) = fixture::position(ra_fixture_before);
        let diagnostic = analysis
-            .diagnostics(&DiagnosticsConfig::default(), file_position.file_id)
+            .diagnostics(&DiagnosticsConfig::default(), true, file_position.file_id)
            .unwrap()
            .pop()
            .unwrap();
        let fix = diagnostic.fix.unwrap();
        let actual = {
-            let file_id = *fix.source_change.source_file_edits.keys().next().unwrap();
+            let source_change = fix.source_change.unwrap();
+            let file_id = *source_change.source_file_edits.keys().next().unwrap();
            let mut actual = analysis.file_text(file_id).unwrap().to_string();
-            for edit in fix.source_change.source_file_edits.values() {
+            for edit in source_change.source_file_edits.values() {
                edit.apply(&mut actual);
            }
            actual
@@ -317,9 +332,9 @@ mod tests {
        assert_eq_text!(&after, &actual);
        assert!(
-            fix.fix_trigger_range.contains_inclusive(file_position.offset),
+            fix.target.contains_inclusive(file_position.offset),
            "diagnostic fix range {:?} does not touch cursor position {:?}",
-            fix.fix_trigger_range,
+            fix.target,
            file_position.offset
        );
    }
@@ -328,7 +343,7 @@ mod tests {
    fn check_no_fix(ra_fixture: &str) {
        let (analysis, file_position) = fixture::position(ra_fixture);
        let diagnostic = analysis
-            .diagnostics(&DiagnosticsConfig::default(), file_position.file_id)
+            .diagnostics(&DiagnosticsConfig::default(), true, file_position.file_id)
            .unwrap()
            .pop()
            .unwrap();
@@ -342,7 +357,7 @@ mod tests {
        let diagnostics = files
            .into_iter()
            .flat_map(|file_id| {
-                analysis.diagnostics(&DiagnosticsConfig::default(), file_id).unwrap()
+                analysis.diagnostics(&DiagnosticsConfig::default(), true, file_id).unwrap()
            })
            .collect::<Vec<_>>();
        assert_eq!(diagnostics.len(), 0, "unexpected diagnostics:\n{:#?}", diagnostics);
@@ -350,7 +365,8 @@ mod tests {
    fn check_expect(ra_fixture: &str, expect: Expect) {
        let (analysis, file_id) = fixture::file(ra_fixture);
-        let diagnostics = analysis.diagnostics(&DiagnosticsConfig::default(), file_id).unwrap();
+        let diagnostics =
+            analysis.diagnostics(&DiagnosticsConfig::default(), true, file_id).unwrap();
        expect.assert_debug_eq(&diagnostics)
    }
@@ -663,24 +679,31 @@ fn test_fn() {
                        range: 0..8,
                        severity: Error,
                        fix: Some(
-                            Fix {
+                            Assist {
+                                id: AssistId(
+                                    "create_module",
+                                    QuickFix,
+                                ),
                                label: "Create module",
-                                source_change: SourceChange {
+                                group: None,
-                                    source_file_edits: {},
+                                target: 0..8,
-                                    file_system_edits: [
+                                source_change: Some(
-                                        CreateFile {
+                                    SourceChange {
-                                            dst: AnchoredPathBuf {
+                                        source_file_edits: {},
-                                                anchor: FileId(
+                                        file_system_edits: [
-                                                    0,
+                                            CreateFile {
-                                                ),
+                                                dst: AnchoredPathBuf {
-                                                path: "foo.rs",
+                                                    anchor: FileId(
+                                                        0,
+                                                    ),
+                                                    path: "foo.rs",
+                                                },
+                                                initial_contents: "",
                                            },
-                                            initial_contents: "",
+                                        ],
-                                        },
+                                        is_snippet: false,
-                                    ],
+                                    },
-                                    is_snippet: false,
+                                ),
-                                },
-                                fix_trigger_range: 0..8,
                            },
                        ),
                        unused: false,
@@ -888,10 +911,11 @@ struct Foo {
        let (analysis, file_id) = fixture::file(r#"mod foo;"#);
-        let diagnostics = analysis.diagnostics(&config, file_id).unwrap();
+        let diagnostics = analysis.diagnostics(&config, true, file_id).unwrap();
        assert!(diagnostics.is_empty());
-        let diagnostics = analysis.diagnostics(&DiagnosticsConfig::default(), file_id).unwrap();
+        let diagnostics =
+            analysis.diagnostics(&DiagnosticsConfig::default(), true, file_id).unwrap();
        assert!(!diagnostics.is_empty());
    }
@@ -997,8 +1021,9 @@ impl TestStruct {
        let expected = r#"fn foo() {}"#;
        let (analysis, file_position) = fixture::position(input);
-        let diagnostics =
+        let diagnostics = analysis
-            analysis.diagnostics(&DiagnosticsConfig::default(), file_position.file_id).unwrap();
+            .diagnostics(&DiagnosticsConfig::default(), true, file_position.file_id)
+            .unwrap();
        assert_eq!(diagnostics.len(), 1);
        check_fix(input, expected);
diff --git a/crates/ide/src/diagnostics/field_shorthand.rs b/crates/ide/src/diagnostics/field_shorthand.rs
index 5c89e2170..2b1787f9b 100644
--- a/crates/ide/src/diagnostics/field_shorthand.rs
+++ b/crates/ide/src/diagnostics/field_shorthand.rs
@@ -5,7 +5,7 @@ use ide_db::{base_db::FileId, source_change::SourceChange};
 use syntax::{ast, match_ast, AstNode, SyntaxNode};
 use text_edit::TextEdit;
-use crate::{Diagnostic, Fix};
+use crate::{diagnostics::fix, Diagnostic};
 pub(super) fn check(acc: &mut Vec<Diagnostic>, file_id: FileId, node: &SyntaxNode) {
    match_ast! {
@@ -47,7 +47,8 @@ fn check_expr_field_shorthand(
        let field_range = record_field.syntax().text_range();
        acc.push(
            Diagnostic::hint(field_range, "Shorthand struct initialization".to_string()).with_fix(
-                Some(Fix::new(
+                Some(fix(
+                    "use_expr_field_shorthand",
                    "Use struct shorthand initialization",
                    SourceChange::from_text_edit(file_id, edit),
                    field_range,
@@ -86,7 +87,8 @@ fn check_pat_field_shorthand(
        let field_range = record_pat_field.syntax().text_range();
        acc.push(Diagnostic::hint(field_range, "Shorthand struct pattern".to_string()).with_fix(
-            Some(Fix::new(
+            Some(fix(
+                "use_pat_field_shorthand",
                "Use struct field shorthand",
                SourceChange::from_text_edit(file_id, edit),
                field_range,
diff --git a/crates/ide/src/diagnostics/fixes.rs b/crates/ide/src/diagnostics/fixes.rs
index 5fb3e2d91..7be8b3459 100644
--- a/crates/ide/src/diagnostics/fixes.rs
+++ b/crates/ide/src/diagnostics/fixes.rs
@@ -20,20 +20,30 @@ use syntax::{
 };
 use text_edit::TextEdit;
-use crate::{diagnostics::Fix, references::rename::rename_with_semantics, FilePosition};
+use crate::{
+    diagnostics::{fix, unresolved_fix},
+    references::rename::rename_with_semantics,
+    Assist, FilePosition,
+};
 /// A [Diagnostic] that potentially has a fix available.
 ///
 /// [Diagnostic]: hir::diagnostics::Diagnostic
 pub(crate) trait DiagnosticWithFix: Diagnostic {
-    fn fix(&self, sema: &Semantics<RootDatabase>) -> Option<Fix>;
+    /// `resolve` determines if the diagnostic should fill in the `edit` field
+    /// of the assist.
+    ///
+    /// If `resolve` is false, the edit will be computed later, on demand, and
+    /// can be omitted.
+    fn fix(&self, sema: &Semantics<RootDatabase>, _resolve: bool) -> Option<Assist>;
 }
 impl DiagnosticWithFix for UnresolvedModule {
-    fn fix(&self, sema: &Semantics<RootDatabase>) -> Option<Fix> {
+    fn fix(&self, sema: &Semantics<RootDatabase>, _resolve: bool) -> Option<Assist> {
        let root = sema.db.parse_or_expand(self.file)?;
        let unresolved_module = self.decl.to_node(&root);
-        Some(Fix::new(
+        Some(fix(
+            "create_module",
            "Create module",
            FileSystemEdit::CreateFile {
                dst: AnchoredPathBuf {
@@ -49,7 +59,7 @@ impl DiagnosticWithFix for UnresolvedModule {
 }
 impl DiagnosticWithFix for NoSuchField {
-    fn fix(&self, sema: &Semantics<RootDatabase>) -> Option<Fix> {
+    fn fix(&self, sema: &Semantics<RootDatabase>, _resolve: bool) -> Option<Assist> {
        let root = sema.db.parse_or_expand(self.file)?;
        missing_record_expr_field_fix(
            &sema,
@@ -60,7 +70,7 @@ impl DiagnosticWithFix for NoSuchField {
 }
 impl DiagnosticWithFix for MissingFields {
-    fn fix(&self, sema: &Semantics<RootDatabase>) -> Option<Fix> {
+    fn fix(&self, sema: &Semantics<RootDatabase>, _resolve: bool) -> Option<Assist> {
        // Note that although we could add a diagnostics to
        // fill the missing tuple field, e.g :
        // `struct A(usize);`
@@ -86,7 +96,8 @@ impl DiagnosticWithFix for MissingFields {
                .into_text_edit(&mut builder);
            builder.finish()
        };
-        Some(Fix::new(
+        Some(fix(
+            "fill_missing_fields",
            "Fill struct fields",
            SourceChange::from_text_edit(self.file.original_file(sema.db), edit),
            sema.original_range(&field_list_parent.syntax()).range,
@@ -95,7 +106,7 @@ impl DiagnosticWithFix for MissingFields {
 }
 impl DiagnosticWithFix for MissingOkOrSomeInTailExpr {
-    fn fix(&self, sema: &Semantics<RootDatabase>) -> Option<Fix> {
+    fn fix(&self, sema: &Semantics<RootDatabase>, _resolve: bool) -> Option<Assist> {
        let root = sema.db.parse_or_expand(self.file)?;
        let tail_expr = self.expr.to_node(&root);
        let tail_expr_range = tail_expr.syntax().text_range();
@@ -103,12 +114,12 @@ impl DiagnosticWithFix for MissingOkOrSomeInTailExpr {
        let edit = TextEdit::replace(tail_expr_range, replacement);
        let source_change = SourceChange::from_text_edit(self.file.original_file(sema.db), edit);
        let name = if self.required == "Ok" { "Wrap with Ok" } else { "Wrap with Some" };
-        Some(Fix::new(name, source_change, tail_expr_range))
+        Some(fix("wrap_tail_expr", name, source_change, tail_expr_range))
    }
 }
 impl DiagnosticWithFix for RemoveThisSemicolon {
-    fn fix(&self, sema: &Semantics<RootDatabase>) -> Option<Fix> {
+    fn fix(&self, sema: &Semantics<RootDatabase>, _resolve: bool) -> Option<Assist> {
        let root = sema.db.parse_or_expand(self.file)?;
        let semicolon = self
@@ -123,12 +134,12 @@ impl DiagnosticWithFix for RemoveThisSemicolon {
        let edit = TextEdit::delete(semicolon);
        let source_change = SourceChange::from_text_edit(self.file.original_file(sema.db), edit);
-        Some(Fix::new("Remove this semicolon", source_change, semicolon))
+        Some(fix("remove_semicolon", "Remove this semicolon", source_change, semicolon))
    }
 }
 impl DiagnosticWithFix for IncorrectCase {
-    fn fix(&self, sema: &Semantics<RootDatabase>) -> Option<Fix> {
+    fn fix(&self, sema: &Semantics<RootDatabase>, resolve: bool) -> Option<Assist> {
        let root = sema.db.parse_or_expand(self.file)?;
        let name_node = self.ident.to_node(&root);
@@ -136,16 +147,19 @@ impl DiagnosticWithFix for IncorrectCase {
        let frange = name_node.original_file_range(sema.db);
        let file_position = FilePosition { file_id: frange.file_id, offset: frange.range.start() };
-        let rename_changes =
-            rename_with_semantics(sema, file_position, &self.suggested_text).ok()?;
        let label = format!("Rename to {}", self.suggested_text);
-        Some(Fix::new(&label, rename_changes, frange.range))
+        let mut res = unresolved_fix("change_case", &label, frange.range);
+        if resolve {
+            let source_change = rename_with_semantics(sema, file_position, &self.suggested_text);
+            res.source_change = Some(source_change.ok().unwrap_or_default());
+        }
+        Some(res)
    }
 }
 impl DiagnosticWithFix for ReplaceFilterMapNextWithFindMap {
-    fn fix(&self, sema: &Semantics<RootDatabase>) -> Option<Fix> {
+    fn fix(&self, sema: &Semantics<RootDatabase>, _resolve: bool) -> Option<Assist> {
        let root = sema.db.parse_or_expand(self.file)?;
        let next_expr = self.next_expr.to_node(&root);
        let next_call = ast::MethodCallExpr::cast(next_expr.syntax().clone())?;
@@ -163,7 +177,8 @@ impl DiagnosticWithFix for ReplaceFilterMapNextWithFindMap {
        let source_change = SourceChange::from_text_edit(self.file.original_file(sema.db), edit);
-        Some(Fix::new(
+        Some(fix(
+            "replace_with_find_map",
            "Replace filter_map(..).next() with find_map()",
            source_change,
            trigger_range,
@@ -175,7 +190,7 @@ fn missing_record_expr_field_fix(
    sema: &Semantics<RootDatabase>,
    usage_file_id: FileId,
    record_expr_field: &ast::RecordExprField,
-) -> Option<Fix> {
+) -> Option<Assist> {
    let record_lit = ast::RecordExpr::cast(record_expr_field.syntax().parent()?.parent()?)?;
    let def_id = sema.resolve_variant(record_lit)?;
    let module;
@@ -233,7 +248,12 @@ fn missing_record_expr_field_fix(
        def_file_id,
        TextEdit::insert(last_field_syntax.text_range().end(), new_field),
    );
-    return Some(Fix::new("Create field", source_change, record_expr_field.syntax().text_range()));
+    return Some(fix(
+        "create_field",
+        "Create field",
+        source_change,
+        record_expr_field.syntax().text_range(),
+    ));
    fn record_field_list(field_def_list: ast::FieldList) -> Option<ast::RecordFieldList> {
        match field_def_list {
diff --git a/crates/ide/src/diagnostics/unlinked_file.rs b/crates/ide/src/diagnostics/unlinked_file.rs
index e174fb767..7d39f4fbe 100644
--- a/crates/ide/src/diagnostics/unlinked_file.rs
+++ b/crates/ide/src/diagnostics/unlinked_file.rs
@@ -16,9 +16,10 @@ use syntax::{
 };
 use text_edit::TextEdit;
-use crate::Fix;
+use crate::{
+    diagnostics::{fix, fixes::DiagnosticWithFix},
-use super::fixes::DiagnosticWithFix;
+    Assist,
+};
 // Diagnostic: unlinked-file
 //
@@ -49,7 +50,7 @@ impl Diagnostic for UnlinkedFile {
 }
 impl DiagnosticWithFix for UnlinkedFile {
-    fn fix(&self, sema: &hir::Semantics<RootDatabase>) -> Option<Fix> {
+    fn fix(&self, sema: &hir::Semantics<RootDatabase>, _resolve: bool) -> Option<Assist> {
        // If there's an existing module that could add a `mod` item to include the unlinked file,
        // suggest that as a fix.
@@ -100,7 +101,7 @@ fn make_fix(
    parent_file_id: FileId,
    new_mod_name: &str,
    added_file_id: FileId,
-) -> Option<Fix> {
+) -> Option<Assist> {
    fn is_outline_mod(item: &ast::Item) -> bool {
        matches!(item, ast::Item::Module(m) if m.item_list().is_none())
    }
@@ -152,7 +153,8 @@ fn make_fix(
    let edit = builder.finish();
    let trigger_range = db.parse(added_file_id).tree().syntax().text_range();
-    Some(Fix::new(
+    Some(fix(
+        "add_mod_declaration",
        &format!("Insert `{}`", mod_decl),
        SourceChange::from_text_edit(parent_file_id, edit),
        trigger_range,
diff --git a/crates/ide/src/expand_macro.rs b/crates/ide/src/expand_macro.rs
index d5628e3df..be0ee03bf 100644
--- a/crates/ide/src/expand_macro.rs
+++ b/crates/ide/src/expand_macro.rs
@@ -1,3 +1,5 @@
+use std::iter;
 use hir::Semantics;
 use ide_db::RootDatabase;
 use syntax::{
@@ -91,27 +93,42 @@ fn insert_whitespaces(syn: SyntaxNode) -> String {
        let is_last =
            |f: fn(SyntaxKind) -> bool, default| -> bool { last.map(f).unwrap_or(default) };
-        res += &match token.kind() {
+        match token.kind() {
-            k if is_text(k) && is_next(|it| !it.is_punct(), true) => token.text().to_string() + " ",
+            k if is_text(k) && is_next(|it| !it.is_punct(), true) => {
+                res.push_str(token.text());
+                res.push(' ');
+            }
            L_CURLY if is_next(|it| it != R_CURLY, true) => {
                indent += 1;
-                let leading_space = if is_last(is_text, false) { " " } else { "" };
+                if is_last(is_text, false) {
-                format!("{}{{\n{}", leading_space, "  ".repeat(indent))
+                    res.push(' ');
+                }
+                res.push_str("{\n");
+                res.extend(iter::repeat(" ").take(2 * indent));
            }
            R_CURLY if is_last(|it| it != L_CURLY, true) => {
                indent = indent.saturating_sub(1);
-                format!("\n{}}}", "  ".repeat(indent))
+                res.push('\n');
+                res.extend(iter::repeat(" ").take(2 * indent));
+                res.push_str("}");
+            }
+            R_CURLY => {
+                res.push_str("}\n");
+                res.extend(iter::repeat(" ").take(2 * indent));
            }
-            R_CURLY => format!("}}\n{}", "  ".repeat(indent)),
            LIFETIME_IDENT if is_next(|it| it == IDENT, true) => {
-                format!("{} ", token.text().to_string())
+                res.push_str(token.text());
+                res.push(' ');
            }
-            T![;] => format!(";\n{}", "  ".repeat(indent)),
+            T![;] => {
-            T![->] => " -> ".to_string(),
+                res.push_str(";\n");
-            T![=] => " = ".to_string(),
+                res.extend(iter::repeat(" ").take(2 * indent));
-            T![=>] => " => ".to_string(),
+            }
-            _ => token.text().to_string(),
+            T![->] => res.push_str(" -> "),
-        };
+            T![=] => res.push_str(" = "),
+            T![=>] => res.push_str(" => "),
+            _ => res.push_str(token.text()),
+        }
        last = Some(token.kind());
    }
diff --git a/crates/ide/src/goto_definition.rs b/crates/ide/src/goto_definition.rs
index ca8ccb2da..a04333e63 100644
--- a/crates/ide/src/goto_definition.rs
+++ b/crates/ide/src/goto_definition.rs
@@ -110,6 +110,13 @@ mod tests {
        assert_eq!(expected, FileRange { file_id: nav.file_id, range: nav.focus_or_full_range() });
    }
+    fn check_unresolved(ra_fixture: &str) {
+        let (analysis, position) = fixture::position(ra_fixture);
+        let navs = analysis.goto_definition(position).unwrap().expect("no definition found").info;
+        assert!(navs.is_empty(), "didn't expect this to resolve anywhere: {:?}", navs)
+    }
    #[test]
    fn goto_def_for_extern_crate() {
        check(
@@ -927,17 +934,12 @@ fn f() -> impl Iterator<Item$0 = u8> {}
    }
    #[test]
-    #[should_panic = "unresolved reference"]
    fn unknown_assoc_ty() {
-        check(
+        check_unresolved(
            r#"
-trait Iterator {
+trait Iterator { type Item; }
-    type Item;
-       //^^^^
-}
 fn f() -> impl Iterator<Invalid$0 = u8> {}
-            "#,
+"#,
        )
    }
@@ -1188,4 +1190,30 @@ pub fn gimme() -> theitem::TheItem {
 "#,
        );
    }
+    #[test]
+    fn goto_ident_from_pat_macro() {
+        check(
+            r#"
+macro_rules! pat {
+    ($name:ident) => { Enum::Variant1($name) }
+}
+enum Enum {
+    Variant1(u8),
+    Variant2,
+}
+fn f(e: Enum) {
+    match e {
+        pat!(bind) => {
+           //^^^^
+            bind$0
+        }
+        Enum::Variant2 => {}
+    }
+}
+"#,
+        );
+    }
 }
diff --git a/crates/ide/src/lib.rs b/crates/ide/src/lib.rs
index 3f73c0632..b24c664ba 100644
--- a/crates/ide/src/lib.rs
+++ b/crates/ide/src/lib.rs
@@ -69,7 +69,7 @@ use crate::display::ToNav;
 pub use crate::{
    annotations::{Annotation, AnnotationConfig, AnnotationKind},
    call_hierarchy::CallItem,
-    diagnostics::{Diagnostic, DiagnosticsConfig, Fix, Severity},
+    diagnostics::{Diagnostic, DiagnosticsConfig, Severity},
    display::navigation_target::NavigationTarget,
    expand_macro::ExpandedMacro,
    file_structure::{StructureNode, StructureNodeKind},
@@ -82,7 +82,7 @@ pub use crate::{
    references::{rename::RenameError, ReferenceSearchResult},
    runnables::{Runnable, RunnableKind, TestId},
    syntax_highlighting::{
-        tags::{Highlight, HlMod, HlMods, HlPunct, HlTag},
+        tags::{Highlight, HlMod, HlMods, HlOperator, HlPunct, HlTag},
        HlRange,
    },
 };
@@ -526,9 +526,39 @@ impl Analysis {
    pub fn diagnostics(
        &self,
        config: &DiagnosticsConfig,
+        resolve: bool,
        file_id: FileId,
    ) -> Cancelable<Vec<Diagnostic>> {
-        self.with_db(|db| diagnostics::diagnostics(db, config, file_id))
+        self.with_db(|db| diagnostics::diagnostics(db, config, resolve, file_id))
+    }
+    /// Convenience function to return assists + quick fixes for diagnostics
+    pub fn assists_with_fixes(
+        &self,
+        assist_config: &AssistConfig,
+        diagnostics_config: &DiagnosticsConfig,
+        resolve: bool,
+        frange: FileRange,
+    ) -> Cancelable<Vec<Assist>> {
+        let include_fixes = match &assist_config.allowed {
+            Some(it) => it.iter().any(|&it| it == AssistKind::None || it == AssistKind::QuickFix),
+            None => true,
+        };
+        self.with_db(|db| {
+            let mut res = Assist::get(db, assist_config, resolve, frange);
+            ssr::add_ssr_assist(db, &mut res, resolve, frange);
+            if include_fixes {
+                res.extend(
+                    diagnostics::diagnostics(db, diagnostics_config, resolve, frange.file_id)
+                        .into_iter()
+                        .filter_map(|it| it.fix)
+                        .filter(|it| it.target.intersect(frange.range).is_some()),
+                );
+            }
+            res
+        })
    }
    /// Returns the edit required to rename reference at the position to the new
diff --git a/crates/ide/src/syntax_highlighting/highlight.rs b/crates/ide/src/syntax_highlighting/highlight.rs
index 5ccb84714..8cc877c1c 100644
--- a/crates/ide/src/syntax_highlighting/highlight.rs
+++ b/crates/ide/src/syntax_highlighting/highlight.rs
@@ -12,7 +12,10 @@ use syntax::{
    SyntaxNode, SyntaxToken, T,
 };
-use crate::{syntax_highlighting::tags::HlPunct, Highlight, HlMod, HlTag};
+use crate::{
+    syntax_highlighting::tags::{HlOperator, HlPunct},
+    Highlight, HlMod, HlTag,
+};
 pub(super) fn element(
    sema: &Semantics<RootDatabase>,
@@ -132,7 +135,7 @@ pub(super) fn element(
        INT_NUMBER | FLOAT_NUMBER => HlTag::NumericLiteral.into(),
        BYTE => HlTag::ByteLiteral.into(),
        CHAR => HlTag::CharLiteral.into(),
-        QUESTION => Highlight::new(HlTag::Operator) | HlMod::ControlFlow,
+        QUESTION => Highlight::new(HlTag::Operator(HlOperator::Other)) | HlMod::ControlFlow,
        LIFETIME => {
            let lifetime = element.into_node().and_then(ast::Lifetime::cast).unwrap();
@@ -146,8 +149,11 @@ pub(super) fn element(
            }
        }
        p if p.is_punct() => match p {
+            T![&] if element.parent().and_then(ast::BinExpr::cast).is_some() => {
+                HlTag::Operator(HlOperator::Bitwise).into()
+            }
            T![&] => {
-                let h = HlTag::Operator.into();
+                let h = HlTag::Operator(HlOperator::Other).into();
                let is_unsafe = element
                    .parent()
                    .and_then(ast::RefExpr::cast)
@@ -159,13 +165,18 @@ pub(super) fn element(
                    h
                }
            }
-            T![::] | T![->] | T![=>] | T![..] | T![=] | T![@] | T![.] => HlTag::Operator.into(),
+            T![::] | T![->] | T![=>] | T![..] | T![=] | T![@] | T![.] => {
+                HlTag::Operator(HlOperator::Other).into()
+            }
            T![!] if element.parent().and_then(ast::MacroCall::cast).is_some() => {
                HlTag::Symbol(SymbolKind::Macro).into()
            }
            T![!] if element.parent().and_then(ast::NeverType::cast).is_some() => {
                HlTag::BuiltinType.into()
            }
+            T![!] if element.parent().and_then(ast::PrefixExpr::cast).is_some() => {
+                HlTag::Operator(HlOperator::Logical).into()
+            }
            T![*] if element.parent().and_then(ast::PtrType::cast).is_some() => {
                HlTag::Keyword.into()
            }
@@ -175,9 +186,9 @@ pub(super) fn element(
                let expr = prefix_expr.expr()?;
                let ty = sema.type_of_expr(&expr)?;
                if ty.is_raw_ptr() {
-                    HlTag::Operator | HlMod::Unsafe
+                    HlTag::Operator(HlOperator::Other) | HlMod::Unsafe
                } else if let Some(ast::PrefixOp::Deref) = prefix_expr.op_kind() {
-                    HlTag::Operator.into()
+                    HlTag::Operator(HlOperator::Other).into()
                } else {
                    HlTag::Punctuation(HlPunct::Other).into()
                }
@@ -188,19 +199,43 @@ pub(super) fn element(
                let expr = prefix_expr.expr()?;
                match expr {
                    ast::Expr::Literal(_) => HlTag::NumericLiteral,
-                    _ => HlTag::Operator,
+                    _ => HlTag::Operator(HlOperator::Other),
                }
                .into()
            }
            _ if element.parent().and_then(ast::PrefixExpr::cast).is_some() => {
-                HlTag::Operator.into()
+                HlTag::Operator(HlOperator::Other).into()
+            }
+            T![+] | T![-] | T![*] | T![/] | T![+=] | T![-=] | T![*=] | T![/=]
+                if element.parent().and_then(ast::BinExpr::cast).is_some() =>
+            {
+                HlTag::Operator(HlOperator::Arithmetic).into()
+            }
+            T![|] | T![&] | T![!] | T![^] | T![|=] | T![&=] | T![^=]
+                if element.parent().and_then(ast::BinExpr::cast).is_some() =>
+            {
+                HlTag::Operator(HlOperator::Bitwise).into()
+            }
+            T![&&] | T![||] if element.parent().and_then(ast::BinExpr::cast).is_some() => {
+                HlTag::Operator(HlOperator::Logical).into()
+            }
+            T![>] | T![<] | T![==] | T![>=] | T![<=] | T![!=]
+                if element.parent().and_then(ast::BinExpr::cast).is_some() =>
+            {
+                HlTag::Operator(HlOperator::Comparision).into()
+            }
+            _ if element.parent().and_then(ast::BinExpr::cast).is_some() => {
+                HlTag::Operator(HlOperator::Other).into()
            }
-            _ if element.parent().and_then(ast::BinExpr::cast).is_some() => HlTag::Operator.into(),
            _ if element.parent().and_then(ast::RangeExpr::cast).is_some() => {
-                HlTag::Operator.into()
+                HlTag::Operator(HlOperator::Other).into()
+            }
+            _ if element.parent().and_then(ast::RangePat::cast).is_some() => {
+                HlTag::Operator(HlOperator::Other).into()
+            }
+            _ if element.parent().and_then(ast::RestPat::cast).is_some() => {
+                HlTag::Operator(HlOperator::Other).into()
            }
-            _ if element.parent().and_then(ast::RangePat::cast).is_some() => HlTag::Operator.into(),
-            _ if element.parent().and_then(ast::RestPat::cast).is_some() => HlTag::Operator.into(),
            _ if element.parent().and_then(ast::Attr::cast).is_some() => HlTag::Attribute.into(),
            kind => HlTag::Punctuation(match kind {
                T!['['] | T![']'] => HlPunct::Bracket,
@@ -323,8 +358,18 @@ fn highlight_def(db: &RootDatabase, def: Definition) -> Highlight {
            hir::ModuleDef::Trait(_) => HlTag::Symbol(SymbolKind::Trait),
            hir::ModuleDef::TypeAlias(type_) => {
                let mut h = Highlight::new(HlTag::Symbol(SymbolKind::TypeAlias));
-                if type_.as_assoc_item(db).is_some() {
+                if let Some(item) = type_.as_assoc_item(db) {
-                    h |= HlMod::Associated
+                    h |= HlMod::Associated;
+                    match item.container(db) {
+                        AssocItemContainer::Impl(i) => {
+                            if i.trait_(db).is_some() {
+                                h |= HlMod::Trait;
+                            }
+                        }
+                        AssocItemContainer::Trait(_t) => {
+                            h |= HlMod::Trait;
+                        }
+                    }
                }
                return h;
            }
diff --git a/crates/ide/src/syntax_highlighting/tags.rs b/crates/ide/src/syntax_highlighting/tags.rs
index 1cec991aa..8128d231d 100644
--- a/crates/ide/src/syntax_highlighting/tags.rs
+++ b/crates/ide/src/syntax_highlighting/tags.rs
@@ -28,7 +28,7 @@ pub enum HlTag {
    FormatSpecifier,
    Keyword,
    NumericLiteral,
-    Operator,
+    Operator(HlOperator),
    Punctuation(HlPunct),
    StringLiteral,
    UnresolvedReference,
@@ -87,6 +87,20 @@ pub enum HlPunct {
    Other,
 }
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub enum HlOperator {
+    /// |, &, !, ^, |=, &=, ^=
+    Bitwise,
+    /// +, -, *, /, +=, -=, *=, /=
+    Arithmetic,
+    /// &&, ||, !
+    Logical,
+    /// >, <, ==, >=, <=, !=
+    Comparision,
+    ///
+    Other,
+}
 impl HlTag {
    fn as_str(self) -> &'static str {
        match self {
@@ -133,7 +147,13 @@ impl HlTag {
                HlPunct::Other => "punctuation",
            },
            HlTag::NumericLiteral => "numeric_literal",
-            HlTag::Operator => "operator",
+            HlTag::Operator(op) => match op {
+                HlOperator::Bitwise => "bitwise",
+                HlOperator::Arithmetic => "arithmetic",
+                HlOperator::Logical => "logical",
+                HlOperator::Comparision => "comparision",
+                HlOperator::Other => "operator",
+            },
            HlTag::StringLiteral => "string_literal",
            HlTag::UnresolvedReference => "unresolved_reference",
            HlTag::None => "none",
diff --git a/crates/ide/src/syntax_highlighting/test_data/highlight_doctest.html b/crates/ide/src/syntax_highlighting/test_data/highlight_doctest.html
index b6d1cac4e..6ee6d85fb 100644
--- a/crates/ide/src/syntax_highlighting/test_data/highlight_doctest.html
+++ b/crates/ide/src/syntax_highlighting/test_data/highlight_doctest.html
@@ -76,7 +76,7 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
    <span class="comment documentation">/// </span><span class="comment injected">// calls bar on foo</span>
    <span class="comment documentation">/// </span><span class="macro injected">assert!</span><span class="parenthesis injected">(</span><span class="none injected">foo</span><span class="operator injected">.</span><span class="none injected">bar</span><span class="parenthesis injected">(</span><span class="parenthesis injected">)</span><span class="parenthesis injected">)</span><span class="semicolon injected">;</span>
    <span class="comment documentation">///</span>
-    <span class="comment documentation">/// </span><span class="keyword injected">let</span><span class="none injected"> </span><span class="variable declaration injected">bar</span><span class="none injected"> </span><span class="operator injected">=</span><span class="none injected"> </span><span class="variable injected">foo</span><span class="operator injected">.</span><span class="field injected">bar</span><span class="none injected"> </span><span class="operator injected">||</span><span class="none injected"> </span><span class="struct injected">Foo</span><span class="operator injected">::</span><span class="constant injected">bar</span><span class="semicolon injected">;</span>
+    <span class="comment documentation">/// </span><span class="keyword injected">let</span><span class="none injected"> </span><span class="variable declaration injected">bar</span><span class="none injected"> </span><span class="operator injected">=</span><span class="none injected"> </span><span class="variable injected">foo</span><span class="operator injected">.</span><span class="field injected">bar</span><span class="none injected"> </span><span class="logical injected">||</span><span class="none injected"> </span><span class="struct injected">Foo</span><span class="operator injected">::</span><span class="constant injected">bar</span><span class="semicolon injected">;</span>
    <span class="comment documentation">///</span>
    <span class="comment documentation">/// </span><span class="comment injected">/* multi-line</span>
    <span class="comment documentation">/// </span><span class="comment injected">       comment */</span>
diff --git a/crates/ide/src/syntax_highlighting/test_data/highlighting.html b/crates/ide/src/syntax_highlighting/test_data/highlighting.html
index 973173254..c43bcb691 100644
--- a/crates/ide/src/syntax_highlighting/test_data/highlighting.html
+++ b/crates/ide/src/syntax_highlighting/test_data/highlighting.html
@@ -213,7 +213,7 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
    <span class="keyword">let</span> <span class="variable declaration">baz</span> <span class="operator">=</span> <span class="numeric_literal">-</span><span class="numeric_literal">42</span><span class="semicolon">;</span>
    <span class="keyword">let</span> <span class="variable declaration">baz</span> <span class="operator">=</span> <span class="operator">-</span><span class="variable">baz</span><span class="semicolon">;</span>
-    <span class="keyword">let</span> <span class="punctuation">_</span> <span class="operator">=</span> <span class="operator">!</span><span class="bool_literal">true</span><span class="semicolon">;</span>
+    <span class="keyword">let</span> <span class="punctuation">_</span> <span class="operator">=</span> <span class="logical">!</span><span class="bool_literal">true</span><span class="semicolon">;</span>
    <span class="label declaration">'foo</span><span class="colon">:</span> <span class="keyword control">loop</span> <span class="brace">{</span>
        <span class="keyword control">break</span> <span class="label">'foo</span><span class="semicolon">;</span>
diff --git a/crates/ide/src/syntax_highlighting/tests.rs b/crates/ide/src/syntax_highlighting/tests.rs
index 1b02857ec..933cfa6f3 100644
--- a/crates/ide/src/syntax_highlighting/tests.rs
+++ b/crates/ide/src/syntax_highlighting/tests.rs
@@ -1,6 +1,8 @@
+use std::time::Instant;
 use expect_test::{expect_file, ExpectFile};
 use ide_db::SymbolKind;
-use test_utils::{bench, bench_fixture, skip_slow_tests};
+use test_utils::{bench, bench_fixture, skip_slow_tests, AssertLinear};
 use crate::{fixture, FileRange, HlTag, TextRange};
@@ -258,6 +260,36 @@ fn benchmark_syntax_highlighting_long_struct() {
 }
 #[test]
+fn syntax_highlighting_not_quadratic() {
+    if skip_slow_tests() {
+        return;
+    }
+    let mut al = AssertLinear::default();
+    while al.next_round() {
+        for i in 6..=10 {
+            let n = 1 << i;
+            let fixture = bench_fixture::big_struct_n(n);
+            let (analysis, file_id) = fixture::file(&fixture);
+            let time = Instant::now();
+            let hash = analysis
+                .highlight(file_id)
+                .unwrap()
+                .iter()
+                .filter(|it| it.highlight.tag == HlTag::Symbol(SymbolKind::Struct))
+                .count();
+            assert!(hash > n as usize);
+            let elapsed = time.elapsed();
+            al.sample(n as f64, elapsed.as_millis() as f64);
+        }
+    }
+}
+#[test]
 fn benchmark_syntax_highlighting_parser() {
    if skip_slow_tests() {
        return;
diff --git a/crates/ide/src/typing/on_enter.rs b/crates/ide/src/typing/on_enter.rs
index 9144681bf..7d2db201a 100644
--- a/crates/ide/src/typing/on_enter.rs
+++ b/crates/ide/src/typing/on_enter.rs
@@ -4,10 +4,11 @@
 use ide_db::base_db::{FilePosition, SourceDatabase};
 use ide_db::RootDatabase;
 use syntax::{
-    ast::{self, AstToken},
+    algo::find_node_at_offset,
+    ast::{self, edit::IndentLevel, AstToken},
    AstNode, SmolStr, SourceFile,
    SyntaxKind::*,
-    SyntaxToken, TextRange, TextSize, TokenAtOffset,
+    SyntaxNode, SyntaxToken, TextRange, TextSize, TokenAtOffset,
 };
 use text_edit::TextEdit;
@@ -18,6 +19,8 @@ use text_edit::TextEdit;
 //
 // - kbd:[Enter] inside triple-slash comments automatically inserts `///`
 // - kbd:[Enter] in the middle or after a trailing space in `//` inserts `//`
+// - kbd:[Enter] inside `//!` doc comments automatically inserts `//!`
+// - kbd:[Enter] after `{` indents contents and closing `}` of single-line block
 //
 // This action needs to be assigned to shortcut explicitly.
 //
@@ -37,25 +40,43 @@ use text_edit::TextEdit;
 pub(crate) fn on_enter(db: &RootDatabase, position: FilePosition) -> Option<TextEdit> {
    let parse = db.parse(position.file_id);
    let file = parse.tree();
-    let comment = file
+    let token = file.syntax().token_at_offset(position.offset).left_biased()?;
-        .syntax()
-        .token_at_offset(position.offset)
-        .left_biased()
-        .and_then(ast::Comment::cast)?;
+    if let Some(comment) = ast::Comment::cast(token.clone()) {
+        return on_enter_in_comment(&comment, &file, position.offset);
+    }
+    if token.kind() == L_CURLY {
+        // Typing enter after the `{` of a block expression, where the `}` is on the same line
+        if let Some(edit) = find_node_at_offset(file.syntax(), position.offset - TextSize::of('{'))
+            .and_then(|block| on_enter_in_block(block, position))
+        {
+            cov_mark::hit!(indent_block_contents);
+            return Some(edit);
+        }
+    }
+    None
+}
+fn on_enter_in_comment(
+    comment: &ast::Comment,
+    file: &ast::SourceFile,
+    offset: TextSize,
+) -> Option<TextEdit> {
    if comment.kind().shape.is_block() {
        return None;
    }
    let prefix = comment.prefix();
    let comment_range = comment.syntax().text_range();
-    if position.offset < comment_range.start() + TextSize::of(prefix) {
+    if offset < comment_range.start() + TextSize::of(prefix) {
        return None;
    }
    let mut remove_trailing_whitespace = false;
    // Continuing single-line non-doc comments (like this one :) ) is annoying
-    if prefix == "//" && comment_range.end() == position.offset {
+    if prefix == "//" && comment_range.end() == offset {
        if comment.text().ends_with(' ') {
            cov_mark::hit!(continues_end_of_line_comment_with_space);
            remove_trailing_whitespace = true;
@@ -69,14 +90,42 @@ pub(crate) fn on_enter(db: &RootDatabase, position: FilePosition) -> Option<Text
    let delete = if remove_trailing_whitespace {
        let trimmed_len = comment.text().trim_end().len() as u32;
        let trailing_whitespace_len = comment.text().len() as u32 - trimmed_len;
-        TextRange::new(position.offset - TextSize::from(trailing_whitespace_len), position.offset)
+        TextRange::new(offset - TextSize::from(trailing_whitespace_len), offset)
    } else {
-        TextRange::empty(position.offset)
+        TextRange::empty(offset)
    };
    let edit = TextEdit::replace(delete, inserted);
    Some(edit)
 }
+fn on_enter_in_block(block: ast::BlockExpr, position: FilePosition) -> Option<TextEdit> {
+    let contents = block_contents(&block)?;
+    if block.syntax().text().contains_char('\n') {
+        return None;
+    }
+    let indent = IndentLevel::from_node(block.syntax());
+    let mut edit = TextEdit::insert(position.offset, format!("\n{}$0", indent + 1));
+    edit.union(TextEdit::insert(contents.text_range().end(), format!("\n{}", indent))).ok()?;
+    Some(edit)
+}
+fn block_contents(block: &ast::BlockExpr) -> Option<SyntaxNode> {
+    let mut node = block.tail_expr().map(|e| e.syntax().clone());
+    for stmt in block.statements() {
+        if node.is_some() {
+            // More than 1 node in the block
+            return None;
+        }
+        node = Some(stmt.syntax().clone());
+    }
+    node
+}
 fn followed_by_comment(comment: &ast::Comment) -> bool {
    let ws = match comment.syntax().next_token().and_then(ast::Whitespace::cast) {
        Some(it) => it,
@@ -187,6 +236,25 @@ fn foo() {
    }
    #[test]
+    fn continues_another_doc_comment() {
+        do_check(
+            r#"
+fn main() {
+    //! Documentation for$0 on enter
+    let x = 1 + 1;
+}
+"#,
+            r#"
+fn main() {
+    //! Documentation for
+    //! $0 on enter
+    let x = 1 + 1;
+}
+"#,
+        );
+    }
+    #[test]
    fn continues_code_comment_in_the_middle_of_line() {
        do_check(
            r"
@@ -276,4 +344,144 @@ fn main() {
 ",
        );
    }
+    #[test]
+    fn indents_fn_body_block() {
+        cov_mark::check!(indent_block_contents);
+        do_check(
+            r#"
+fn f() {$0()}
+        "#,
+            r#"
+fn f() {
+    $0()
+}
+        "#,
+        );
+    }
+    #[test]
+    fn indents_block_expr() {
+        do_check(
+            r#"
+fn f() {
+    let x = {$0()};
+}
+        "#,
+            r#"
+fn f() {
+    let x = {
+        $0()
+    };
+}
+        "#,
+        );
+    }
+    #[test]
+    fn indents_match_arm() {
+        do_check(
+            r#"
+fn f() {
+    match 6 {
+        1 => {$0f()},
+        _ => (),
+    }
+}
+        "#,
+            r#"
+fn f() {
+    match 6 {
+        1 => {
+            $0f()
+        },
+        _ => (),
+    }
+}
+        "#,
+        );
+    }
+    #[test]
+    fn indents_block_with_statement() {
+        do_check(
+            r#"
+fn f() {$0a = b}
+        "#,
+            r#"
+fn f() {
+    $0a = b
+}
+        "#,
+        );
+        do_check(
+            r#"
+fn f() {$0fn f() {}}
+        "#,
+            r#"
+fn f() {
+    $0fn f() {}
+}
+        "#,
+        );
+    }
+    #[test]
+    fn indents_nested_blocks() {
+        do_check(
+            r#"
+fn f() {$0{}}
+        "#,
+            r#"
+fn f() {
+    $0{}
+}
+        "#,
+        );
+    }
+    #[test]
+    fn does_not_indent_empty_block() {
+        do_check_noop(
+            r#"
+fn f() {$0}
+        "#,
+        );
+        do_check_noop(
+            r#"
+fn f() {{$0}}
+        "#,
+        );
+    }
+    #[test]
+    fn does_not_indent_block_with_too_much_content() {
+        do_check_noop(
+            r#"
+fn f() {$0 a = b; ()}
+        "#,
+        );
+        do_check_noop(
+            r#"
+fn f() {$0 a = b; a = b; }
+        "#,
+        );
+    }
+    #[test]
+    fn does_not_indent_multiline_block() {
+        do_check_noop(
+            r#"
+fn f() {$0
+}
+        "#,
+        );
+        do_check_noop(
+            r#"
+fn f() {$0
+}
+        "#,
+        );
+    }
 }
diff --git a/crates/ide_assists/src/handlers/extract_function.rs b/crates/ide_assists/src/handlers/extract_function.rs
index 5fdc8bf38..059414274 100644
--- a/crates/ide_assists/src/handlers/extract_function.rs
+++ b/crates/ide_assists/src/handlers/extract_function.rs
@@ -75,7 +75,8 @@ pub(crate) fn extract_function(acc: &mut Assists, ctx: &AssistContext) -> Option
    let insert_after = scope_for_fn_insertion(&body, anchor)?;
    let module = ctx.sema.scope(&insert_after).module()?;
-    let vars_defined_in_body_and_outlive = vars_defined_in_body_and_outlive(ctx, &body);
+    let vars_defined_in_body_and_outlive =
+        vars_defined_in_body_and_outlive(ctx, &body, &node.parent().as_ref().unwrap_or(&node));
    let ret_ty = body_return_ty(ctx, &body)?;
    // FIXME: we compute variables that outlive here just to check `never!` condition
@@ -257,7 +258,7 @@ struct Function {
    control_flow: ControlFlow,
    ret_ty: RetType,
    body: FunctionBody,
-    vars_defined_in_body_and_outlive: Vec<Local>,
+    vars_defined_in_body_and_outlive: Vec<OutlivedLocal>,
 }
 #[derive(Debug)]
@@ -296,9 +297,9 @@ impl Function {
            RetType::Expr(ty) => FunType::Single(ty.clone()),
            RetType::Stmt => match self.vars_defined_in_body_and_outlive.as_slice() {
                [] => FunType::Unit,
-                [var] => FunType::Single(var.ty(ctx.db())),
+                [var] => FunType::Single(var.local.ty(ctx.db())),
                vars => {
-                    let types = vars.iter().map(|v| v.ty(ctx.db())).collect();
+                    let types = vars.iter().map(|v| v.local.ty(ctx.db())).collect();
                    FunType::Tuple(types)
                }
            },
@@ -562,6 +563,12 @@ impl HasTokenAtOffset for FunctionBody {
    }
 }
+#[derive(Debug)]
+struct OutlivedLocal {
+    local: Local,
+    mut_usage_outside_body: bool,
+}
 /// Try to guess what user wants to extract
 ///
 /// We have basically have two cases:
@@ -707,10 +714,10 @@ fn has_exclusive_usages(ctx: &AssistContext, usages: &LocalUsages, body: &Functi
        .any(|reference| reference_is_exclusive(reference, body, ctx))
 }
-/// checks if this reference requires `&mut` access inside body
+/// checks if this reference requires `&mut` access inside node
 fn reference_is_exclusive(
    reference: &FileReference,
-    body: &FunctionBody,
+    node: &dyn HasTokenAtOffset,
    ctx: &AssistContext,
 ) -> bool {
    // we directly modify variable with set: `n = 0`, `n += 1`
@@ -719,7 +726,7 @@ fn reference_is_exclusive(
    }
    // we take `&mut` reference to variable: `&mut v`
-    let path = match path_element_of_reference(body, reference) {
+    let path = match path_element_of_reference(node, reference) {
        Some(path) => path,
        None => return false,
    };
@@ -729,6 +736,14 @@ fn reference_is_exclusive(
 /// checks if this expr requires `&mut` access, recurses on field access
 fn expr_require_exclusive_access(ctx: &AssistContext, expr: &ast::Expr) -> Option<bool> {
+    match expr {
+        ast::Expr::MacroCall(_) => {
+            // FIXME: expand macro and check output for mutable usages of the variable?
+            return None;
+        }
+        _ => (),
+    }
    let parent = expr.syntax().parent()?;
    if let Some(bin_expr) = ast::BinExpr::cast(parent.clone()) {
@@ -787,7 +802,7 @@ impl HasTokenAtOffset for SyntaxNode {
    }
 }
-/// find relevant `ast::PathExpr` for reference
+/// find relevant `ast::Expr` for reference
 ///
 /// # Preconditions
 ///
@@ -804,7 +819,11 @@ fn path_element_of_reference(
        stdx::never!(false, "cannot find path parent of variable usage: {:?}", token);
        None
    })?;
-    stdx::always!(matches!(path, ast::Expr::PathExpr(_)));
+    stdx::always!(
+        matches!(path, ast::Expr::PathExpr(_) | ast::Expr::MacroCall(_)),
+        "unexpected expression type for variable usage: {:?}",
+        path
+    );
    Some(path)
 }
@@ -820,10 +839,16 @@ fn vars_defined_in_body(body: &FunctionBody, ctx: &AssistContext) -> Vec<Local>
 }
 /// list local variables defined inside `body` that should be returned from extracted function
-fn vars_defined_in_body_and_outlive(ctx: &AssistContext, body: &FunctionBody) -> Vec<Local> {
+fn vars_defined_in_body_and_outlive(
-    let mut vars_defined_in_body = vars_defined_in_body(&body, ctx);
+    ctx: &AssistContext,
-    vars_defined_in_body.retain(|var| var_outlives_body(ctx, body, var));
+    body: &FunctionBody,
+    parent: &SyntaxNode,
+) -> Vec<OutlivedLocal> {
+    let vars_defined_in_body = vars_defined_in_body(&body, ctx);
    vars_defined_in_body
+        .into_iter()
+        .filter_map(|var| var_outlives_body(ctx, body, var, parent))
+        .collect()
 }
 /// checks if the relevant local was defined before(outside of) body
@@ -843,11 +868,23 @@ fn either_syntax(value: &Either<ast::IdentPat, ast::SelfParam>) -> &SyntaxNode {
    }
 }
-/// checks if local variable is used after(outside of) body
+/// returns usage details if local variable is used after(outside of) body
-fn var_outlives_body(ctx: &AssistContext, body: &FunctionBody, var: &Local) -> bool {
+fn var_outlives_body(
-    let usages = LocalUsages::find(ctx, *var);
+    ctx: &AssistContext,
+    body: &FunctionBody,
+    var: Local,
+    parent: &SyntaxNode,
+) -> Option<OutlivedLocal> {
+    let usages = LocalUsages::find(ctx, var);
    let has_usages = usages.iter().any(|reference| body.preceedes_range(reference.range));
-    has_usages
+    if !has_usages {
+        return None;
+    }
+    let has_mut_usages = usages
+        .iter()
+        .filter(|reference| body.preceedes_range(reference.range))
+        .any(|reference| reference_is_exclusive(reference, parent, ctx));
+    Some(OutlivedLocal { local: var, mut_usage_outside_body: has_mut_usages })
 }
 fn body_return_ty(ctx: &AssistContext, body: &FunctionBody) -> Option<RetType> {
@@ -927,16 +964,25 @@ fn format_replacement(ctx: &AssistContext, fun: &Function, indent: IndentLevel)
    let mut buf = String::new();
    match fun.vars_defined_in_body_and_outlive.as_slice() {
        [] => {}
-        [var] => format_to!(buf, "let {} = ", var.name(ctx.db()).unwrap()),
+        [var] => {
+            format_to!(buf, "let {}{} = ", mut_modifier(var), var.local.name(ctx.db()).unwrap())
+        }
        [v0, vs @ ..] => {
            buf.push_str("let (");
-            format_to!(buf, "{}", v0.name(ctx.db()).unwrap());
+            format_to!(buf, "{}{}", mut_modifier(v0), v0.local.name(ctx.db()).unwrap());
            for var in vs {
-                format_to!(buf, ", {}", var.name(ctx.db()).unwrap());
+                format_to!(buf, ", {}{}", mut_modifier(var), var.local.name(ctx.db()).unwrap());
            }
            buf.push_str(") = ");
        }
    }
+    fn mut_modifier(var: &OutlivedLocal) -> &'static str {
+        if var.mut_usage_outside_body {
+            "mut "
+        } else {
+            ""
+        }
+    }
    format_to!(buf, "{}", expr);
    if fun.ret_ty.is_unit()
        && (!fun.vars_defined_in_body_and_outlive.is_empty() || !expr.is_block_like())
@@ -1199,10 +1245,10 @@ fn make_body(
                match fun.vars_defined_in_body_and_outlive.as_slice() {
                    [] => {}
                    [var] => {
-                        tail_expr = Some(path_expr_from_local(ctx, *var));
+                        tail_expr = Some(path_expr_from_local(ctx, var.local));
                    }
                    vars => {
-                        let exprs = vars.iter().map(|var| path_expr_from_local(ctx, *var));
+                        let exprs = vars.iter().map(|var| path_expr_from_local(ctx, var.local));
                        let expr = make::expr_tuple(exprs);
                        tail_expr = Some(expr);
                    }
@@ -2111,6 +2157,30 @@ fn $0fun_name(n: i32) -> i32 {
    }
    #[test]
+    fn variable_defined_inside_and_used_after_mutably_no_ret() {
+        check_assist(
+            extract_function,
+            r"
+fn foo() {
+    let n = 1;
+    $0let mut k = n * n;$0
+    k += 1;
+}",
+            r"
+fn foo() {
+    let n = 1;
+    let mut k = fun_name(n);
+    k += 1;
+}
+fn $0fun_name(n: i32) -> i32 {
+    let mut k = n * n;
+    k
+}",
+        );
+    }
+    #[test]
    fn two_variables_defined_inside_and_used_after_no_ret() {
        check_assist(
            extract_function,
@@ -2137,6 +2207,38 @@ fn $0fun_name(n: i32) -> (i32, i32) {
    }
    #[test]
+    fn multi_variables_defined_inside_and_used_after_mutably_no_ret() {
+        check_assist(
+            extract_function,
+            r"
+fn foo() {
+    let n = 1;
+    $0let mut k = n * n;
+    let mut m = k + 2;
+    let mut o = m + 3;
+    o += 1;$0
+    k += o;
+    m = 1;
+}",
+            r"
+fn foo() {
+    let n = 1;
+    let (mut k, mut m, o) = fun_name(n);
+    k += o;
+    m = 1;
+}
+fn $0fun_name(n: i32) -> (i32, i32, i32) {
+    let mut k = n * n;
+    let mut m = k + 2;
+    let mut o = m + 3;
+    o += 1;
+    (k, m, o)
+}",
+        );
+    }
+    #[test]
    fn nontrivial_patterns_define_variables() {
        check_assist(
            extract_function,
@@ -3372,4 +3474,36 @@ fn foo() -> Result<(), i64> {
 }"##,
        );
    }
+    #[test]
+    fn param_usage_in_macro() {
+        check_assist(
+            extract_function,
+            r"
+macro_rules! m {
+    ($val:expr) => { $val };
+}
+fn foo() {
+    let n = 1;
+    $0let k = n * m!(n);$0
+    let m = k + 1;
+}",
+            r"
+macro_rules! m {
+    ($val:expr) => { $val };
+}
+fn foo() {
+    let n = 1;
+    let k = fun_name(n);
+    let m = k + 1;
+}
+fn $0fun_name(n: i32) -> i32 {
+    let k = n * m!(n);
+    k
+}",
+        );
+    }
 }
diff --git a/crates/ide_assists/src/handlers/flip_comma.rs b/crates/ide_assists/src/handlers/flip_comma.rs
index 7f5e75d34..99be5e090 100644
--- a/crates/ide_assists/src/handlers/flip_comma.rs
+++ b/crates/ide_assists/src/handlers/flip_comma.rs
@@ -66,26 +66,12 @@ mod tests {
    }
    #[test]
-    #[should_panic]
    fn flip_comma_before_punct() {
        // See https://github.com/rust-analyzer/rust-analyzer/issues/1619
        // "Flip comma" assist shouldn't be applicable to the last comma in enum or struct
        // declaration body.
-        check_assist_target(
+        check_assist_not_applicable(flip_comma, "pub enum Test { A,$0 }");
-            flip_comma,
+        check_assist_not_applicable(flip_comma, "pub struct Test { foo: usize,$0 }");
-            "pub enum Test { \
-             A,$0 \
-             }",
-            ",",
-        );
-        check_assist_target(
-            flip_comma,
-            "pub struct Test { \
-             foo: usize,$0 \
-             }",
-            ",",
-        );
    }
    #[test]
diff --git a/crates/ide_assists/src/handlers/remove_dbg.rs b/crates/ide_assists/src/handlers/remove_dbg.rs
index 2862cfa9c..c8226550f 100644
--- a/crates/ide_assists/src/handlers/remove_dbg.rs
+++ b/crates/ide_assists/src/handlers/remove_dbg.rs
@@ -30,7 +30,7 @@ pub(crate) fn remove_dbg(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
        if new_contents.is_empty() {
            match_ast! {
                match it {
-                    ast::BlockExpr(it) => {
+                    ast::BlockExpr(_it) => {
                        macro_call.syntax()
                            .prev_sibling_or_token()
                            .and_then(whitespace_start)
diff --git a/crates/ide_assists/src/lib.rs b/crates/ide_assists/src/lib.rs
index 3e2c82dac..3694f468f 100644
--- a/crates/ide_assists/src/lib.rs
+++ b/crates/ide_assists/src/lib.rs
@@ -28,7 +28,9 @@ pub use assist_config::AssistConfig;
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum AssistKind {
+    // FIXME: does the None variant make sense? Probably not.
    None,
    QuickFix,
    Generate,
    Refactor,
diff --git a/crates/ide_completion/src/item.rs b/crates/ide_completion/src/item.rs
index cc4ac9ea2..16991b688 100644
--- a/crates/ide_completion/src/item.rs
+++ b/crates/ide_completion/src/item.rs
@@ -29,7 +29,7 @@ pub struct CompletionItem {
    /// Range of identifier that is being completed.
    ///
    /// It should be used primarily for UI, but we also use this to convert
-    /// genetic TextEdit into LSP's completion edit (see conv.rs).
+    /// generic TextEdit into LSP's completion edit (see conv.rs).
    ///
    /// `source_range` must contain the completion offset. `insert_text` should
    /// start with what `source_range` points to, or VSCode will filter out the
diff --git a/crates/project_model/src/build_data.rs b/crates/project_model/src/build_data.rs
index 0d4d39fef..ab5cc8c49 100644
--- a/crates/project_model/src/build_data.rs
+++ b/crates/project_model/src/build_data.rs
@@ -58,12 +58,17 @@ impl PartialEq for BuildDataConfig {
 impl Eq for BuildDataConfig {}
-#[derive(Debug, Default)]
+#[derive(Debug)]
 pub struct BuildDataCollector {
+    wrap_rustc: bool,
    configs: FxHashMap<AbsPathBuf, BuildDataConfig>,
 }
 impl BuildDataCollector {
+    pub fn new(wrap_rustc: bool) -> Self {
+        Self { wrap_rustc, configs: FxHashMap::default() }
+    }
    pub(crate) fn add_config(&mut self, workspace_root: &AbsPath, config: BuildDataConfig) {
        self.configs.insert(workspace_root.to_path_buf(), config);
    }
@@ -71,15 +76,14 @@ impl BuildDataCollector {
    pub fn collect(&mut self, progress: &dyn Fn(String)) -> Result<BuildDataResult> {
        let mut res = BuildDataResult::default();
        for (path, config) in self.configs.iter() {
-            res.per_workspace.insert(
+            let workspace_build_data = WorkspaceBuildData::collect(
-                path.clone(),
+                &config.cargo_toml,
-                collect_from_workspace(
+                &config.cargo_features,
-                    &config.cargo_toml,
+                &config.packages,
-                    &config.cargo_features,
+                self.wrap_rustc,
-                    &config.packages,
+                progress,
-                    progress,
+            )?;
-                )?,
+            res.per_workspace.insert(path.clone(), workspace_build_data);
-            );
        }
        Ok(res)
    }
@@ -120,119 +124,137 @@ impl BuildDataConfig {
    }
 }
-fn collect_from_workspace(
+impl WorkspaceBuildData {
-    cargo_toml: &AbsPath,
+    fn collect(
-    cargo_features: &CargoConfig,
+        cargo_toml: &AbsPath,
-    packages: &Vec<cargo_metadata::Package>,
+        cargo_features: &CargoConfig,
-    progress: &dyn Fn(String),
+        packages: &Vec<cargo_metadata::Package>,
-) -> Result<WorkspaceBuildData> {
+        wrap_rustc: bool,
-    let mut cmd = Command::new(toolchain::cargo());
+        progress: &dyn Fn(String),
-    cmd.args(&["check", "--workspace", "--message-format=json", "--manifest-path"])
+    ) -> Result<WorkspaceBuildData> {
-        .arg(cargo_toml.as_ref());
+        let mut cmd = Command::new(toolchain::cargo());
-    // --all-targets includes tests, benches and examples in addition to the
+        if wrap_rustc {
-    // default lib and bins. This is an independent concept from the --targets
+            // Setup RUSTC_WRAPPER to point to `rust-analyzer` binary itself. We use
-    // flag below.
+            // that to compile only proc macros and build scripts during the initial
-    cmd.arg("--all-targets");
+            // `cargo check`.
+            let myself = std::env::current_exe()?;
-    if let Some(target) = &cargo_features.target {
+            cmd.env("RUSTC_WRAPPER", myself);
-        cmd.args(&["--target", target]);
+            cmd.env("RA_RUSTC_WRAPPER", "1");
-    }
+        }
+        cmd.args(&["check", "--workspace", "--message-format=json", "--manifest-path"])
+            .arg(cargo_toml.as_ref());
-    if cargo_features.all_features {
+        // --all-targets includes tests, benches and examples in addition to the
-        cmd.arg("--all-features");
+        // default lib and bins. This is an independent concept from the --targets
-    } else {
+        // flag below.
-        if cargo_features.no_default_features {
+        cmd.arg("--all-targets");
-            // FIXME: `NoDefaultFeatures` is mutual exclusive with `SomeFeatures`
-            // https://github.com/oli-obk/cargo_metadata/issues/79
+        if let Some(target) = &cargo_features.target {
-            cmd.arg("--no-default-features");
+            cmd.args(&["--target", target]);
        }
-        if !cargo_features.features.is_empty() {
-            cmd.arg("--features");
+        if cargo_features.all_features {
-            cmd.arg(cargo_features.features.join(" "));
+            cmd.arg("--all-features");
+        } else {
+            if cargo_features.no_default_features {
+                // FIXME: `NoDefaultFeatures` is mutual exclusive with `SomeFeatures`
+                // https://github.com/oli-obk/cargo_metadata/issues/79
+                cmd.arg("--no-default-features");
+            }
+            if !cargo_features.features.is_empty() {
+                cmd.arg("--features");
+                cmd.arg(cargo_features.features.join(" "));
+            }
        }
-    }
-    cmd.stdout(Stdio::piped()).stderr(Stdio::piped()).stdin(Stdio::null());
+        cmd.stdout(Stdio::piped()).stderr(Stdio::piped()).stdin(Stdio::null());
-    let mut child = cmd.spawn().map(JodChild)?;
+        let mut child = cmd.spawn().map(JodChild)?;
-    let child_stdout = child.stdout.take().unwrap();
+        let child_stdout = child.stdout.take().unwrap();
-    let stdout = BufReader::new(child_stdout);
+        let stdout = BufReader::new(child_stdout);
-    let mut res = WorkspaceBuildData::default();
+        let mut res = WorkspaceBuildData::default();
-    for message in cargo_metadata::Message::parse_stream(stdout).flatten() {
+        for message in cargo_metadata::Message::parse_stream(stdout).flatten() {
-        match message {
+            match message {
-            Message::BuildScriptExecuted(BuildScript {
+                Message::BuildScriptExecuted(BuildScript {
-                package_id, out_dir, cfgs, env, ..
+                    package_id,
-            }) => {
+                    out_dir,
-                let cfgs = {
+                    cfgs,
-                    let mut acc = Vec::new();
+                    env,
-                    for cfg in cfgs {
+                    ..
-                        match cfg.parse::<CfgFlag>() {
+                }) => {
-                            Ok(it) => acc.push(it),
+                    let cfgs = {
-                            Err(err) => {
+                        let mut acc = Vec::new();
-                                anyhow::bail!("invalid cfg from cargo-metadata: {}", err)
+                        for cfg in cfgs {
-                            }
+                            match cfg.parse::<CfgFlag>() {
-                        };
+                                Ok(it) => acc.push(it),
+                                Err(err) => {
+                                    anyhow::bail!("invalid cfg from cargo-metadata: {}", err)
+                                }
+                            };
+                        }
+                        acc
+                    };
+                    let package_build_data =
+                        res.per_package.entry(package_id.repr.clone()).or_default();
+                    // cargo_metadata crate returns default (empty) path for
+                    // older cargos, which is not absolute, so work around that.
+                    if !out_dir.as_str().is_empty() {
+                        let out_dir = AbsPathBuf::assert(PathBuf::from(out_dir.into_os_string()));
+                        package_build_data.out_dir = Some(out_dir);
+                        package_build_data.cfgs = cfgs;
                    }
-                    acc
-                };
-                let package_build_data =
-                    res.per_package.entry(package_id.repr.clone()).or_default();
-                // cargo_metadata crate returns default (empty) path for
-                // older cargos, which is not absolute, so work around that.
-                if !out_dir.as_str().is_empty() {
-                    let out_dir = AbsPathBuf::assert(PathBuf::from(out_dir.into_os_string()));
-                    package_build_data.out_dir = Some(out_dir);
-                    package_build_data.cfgs = cfgs;
-                }
-                package_build_data.envs = env;
+                    package_build_data.envs = env;
-            }
+                }
-            Message::CompilerArtifact(message) => {
+                Message::CompilerArtifact(message) => {
-                progress(format!("metadata {}", message.target.name));
+                    progress(format!("metadata {}", message.target.name));
-                if message.target.kind.contains(&"proc-macro".to_string()) {
+                    if message.target.kind.contains(&"proc-macro".to_string()) {
-                    let package_id = message.package_id;
+                        let package_id = message.package_id;
-                    // Skip rmeta file
+                        // Skip rmeta file
-                    if let Some(filename) = message.filenames.iter().find(|name| is_dylib(name)) {
+                        if let Some(filename) = message.filenames.iter().find(|name| is_dylib(name))
-                        let filename = AbsPathBuf::assert(PathBuf::from(&filename));
+                        {
-                        let package_build_data =
+                            let filename = AbsPathBuf::assert(PathBuf::from(&filename));
-                            res.per_package.entry(package_id.repr.clone()).or_default();
+                            let package_build_data =
-                        package_build_data.proc_macro_dylib_path = Some(filename);
+                                res.per_package.entry(package_id.repr.clone()).or_default();
+                            package_build_data.proc_macro_dylib_path = Some(filename);
+                        }
                    }
                }
+                Message::CompilerMessage(message) => {
+                    progress(message.target.name.clone());
+                }
+                Message::BuildFinished(_) => {}
+                Message::TextLine(_) => {}
+                _ => {}
            }
-            Message::CompilerMessage(message) => {
-                progress(message.target.name.clone());
-            }
-            Message::BuildFinished(_) => {}
-            Message::TextLine(_) => {}
-            _ => {}
        }
-    }
-    for package in packages {
+        for package in packages {
-        let package_build_data = res.per_package.entry(package.id.repr.clone()).or_default();
+            let package_build_data = res.per_package.entry(package.id.repr.clone()).or_default();
-        inject_cargo_env(package, package_build_data);
+            inject_cargo_env(package, package_build_data);
-        if let Some(out_dir) = &package_build_data.out_dir {
+            if let Some(out_dir) = &package_build_data.out_dir {
-            // NOTE: cargo and rustc seem to hide non-UTF-8 strings from env! and option_env!()
+                // NOTE: cargo and rustc seem to hide non-UTF-8 strings from env! and option_env!()
-            if let Some(out_dir) = out_dir.to_str().map(|s| s.to_owned()) {
+                if let Some(out_dir) = out_dir.to_str().map(|s| s.to_owned()) {
-                package_build_data.envs.push(("OUT_DIR".to_string(), out_dir));
+                    package_build_data.envs.push(("OUT_DIR".to_string(), out_dir));
+                }
            }
        }
-    }
-    let output = child.into_inner().wait_with_output()?;
+        let output = child.into_inner().wait_with_output()?;
-    if !output.status.success() {
+        if !output.status.success() {
-        let mut stderr = String::from_utf8(output.stderr).unwrap_or_default();
+            let mut stderr = String::from_utf8(output.stderr).unwrap_or_default();
-        if stderr.is_empty() {
+            if stderr.is_empty() {
-            stderr = "cargo check failed".to_string();
+                stderr = "cargo check failed".to_string();
+            }
+            res.error = Some(stderr)
        }
-        res.error = Some(stderr)
-    }
-    Ok(res)
+        Ok(res)
+    }
 }
 // FIXME: File a better way to know if it is a dylib
diff --git a/crates/rust-analyzer/Cargo.toml b/crates/rust-analyzer/Cargo.toml
index 3130785cc..0571a912c 100644
--- a/crates/rust-analyzer/Cargo.toml
+++ b/crates/rust-analyzer/Cargo.toml
@@ -22,7 +22,7 @@ env_logger = { version = "0.8.1", default-features = false }
 itertools = "0.10.0"
 jod-thread = "0.1.0"
 log = "0.4.8"
-lsp-types = { version = "0.88.0", features = ["proposed"] }
+lsp-types = { version = "0.89.0", features = ["proposed"] }
 parking_lot = "0.11.0"
 xflags = "0.2.1"
 oorandom = "11.1.2"
diff --git a/crates/rust-analyzer/build.rs b/crates/rust-analyzer/build.rs
index 999dc5928..13b903891 100644
--- a/crates/rust-analyzer/build.rs
+++ b/crates/rust-analyzer/build.rs
@@ -39,7 +39,8 @@ fn set_rerun() {
 }
 fn rev() -> Option<String> {
-    let output = Command::new("git").args(&["describe", "--tags"]).output().ok()?;
+    let output =
+        Command::new("git").args(&["describe", "--tags", "--exclude", "nightly"]).output().ok()?;
    let stdout = String::from_utf8(output.stdout).ok()?;
    Some(stdout)
 }
diff --git a/crates/rust-analyzer/src/benchmarks.rs b/crates/rust-analyzer/src/benchmarks.rs
index bf569b40b..bdd94b1c4 100644
--- a/crates/rust-analyzer/src/benchmarks.rs
+++ b/crates/rust-analyzer/src/benchmarks.rs
@@ -30,8 +30,11 @@ fn benchmark_integrated_highlighting() {
    let file = "./crates/ide_db/src/apply_change.rs";
    let cargo_config = Default::default();
-    let load_cargo_config =
+    let load_cargo_config = LoadCargoConfig {
-        LoadCargoConfig { load_out_dirs_from_check: true, with_proc_macro: false };
+        load_out_dirs_from_check: true,
+        wrap_rustc: false,
+        with_proc_macro: false,
+    };
    let (mut host, vfs, _proc_macro) = {
        let _it = stdx::timeit("workspace loading");
diff --git a/crates/rust-analyzer/src/bin/main.rs b/crates/rust-analyzer/src/bin/main.rs
index 873e82c7b..f0abb5b15 100644
--- a/crates/rust-analyzer/src/bin/main.rs
+++ b/crates/rust-analyzer/src/bin/main.rs
@@ -3,6 +3,7 @@
 //! Based on cli flags, either spawns an LSP server, or runs a batch analysis
 mod flags;
 mod logger;
+mod rustc_wrapper;
 use std::{convert::TryFrom, env, fs, path::Path, process};
@@ -26,6 +27,20 @@ static ALLOC: mimalloc::MiMalloc = mimalloc::MiMalloc;
 static ALLOC: jemallocator::Jemalloc = jemallocator::Jemalloc;
 fn main() {
+    if std::env::var("RA_RUSTC_WRAPPER").is_ok() {
+        let mut args = std::env::args_os();
+        let _me = args.next().unwrap();
+        let rustc = args.next().unwrap();
+        let code = match rustc_wrapper::run_rustc_skipping_cargo_checking(rustc, args.collect()) {
+            Ok(rustc_wrapper::ExitCode(code)) => code.unwrap_or(102),
+            Err(err) => {
+                eprintln!("{}", err);
+                101
+            }
+        };
+        process::exit(code);
+    }
    if let Err(err) = try_main() {
        log::error!("Unexpected error: {}", err);
        eprintln!("{}", err);
diff --git a/crates/rust-analyzer/src/bin/rustc_wrapper.rs b/crates/rust-analyzer/src/bin/rustc_wrapper.rs
new file mode 100644
index 000000000..2f6d4706d
--- /dev/null
+++ b/crates/rust-analyzer/src/bin/rustc_wrapper.rs
@@ -0,0 +1,46 @@
+//! We setup RUSTC_WRAPPER to point to `rust-analyzer` binary itself during the
+//! initial `cargo check`. That way, we avoid checking the actual project, and
+//! only build proc macros and build.rs.
+//!
+//! Code taken from IntelliJ :0)
+//!     https://github.com/intellij-rust/intellij-rust/blob/master/native-helper/src/main.rs
+use std::{
+    ffi::OsString,
+    io,
+    process::{Command, Stdio},
+};
+/// ExitCode/ExitStatus are impossible to create :(.
+pub(crate) struct ExitCode(pub(crate) Option<i32>);
+pub(crate) fn run_rustc_skipping_cargo_checking(
+    rustc_executable: OsString,
+    args: Vec<OsString>,
+) -> io::Result<ExitCode> {
+    let is_cargo_check = args.iter().any(|arg| {
+        let arg = arg.to_string_lossy();
+        // `cargo check` invokes `rustc` with `--emit=metadata` argument.
+        //
+        // https://doc.rust-lang.org/rustc/command-line-arguments.html#--emit-specifies-the-types-of-output-files-to-generate
+        // link —     Generates the crates specified by --crate-type. The default
+        //            output filenames depend on the crate type and platform. This
+        //            is the default if --emit is not specified.
+        // metadata — Generates a file containing metadata about the crate.
+        //            The default output filename is CRATE_NAME.rmeta.
+        arg.starts_with("--emit=") && arg.contains("metadata") && !arg.contains("link")
+    });
+    if is_cargo_check {
+        return Ok(ExitCode(Some(0)));
+    }
+    run_rustc(rustc_executable, args)
+}
+fn run_rustc(rustc_executable: OsString, args: Vec<OsString>) -> io::Result<ExitCode> {
+    let mut child = Command::new(rustc_executable)
+        .args(args)
+        .stdin(Stdio::inherit())
+        .stdout(Stdio::inherit())
+        .stderr(Stdio::inherit())
+        .spawn()?;
+    Ok(ExitCode(child.wait()?.code()))
+}
diff --git a/crates/rust-analyzer/src/cli/analysis_stats.rs b/crates/rust-analyzer/src/cli/analysis_stats.rs
index fe9f273b0..3f3134562 100644
--- a/crates/rust-analyzer/src/cli/analysis_stats.rs
+++ b/crates/rust-analyzer/src/cli/analysis_stats.rs
@@ -68,6 +68,7 @@ impl AnalysisStatsCmd {
        cargo_config.no_sysroot = self.no_sysroot;
        let load_cargo_config = LoadCargoConfig {
            load_out_dirs_from_check: self.load_output_dirs,
+            wrap_rustc: false,
            with_proc_macro: self.with_proc_macro,
        };
        let (host, vfs, _proc_macro) =
diff --git a/crates/rust-analyzer/src/cli/diagnostics.rs b/crates/rust-analyzer/src/cli/diagnostics.rs
index 8b985716b..74f784338 100644
--- a/crates/rust-analyzer/src/cli/diagnostics.rs
+++ b/crates/rust-analyzer/src/cli/diagnostics.rs
@@ -34,7 +34,8 @@ pub fn diagnostics(
    with_proc_macro: bool,
 ) -> Result<()> {
    let cargo_config = Default::default();
-    let load_cargo_config = LoadCargoConfig { load_out_dirs_from_check, with_proc_macro };
+    let load_cargo_config =
+        LoadCargoConfig { load_out_dirs_from_check, with_proc_macro, wrap_rustc: false };
    let (host, _vfs, _proc_macro) =
        load_workspace_at(path, &cargo_config, &load_cargo_config, &|_| {})?;
    let db = host.raw_database();
@@ -56,7 +57,8 @@ pub fn diagnostics(
            let crate_name =
                module.krate().display_name(db).as_deref().unwrap_or("unknown").to_string();
            println!("processing crate: {}, module: {}", crate_name, _vfs.file_path(file_id));
-            for diagnostic in analysis.diagnostics(&DiagnosticsConfig::default(), file_id).unwrap()
+            for diagnostic in
+                analysis.diagnostics(&DiagnosticsConfig::default(), false, file_id).unwrap()
            {
                if matches!(diagnostic.severity, Severity::Error) {
                    found_error = true;
diff --git a/crates/rust-analyzer/src/cli/load_cargo.rs b/crates/rust-analyzer/src/cli/load_cargo.rs
index 310c36904..75bad1112 100644
--- a/crates/rust-analyzer/src/cli/load_cargo.rs
+++ b/crates/rust-analyzer/src/cli/load_cargo.rs
@@ -15,6 +15,7 @@ use crate::reload::{ProjectFolders, SourceRootConfig};
 pub struct LoadCargoConfig {
    pub load_out_dirs_from_check: bool,
+    pub wrap_rustc: bool,
    pub with_proc_macro: bool,
 }
@@ -52,7 +53,7 @@ pub fn load_workspace(
    };
    let build_data = if config.load_out_dirs_from_check {
-        let mut collector = BuildDataCollector::default();
+        let mut collector = BuildDataCollector::new(config.wrap_rustc);
        ws.collect_build_data_configs(&mut collector);
        Some(collector.collect(progress)?)
    } else {
@@ -136,8 +137,11 @@ mod tests {
    fn test_loading_rust_analyzer() -> Result<()> {
        let path = Path::new(env!("CARGO_MANIFEST_DIR")).parent().unwrap().parent().unwrap();
        let cargo_config = Default::default();
-        let load_cargo_config =
+        let load_cargo_config = LoadCargoConfig {
-            LoadCargoConfig { load_out_dirs_from_check: false, with_proc_macro: false };
+            load_out_dirs_from_check: false,
+            wrap_rustc: false,
+            with_proc_macro: false,
+        };
        let (host, _vfs, _proc_macro) =
            load_workspace_at(path, &cargo_config, &load_cargo_config, &|_| {})?;
diff --git a/crates/rust-analyzer/src/cli/ssr.rs b/crates/rust-analyzer/src/cli/ssr.rs
index 79f426fff..1fd9b5a9b 100644
--- a/crates/rust-analyzer/src/cli/ssr.rs
+++ b/crates/rust-analyzer/src/cli/ssr.rs
@@ -9,8 +9,11 @@ use ide_ssr::{MatchFinder, SsrPattern, SsrRule};
 pub fn apply_ssr_rules(rules: Vec<SsrRule>) -> Result<()> {
    use ide_db::base_db::SourceDatabaseExt;
    let cargo_config = Default::default();
-    let load_cargo_config =
+    let load_cargo_config = LoadCargoConfig {
-        LoadCargoConfig { load_out_dirs_from_check: true, with_proc_macro: true };
+        load_out_dirs_from_check: true,
+        wrap_rustc: false,
+        with_proc_macro: true,
+    };
    let (host, vfs, _proc_macro) =
        load_workspace_at(&std::env::current_dir()?, &cargo_config, &load_cargo_config, &|_| {})?;
    let db = host.raw_database();
@@ -37,7 +40,7 @@ pub fn search_for_patterns(patterns: Vec<SsrPattern>, debug_snippet: Option<Stri
    use ide_db::symbol_index::SymbolsDatabase;
    let cargo_config = Default::default();
    let load_cargo_config =
-        LoadCargoConfig { load_out_dirs_from_check: true, with_proc_macro: true };
+        LoadCargoConfig { load_out_dirs_from_check: true, wrap_rustc: true, with_proc_macro: true };
    let (host, _vfs, _proc_macro) =
        load_workspace_at(&std::env::current_dir()?, &cargo_config, &load_cargo_config, &|_| {})?;
    let db = host.raw_database();
diff --git a/crates/rust-analyzer/src/config.rs b/crates/rust-analyzer/src/config.rs
index e012b4452..1edaa394a 100644
--- a/crates/rust-analyzer/src/config.rs
+++ b/crates/rust-analyzer/src/config.rs
@@ -48,6 +48,9 @@ config_data! {
        /// Run build scripts (`build.rs`) for more precise code analysis.
        cargo_runBuildScripts |
        cargo_loadOutDirsFromCheck: bool = "true",
+        /// Use `RUSTC_WRAPPER=rust-analyzer` when running build scripts to
+        /// avoid compiling unnecessary things.
+        cargo_useRustcWrapperForBuildScripts: bool = "true",
        /// Do not activate the `default` feature.
        cargo_noDefaultFeatures: bool    = "false",
        /// Compilation target (target triple).
@@ -493,6 +496,9 @@ impl Config {
    pub fn run_build_scripts(&self) -> bool {
        self.data.cargo_runBuildScripts || self.data.procMacro_enable
    }
+    pub fn wrap_rustc(&self) -> bool {
+        self.data.cargo_useRustcWrapperForBuildScripts
+    }
    pub fn cargo(&self) -> CargoConfig {
        let rustc_source = self.data.rustcSource.as_ref().map(|rustc_src| {
            if rustc_src == "discover" {
@@ -656,6 +662,19 @@ impl Config {
    pub fn code_lens_refresh(&self) -> bool {
        try_or!(self.caps.workspace.as_ref()?.code_lens.as_ref()?.refresh_support?, false)
    }
+    pub fn insert_replace_support(&self) -> bool {
+        try_or!(
+            self.caps
+                .text_document
+                .as_ref()?
+                .completion
+                .as_ref()?
+                .completion_item
+                .as_ref()?
+                .insert_replace_support?,
+            false
+        )
+    }
 }
 #[derive(Deserialize, Debug, Clone)]
diff --git a/crates/rust-analyzer/src/from_proto.rs b/crates/rust-analyzer/src/from_proto.rs
index 5b02b2598..712d5a9c2 100644
--- a/crates/rust-analyzer/src/from_proto.rs
+++ b/crates/rust-analyzer/src/from_proto.rs
@@ -42,27 +42,27 @@ pub(crate) fn text_range(line_index: &LineIndex, range: lsp_types::Range) -> Tex
    TextRange::new(start, end)
 }
-pub(crate) fn file_id(world: &GlobalStateSnapshot, url: &lsp_types::Url) -> Result<FileId> {
+pub(crate) fn file_id(snap: &GlobalStateSnapshot, url: &lsp_types::Url) -> Result<FileId> {
-    world.url_to_file_id(url)
+    snap.url_to_file_id(url)
 }
 pub(crate) fn file_position(
-    world: &GlobalStateSnapshot,
+    snap: &GlobalStateSnapshot,
    tdpp: lsp_types::TextDocumentPositionParams,
 ) -> Result<FilePosition> {
-    let file_id = file_id(world, &tdpp.text_document.uri)?;
+    let file_id = file_id(snap, &tdpp.text_document.uri)?;
-    let line_index = world.file_line_index(file_id)?;
+    let line_index = snap.file_line_index(file_id)?;
    let offset = offset(&line_index, tdpp.position);
    Ok(FilePosition { file_id, offset })
 }
 pub(crate) fn file_range(
-    world: &GlobalStateSnapshot,
+    snap: &GlobalStateSnapshot,
    text_document_identifier: lsp_types::TextDocumentIdentifier,
    range: lsp_types::Range,
 ) -> Result<FileRange> {
-    let file_id = file_id(world, &text_document_identifier.uri)?;
+    let file_id = file_id(snap, &text_document_identifier.uri)?;
-    let line_index = world.file_line_index(file_id)?;
+    let line_index = snap.file_line_index(file_id)?;
    let range = text_range(&line_index, range);
    Ok(FileRange { file_id, range })
 }
@@ -82,7 +82,7 @@ pub(crate) fn assist_kind(kind: lsp_types::CodeActionKind) -> Option<AssistKind>
 }
 pub(crate) fn annotation(
-    world: &GlobalStateSnapshot,
+    snap: &GlobalStateSnapshot,
    code_lens: lsp_types::CodeLens,
 ) -> Result<Annotation> {
    let data = code_lens.data.unwrap();
@@ -91,25 +91,25 @@ pub(crate) fn annotation(
    match resolve {
        lsp_ext::CodeLensResolveData::Impls(params) => {
            let file_id =
-                world.url_to_file_id(&params.text_document_position_params.text_document.uri)?;
+                snap.url_to_file_id(&params.text_document_position_params.text_document.uri)?;
-            let line_index = world.file_line_index(file_id)?;
+            let line_index = snap.file_line_index(file_id)?;
            Ok(Annotation {
                range: text_range(&line_index, code_lens.range),
                kind: AnnotationKind::HasImpls {
-                    position: file_position(world, params.text_document_position_params)?,
+                    position: file_position(snap, params.text_document_position_params)?,
                    data: None,
                },
            })
        }
        lsp_ext::CodeLensResolveData::References(params) => {
-            let file_id = world.url_to_file_id(&params.text_document.uri)?;
+            let file_id = snap.url_to_file_id(&params.text_document.uri)?;
-            let line_index = world.file_line_index(file_id)?;
+            let line_index = snap.file_line_index(file_id)?;
            Ok(Annotation {
                range: text_range(&line_index, code_lens.range),
                kind: AnnotationKind::HasReferences {
-                    position: file_position(world, params)?,
+                    position: file_position(snap, params)?,
                    data: None,
                },
            })
diff --git a/crates/rust-analyzer/src/handlers.rs b/crates/rust-analyzer/src/handlers.rs
index 31d8c487b..4f0c9d23c 100644
--- a/crates/rust-analyzer/src/handlers.rs
+++ b/crates/rust-analyzer/src/handlers.rs
@@ -17,7 +17,7 @@ use lsp_server::ErrorCode;
 use lsp_types::{
    CallHierarchyIncomingCall, CallHierarchyIncomingCallsParams, CallHierarchyItem,
    CallHierarchyOutgoingCall, CallHierarchyOutgoingCallsParams, CallHierarchyPrepareParams,
-    CodeActionKind, CodeLens, CompletionItem, Diagnostic, DiagnosticTag, DocumentFormattingParams,
+    CodeLens, CompletionItem, Diagnostic, DiagnosticTag, DocumentFormattingParams,
    DocumentHighlight, FoldingRange, FoldingRangeParams, HoverContents, Location, NumberOrString,
    Position, PrepareRenameResponse, Range, RenameParams, SemanticTokensDeltaParams,
    SemanticTokensFullDeltaResult, SemanticTokensParams, SemanticTokensRangeParams,
@@ -36,7 +36,7 @@ use crate::{
    diff::diff,
    from_proto,
    global_state::{GlobalState, GlobalStateSnapshot},
-    line_index::{LineEndings, LineIndex},
+    line_index::LineEndings,
    lsp_ext::{self, InlayHint, InlayHintsParams},
    lsp_utils::all_edits_are_disjoint,
    to_proto, LspError, Result,
@@ -664,10 +664,13 @@ pub(crate) fn handle_completion(
    };
    let line_index = snap.file_line_index(position.file_id)?;
+    let insert_replace_support =
+        snap.config.insert_replace_support().then(|| text_document_position.position);
    let items: Vec<CompletionItem> = items
        .into_iter()
        .flat_map(|item| {
-            let mut new_completion_items = to_proto::completion_item(&line_index, item.clone());
+            let mut new_completion_items =
+                to_proto::completion_item(insert_replace_support, &line_index, item.clone());
            if completion_config.enable_imports_on_the_fly {
                for new_item in &mut new_completion_items {
@@ -979,84 +982,52 @@ pub(crate) fn handle_code_action(
    params: lsp_types::CodeActionParams,
 ) -> Result<Option<Vec<lsp_ext::CodeAction>>> {
    let _p = profile::span("handle_code_action");
-    // We intentionally don't support command-based actions, as those either
-    // requires custom client-code anyway, or requires server-initiated edits.
-    // Server initiated edits break causality, so we avoid those as well.
    if !snap.config.code_action_literals() {
+        // We intentionally don't support command-based actions, as those either
+        // require either custom client-code or server-initiated edits. Server
+        // initiated edits break causality, so we avoid those.
        return Ok(None);
    }
-    let file_id = from_proto::file_id(&snap, &params.text_document.uri)?;
+    let line_index =
-    let line_index = snap.file_line_index(file_id)?;
+        snap.file_line_index(from_proto::file_id(&snap, &params.text_document.uri)?)?;
-    let range = from_proto::text_range(&line_index, params.range);
+    let frange = from_proto::file_range(&snap, params.text_document.clone(), params.range)?;
-    let frange = FileRange { file_id, range };
    let mut assists_config = snap.config.assist();
    assists_config.allowed = params
-        .clone()
        .context
        .only
+        .clone()
        .map(|it| it.into_iter().filter_map(from_proto::assist_kind).collect());
    let mut res: Vec<lsp_ext::CodeAction> = Vec::new();
-    let include_quick_fixes = match &params.context.only {
+    let code_action_resolve_cap = snap.config.code_action_resolve();
-        Some(v) => v.iter().any(|it| {
+    let assists = snap.analysis.assists_with_fixes(
-            it == &lsp_types::CodeActionKind::EMPTY || it == &lsp_types::CodeActionKind::QUICKFIX
+        &assists_config,
-        }),
+        &snap.config.diagnostics(),
-        None => true,
+        !code_action_resolve_cap,
-    };
+        frange,
-    if include_quick_fixes {
+    )?;
-        add_quick_fixes(&snap, frange, &line_index, &mut res)?;
+    for (index, assist) in assists.into_iter().enumerate() {
-    }
+        let resolve_data =
+            if code_action_resolve_cap { Some((index, params.clone())) } else { None };
-    if snap.config.code_action_resolve() {
+        let code_action = to_proto::code_action(&snap, assist, resolve_data)?;
-        for (index, assist) in
+        res.push(code_action)
-            snap.analysis.assists(&assists_config, false, frange)?.into_iter().enumerate()
-        {
-            res.push(to_proto::unresolved_code_action(&snap, params.clone(), assist, index)?);
-        }
-    } else {
-        for assist in snap.analysis.assists(&assists_config, true, frange)?.into_iter() {
-            res.push(to_proto::resolved_code_action(&snap, assist)?);
-        }
-    }
-    Ok(Some(res))
-}
-fn add_quick_fixes(
-    snap: &GlobalStateSnapshot,
-    frange: FileRange,
-    line_index: &LineIndex,
-    acc: &mut Vec<lsp_ext::CodeAction>,
-) -> Result<()> {
-    let diagnostics = snap.analysis.diagnostics(&snap.config.diagnostics(), frange.file_id)?;
-    for fix in diagnostics
-        .into_iter()
-        .filter_map(|d| d.fix)
-        .filter(|fix| fix.fix_trigger_range.intersect(frange.range).is_some())
-    {
-        let edit = to_proto::snippet_workspace_edit(&snap, fix.source_change)?;
-        let action = lsp_ext::CodeAction {
-            title: fix.label.to_string(),
-            group: None,
-            kind: Some(CodeActionKind::QUICKFIX),
-            edit: Some(edit),
-            is_preferred: Some(false),
-            data: None,
-        };
-        acc.push(action);
    }
+    // Fixes from `cargo check`.
    for fix in snap.check_fixes.get(&frange.file_id).into_iter().flatten() {
+        // FIXME: this mapping is awkward and shouldn't exist. Refactor
+        // `snap.check_fixes` to not convert to LSP prematurely.
        let fix_range = from_proto::text_range(&line_index, fix.range);
        if fix_range.intersect(frange.range).is_some() {
-            acc.push(fix.action.clone());
+            res.push(fix.action.clone());
        }
    }
-    Ok(())
+    Ok(Some(res))
 }
 pub(crate) fn handle_code_action_resolve(
@@ -1081,12 +1052,18 @@ pub(crate) fn handle_code_action_resolve(
        .only
        .map(|it| it.into_iter().filter_map(from_proto::assist_kind).collect());
-    let assists = snap.analysis.assists(&assists_config, true, frange)?;
+    let assists = snap.analysis.assists_with_fixes(
+        &assists_config,
+        &snap.config.diagnostics(),
+        true,
+        frange,
+    )?;
    let (id, index) = split_once(&params.id, ':').unwrap();
    let index = index.parse::<usize>().unwrap();
    let assist = &assists[index];
    assert!(assist.id.0 == id);
-    let edit = to_proto::resolved_code_action(&snap, assist.clone())?.edit;
+    let edit = to_proto::code_action(&snap, assist.clone(), None)?.edit;
    code_action.edit = edit;
    Ok(code_action)
 }
@@ -1205,7 +1182,7 @@ pub(crate) fn publish_diagnostics(
    let diagnostics: Vec<Diagnostic> = snap
        .analysis
-        .diagnostics(&snap.config.diagnostics(), file_id)?
+        .diagnostics(&snap.config.diagnostics(), false, file_id)?
        .into_iter()
        .map(|d| Diagnostic {
            range: to_proto::range(&line_index, d.range),
diff --git a/crates/rust-analyzer/src/lsp_utils.rs b/crates/rust-analyzer/src/lsp_utils.rs
index 2ac487632..73c4193e8 100644
--- a/crates/rust-analyzer/src/lsp_utils.rs
+++ b/crates/rust-analyzer/src/lsp_utils.rs
@@ -150,8 +150,16 @@ pub(crate) fn all_edits_are_disjoint(
            edit_ranges.push(edit.range);
        }
        Some(lsp_types::CompletionTextEdit::InsertAndReplace(edit)) => {
-            edit_ranges.push(edit.insert);
+            let replace = edit.replace;
-            edit_ranges.push(edit.replace);
+            let insert = edit.insert;
+            if replace.start != insert.start
+                || insert.start > insert.end
+                || insert.end > replace.end
+            {
+                // insert has to be a prefix of replace but it is not
+                return false;
+            }
+            edit_ranges.push(replace);
        }
        None => {}
    }
@@ -314,18 +322,6 @@ mod tests {
            Some(CompletionTextEdit::InsertAndReplace(InsertReplaceEdit {
                new_text: "new_text".to_string(),
                insert: disjoint_edit.range,
-                replace: joint_edit.range,
-            }));
-        completion_with_joint_edits.additional_text_edits = None;
-        assert!(
-            !all_edits_are_disjoint(&completion_with_joint_edits, &[]),
-            "Completion with disjoint edits fails the validation even with empty extra edits"
-        );
-        completion_with_joint_edits.text_edit =
-            Some(CompletionTextEdit::InsertAndReplace(InsertReplaceEdit {
-                new_text: "new_text".to_string(),
-                insert: disjoint_edit.range,
                replace: disjoint_edit_2.range,
            }));
        completion_with_joint_edits.additional_text_edits = Some(vec![joint_edit]);
diff --git a/crates/rust-analyzer/src/main_loop.rs b/crates/rust-analyzer/src/main_loop.rs
index 47c6c6d77..b3d4c6ec5 100644
--- a/crates/rust-analyzer/src/main_loop.rs
+++ b/crates/rust-analyzer/src/main_loop.rs
@@ -236,7 +236,8 @@ impl GlobalState {
                                    let workspaces_updated = !Arc::ptr_eq(&old, &self.workspaces);
                                    if self.config.run_build_scripts() && workspaces_updated {
-                                        let mut collector = BuildDataCollector::default();
+                                        let mut collector =
+                                            BuildDataCollector::new(self.config.wrap_rustc());
                                        for ws in self.workspaces.iter() {
                                            ws.collect_build_data_configs(&mut collector);
                                        }
diff --git a/crates/rust-analyzer/src/reload.rs b/crates/rust-analyzer/src/reload.rs
index d0cc1b61a..e51532d88 100644
--- a/crates/rust-analyzer/src/reload.rs
+++ b/crates/rust-analyzer/src/reload.rs
@@ -100,10 +100,6 @@ impl GlobalState {
        }
    }
    pub(crate) fn report_new_status_if_needed(&mut self) {
-        if !self.config.server_status_notification() {
-            return;
-        }
        let mut status = lsp_ext::ServerStatusParams {
            health: lsp_ext::Health::Ok,
            quiescent: self.is_quiescent(),
@@ -129,7 +125,14 @@ impl GlobalState {
        if self.last_reported_status.as_ref() != Some(&status) {
            self.last_reported_status = Some(status.clone());
-            self.send_notification::<lsp_ext::ServerStatusNotification>(status);
+            if let (lsp_ext::Health::Error, Some(message)) = (status.health, &status.message) {
+                self.show_message(lsp_types::MessageType::Error, message.clone());
+            }
+            if self.config.server_status_notification() {
+                self.send_notification::<lsp_ext::ServerStatusNotification>(status);
+            }
        }
    }
@@ -225,7 +228,6 @@ impl GlobalState {
        if let Some(error_message) = self.fetch_workspace_error() {
            log::error!("failed to switch workspaces: {}", error_message);
-            self.show_message(lsp_types::MessageType::Error, error_message);
            if !self.workspaces.is_empty() {
                return;
            }
@@ -233,7 +235,6 @@ impl GlobalState {
        if let Some(error_message) = self.build_data_error() {
            log::error!("failed to switch build data: {}", error_message);
-            self.show_message(lsp_types::MessageType::Error, error_message);
        }
        let workspaces = self
diff --git a/crates/rust-analyzer/src/semantic_tokens.rs b/crates/rust-analyzer/src/semantic_tokens.rs
index 2dc8a42f1..adc059817 100644
--- a/crates/rust-analyzer/src/semantic_tokens.rs
+++ b/crates/rust-analyzer/src/semantic_tokens.rs
@@ -39,7 +39,9 @@ macro_rules! define_semantic_token_types {
 define_semantic_token_types![
    (ANGLE, "angle"),
+    (ARITHMETIC, "arithmetic"),
    (ATTRIBUTE, "attribute"),
+    (BITWISE, "bitwise"),
    (BOOLEAN, "boolean"),
    (BRACE, "brace"),
    (BRACKET, "bracket"),
@@ -47,6 +49,7 @@ define_semantic_token_types![
    (CHAR_LITERAL, "characterLiteral"),
    (COLON, "colon"),
    (COMMA, "comma"),
+    (COMPARISION, "comparision"),
    (CONST_PARAMETER, "constParameter"),
    (DOT, "dot"),
    (ESCAPE_SEQUENCE, "escapeSequence"),
@@ -54,6 +57,8 @@ define_semantic_token_types![
    (GENERIC, "generic"),
    (LABEL, "label"),
    (LIFETIME, "lifetime"),
+    (LOGICAL, "logical"),
+    (OPERATOR, "operator"),
    (PARENTHESIS, "parenthesis"),
    (PUNCTUATION, "punctuation"),
    (SELF_KEYWORD, "selfKeyword"),
diff --git a/crates/rust-analyzer/src/to_proto.rs b/crates/rust-analyzer/src/to_proto.rs
index 2ac31d981..8d7cb9b74 100644
--- a/crates/rust-analyzer/src/to_proto.rs
+++ b/crates/rust-analyzer/src/to_proto.rs
@@ -7,9 +7,9 @@ use std::{
 use ide::{
    Annotation, AnnotationKind, Assist, AssistKind, CallInfo, CompletionItem, CompletionItemKind,
    CompletionRelevance, Documentation, FileId, FileRange, FileSystemEdit, Fold, FoldKind,
-    Highlight, HlMod, HlPunct, HlRange, HlTag, Indel, InlayHint, InlayKind, InsertTextFormat,
+    Highlight, HlMod, HlOperator, HlPunct, HlRange, HlTag, Indel, InlayHint, InlayKind,
-    Markup, NavigationTarget, ReferenceAccess, RenameError, Runnable, Severity, SourceChange,
+    InsertTextFormat, Markup, NavigationTarget, ReferenceAccess, RenameError, Runnable, Severity,
-    StructureNodeKind, SymbolKind, TextEdit, TextRange, TextSize,
+    SourceChange, StructureNodeKind, SymbolKind, TextEdit, TextRange, TextSize,
 };
 use itertools::Itertools;
 use serde_json::to_value;
@@ -145,6 +145,23 @@ pub(crate) fn text_edit(line_index: &LineIndex, indel: Indel) -> lsp_types::Text
    lsp_types::TextEdit { range, new_text }
 }
+pub(crate) fn completion_text_edit(
+    line_index: &LineIndex,
+    insert_replace_support: Option<lsp_types::Position>,
+    indel: Indel,
+) -> lsp_types::CompletionTextEdit {
+    let text_edit = text_edit(line_index, indel);
+    match insert_replace_support {
+        Some(cursor_pos) => lsp_types::InsertReplaceEdit {
+            new_text: text_edit.new_text,
+            insert: lsp_types::Range { start: text_edit.range.start, end: cursor_pos },
+            replace: text_edit.range,
+        }
+        .into(),
+        None => text_edit.into(),
+    }
+}
 pub(crate) fn snippet_text_edit(
    line_index: &LineIndex,
    is_snippet: bool,
@@ -179,6 +196,7 @@ pub(crate) fn snippet_text_edit_vec(
 }
 pub(crate) fn completion_item(
+    insert_replace_support: Option<lsp_types::Position>,
    line_index: &LineIndex,
    item: CompletionItem,
 ) -> Vec<lsp_types::CompletionItem> {
@@ -190,7 +208,7 @@ pub(crate) fn completion_item(
    for indel in item.text_edit().iter() {
        if indel.delete.contains_range(source_range) {
            text_edit = Some(if indel.delete == source_range {
-                self::text_edit(line_index, indel.clone())
+                self::completion_text_edit(line_index, insert_replace_support, indel.clone())
            } else {
                assert!(source_range.end() == indel.delete.end());
                let range1 = TextRange::new(indel.delete.start(), source_range.start());
@@ -198,7 +216,7 @@ pub(crate) fn completion_item(
                let indel1 = Indel::replace(range1, String::new());
                let indel2 = Indel::replace(range2, indel.insert.clone());
                additional_text_edits.push(self::text_edit(line_index, indel1));
-                self::text_edit(line_index, indel2)
+                self::completion_text_edit(line_index, insert_replace_support, indel2)
            })
        } else {
            assert!(source_range.intersect(indel.delete).is_none());
@@ -213,7 +231,7 @@ pub(crate) fn completion_item(
        detail: item.detail().map(|it| it.to_string()),
        filter_text: Some(item.lookup().to_string()),
        kind: item.kind().map(completion_item_kind),
-        text_edit: Some(text_edit.into()),
+        text_edit: Some(text_edit),
        additional_text_edits: Some(additional_text_edits),
        documentation: item.documentation().map(documentation),
        deprecated: Some(item.deprecated()),
@@ -445,7 +463,13 @@ fn semantic_token_type_and_modifiers(
        HlTag::FormatSpecifier => semantic_tokens::FORMAT_SPECIFIER,
        HlTag::Keyword => lsp_types::SemanticTokenType::KEYWORD,
        HlTag::None => semantic_tokens::GENERIC,
-        HlTag::Operator => lsp_types::SemanticTokenType::OPERATOR,
+        HlTag::Operator(op) => match op {
+            HlOperator::Bitwise => semantic_tokens::BITWISE,
+            HlOperator::Arithmetic => semantic_tokens::ARITHMETIC,
+            HlOperator::Logical => semantic_tokens::LOGICAL,
+            HlOperator::Comparision => semantic_tokens::COMPARISION,
+            HlOperator::Other => semantic_tokens::OPERATOR,
+        },
        HlTag::StringLiteral => lsp_types::SemanticTokenType::STRING,
        HlTag::UnresolvedReference => semantic_tokens::UNRESOLVED_REFERENCE,
        HlTag::Punctuation(punct) => match punct {
@@ -825,40 +849,31 @@ pub(crate) fn code_action_kind(kind: AssistKind) -> lsp_types::CodeActionKind {
    }
 }
-pub(crate) fn unresolved_code_action(
+pub(crate) fn code_action(
    snap: &GlobalStateSnapshot,
-    code_action_params: lsp_types::CodeActionParams,
    assist: Assist,
-    index: usize,
+    resolve_data: Option<(usize, lsp_types::CodeActionParams)>,
 ) -> Result<lsp_ext::CodeAction> {
-    assert!(assist.source_change.is_none());
+    let mut res = lsp_ext::CodeAction {
-    let res = lsp_ext::CodeAction {
        title: assist.label.to_string(),
        group: assist.group.filter(|_| snap.config.code_action_group()).map(|gr| gr.0),
        kind: Some(code_action_kind(assist.id.1)),
        edit: None,
        is_preferred: None,
-        data: Some(lsp_ext::CodeActionData {
-            id: format!("{}:{}", assist.id.0, index.to_string()),
-            code_action_params,
-        }),
-    };
-    Ok(res)
-}
-pub(crate) fn resolved_code_action(
-    snap: &GlobalStateSnapshot,
-    assist: Assist,
-) -> Result<lsp_ext::CodeAction> {
-    let change = assist.source_change.unwrap();
-    let res = lsp_ext::CodeAction {
-        edit: Some(snippet_workspace_edit(snap, change)?),
-        title: assist.label.to_string(),
-        group: assist.group.filter(|_| snap.config.code_action_group()).map(|gr| gr.0),
-        kind: Some(code_action_kind(assist.id.1)),
-        is_preferred: None,
        data: None,
    };
+    match (assist.source_change, resolve_data) {
+        (Some(it), _) => res.edit = Some(snippet_workspace_edit(snap, it)?),
+        (None, Some((index, code_action_params))) => {
+            res.data = Some(lsp_ext::CodeActionData {
+                id: format!("{}:{}", assist.id.0, index.to_string()),
+                code_action_params,
+            });
+        }
+        (None, None) => {
+            stdx::never!("assist should always be resolved if client can't do lazy resolving")
+        }
+    };
    Ok(res)
 }
@@ -1136,7 +1151,7 @@ mod tests {
            .unwrap()
            .into_iter()
            .filter(|c| c.label().ends_with("arg"))
-            .map(|c| completion_item(&line_index, c))
+            .map(|c| completion_item(None, &line_index, c))
            .flat_map(|comps| comps.into_iter().map(|c| (c.label, c.sort_text)))
            .collect();
        expect_test::expect![[r#"
diff --git a/crates/rust-analyzer/tests/rust-analyzer/main.rs b/crates/rust-analyzer/tests/rust-analyzer/main.rs
index 4442cbff6..52a2674d5 100644
--- a/crates/rust-analyzer/tests/rust-analyzer/main.rs
+++ b/crates/rust-analyzer/tests/rust-analyzer/main.rs
@@ -340,7 +340,6 @@ fn main() {}
                }
              ]
            },
-            "isPreferred": false,
            "kind": "quickfix",
            "title": "Create module"
        }]),
@@ -411,7 +410,6 @@ fn main() {{}}
                }
              ]
            },
-            "isPreferred": false,
            "kind": "quickfix",
            "title": "Create module"
        }]),
@@ -527,7 +525,7 @@ version = \"0.0.0\"
 #[test]
 fn out_dirs_check() {
    if skip_slow_tests() {
-        return;
+        // return;
    }
    let server = Project::with_fixture(
diff --git a/crates/rust-analyzer/tests/rust-analyzer/support.rs b/crates/rust-analyzer/tests/rust-analyzer/support.rs
index 8d68f1b7d..75e677762 100644
--- a/crates/rust-analyzer/tests/rust-analyzer/support.rs
+++ b/crates/rust-analyzer/tests/rust-analyzer/support.rs
@@ -32,8 +32,12 @@ impl<'a> Project<'a> {
            tmp_dir: None,
            roots: vec![],
            config: serde_json::json!({
-                // Loading standard library is costly, let's ignore it by default
+                "cargo": {
-                "cargo": { "noSysroot": true }
+                    // Loading standard library is costly, let's ignore it by default
+                    "noSysroot": true,
+                    // Can't use test binary as rustc wrapper.
+                    "useRustcWrapperForBuildScripts": false,
+                }
            }),
        }
    }
@@ -49,7 +53,17 @@ impl<'a> Project<'a> {
    }
    pub(crate) fn with_config(mut self, config: serde_json::Value) -> Project<'a> {
-        self.config = config;
+        fn merge(dst: &mut serde_json::Value, src: serde_json::Value) {
+            match (dst, src) {
+                (Value::Object(dst), Value::Object(src)) => {
+                    for (k, v) in src {
+                        merge(dst.entry(k).or_insert(v.clone()), v)
+                    }
+                }
+                (dst, src) => *dst = src,
+            }
+        }
+        merge(&mut self.config, config);
        self
    }
@@ -154,6 +168,7 @@ impl Server {
        self.send_notification(r)
    }
+    #[track_caller]
    pub(crate) fn request<R>(&self, params: R::Params, expected_resp: Value)
    where
        R: lsp_types::request::Request,
diff --git a/crates/test_utils/src/assert_linear.rs b/crates/test_utils/src/assert_linear.rs
new file mode 100644
index 000000000..6ecc232e1
--- /dev/null
+++ b/crates/test_utils/src/assert_linear.rs
@@ -0,0 +1,112 @@
+//! Checks that a set of measurements looks like a linear function rather than
+//! like a quadratic function. Algorithm:
+//!
+//! 1. Linearly scale input to be in [0; 1)
+//! 2. Using linear regression, compute the best linear function approximating
+//!    the input.
+//! 3. Compute RMSE and  maximal absolute error.
+//! 4. Check that errors are within tolerances and that the constant term is not
+//!    too negative.
+//!
+//! Ideally, we should use a proper "model selection" to directly compare
+//! quadratic and linear models, but that sounds rather complicated:
+//!
+//!     https://stats.stackexchange.com/questions/21844/selecting-best-model-based-on-linear-quadratic-and-cubic-fit-of-data
+//!
+//! We might get false positives on a VM, but never false negatives. So, if the
+//! first round fails, we repeat the ordeal three more times and fail only if
+//! every time there's a fault.
+use stdx::format_to;
+#[derive(Default)]
+pub struct AssertLinear {
+    rounds: Vec<Round>,
+}
+#[derive(Default)]
+struct Round {
+    samples: Vec<(f64, f64)>,
+    plot: String,
+    linear: bool,
+}
+impl AssertLinear {
+    pub fn next_round(&mut self) -> bool {
+        if let Some(round) = self.rounds.last_mut() {
+            round.finish();
+        }
+        if self.rounds.iter().any(|it| it.linear) || self.rounds.len() == 4 {
+            return false;
+        }
+        self.rounds.push(Round::default());
+        true
+    }
+    pub fn sample(&mut self, x: f64, y: f64) {
+        self.rounds.last_mut().unwrap().samples.push((x, y))
+    }
+}
+impl Drop for AssertLinear {
+    fn drop(&mut self) {
+        assert!(!self.rounds.is_empty());
+        if self.rounds.iter().all(|it| !it.linear) {
+            for round in &self.rounds {
+                eprintln!("\n{}", round.plot);
+            }
+            panic!("Doesn't look linear!")
+        }
+    }
+}
+impl Round {
+    fn finish(&mut self) {
+        let (mut xs, mut ys): (Vec<_>, Vec<_>) = self.samples.iter().copied().unzip();
+        normalize(&mut xs);
+        normalize(&mut ys);
+        let xy = xs.iter().copied().zip(ys.iter().copied());
+        // Linear regression: finding a and b to fit y = a + b*x.
+        let mean_x = mean(&xs);
+        let mean_y = mean(&ys);
+        let b = {
+            let mut num = 0.0;
+            let mut denom = 0.0;
+            for (x, y) in xy.clone() {
+                num += (x - mean_x) * (y - mean_y);
+                denom += (x - mean_x).powi(2);
+            }
+            num / denom
+        };
+        let a = mean_y - b * mean_x;
+        self.plot = format!("y_pred = {:.3} + {:.3} * x\n\nx     y     y_pred\n", a, b);
+        let mut se = 0.0;
+        let mut max_error = 0.0f64;
+        for (x, y) in xy {
+            let y_pred = a + b * x;
+            se += (y - y_pred).powi(2);
+            max_error = max_error.max((y_pred - y).abs());
+            format_to!(self.plot, "{:.3} {:.3} {:.3}\n", x, y, y_pred);
+        }
+        let rmse = (se / xs.len() as f64).sqrt();
+        format_to!(self.plot, "\nrmse = {:.3} max error = {:.3}", rmse, max_error);
+        self.linear = rmse < 0.05 && max_error < 0.1 && a > -0.1;
+        fn normalize(xs: &mut Vec<f64>) {
+            let max = xs.iter().copied().max_by(|a, b| a.partial_cmp(b).unwrap()).unwrap();
+            xs.iter_mut().for_each(|it| *it /= max);
+        }
+        fn mean(xs: &[f64]) -> f64 {
+            xs.iter().copied().sum::<f64>() / (xs.len() as f64)
+        }
+    }
+}
diff --git a/crates/test_utils/src/bench_fixture.rs b/crates/test_utils/src/bench_fixture.rs
index 3a37c4473..979156263 100644
--- a/crates/test_utils/src/bench_fixture.rs
+++ b/crates/test_utils/src/bench_fixture.rs
@@ -8,7 +8,10 @@ use crate::project_root;
 pub fn big_struct() -> String {
    let n = 1_000;
+    big_struct_n(n)
+}
+pub fn big_struct_n(n: u32) -> String {
    let mut buf = "pub struct RegisterBlock {".to_string();
    for i in 0..n {
        format_to!(buf, "  /// Doc comment for {}.\n", i);
diff --git a/crates/test_utils/src/lib.rs b/crates/test_utils/src/lib.rs
index c5f859790..72466c957 100644
--- a/crates/test_utils/src/lib.rs
+++ b/crates/test_utils/src/lib.rs
@@ -8,6 +8,7 @@
 pub mod bench_fixture;
 mod fixture;
+mod assert_linear;
 use std::{
    convert::{TryFrom, TryInto},
@@ -22,7 +23,7 @@ use text_size::{TextRange, TextSize};
 pub use dissimilar::diff as __diff;
 pub use rustc_hash::FxHashMap;
-pub use crate::fixture::Fixture;
+pub use crate::{assert_linear::AssertLinear, fixture::Fixture};
 pub const CURSOR_MARKER: &str = "$0";
 pub const ESCAPED_CURSOR_MARKER: &str = "\\$0";
diff --git a/docs/dev/README.md b/docs/dev/README.md
index 9c0eb1358..f74f7d8eb 100644
--- a/docs/dev/README.md
+++ b/docs/dev/README.md
@@ -235,12 +235,14 @@ We don't do "patch" releases, unless something truly egregious comes up.
 There are three sets of people with extra permissions:
-* rust-analyzer GitHub organization **admins** (which include current t-compiler leads).
+* rust-analyzer GitHub organization (**admins**)[https://github.com/orgs/rust-analyzer/people?query=role:owner] (which include current t-compiler leads).
  Admins have full access to the org.
-* **review** team in the organization.
+* (**review**)[https://github.com/orgs/rust-analyzer/teams/review] team in the organization.
  Reviewers have `r+` access to all of organization's repositories and publish rights on crates.io.
  They also have direct commit access, but all changes should via bors queue.
  It's ok to self-approve if you think you know what you are doing!
  bors should automatically sync the permissions.
-* **triage** team in the organization.
+* (**triage**)[https://github.com/orgs/rust-analyzer/teams/triage] team in the organization.
  This team can label and close issues.
+Note that at the time being you need to be a member of the org yourself to view the links.
diff --git a/docs/dev/architecture.md b/docs/dev/architecture.md
index 3ffd9e8cb..39edf9e19 100644
--- a/docs/dev/architecture.md
+++ b/docs/dev/architecture.md
@@ -139,7 +139,7 @@ If an AST method returns an `Option`, it *can* be `None` at runtime, even if thi
 ### `crates/base_db`
 We use the [salsa](https://github.com/salsa-rs/salsa) crate for incremental and on-demand computation.
-Roughly, you can think of salsa as a key-value store, but it can also compute derived values using specified functions. 
+Roughly, you can think of salsa as a key-value store, but it can also compute derived values using specified functions.
 The `base_db` crate provides basic infrastructure for interacting with salsa.
 Crucially, it defines most of the "input" queries: facts supplied by the client of the analyzer.
 Reading the docs of the `base_db::input` module should be useful: everything else is strictly derived from those inputs.
@@ -308,7 +308,7 @@ This sections talks about the things which are everywhere and nowhere in particu
 ### Code generation
-Some ]components in this repository are generated through automatic processes.
+Some components in this repository are generated through automatic processes.
 Generated code is updated automatically on `cargo test`.
 Generated code is generally committed to the git repository.
diff --git a/docs/dev/style.md b/docs/dev/style.md
index 468dedff2..7c47c26b2 100644
--- a/docs/dev/style.md
+++ b/docs/dev/style.md
@@ -152,6 +152,16 @@ Do not reuse marks between several tests.
 **Rationale:** marks provide an easy way to find the canonical test for each bit of code.
 This makes it much easier to understand.
+More than one mark per test / code branch doesn't add significantly to understanding.
+## `#[should_panic]`
+Do not use `#[should_panic]` tests.
+Instead, explicitly check for `None`, `Err`, etc.
+**Rationale:**a `#[should_panic]` is a tool for library authors, to makes sure that API does not fail silently, when misused.
+`rust-analyzer` is not a library, we don't need to test for API misuse, and we have to handle any user input without panics.
+Panic messages in the logs from the `#[should_panic]` tests are confusing.
 ## Function Preconditions
diff --git a/docs/user/generated_config.adoc b/docs/user/generated_config.adoc
index 871c65add..e0ee35b4e 100644
--- a/docs/user/generated_config.adoc
+++ b/docs/user/generated_config.adoc
@@ -39,6 +39,12 @@ List of features to activate.
 --
 Run build scripts (`build.rs`) for more precise code analysis.
 --
+[[rust-analyzer.cargo.useRustcWrapperForBuildScripts]]rust-analyzer.cargo.useRustcWrapperForBuildScripts (default: `true`)::
+
+--
+Use `RUSTC_WRAPPER=rust-analyzer` when running build scripts to
+avoid compiling unnecessary things.
+--
 [[rust-analyzer.cargo.noDefaultFeatures]]rust-analyzer.cargo.noDefaultFeatures (default: `false`)::
 +
 --
diff --git a/editors/code/package.json b/editors/code/package.json
index d263610f5..06ed62d8d 100644
--- a/editors/code/package.json
+++ b/editors/code/package.json
@@ -434,6 +434,11 @@
                    "default": true,
                    "type": "boolean"
                },
+                "rust-analyzer.cargo.useRustcWrapperForBuildScripts": {
+                    "markdownDescription": "Use `RUSTC_WRAPPER=rust-analyzer` when running build scripts to\navoid compiling unnecessary things.",
+                    "default": true,
+                    "type": "boolean"
+                },
                "rust-analyzer.cargo.noDefaultFeatures": {
                    "markdownDescription": "Do not activate the `default` feature.",
                    "default": false,