87 files changed, 3822 insertions, 3812 deletions
diff --git a/crates/base_db/src/fixture.rs b/crates/base_db/src/fixture.rs
index 8d4641355..04e2be390 100644
--- a/crates/base_db/src/fixture.rs
+++ b/crates/base_db/src/fixture.rs
@@ -1,62 +1,4 @@
-//! Fixtures are strings containing rust source code with optional metadata.
+//! A set of high-level utility fixture methods to use in tests.
-//! A fixture without metadata is parsed into a single source file.
-//! Use this to test functionality local to one file.
-//!
-//! Simple Example:
-//! ```
-//! r#"
-//! fn main() {
-//!     println!("Hello World")
-//! }
-//! "#
-//! ```
-//!
-//! Metadata can be added to a fixture after a `//-` comment.
-//! The basic form is specifying filenames,
-//! which is also how to define multiple files in a single test fixture
-//!
-//! Example using two files in the same crate:
-//! ```
-//! "
-//! //- /main.rs
-//! mod foo;
-//! fn main() {
-//!     foo::bar();
-//! }
-//!
-//! //- /foo.rs
-//! pub fn bar() {}
-//! "
-//! ```
-//!
-//! Example using two crates with one file each, with one crate depending on the other:
-//! ```
-//! r#"
-//! //- /main.rs crate:a deps:b
-//! fn main() {
-//!     b::foo();
-//! }
-//! //- /lib.rs crate:b
-//! pub fn b() {
-//!     println!("Hello World")
-//! }
-//! "#
-//! ```
-//!
-//! Metadata allows specifying all settings and variables
-//! that are available in a real rust project:
-//! - crate names via `crate:cratename`
-//! - dependencies via `deps:dep1,dep2`
-//! - configuration settings via `cfg:dbg=false,opt_level=2`
-//! - environment variables via `env:PATH=/bin,RUST_LOG=debug`
-//!
-//! Example using all available metadata:
-//! ```
-//! "
-//! //- /lib.rs crate:foo deps:bar,baz cfg:foo=a,bar=b env:OUTDIR=path/to,OTHER=foo
-//! fn insert_source_code_here() {}
-//! "
-//! ```
 use std::{mem, str::FromStr, sync::Arc};
 use cfg::CfgOptions;
diff --git a/crates/hir/src/lib.rs b/crates/hir/src/lib.rs
index 003821981..eba46a056 100644
--- a/crates/hir/src/lib.rs
+++ b/crates/hir/src/lib.rs
@@ -53,13 +53,14 @@ use hir_def::{
 use hir_expand::{diagnostics::DiagnosticSink, name::name, MacroDefKind};
 use hir_ty::{
    autoderef, could_unify,
-    method_resolution::{self, TyFingerprint},
+    method_resolution::{self, def_crates, TyFingerprint},
    primitive::UintTy,
+    subst_prefix,
    traits::FnTrait,
    AliasEq, AliasTy, BoundVar, CallableDefId, CallableSig, Canonical, CanonicalVarKinds, Cast,
-    DebruijnIndex, InEnvironment, Interner, QuantifiedWhereClause, Scalar, Solution,
+    DebruijnIndex, InEnvironment, Interner, QuantifiedWhereClause, Scalar, Solution, Substitution,
-    SolutionVariables, Substitution, TraitEnvironment, Ty, TyBuilder, TyDefId, TyKind,
+    TraitEnvironment, TraitRefExt, Ty, TyBuilder, TyDefId, TyExt, TyKind, TyVariableKind,
-    TyVariableKind, WhereClause,
+    WhereClause,
 };
 use itertools::Itertools;
 use rustc_hash::FxHashSet;
@@ -1503,7 +1504,7 @@ impl TypeParam {
        let krate = self.id.parent.module(db.upcast()).krate();
        let ty = params.get(local_idx)?.clone();
        let subst = TyBuilder::type_params_subst(db, self.id.parent);
-        let ty = ty.substitute(&Interner, &subst.prefix(local_idx));
+        let ty = ty.substitute(&Interner, &subst_prefix(&subst, local_idx));
        Some(Type::new_with_resolver_inner(db, krate, &resolver, ty))
    }
 }
@@ -1568,7 +1569,7 @@ impl Impl {
    }
    pub fn all_for_type(db: &dyn HirDatabase, Type { krate, ty, .. }: Type) -> Vec<Impl> {
-        let def_crates = match ty.def_crates(db, krate) {
+        let def_crates = match def_crates(db, &ty, krate) {
            Some(def_crates) => def_crates,
            None => return Vec::new(),
        };
@@ -1579,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))
@@ -1591,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
    }
@@ -1790,7 +1803,7 @@ impl Type {
            .build();
        let goal = Canonical {
-            value: hir_ty::InEnvironment::new(self.env.env.clone(), trait_ref.cast(&Interner)),
+            value: hir_ty::InEnvironment::new(&self.env.env, trait_ref.cast(&Interner)),
            binders: CanonicalVarKinds::empty(&Interner),
        };
@@ -1807,9 +1820,9 @@ impl Type {
            .push(self.ty.clone())
            .fill(args.iter().map(|t| t.ty.clone()))
            .build();
-        let goal = Canonical::new(
+        let goal = hir_ty::make_canonical(
            InEnvironment::new(
-                self.env.env.clone(),
+                &self.env.env,
                AliasEq {
                    alias: AliasTy::Projection(projection),
                    ty: TyKind::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, 0))
@@ -1821,9 +1834,10 @@ impl Type {
        );
        match db.trait_solve(self.krate, goal)? {
-            Solution::Unique(SolutionVariables(subst)) => subst
+            Solution::Unique(s) => s
                .value
-                .interned()
+                .subst
+                .as_slice(&Interner)
                .first()
                .map(|ty| self.derived(ty.assert_ty_ref(&Interner).clone())),
            Solution::Ambig(_) => None,
@@ -1887,9 +1901,10 @@ impl Type {
                    substs.iter(&Interner).filter_map(|a| a.ty(&Interner)).any(go)
                }
-                TyKind::Array(ty) | TyKind::Slice(ty) | TyKind::Raw(_, ty) | TyKind::Ref(_, ty) => {
+                TyKind::Array(ty, _)
-                    go(ty)
+                | TyKind::Slice(ty)
-                }
+                | TyKind::Raw(_, ty)
+                | TyKind::Ref(_, _, ty) => go(ty),
                TyKind::Scalar(_)
                | TyKind::Str
@@ -1900,7 +1915,9 @@ impl Type {
                | TyKind::Dyn(_)
                | TyKind::Function(_)
                | TyKind::Alias(_)
-                | TyKind::Foreign(_) => false,
+                | TyKind::Foreign(_)
+                | TyKind::Generator(..)
+                | TyKind::GeneratorWitness(..) => false,
            }
        }
    }
@@ -1953,7 +1970,7 @@ impl Type {
        krate: Crate,
        mut callback: impl FnMut(AssocItem) -> Option<T>,
    ) -> Option<T> {
-        for krate in self.ty.def_crates(db, krate.id)? {
+        for krate in def_crates(db, &self.ty, krate.id)? {
            let impls = db.inherent_impls_in_crate(krate);
            for impl_def in impls.for_self_ty(&self.ty) {
@@ -1970,9 +1987,9 @@ impl Type {
    pub fn type_parameters(&self) -> impl Iterator<Item = Type> + '_ {
        self.ty
            .strip_references()
-            .substs()
+            .as_adt()
            .into_iter()
-            .flat_map(|substs| substs.iter(&Interner))
+            .flat_map(|(_, substs)| substs.iter(&Interner))
            .filter_map(|arg| arg.ty(&Interner).cloned())
            .map(move |ty| self.derived(ty))
    }
@@ -2113,18 +2130,22 @@ impl Type {
        fn walk_type(db: &dyn HirDatabase, type_: &Type, cb: &mut impl FnMut(Type)) {
            let ty = type_.ty.strip_references();
            match ty.kind(&Interner) {
-                TyKind::Adt(..) => {
+                TyKind::Adt(_, substs) => {
                    cb(type_.derived(ty.clone()));
+                    walk_substs(db, type_, &substs, cb);
                }
-                TyKind::AssociatedType(..) => {
+                TyKind::AssociatedType(_, substs) => {
                    if let Some(_) = ty.associated_type_parent_trait(db) {
                        cb(type_.derived(ty.clone()));
                    }
+                    walk_substs(db, type_, &substs, cb);
                }
-                TyKind::OpaqueType(..) => {
+                TyKind::OpaqueType(_, subst) => {
                    if let Some(bounds) = ty.impl_trait_bounds(db) {
                        walk_bounds(db, &type_.derived(ty.clone()), &bounds, cb);
                    }
+                    walk_substs(db, type_, subst, cb);
                }
                TyKind::Alias(AliasTy::Opaque(opaque_ty)) => {
                    if let Some(bounds) = ty.impl_trait_bounds(db) {
@@ -2147,15 +2168,24 @@ impl Type {
                    );
                }
-                TyKind::Ref(_, ty) | TyKind::Raw(_, ty) | TyKind::Array(ty) | TyKind::Slice(ty) => {
+                TyKind::Ref(_, _, ty)
+                | TyKind::Raw(_, ty)
+                | TyKind::Array(ty, _)
+                | TyKind::Slice(ty) => {
                    walk_type(db, &type_.derived(ty.clone()), cb);
                }
+                TyKind::FnDef(_, substs)
+                | TyKind::Tuple(_, substs)
+                | TyKind::Closure(.., substs) => {
+                    walk_substs(db, type_, &substs, cb);
+                }
+                TyKind::Function(hir_ty::FnPointer { substitution, .. }) => {
+                    walk_substs(db, type_, &substitution.0, cb);
+                }
                _ => {}
            }
-            if let Some(substs) = ty.substs() {
-                walk_substs(db, type_, &substs, cb);
-            }
        }
        walk_type(db, self, &mut cb);
diff --git a/crates/hir/src/source_analyzer.rs b/crates/hir/src/source_analyzer.rs
index 4ce1c2080..847d2537d 100644
--- a/crates/hir/src/source_analyzer.rs
+++ b/crates/hir/src/source_analyzer.rs
@@ -20,7 +20,7 @@ use hir_def::{
 use hir_expand::{hygiene::Hygiene, name::AsName, HirFileId, InFile};
 use hir_ty::{
    diagnostics::{record_literal_missing_fields, record_pattern_missing_fields},
-    InferenceResult, Interner, Substitution, TyLoweringContext,
+    InferenceResult, Interner, Substitution, TyExt, TyLoweringContext,
 };
 use syntax::{
    ast::{self, AstNode},
@@ -161,14 +161,15 @@ impl SourceAnalyzer {
        db: &dyn HirDatabase,
        field: &ast::RecordExprField,
    ) -> Option<(Field, Option<Local>)> {
-        let expr_id =
+        let record_expr = ast::RecordExpr::cast(field.syntax().parent().and_then(|p| p.parent())?)?;
-            self.body_source_map.as_ref()?.node_field(InFile::new(self.file_id, field))?;
+        let expr = ast::Expr::from(record_expr);
+        let expr_id = self.body_source_map.as_ref()?.node_expr(InFile::new(self.file_id, &expr))?;
+        let local_name = field.field_name()?.as_name();
        let local = if field.name_ref().is_some() {
            None
        } else {
-            let local_name = field.field_name()?.as_name();
+            let path = ModPath::from_segments(PathKind::Plain, once(local_name.clone()));
-            let path = ModPath::from_segments(PathKind::Plain, once(local_name));
            match self.resolver.resolve_path_in_value_ns_fully(db.upcast(), &path) {
                Some(ValueNs::LocalBinding(pat_id)) => {
                    Some(Local { pat_id, parent: self.resolver.body_owner()? })
@@ -176,18 +177,24 @@ impl SourceAnalyzer {
                _ => None,
            }
        };
-        let struct_field = self.infer.as_ref()?.record_field_resolution(expr_id)?;
+        let variant = self.infer.as_ref()?.variant_resolution_for_expr(expr_id)?;
-        Some((struct_field.into(), local))
+        let variant_data = variant.variant_data(db.upcast());
+        let field = FieldId { parent: variant, local_id: variant_data.field(&local_name)? };
+        Some((field.into(), local))
    }
    pub(crate) fn resolve_record_pat_field(
        &self,
-        _db: &dyn HirDatabase,
+        db: &dyn HirDatabase,
        field: &ast::RecordPatField,
    ) -> Option<Field> {
-        let pat_id = self.pat_id(&field.pat()?)?;
+        let field_name = field.field_name()?.as_name();
-        let struct_field = self.infer.as_ref()?.record_pat_field_resolution(pat_id)?;
+        let record_pat = ast::RecordPat::cast(field.syntax().parent().and_then(|p| p.parent())?)?;
-        Some(struct_field.into())
+        let pat_id = self.pat_id(&record_pat.into())?;
+        let variant = self.infer.as_ref()?.variant_resolution_for_pat(pat_id)?;
+        let variant_data = variant.variant_data(db.upcast());
+        let field = FieldId { parent: variant, local_id: variant_data.field(&field_name)? };
+        Some(field.into())
    }
    pub(crate) fn resolve_macro_call(
@@ -299,7 +306,7 @@ impl SourceAnalyzer {
        let infer = self.infer.as_ref()?;
        let expr_id = self.expr_id(db, &literal.clone().into())?;
-        let substs = infer.type_of_expr[expr_id].substs()?;
+        let substs = infer.type_of_expr[expr_id].as_adt()?.1;
        let (variant, missing_fields, _exhaustive) =
            record_literal_missing_fields(db, infer, expr_id, &body[expr_id])?;
@@ -317,7 +324,7 @@ impl SourceAnalyzer {
        let infer = self.infer.as_ref()?;
        let pat_id = self.pat_id(&pattern.clone().into())?;
-        let substs = infer.type_of_pat[pat_id].substs()?;
+        let substs = infer.type_of_pat[pat_id].as_adt()?.1;
        let (variant, missing_fields, _exhaustive) =
            record_pattern_missing_fields(db, infer, pat_id, &body[pat_id])?;
diff --git a/crates/hir_def/src/attr.rs b/crates/hir_def/src/attr.rs
index ab77d924a..786fad6e1 100644
--- a/crates/hir_def/src/attr.rs
+++ b/crates/hir_def/src/attr.rs
@@ -9,14 +9,14 @@ 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;
 use smallvec::{smallvec, SmallVec};
 use syntax::{
    ast::{self, AstNode, AttrsOwner},
-    match_ast, AstToken, SmolStr, SyntaxNode, TextRange, TextSize,
+    match_ast, AstPtr, AstToken, SmolStr, SyntaxNode, TextRange, TextSize,
 };
 use tt::Subtree;
@@ -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()?;
@@ -215,12 +218,11 @@ impl Attrs {
        let mut res = ArenaMap::default();
        for (id, fld) in src.value.iter() {
-            let attrs = match fld {
+            let owner: &dyn AttrsOwner = match fld {
-                Either::Left(_tuple) => Attrs::default(),
+                Either::Left(tuple) => tuple,
-                Either::Right(record) => {
+                Either::Right(record) => record,
-                    RawAttrs::from_attrs_owner(db, src.with_value(record)).filter(db, krate)
-                }
            };
+            let attrs = RawAttrs::from_attrs_owner(db, src.with_value(owner)).filter(db, krate);
            res.insert(id, attrs);
        }
@@ -404,10 +406,14 @@ impl AttrsWithOwner {
                return AttrSourceMap { attrs };
            }
            AttrDefId::FieldId(id) => {
-                id.parent.child_source(db).map(|source| match &source[id.local_id] {
+                let map = db.fields_attrs_source_map(id.parent);
-                    Either::Left(field) => ast::AttrsOwnerNode::new(field.clone()),
+                let file_id = id.parent.file_id(db);
-                    Either::Right(field) => ast::AttrsOwnerNode::new(field.clone()),
+                let root = db.parse_or_expand(file_id).unwrap();
-                })
+                let owner = match &map[id.local_id] {
+                    Either::Left(it) => ast::AttrsOwnerNode::new(it.to_node(&root)),
+                    Either::Right(it) => ast::AttrsOwnerNode::new(it.to_node(&root)),
+                };
+                InFile::new(file_id, owner)
            }
            AttrDefId::AdtId(adt) => match adt {
                AdtId::StructId(id) => id.lookup(db).source(db).map(ast::AttrsOwnerNode::new),
@@ -415,10 +421,12 @@ impl AttrsWithOwner {
                AdtId::EnumId(id) => id.lookup(db).source(db).map(ast::AttrsOwnerNode::new),
            },
            AttrDefId::FunctionId(id) => id.lookup(db).source(db).map(ast::AttrsOwnerNode::new),
-            AttrDefId::EnumVariantId(id) => id
+            AttrDefId::EnumVariantId(id) => {
-                .parent
+                let map = db.variants_attrs_source_map(id.parent);
-                .child_source(db)
+                let file_id = id.parent.lookup(db).id.file_id();
-                .map(|source| ast::AttrsOwnerNode::new(source[id.local_id].clone())),
+                let root = db.parse_or_expand(file_id).unwrap();
+                InFile::new(file_id, ast::AttrsOwnerNode::new(map[id.local_id].to_node(&root)))
+            }
            AttrDefId::StaticId(id) => id.lookup(db).source(db).map(ast::AttrsOwnerNode::new),
            AttrDefId::ConstId(id) => id.lookup(db).source(db).map(ast::AttrsOwnerNode::new),
            AttrDefId::TraitId(id) => id.lookup(db).source(db).map(ast::AttrsOwnerNode::new),
@@ -463,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
@@ -555,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()
    }
 }
@@ -567,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 {
@@ -580,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
@@ -601,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>,
 }
@@ -615,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() {
@@ -628,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
@@ -743,7 +751,38 @@ 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)
+}
+pub(crate) fn variants_attrs_source_map(
+    db: &dyn DefDatabase,
+    def: EnumId,
+) -> Arc<ArenaMap<LocalEnumVariantId, AstPtr<ast::Variant>>> {
+    let mut res = ArenaMap::default();
+    let child_source = def.child_source(db);
+    for (idx, variant) in child_source.value.iter() {
+        res.insert(idx, AstPtr::new(variant));
+    }
+    Arc::new(res)
+}
+pub(crate) fn fields_attrs_source_map(
+    db: &dyn DefDatabase,
+    def: VariantId,
+) -> Arc<ArenaMap<LocalFieldId, Either<AstPtr<ast::TupleField>, AstPtr<ast::RecordField>>>> {
+    let mut res = ArenaMap::default();
+    let child_source = def.child_source(db);
+    for (idx, variant) in child_source.value.iter() {
+        res.insert(
+            idx,
+            variant
+                .as_ref()
+                .either(|l| Either::Left(AstPtr::new(l)), |r| Either::Right(AstPtr::new(r))),
+        );
+    }
-    attrs.into_iter().map(|(_, attr)| attr)
+    Arc::new(res)
 }
diff --git a/crates/hir_def/src/body/lower.rs b/crates/hir_def/src/body/lower.rs
index 63e89a1f4..bfb75a8a5 100644
--- a/crates/hir_def/src/body/lower.rs
+++ b/crates/hir_def/src/body/lower.rs
@@ -30,6 +30,7 @@ use crate::{
        LabelId, Literal, LogicOp, MatchArm, Ordering, Pat, PatId, RecordFieldPat, RecordLitField,
        Statement,
    },
+    intern::Interned,
    item_scope::BuiltinShadowMode,
    path::{GenericArgs, Path},
    type_ref::{Mutability, Rawness, TypeRef},
@@ -322,8 +323,10 @@ impl ExprCollector<'_> {
                    Vec::new()
                };
                let method_name = e.name_ref().map(|nr| nr.as_name()).unwrap_or_else(Name::missing);
-                let generic_args =
+                let generic_args = e
-                    e.generic_arg_list().and_then(|it| GenericArgs::from_ast(&self.ctx(), it));
+                    .generic_arg_list()
+                    .and_then(|it| GenericArgs::from_ast(&self.ctx(), it))
+                    .map(Box::new);
                self.alloc_expr(
                    Expr::MethodCall { receiver, method_name, args, generic_args },
                    syntax_ptr,
@@ -385,7 +388,7 @@ impl ExprCollector<'_> {
                self.alloc_expr(Expr::Yield { expr }, syntax_ptr)
            }
            ast::Expr::RecordExpr(e) => {
-                let path = e.path().and_then(|path| self.expander.parse_path(path));
+                let path = e.path().and_then(|path| self.expander.parse_path(path)).map(Box::new);
                let record_lit = if let Some(nfl) = e.record_expr_field_list() {
                    let fields = nfl
                        .fields()
@@ -430,7 +433,7 @@ impl ExprCollector<'_> {
            }
            ast::Expr::CastExpr(e) => {
                let expr = self.collect_expr_opt(e.expr());
-                let type_ref = TypeRef::from_ast_opt(&self.ctx(), e.ty());
+                let type_ref = Interned::new(TypeRef::from_ast_opt(&self.ctx(), e.ty()));
                self.alloc_expr(Expr::Cast { expr, type_ref }, syntax_ptr)
            }
            ast::Expr::RefExpr(e) => {
@@ -464,13 +467,16 @@ impl ExprCollector<'_> {
                if let Some(pl) = e.param_list() {
                    for param in pl.params() {
                        let pat = self.collect_pat_opt(param.pat());
-                        let type_ref = param.ty().map(|it| TypeRef::from_ast(&self.ctx(), it));
+                        let type_ref =
+                            param.ty().map(|it| Interned::new(TypeRef::from_ast(&self.ctx(), it)));
                        args.push(pat);
                        arg_types.push(type_ref);
                    }
                }
-                let ret_type =
+                let ret_type = e
-                    e.ret_type().and_then(|r| r.ty()).map(|it| TypeRef::from_ast(&self.ctx(), it));
+                    .ret_type()
+                    .and_then(|r| r.ty())
+                    .map(|it| Interned::new(TypeRef::from_ast(&self.ctx(), it)));
                let body = self.collect_expr_opt(e.body());
                self.alloc_expr(Expr::Lambda { args, arg_types, ret_type, body }, syntax_ptr)
            }
@@ -625,7 +631,8 @@ impl ExprCollector<'_> {
                    return;
                }
                let pat = self.collect_pat_opt(stmt.pat());
-                let type_ref = stmt.ty().map(|it| TypeRef::from_ast(&self.ctx(), it));
+                let type_ref =
+                    stmt.ty().map(|it| Interned::new(TypeRef::from_ast(&self.ctx(), it)));
                let initializer = stmt.initializer().map(|e| self.collect_expr(e));
                self.statements_in_scope.push(Statement::Let { pat, type_ref, initializer });
            }
@@ -755,7 +762,7 @@ impl ExprCollector<'_> {
                }
            }
            ast::Pat::TupleStructPat(p) => {
-                let path = p.path().and_then(|path| self.expander.parse_path(path));
+                let path = p.path().and_then(|path| self.expander.parse_path(path)).map(Box::new);
                let (args, ellipsis) = self.collect_tuple_pat(p.fields());
                Pat::TupleStruct { path, args, ellipsis }
            }
@@ -765,7 +772,7 @@ impl ExprCollector<'_> {
                Pat::Ref { pat, mutability }
            }
            ast::Pat::PathPat(p) => {
-                let path = p.path().and_then(|path| self.expander.parse_path(path));
+                let path = p.path().and_then(|path| self.expander.parse_path(path)).map(Box::new);
                path.map(Pat::Path).unwrap_or(Pat::Missing)
            }
            ast::Pat::OrPat(p) => {
@@ -779,7 +786,7 @@ impl ExprCollector<'_> {
            }
            ast::Pat::WildcardPat(_) => Pat::Wild,
            ast::Pat::RecordPat(p) => {
-                let path = p.path().and_then(|path| self.expander.parse_path(path));
+                let path = p.path().and_then(|path| self.expander.parse_path(path)).map(Box::new);
                let args: Vec<_> = p
                    .record_pat_field_list()
                    .expect("every struct should have a field list")
diff --git a/crates/hir_def/src/body/tests.rs b/crates/hir_def/src/body/tests.rs
index faa133297..c1d3e998f 100644
--- a/crates/hir_def/src/body/tests.rs
+++ b/crates/hir_def/src/body/tests.rs
@@ -143,7 +143,7 @@ fn f() {
  //^^^^^^^^^^^^^ could not convert tokens
    env!("OUT_DIR");
-  //^^^^^^^^^^^^^^^ `OUT_DIR` not set, enable "load out dirs from check" to fix
+  //^^^^^^^^^^^^^^^ `OUT_DIR` not set, enable "run build scripts" to fix
    compile_error!("compile_error works");
  //^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ compile_error works
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/db.rs b/crates/hir_def/src/db.rs
index 9b7a213a1..7eadc8e0d 100644
--- a/crates/hir_def/src/db.rs
+++ b/crates/hir_def/src/db.rs
@@ -2,9 +2,10 @@
 use std::sync::Arc;
 use base_db::{salsa, CrateId, SourceDatabase, Upcast};
+use either::Either;
 use hir_expand::{db::AstDatabase, HirFileId};
 use la_arena::ArenaMap;
-use syntax::SmolStr;
+use syntax::{ast, AstPtr, SmolStr};
 use crate::{
    adt::{EnumData, StructData},
@@ -122,6 +123,18 @@ pub trait DefDatabase: InternDatabase + AstDatabase + Upcast<dyn AstDatabase> {
    #[salsa::invoke(Attrs::fields_attrs_query)]
    fn fields_attrs(&self, def: VariantId) -> Arc<ArenaMap<LocalFieldId, Attrs>>;
+    #[salsa::invoke(crate::attr::variants_attrs_source_map)]
+    fn variants_attrs_source_map(
+        &self,
+        def: EnumId,
+    ) -> Arc<ArenaMap<LocalEnumVariantId, AstPtr<ast::Variant>>>;
+    #[salsa::invoke(crate::attr::fields_attrs_source_map)]
+    fn fields_attrs_source_map(
+        &self,
+        def: VariantId,
+    ) -> Arc<ArenaMap<LocalFieldId, Either<AstPtr<ast::TupleField>, AstPtr<ast::RecordField>>>>;
    #[salsa::invoke(AttrsWithOwner::attrs_query)]
    fn attrs(&self, def: AttrDefId) -> AttrsWithOwner;
diff --git a/crates/hir_def/src/expr.rs b/crates/hir_def/src/expr.rs
index 6c7376fad..b4ad984bd 100644
--- a/crates/hir_def/src/expr.rs
+++ b/crates/hir_def/src/expr.rs
@@ -18,6 +18,7 @@ use syntax::ast::RangeOp;
 use crate::{
    builtin_type::{BuiltinFloat, BuiltinInt, BuiltinUint},
+    intern::Interned,
    path::{GenericArgs, Path},
    type_ref::{Mutability, Rawness, TypeRef},
    BlockId,
@@ -86,7 +87,7 @@ pub enum Expr {
        receiver: ExprId,
        method_name: Name,
        args: Vec<ExprId>,
-        generic_args: Option<GenericArgs>,
+        generic_args: Option<Box<GenericArgs>>,
    },
    Match {
        expr: ExprId,
@@ -106,7 +107,7 @@ pub enum Expr {
        expr: Option<ExprId>,
    },
    RecordLit {
-        path: Option<Path>,
+        path: Option<Box<Path>>,
        fields: Vec<RecordLitField>,
        spread: Option<ExprId>,
    },
@@ -131,7 +132,7 @@ pub enum Expr {
    },
    Cast {
        expr: ExprId,
-        type_ref: TypeRef,
+        type_ref: Interned<TypeRef>,
    },
    Ref {
        expr: ExprId,
@@ -161,8 +162,8 @@ pub enum Expr {
    },
    Lambda {
        args: Vec<PatId>,
-        arg_types: Vec<Option<TypeRef>>,
+        arg_types: Vec<Option<Interned<TypeRef>>>,
-        ret_type: Option<TypeRef>,
+        ret_type: Option<Interned<TypeRef>>,
        body: ExprId,
    },
    Tuple {
@@ -240,7 +241,7 @@ pub struct RecordLitField {
 #[derive(Debug, Clone, Eq, PartialEq)]
 pub enum Statement {
-    Let { pat: PatId, type_ref: Option<TypeRef>, initializer: Option<ExprId> },
+    Let { pat: PatId, type_ref: Option<Interned<TypeRef>>, initializer: Option<ExprId> },
    Expr(ExprId),
 }
@@ -412,13 +413,13 @@ pub enum Pat {
    Wild,
    Tuple { args: Vec<PatId>, ellipsis: Option<usize> },
    Or(Vec<PatId>),
-    Record { path: Option<Path>, args: Vec<RecordFieldPat>, ellipsis: bool },
+    Record { path: Option<Box<Path>>, args: Vec<RecordFieldPat>, ellipsis: bool },
    Range { start: ExprId, end: ExprId },
    Slice { prefix: Vec<PatId>, slice: Option<PatId>, suffix: Vec<PatId> },
-    Path(Path),
+    Path(Box<Path>),
    Lit(ExprId),
    Bind { mode: BindingAnnotation, name: Name, subpat: Option<PatId> },
-    TupleStruct { path: Option<Path>, args: Vec<PatId>, ellipsis: Option<usize> },
+    TupleStruct { path: Option<Box<Path>>, args: Vec<PatId>, ellipsis: Option<usize> },
    Ref { pat: PatId, mutability: Mutability },
    Box { inner: PatId },
    ConstBlock(ExprId),
diff --git a/crates/hir_def/src/item_scope.rs b/crates/hir_def/src/item_scope.rs
index a8ee5eeac..9014468ea 100644
--- a/crates/hir_def/src/item_scope.rs
+++ b/crates/hir_def/src/item_scope.rs
@@ -11,7 +11,7 @@ use rustc_hash::{FxHashMap, FxHashSet};
 use stdx::format_to;
 use crate::{
-    db::DefDatabase, per_ns::PerNs, visibility::Visibility, AdtId, BuiltinType, ImplId,
+    db::DefDatabase, per_ns::PerNs, visibility::Visibility, AdtId, BuiltinType, ConstId, ImplId,
    LocalModuleId, MacroDefId, ModuleDefId, ModuleId, TraitId,
 };
@@ -37,6 +37,7 @@ pub struct ItemScope {
    defs: Vec<ModuleDefId>,
    impls: Vec<ImplId>,
+    unnamed_consts: Vec<ConstId>,
    /// Traits imported via `use Trait as _;`.
    unnamed_trait_imports: FxHashMap<TraitId, Visibility>,
    /// Macros visible in current module in legacy textual scope
@@ -106,6 +107,10 @@ impl ItemScope {
            .map(|(_, v)| v)
    }
+    pub fn unnamed_consts(&self) -> impl Iterator<Item = ConstId> + '_ {
+        self.unnamed_consts.iter().copied()
+    }
    /// Iterate over all module scoped macros
    pub(crate) fn macros<'a>(&'a self) -> impl Iterator<Item = (&'a Name, MacroDefId)> + 'a {
        self.entries().filter_map(|(name, def)| def.take_macros().map(|macro_| (name, macro_)))
@@ -156,6 +161,10 @@ impl ItemScope {
        self.impls.push(imp)
    }
+    pub(crate) fn define_unnamed_const(&mut self, konst: ConstId) {
+        self.unnamed_consts.push(konst);
+    }
    pub(crate) fn define_legacy_macro(&mut self, name: Name, mac: MacroDefId) {
        self.legacy_macros.insert(name, mac);
    }
@@ -295,6 +304,7 @@ impl ItemScope {
            unresolved,
            defs,
            impls,
+            unnamed_consts,
            unnamed_trait_imports,
            legacy_macros,
        } = self;
@@ -304,6 +314,7 @@ impl ItemScope {
        unresolved.shrink_to_fit();
        defs.shrink_to_fit();
        impls.shrink_to_fit();
+        unnamed_consts.shrink_to_fit();
        unnamed_trait_imports.shrink_to_fit();
        legacy_macros.shrink_to_fit();
    }
diff --git a/crates/hir_def/src/lib.rs b/crates/hir_def/src/lib.rs
index be9a5e1a0..d69116d51 100644
--- a/crates/hir_def/src/lib.rs
+++ b/crates/hir_def/src/lib.rs
@@ -56,12 +56,13 @@ use std::{
    sync::Arc,
 };
+use adt::VariantData;
 use base_db::{impl_intern_key, salsa, CrateId};
 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;
@@ -442,6 +443,26 @@ pub enum VariantId {
 }
 impl_from!(EnumVariantId, StructId, UnionId for VariantId);
+impl VariantId {
+    pub fn variant_data(self, db: &dyn db::DefDatabase) -> Arc<VariantData> {
+        match self {
+            VariantId::StructId(it) => db.struct_data(it).variant_data.clone(),
+            VariantId::UnionId(it) => db.union_data(it).variant_data.clone(),
+            VariantId::EnumVariantId(it) => {
+                db.enum_data(it.parent).variants[it.local_id].variant_data.clone()
+            }
+        }
+    }
+    pub fn file_id(self, db: &dyn db::DefDatabase) -> HirFileId {
+        match self {
+            VariantId::EnumVariantId(it) => it.parent.lookup(db).id.file_id(),
+            VariantId::StructId(it) => it.lookup(db).id.file_id(),
+            VariantId::UnionId(it) => it.lookup(db).id.file_id(),
+        }
+    }
+}
 trait Intern {
    type ID;
    fn intern(self, db: &dyn db::DefDatabase) -> Self::ID;
@@ -669,13 +690,16 @@ fn macro_call_as_call_id(
        )
        .map(MacroCallId::from)
    } else {
-        Ok(def.as_lazy_macro(db.upcast(), krate, MacroCallKind::FnLike(call.ast_id)).into())
+        Ok(def
+            .as_lazy_macro(db.upcast(), krate, MacroCallKind::FnLike { ast_id: call.ast_id })
+            .into())
    };
    Ok(res)
 }
 fn derive_macro_as_call_id(
    item_attr: &AstIdWithPath<ast::Item>,
+    derive_attr: AttrId,
    db: &dyn db::DefDatabase,
    krate: CrateId,
    resolver: impl Fn(path::ModPath) -> Option<MacroDefId>,
@@ -686,7 +710,11 @@ fn derive_macro_as_call_id(
        .as_lazy_macro(
            db.upcast(),
            krate,
-            MacroCallKind::Derive(item_attr.ast_id, last_segment.to_string()),
+            MacroCallKind::Derive {
+                ast_id: item_attr.ast_id,
+                derive_name: last_segment.to_string(),
+                derive_attr,
+            },
        )
        .into();
    Ok(res)
diff --git a/crates/hir_def/src/nameres.rs b/crates/hir_def/src/nameres.rs
index 7dd68219f..9e181751c 100644
--- a/crates/hir_def/src/nameres.rs
+++ b/crates/hir_def/src/nameres.rs
@@ -613,12 +613,12 @@ mod diagnostics {
                DiagnosticKind::UnresolvedProcMacro { ast } => {
                    let mut precise_location = None;
                    let (file, ast, name) = match ast {
-                        MacroCallKind::FnLike(ast) => {
+                        MacroCallKind::FnLike { ast_id } => {
-                            let node = ast.to_node(db.upcast());
+                            let node = ast_id.to_node(db.upcast());
-                            (ast.file_id, SyntaxNodePtr::from(AstPtr::new(&node)), None)
+                            (ast_id.file_id, SyntaxNodePtr::from(AstPtr::new(&node)), None)
                        }
-                        MacroCallKind::Derive(ast, name) => {
+                        MacroCallKind::Derive { ast_id, derive_name, .. } => {
-                            let node = ast.to_node(db.upcast());
+                            let node = ast_id.to_node(db.upcast());
                            // Compute the precise location of the macro name's token in the derive
                            // list.
@@ -639,7 +639,7 @@ mod diagnostics {
                                    });
                                for token in tokens {
                                    if token.kind() == SyntaxKind::IDENT
-                                        && token.text() == name.as_str()
+                                        && token.text() == derive_name.as_str()
                                    {
                                        precise_location = Some(token.text_range());
                                        break 'outer;
@@ -648,9 +648,9 @@ mod diagnostics {
                            }
                            (
-                                ast.file_id,
+                                ast_id.file_id,
                                SyntaxNodePtr::from(AstPtr::new(&node)),
-                                Some(name.clone()),
+                                Some(derive_name.clone()),
                            )
                        }
                    };
@@ -669,13 +669,13 @@ mod diagnostics {
                DiagnosticKind::MacroError { ast, message } => {
                    let (file, ast) = match ast {
-                        MacroCallKind::FnLike(ast) => {
+                        MacroCallKind::FnLike { ast_id, .. } => {
-                            let node = ast.to_node(db.upcast());
+                            let node = ast_id.to_node(db.upcast());
-                            (ast.file_id, SyntaxNodePtr::from(AstPtr::new(&node)))
+                            (ast_id.file_id, SyntaxNodePtr::from(AstPtr::new(&node)))
                        }
-                        MacroCallKind::Derive(ast, _) => {
+                        MacroCallKind::Derive { ast_id, .. } => {
-                            let node = ast.to_node(db.upcast());
+                            let node = ast_id.to_node(db.upcast());
-                            (ast.file_id, SyntaxNodePtr::from(AstPtr::new(&node)))
+                            (ast_id.file_id, SyntaxNodePtr::from(AstPtr::new(&node)))
                        }
                    };
                    sink.push(MacroError { file, node: ast, message: message.clone() });
diff --git a/crates/hir_def/src/nameres/collector.rs b/crates/hir_def/src/nameres/collector.rs
index f42f92702..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;
                        }
@@ -1163,19 +1168,27 @@ impl ModCollector<'_, '_> {
                }
                ModItem::Const(id) => {
                    let it = &self.item_tree[id];
+                    let const_id = ConstLoc {
-                    if let Some(name) = &it.name {
+                        container: module.into(),
-                        def = Some(DefData {
+                        id: ItemTreeId::new(self.file_id, id),
-                            id: ConstLoc {
+                    }
-                                container: module.into(),
+                    .intern(self.def_collector.db);
-                                id: ItemTreeId::new(self.file_id, id),
-                            }
+                    match &it.name {
-                            .intern(self.def_collector.db)
+                        Some(name) => {
-                            .into(),
+                            def = Some(DefData {
-                            name,
+                                id: const_id.into(),
-                            visibility: &self.item_tree[it.visibility],
+                                name,
-                            has_constructor: false,
+                                visibility: &self.item_tree[it.visibility],
-                        });
+                                has_constructor: false,
+                            });
+                        }
+                        None => {
+                            // const _: T = ...;
+                            self.def_collector.def_map.modules[self.module_id]
+                                .scope
+                                .define_unnamed_const(const_id);
+                        }
                    }
                }
                ModItem::Static(id) => {
@@ -1360,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 },
                        });
                    }
                }
@@ -1512,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_def/src/nameres/tests/diagnostics.rs b/crates/hir_def/src/nameres/tests/diagnostics.rs
index fefdadb22..1ac88fc89 100644
--- a/crates/hir_def/src/nameres/tests/diagnostics.rs
+++ b/crates/hir_def/src/nameres/tests/diagnostics.rs
@@ -233,7 +233,7 @@ fn good_out_dir_diagnostic() {
        macro_rules! concat { () => {} }
        include!(concat!(env!("OUT_DIR"), "/out.rs"));
-      //^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `OUT_DIR` not set, enable "load out dirs from check" to fix
+      //^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `OUT_DIR` not set, enable "run build scripts" to fix
        "#,
    );
 }
diff --git a/crates/hir_def/src/path.rs b/crates/hir_def/src/path.rs
index f9c8328f0..b528ff8ba 100644
--- a/crates/hir_def/src/path.rs
+++ b/crates/hir_def/src/path.rs
@@ -289,6 +289,12 @@ impl From<Name> for Path {
    }
 }
+impl From<Name> for Box<Path> {
+    fn from(name: Name) -> Box<Path> {
+        Box::new(Path::from(name))
+    }
+}
 impl From<Name> for ModPath {
    fn from(name: Name) -> ModPath {
        ModPath::from_segments(PathKind::Plain, iter::once(name))
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 75ec4196b..80365fc16 100644
--- a/crates/hir_expand/src/builtin_macro.rs
+++ b/crates/hir_expand/src/builtin_macro.rs
@@ -490,7 +490,7 @@ fn env_expand(
        // unnecessary diagnostics for eg. `CARGO_PKG_NAME`.
        if key == "OUT_DIR" {
            err = Some(mbe::ExpandError::Other(
-                r#"`OUT_DIR` not set, enable "load out dirs from check" to fix"#.into(),
+                r#"`OUT_DIR` not set, enable "run build scripts" to fix"#.into(),
            ));
        }
@@ -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/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 7ca4af80e..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, Solution, Ty, TyBuilder, TyKind,
+    DebruijnIndex, InEnvironment, Interner, ProjectionTyExt, Solution, Substitution, Ty, TyBuilder,
+    TyKind,
 };
 const AUTODEREF_RECURSION_LIMIT: usize = 10;
@@ -35,13 +36,21 @@ pub(crate) fn deref(
    krate: CrateId,
    ty: InEnvironment<&Canonical<Ty>>,
 ) -> Option<Canonical<Ty>> {
-    if let Some(derefed) = ty.goal.value.builtin_deref() {
+    if let Some(derefed) = builtin_deref(&ty.goal.value) {
        Some(Canonical { value: derefed, binders: ty.goal.binders.clone() })
    } else {
        deref_by_trait(db, krate, ty)
    }
 }
+fn builtin_deref(ty: &Ty) -> Option<Ty> {
+    match ty.kind(&Interner) {
+        TyKind::Ref(.., ty) => Some(ty.clone()),
+        TyKind::Raw(.., ty) => Some(ty.clone()),
+        _ => None,
+    }
+}
 fn deref_by_trait(
    db: &dyn HirDatabase,
    krate: CrateId,
@@ -95,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,
            ))),
        ),
@@ -120,23 +129,25 @@ fn deref_by_trait(
            // assumptions will be broken. We would need to properly introduce
            // new variables in that case
-            for i in 1..vars.0.binders.len(&Interner) {
+            for i in 1..vars.binders.len(&Interner) {
-                if vars.0.value.at(&Interner, i - 1).assert_ty_ref(&Interner).kind(&Interner)
+                if vars.value.subst.at(&Interner, i - 1).assert_ty_ref(&Interner).kind(&Interner)
                    != &TyKind::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, i - 1))
                {
                    warn!("complex solution for derefing {:?}: {:?}, ignoring", ty.goal, solution);
                    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
-                    .0
                    .value
-                    .at(&Interner, vars.0.value.len(&Interner) - 1)
+                    .subst
+                    .at(&Interner, vars.value.subst.len(&Interner) - 1)
                    .assert_ty_ref(&Interner)
                    .clone(),
-                binders: vars.0.binders.clone(),
+                binders: vars.binders.clone(),
-            })
+            }))
        }
        Solution::Ambig(_) => {
            info!("Ambiguous solution for derefing {:?}: {:?}", ty.goal, solution);
@@ -144,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 9b2c6975a..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,
 };
@@ -12,8 +13,8 @@ use smallvec::SmallVec;
 use crate::{
    db::HirDatabase, primitive, to_assoc_type_id, to_chalk_trait_id, utils::generics, Binders,
-    CallableSig, FnPointer, FnSig, GenericArg, Interner, ProjectionTy, Substitution, TraitRef, Ty,
+    CallableSig, FnPointer, FnSig, FnSubst, GenericArg, Interner, ProjectionTy, Substitution,
-    TyDefId, 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)
    }
@@ -78,9 +78,12 @@ impl TyBuilder<()> {
    pub fn fn_ptr(sig: CallableSig) -> Ty {
        TyKind::Function(FnPointer {
-            num_args: sig.params().len(),
+            num_binders: 0,
            sig: FnSig { abi: (), safety: Safety::Safe, variadic: sig.is_varargs },
-            substs: Substitution::from_iter(&Interner, sig.params_and_return.iter().cloned()),
+            substitution: FnSubst(Substitution::from_iter(
+                &Interner,
+                sig.params_and_return.iter().cloned(),
+            )),
        })
        .intern(&Interner)
    }
@@ -138,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));
            }
@@ -193,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 dff87ef70..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, Ty, TyBuilder, 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;
+pub(crate) type AssociatedTyDatum = chalk_solve::rust_ir::AssociatedTyDatum<Interner>;
-mod interner;
+pub(crate) type TraitDatum = chalk_solve::rust_ir::TraitDatum<Interner>;
-mod mapping;
+pub(crate) type StructDatum = chalk_solve::rust_ir::AdtDatum<Interner>;
+pub(crate) type ImplDatum = chalk_solve::rust_ir::ImplDatum<Interner>;
-pub(crate) trait ToChalk {
+pub(crate) type OpaqueTyDatum = chalk_solve::rust_ir::OpaqueTyDatum<Interner>;
-    type Chalk;
-    fn to_chalk(self, db: &dyn HirDatabase) -> Self::Chalk;
+pub(crate) type AssocTypeId = chalk_ir::AssocTypeId<Interner>;
-    fn from_chalk(db: &dyn HirDatabase, chalk: Self::Chalk) -> Self;
+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) fn from_chalk<T, ChalkT>(db: &dyn HirDatabase, chalk: ChalkT) -> T
+pub(crate) type AssociatedTyValueId = chalk_solve::rust_ir::AssociatedTyValueId<Interner>;
-where
+pub(crate) type AssociatedTyValue = chalk_solve::rust_ir::AssociatedTyValue<Interner>;
-    T: ToChalk<Chalk = ChalkT>,
+pub(crate) type FnDefDatum = chalk_solve::rust_ir::FnDefDatum<Interner>;
-{
+pub(crate) type Variances = chalk_ir::Variances<Interner>;
-    T::from_chalk(db, chalk)
-}
 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)
            }
@@ -220,7 +210,8 @@ impl<'a> chalk_solve::RustIrDatabase<Interner> for ChalkContext<'a> {
                    let impl_bound = WhereClause::Implemented(TraitRef {
                        trait_id: to_chalk_trait_id(future_trait),
                        // Self type as the first parameter.
-                        substitution: Substitution::single(
+                        substitution: Substitution::from1(
+                            &Interner,
                            TyKind::BoundVar(BoundVar {
                                debruijn: DebruijnIndex::INNERMOST,
                                index: 0,
@@ -232,7 +223,8 @@ impl<'a> chalk_solve::RustIrDatabase<Interner> for ChalkContext<'a> {
                        alias: AliasTy::Projection(ProjectionTy {
                            associated_ty_id: to_assoc_type_id(future_output),
                            // Self type as the first parameter.
-                            substitution: Substitution::single(
+                            substitution: Substitution::from1(
+                                &Interner,
                                TyKind::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, 0))
                                    .intern(&Interner),
                            ),
@@ -242,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![
-                                wrap_in_empty_binders(impl_bound).to_chalk(self.db),
+                                crate::wrap_empty_binders(impl_bound),
-                                wrap_in_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)
                }
            }
        };
@@ -270,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 {
@@ -291,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 {
@@ -408,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)
 }
@@ -422,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());
@@ -444,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,
@@ -513,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)
@@ -561,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 };
@@ -583,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,
@@ -622,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),
@@ -643,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,
    };
@@ -686,42 +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,
    }
 }
-fn wrap_in_empty_binders<T: crate::TypeWalk>(value: T) -> crate::Binders<T> {
-    crate::Binders::wrap_empty(value)
-}
diff --git a/crates/hir_ty/src/chalk_ext.rs b/crates/hir_ty/src/chalk_ext.rs
index b7463366b..8c4542956 100644
--- a/crates/hir_ty/src/chalk_ext.rs
+++ b/crates/hir_ty/src/chalk_ext.rs
@@ -1,13 +1,305 @@
 //! Various extensions traits for Chalk types.
-use crate::{Interner, Ty, TyKind};
+use chalk_ir::Mutability;
+use hir_def::{
+    type_ref::Rawness, AssocContainerId, FunctionId, GenericDefId, HasModule, Lookup, TraitId,
+};
+use crate::{
+    db::HirDatabase, from_assoc_type_id, from_chalk_trait_id, from_foreign_def_id,
+    from_placeholder_idx, to_chalk_trait_id, AdtId, AliasEq, AliasTy, Binders, CallableDefId,
+    CallableSig, FnPointer, ImplTraitId, Interner, Lifetime, ProjectionTy, QuantifiedWhereClause,
+    Substitution, TraitRef, Ty, TyBuilder, TyKind, WhereClause,
+};
 pub trait TyExt {
    fn is_unit(&self) -> bool;
+    fn is_never(&self) -> bool;
+    fn is_unknown(&self) -> bool;
+    fn as_adt(&self) -> Option<(hir_def::AdtId, &Substitution)>;
+    fn as_tuple(&self) -> Option<&Substitution>;
+    fn as_fn_def(&self, db: &dyn HirDatabase) -> Option<FunctionId>;
+    fn as_reference(&self) -> Option<(&Ty, Lifetime, Mutability)>;
+    fn as_reference_or_ptr(&self) -> Option<(&Ty, Rawness, Mutability)>;
+    fn as_generic_def(&self, db: &dyn HirDatabase) -> Option<GenericDefId>;
+    fn callable_def(&self, db: &dyn HirDatabase) -> Option<CallableDefId>;
+    fn callable_sig(&self, db: &dyn HirDatabase) -> Option<CallableSig>;
+    fn strip_references(&self) -> &Ty;
+    /// If this is a `dyn Trait`, returns that trait.
+    fn dyn_trait(&self) -> Option<TraitId>;
+    fn impl_trait_bounds(&self, db: &dyn HirDatabase) -> Option<Vec<QuantifiedWhereClause>>;
+    fn associated_type_parent_trait(&self, db: &dyn HirDatabase) -> Option<TraitId>;
+    /// FIXME: Get rid of this, it's not a good abstraction
+    fn equals_ctor(&self, other: &Ty) -> bool;
 }
 impl TyExt for Ty {
    fn is_unit(&self) -> bool {
        matches!(self.kind(&Interner), TyKind::Tuple(0, _))
    }
+    fn is_never(&self) -> bool {
+        matches!(self.kind(&Interner), TyKind::Never)
+    }
+    fn is_unknown(&self) -> bool {
+        matches!(self.kind(&Interner), TyKind::Error)
+    }
+    fn as_adt(&self) -> Option<(hir_def::AdtId, &Substitution)> {
+        match self.kind(&Interner) {
+            TyKind::Adt(AdtId(adt), parameters) => Some((*adt, parameters)),
+            _ => None,
+        }
+    }
+    fn as_tuple(&self) -> Option<&Substitution> {
+        match self.kind(&Interner) {
+            TyKind::Tuple(_, substs) => Some(substs),
+            _ => None,
+        }
+    }
+    fn as_fn_def(&self, db: &dyn HirDatabase) -> Option<FunctionId> {
+        if let Some(CallableDefId::FunctionId(func)) = self.callable_def(db) {
+            Some(func)
+        } else {
+            None
+        }
+    }
+    fn as_reference(&self) -> Option<(&Ty, Lifetime, Mutability)> {
+        match self.kind(&Interner) {
+            TyKind::Ref(mutability, lifetime, ty) => Some((ty, lifetime.clone(), *mutability)),
+            _ => None,
+        }
+    }
+    fn as_reference_or_ptr(&self) -> Option<(&Ty, Rawness, Mutability)> {
+        match self.kind(&Interner) {
+            TyKind::Ref(mutability, _, ty) => Some((ty, Rawness::Ref, *mutability)),
+            TyKind::Raw(mutability, ty) => Some((ty, Rawness::RawPtr, *mutability)),
+            _ => None,
+        }
+    }
+    fn as_generic_def(&self, db: &dyn HirDatabase) -> Option<GenericDefId> {
+        match *self.kind(&Interner) {
+            TyKind::Adt(AdtId(adt), ..) => Some(adt.into()),
+            TyKind::FnDef(callable, ..) => {
+                Some(db.lookup_intern_callable_def(callable.into()).into())
+            }
+            TyKind::AssociatedType(type_alias, ..) => Some(from_assoc_type_id(type_alias).into()),
+            TyKind::Foreign(type_alias, ..) => Some(from_foreign_def_id(type_alias).into()),
+            _ => None,
+        }
+    }
+    fn callable_def(&self, db: &dyn HirDatabase) -> Option<CallableDefId> {
+        match self.kind(&Interner) {
+            &TyKind::FnDef(def, ..) => Some(db.lookup_intern_callable_def(def.into())),
+            _ => None,
+        }
+    }
+    fn callable_sig(&self, db: &dyn HirDatabase) -> Option<CallableSig> {
+        match self.kind(&Interner) {
+            TyKind::Function(fn_ptr) => Some(CallableSig::from_fn_ptr(fn_ptr)),
+            TyKind::FnDef(def, parameters) => {
+                let callable_def = db.lookup_intern_callable_def((*def).into());
+                let sig = db.callable_item_signature(callable_def);
+                Some(sig.substitute(&Interner, &parameters))
+            }
+            TyKind::Closure(.., substs) => {
+                let sig_param = substs.at(&Interner, 0).assert_ty_ref(&Interner);
+                sig_param.callable_sig(db)
+            }
+            _ => None,
+        }
+    }
+    fn dyn_trait(&self) -> Option<TraitId> {
+        let trait_ref = match self.kind(&Interner) {
+            TyKind::Dyn(dyn_ty) => dyn_ty.bounds.skip_binders().interned().get(0).and_then(|b| {
+                match b.skip_binders() {
+                    WhereClause::Implemented(trait_ref) => Some(trait_ref),
+                    _ => None,
+                }
+            }),
+            _ => None,
+        }?;
+        Some(from_chalk_trait_id(trait_ref.trait_id))
+    }
+    fn strip_references(&self) -> &Ty {
+        let mut t: &Ty = self;
+        while let TyKind::Ref(_mutability, _lifetime, ty) = t.kind(&Interner) {
+            t = ty;
+        }
+        t
+    }
+    fn impl_trait_bounds(&self, db: &dyn HirDatabase) -> Option<Vec<QuantifiedWhereClause>> {
+        match self.kind(&Interner) {
+            TyKind::OpaqueType(opaque_ty_id, ..) => {
+                match db.lookup_intern_impl_trait_id((*opaque_ty_id).into()) {
+                    ImplTraitId::AsyncBlockTypeImplTrait(def, _expr) => {
+                        let krate = def.module(db.upcast()).krate();
+                        if let Some(future_trait) = db
+                            .lang_item(krate, "future_trait".into())
+                            .and_then(|item| item.as_trait())
+                        {
+                            // This is only used by type walking.
+                            // Parameters will be walked outside, and projection predicate is not used.
+                            // So just provide the Future trait.
+                            let impl_bound = Binders::empty(
+                                &Interner,
+                                WhereClause::Implemented(TraitRef {
+                                    trait_id: to_chalk_trait_id(future_trait),
+                                    substitution: Substitution::empty(&Interner),
+                                }),
+                            );
+                            Some(vec![impl_bound])
+                        } else {
+                            None
+                        }
+                    }
+                    ImplTraitId::ReturnTypeImplTrait(..) => None,
+                }
+            }
+            TyKind::Alias(AliasTy::Opaque(opaque_ty)) => {
+                let predicates = match db.lookup_intern_impl_trait_id(opaque_ty.opaque_ty_id.into())
+                {
+                    ImplTraitId::ReturnTypeImplTrait(func, idx) => {
+                        db.return_type_impl_traits(func).map(|it| {
+                            let data = (*it)
+                                .as_ref()
+                                .map(|rpit| rpit.impl_traits[idx as usize].bounds.clone());
+                            data.substitute(&Interner, &opaque_ty.substitution)
+                        })
+                    }
+                    // It always has an parameter for Future::Output type.
+                    ImplTraitId::AsyncBlockTypeImplTrait(..) => unreachable!(),
+                };
+                predicates.map(|it| it.into_value_and_skipped_binders().0)
+            }
+            TyKind::Placeholder(idx) => {
+                let id = from_placeholder_idx(db, *idx);
+                let generic_params = db.generic_params(id.parent);
+                let param_data = &generic_params.types[id.local_id];
+                match param_data.provenance {
+                    hir_def::generics::TypeParamProvenance::ArgumentImplTrait => {
+                        let substs = TyBuilder::type_params_subst(db, id.parent);
+                        let predicates = db
+                            .generic_predicates(id.parent)
+                            .into_iter()
+                            .map(|pred| pred.clone().substitute(&Interner, &substs))
+                            .filter(|wc| match &wc.skip_binders() {
+                                WhereClause::Implemented(tr) => {
+                                    &tr.self_type_parameter(&Interner) == self
+                                }
+                                WhereClause::AliasEq(AliasEq {
+                                    alias: AliasTy::Projection(proj),
+                                    ty: _,
+                                }) => &proj.self_type_parameter(&Interner) == self,
+                                _ => false,
+                            })
+                            .collect::<Vec<_>>();
+                        Some(predicates)
+                    }
+                    _ => None,
+                }
+            }
+            _ => None,
+        }
+    }
+    fn associated_type_parent_trait(&self, db: &dyn HirDatabase) -> Option<TraitId> {
+        match self.kind(&Interner) {
+            TyKind::AssociatedType(id, ..) => {
+                match from_assoc_type_id(*id).lookup(db.upcast()).container {
+                    AssocContainerId::TraitId(trait_id) => Some(trait_id),
+                    _ => None,
+                }
+            }
+            TyKind::Alias(AliasTy::Projection(projection_ty)) => {
+                match from_assoc_type_id(projection_ty.associated_ty_id)
+                    .lookup(db.upcast())
+                    .container
+                {
+                    AssocContainerId::TraitId(trait_id) => Some(trait_id),
+                    _ => None,
+                }
+            }
+            _ => None,
+        }
+    }
+    fn equals_ctor(&self, other: &Ty) -> bool {
+        match (self.kind(&Interner), other.kind(&Interner)) {
+            (TyKind::Adt(adt, ..), TyKind::Adt(adt2, ..)) => adt == adt2,
+            (TyKind::Slice(_), TyKind::Slice(_)) | (TyKind::Array(_, _), TyKind::Array(_, _)) => {
+                true
+            }
+            (TyKind::FnDef(def_id, ..), TyKind::FnDef(def_id2, ..)) => def_id == def_id2,
+            (TyKind::OpaqueType(ty_id, ..), TyKind::OpaqueType(ty_id2, ..)) => ty_id == ty_id2,
+            (TyKind::AssociatedType(ty_id, ..), TyKind::AssociatedType(ty_id2, ..)) => {
+                ty_id == ty_id2
+            }
+            (TyKind::Foreign(ty_id, ..), TyKind::Foreign(ty_id2, ..)) => ty_id == ty_id2,
+            (TyKind::Closure(id1, _), TyKind::Closure(id2, _)) => id1 == id2,
+            (TyKind::Ref(mutability, ..), TyKind::Ref(mutability2, ..))
+            | (TyKind::Raw(mutability, ..), TyKind::Raw(mutability2, ..)) => {
+                mutability == mutability2
+            }
+            (
+                TyKind::Function(FnPointer { num_binders, sig, .. }),
+                TyKind::Function(FnPointer { num_binders: num_binders2, sig: sig2, .. }),
+            ) => num_binders == num_binders2 && sig == sig2,
+            (TyKind::Tuple(cardinality, _), TyKind::Tuple(cardinality2, _)) => {
+                cardinality == cardinality2
+            }
+            (TyKind::Str, TyKind::Str) | (TyKind::Never, TyKind::Never) => true,
+            (TyKind::Scalar(scalar), TyKind::Scalar(scalar2)) => scalar == scalar2,
+            _ => false,
+        }
+    }
+}
+pub trait ProjectionTyExt {
+    fn trait_ref(&self, db: &dyn HirDatabase) -> TraitRef;
+    fn trait_(&self, db: &dyn HirDatabase) -> TraitId;
+}
+impl ProjectionTyExt for ProjectionTy {
+    fn trait_ref(&self, db: &dyn HirDatabase) -> TraitRef {
+        TraitRef {
+            trait_id: to_chalk_trait_id(self.trait_(db)),
+            substitution: self.substitution.clone(),
+        }
+    }
+    fn trait_(&self, db: &dyn HirDatabase) -> TraitId {
+        match from_assoc_type_id(self.associated_ty_id).lookup(db.upcast()).container {
+            AssocContainerId::TraitId(it) => it,
+            _ => panic!("projection ty without parent trait"),
+        }
+    }
+}
+pub trait TraitRefExt {
+    fn hir_trait_id(&self) -> TraitId;
+}
+impl TraitRefExt for TraitRef {
+    fn hir_trait_id(&self) -> TraitId {
+        from_chalk_trait_id(self.trait_id)
+    }
 }
diff --git a/crates/hir_ty/src/db.rs b/crates/hir_ty/src/db.rs
index 4300680d9..1690926ad 100644
--- a/crates/hir_ty/src/db.rs
+++ b/crates/hir_ty/src/db.rs
@@ -1,18 +1,19 @@
-//! 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;
 use base_db::{impl_intern_key, salsa, CrateId, Upcast};
 use hir_def::{
    db::DefDatabase, expr::ExprId, ConstParamId, DefWithBodyId, FunctionId, GenericDefId, ImplId,
-    LocalFieldId, TypeParamId, VariantId,
+    LifetimeParamId, LocalFieldId, TypeParamId, VariantId,
 };
 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;
@@ -86,37 +87,46 @@ pub trait HirDatabase: DefDatabase + Upcast<dyn DefDatabase> {
    #[salsa::interned]
    fn intern_type_param_id(&self, param_id: TypeParamId) -> InternedTypeParamId;
    #[salsa::interned]
+    fn intern_lifetime_param_id(&self, param_id: LifetimeParamId) -> InternedLifetimeParamId;
+    #[salsa::interned]
+    fn intern_const_param_id(&self, param_id: ConstParamId) -> InternedConstParamId;
+    #[salsa::interned]
    fn intern_impl_trait_id(&self, id: ImplTraitId) -> InternedOpaqueTyId;
    #[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(
@@ -125,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> {
@@ -156,6 +166,14 @@ pub struct InternedTypeParamId(salsa::InternId);
 impl_intern_key!(InternedTypeParamId);
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct InternedLifetimeParamId(salsa::InternId);
+impl_intern_key!(InternedLifetimeParamId);
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct InternedConstParamId(salsa::InternId);
+impl_intern_key!(InternedConstParamId);
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct InternedOpaqueTyId(salsa::InternId);
 impl_intern_key!(InternedOpaqueTyId);
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/diagnostics/expr.rs b/crates/hir_ty/src/diagnostics/expr.rs
index db278d0db..79602c3dd 100644
--- a/crates/hir_ty/src/diagnostics/expr.rs
+++ b/crates/hir_ty/src/diagnostics/expr.rs
@@ -14,7 +14,6 @@ use crate::{
        MismatchedArgCount, MissingFields, MissingMatchArms, MissingOkOrSomeInTailExpr,
        MissingPatFields, RemoveThisSemicolon,
    },
-    utils::variant_data,
    AdtId, InferenceResult, Interner, TyExt, TyKind,
 };
@@ -104,7 +103,7 @@ impl<'a, 'b> ExprValidator<'a, 'b> {
            let root = source_ptr.file_syntax(db.upcast());
            if let ast::Expr::RecordExpr(record_expr) = &source_ptr.value.to_node(&root) {
                if let Some(_) = record_expr.record_expr_field_list() {
-                    let variant_data = variant_data(db.upcast(), variant_def);
+                    let variant_data = variant_def.variant_data(db.upcast());
                    let missed_fields = missed_fields
                        .into_iter()
                        .map(|idx| variant_data.fields()[idx].name.clone())
@@ -135,7 +134,7 @@ impl<'a, 'b> ExprValidator<'a, 'b> {
                let root = source_ptr.file_syntax(db.upcast());
                if let ast::Pat::RecordPat(record_pat) = expr.to_node(&root) {
                    if let Some(_) = record_pat.record_pat_field_list() {
-                        let variant_data = variant_data(db.upcast(), variant_def);
+                        let variant_data = variant_def.variant_data(db.upcast());
                        let missed_fields = missed_fields
                            .into_iter()
                            .map(|idx| variant_data.fields()[idx].name.clone())
@@ -315,7 +314,7 @@ impl<'a, 'b> ExprValidator<'a, 'b> {
                if pat_ty == match_expr_ty
                    || match_expr_ty
                        .as_reference()
-                        .map(|(match_expr_ty, _)| match_expr_ty == pat_ty)
+                        .map(|(match_expr_ty, ..)| match_expr_ty == pat_ty)
                        .unwrap_or(false)
                {
                    // If we had a NotUsefulMatchArm diagnostic, we could
@@ -453,7 +452,7 @@ pub fn record_literal_missing_fields(
        return None;
    }
-    let variant_data = variant_data(db.upcast(), variant_def);
+    let variant_data = variant_def.variant_data(db.upcast());
    let specified_fields: FxHashSet<_> = fields.iter().map(|f| &f.name).collect();
    let missed_fields: Vec<LocalFieldId> = variant_data
@@ -483,7 +482,7 @@ pub fn record_pattern_missing_fields(
        return None;
    }
-    let variant_data = variant_data(db.upcast(), variant_def);
+    let variant_data = variant_def.variant_data(db.upcast());
    let specified_fields: FxHashSet<_> = fields.iter().map(|f| &f.name).collect();
    let missed_fields: Vec<LocalFieldId> = variant_data
diff --git a/crates/hir_ty/src/diagnostics/match_check.rs b/crates/hir_ty/src/diagnostics/match_check.rs
index 34291578a..e9762622f 100644
--- a/crates/hir_ty/src/diagnostics/match_check.rs
+++ b/crates/hir_ty/src/diagnostics/match_check.rs
@@ -227,7 +227,7 @@ use hir_def::{
 use la_arena::Idx;
 use smallvec::{smallvec, SmallVec};
-use crate::{db::HirDatabase, AdtId, InferenceResult, Interner, TyKind};
+use crate::{db::HirDatabase, AdtId, InferenceResult, Interner, TyExt, TyKind};
 #[derive(Debug, Clone, Copy)]
 /// Either a pattern from the source code being analyzed, represented as
diff --git a/crates/hir_ty/src/diagnostics/unsafe_check.rs b/crates/hir_ty/src/diagnostics/unsafe_check.rs
index b5efe9df5..ed97dc0e3 100644
--- a/crates/hir_ty/src/diagnostics/unsafe_check.rs
+++ b/crates/hir_ty/src/diagnostics/unsafe_check.rs
@@ -11,7 +11,9 @@ use hir_def::{
 };
 use hir_expand::diagnostics::DiagnosticSink;
-use crate::{db::HirDatabase, diagnostics::MissingUnsafe, InferenceResult, Interner, TyKind};
+use crate::{
+    db::HirDatabase, diagnostics::MissingUnsafe, InferenceResult, Interner, TyExt, TyKind,
+};
 pub(super) struct UnsafeValidator<'a, 'b: 'a> {
    owner: DefWithBodyId,
diff --git a/crates/hir_ty/src/display.rs b/crates/hir_ty/src/display.rs
index f31e6b108..e7c9dabc2 100644
--- a/crates/hir_ty/src/display.rs
+++ b/crates/hir_ty/src/display.rs
@@ -1,8 +1,13 @@
-//! 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, fmt};
+use std::{
+    array,
+    fmt::{self, Debug},
+};
-use chalk_ir::Mutability;
+use chalk_ir::BoundVar;
 use hir_def::{
    db::DefDatabase,
    find_path,
@@ -16,10 +21,12 @@ use hir_def::{
 use hir_expand::name::Name;
 use crate::{
-    db::HirDatabase, from_assoc_type_id, from_foreign_def_id, from_placeholder_idx, primitive,
+    const_from_placeholder_idx, db::HirDatabase, from_assoc_type_id, from_foreign_def_id,
-    to_assoc_type_id, traits::chalk::from_chalk, utils::generics, AdtId, AliasEq, AliasTy,
+    from_placeholder_idx, lt_from_placeholder_idx, mapping::from_chalk, primitive, subst_prefix,
-    CallableDefId, CallableSig, DomainGoal, GenericArg, ImplTraitId, Interner, Lifetime, OpaqueTy,
+    to_assoc_type_id, utils::generics, AdtId, AliasEq, AliasTy, CallableDefId, CallableSig, Const,
-    ProjectionTy, QuantifiedWhereClause, Scalar, TraitRef, Ty, TyExt, TyKind, WhereClause,
+    ConstValue, DomainGoal, GenericArg, ImplTraitId, Interner, Lifetime, LifetimeData,
+    LifetimeOutlives, Mutability, OpaqueTy, ProjectionTy, ProjectionTyExt, QuantifiedWhereClause,
+    Scalar, TraitRef, TraitRefExt, Ty, TyExt, TyKind, WhereClause,
 };
 pub struct HirFormatter<'a> {
@@ -46,6 +53,10 @@ pub trait HirDisplay {
    where
        Self: Sized,
    {
+        assert!(
+            !matches!(display_target, DisplayTarget::SourceCode { .. }),
+            "HirDisplayWrapper cannot fail with DisplaySourceCodeError, use HirDisplay::hir_fmt directly instead"
+        );
        HirDisplayWrapper { db, t: self, max_size, omit_verbose_types, display_target }
    }
@@ -230,7 +241,7 @@ where
            Err(HirDisplayError::FmtError) => Err(fmt::Error),
            Err(HirDisplayError::DisplaySourceCodeError(_)) => {
                // This should never happen
-                panic!("HirDisplay failed when calling Display::fmt!")
+                panic!("HirDisplay::hir_fmt failed with DisplaySourceCodeError when calling Display::fmt!")
            }
        }
    }
@@ -251,16 +262,12 @@ impl HirDisplay for ProjectionTy {
        }
        let trait_ = f.db.trait_data(self.trait_(f.db));
-        let first_parameter = self.self_type_parameter(&Interner).into_displayable(
+        write!(f, "<")?;
-            f.db,
+        self.self_type_parameter(&Interner).hir_fmt(f)?;
-            f.max_size,
+        write!(f, " as {}", trait_.name)?;
-            f.omit_verbose_types,
-            f.display_target,
-        );
-        write!(f, "<{} as {}", first_parameter, 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)?;
@@ -282,10 +289,35 @@ 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),
+        }
+    }
+}
+impl HirDisplay for Const {
+    fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
+        let data = self.interned();
+        match data.value {
+            ConstValue::BoundVar(idx) => idx.hir_fmt(f),
+            ConstValue::InferenceVar(..) => write!(f, "_"),
+            ConstValue::Placeholder(idx) => {
+                let id = const_from_placeholder_idx(f.db, idx);
+                let generics = generics(f.db.upcast(), id.parent);
+                let param_data = &generics.params.consts[id.local_id];
+                write!(f, "{}", param_data.name)
+            }
+            ConstValue::Concrete(_) => write!(f, "_"),
        }
    }
 }
+impl HirDisplay for BoundVar {
+    fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
+        write!(f, "?{}.{}", self.debruijn.depth(), self.index)
+    }
+}
 impl HirDisplay for Ty {
    fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
        if f.should_truncate() {
@@ -305,15 +337,14 @@ impl HirDisplay for Ty {
                t.hir_fmt(f)?;
                write!(f, "]")?;
            }
-            TyKind::Array(t) => {
+            TyKind::Array(t, c) => {
                write!(f, "[")?;
                t.hir_fmt(f)?;
-                write!(f, "; _]")?;
+                write!(f, "; ")?;
+                c.hir_fmt(f)?;
+                write!(f, "]")?;
            }
-            TyKind::Raw(m, t) | TyKind::Ref(m, t) => {
+            TyKind::Raw(m, t) | TyKind::Ref(m, _, t) => {
-                let ty_display =
-                    t.into_displayable(f.db, f.max_size, f.omit_verbose_types, f.display_target);
                if matches!(self.kind(&Interner), TyKind::Raw(..)) {
                    write!(
                        f,
@@ -368,16 +399,16 @@ impl HirDisplay for Ty {
                    if fn_traits(f.db.upcast(), trait_).any(|it| it == trait_)
                        && predicates.len() <= 2
                    {
-                        return write!(f, "{}", ty_display);
+                        return t.hir_fmt(f);
                    }
                }
                if predicates.len() > 1 {
                    write!(f, "(")?;
-                    write!(f, "{}", ty_display)?;
+                    t.hir_fmt(f)?;
                    write!(f, ")")?;
                } else {
-                    write!(f, "{}", ty_display)?;
+                    t.hir_fmt(f)?;
                }
            }
            TyKind::Tuple(_, substs) => {
@@ -387,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, ")")?;
                }
            }
@@ -415,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, ">")?;
                    }
                }
@@ -424,14 +455,8 @@ impl HirDisplay for Ty {
                write!(f, ")")?;
                let ret = sig.ret();
                if !ret.is_unit() {
-                    let ret_display = ret.into_displayable(
+                    write!(f, " -> ")?;
-                        f.db,
+                    ret.hir_fmt(f)?;
-                        f.max_size,
-                        f.omit_verbose_types,
-                        f.display_target,
-                    );
-                    write!(f, " -> {}", ret_display)?;
                }
            }
            TyKind::Adt(AdtId(def_id), parameters) => {
@@ -468,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() {
@@ -480,9 +505,11 @@ impl HirDisplay for Ty {
                                            default_from = i + 1;
                                        }
                                        (_, Some(default_parameter)) => {
-                                            let actual_default = default_parameter
+                                            let actual_default =
-                                                .clone()
+                                                default_parameter.clone().substitute(
-                                                .substitute(&Interner, &parameters.prefix(i));
+                                                    &Interner,
+                                                    &subst_prefix(parameters, i),
+                                                );
                                            if parameter.assert_ty_ref(&Interner) != &actual_default
                                            {
                                                default_from = i + 1;
@@ -490,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, "<")?;
@@ -517,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 {
@@ -571,13 +598,8 @@ impl HirDisplay for Ty {
                        write!(f, "|")?;
                    };
-                    let ret_display = sig.ret().into_displayable(
+                    write!(f, " -> ")?;
-                        f.db,
+                    sig.ret().hir_fmt(f)?;
-                        f.max_size,
-                        f.omit_verbose_types,
-                        f.display_target,
-                    );
-                    write!(f, " -> {}", ret_display)?;
                } else {
                    write!(f, "{{closure}}")?;
                }
@@ -598,12 +620,12 @@ impl HirDisplay for Ty {
                                .map(|pred| pred.clone().substitute(&Interner, &substs))
                                .filter(|wc| match &wc.skip_binders() {
                                    WhereClause::Implemented(tr) => {
-                                        tr.self_type_parameter(&Interner) == self
+                                        &tr.self_type_parameter(&Interner) == self
                                    }
                                    WhereClause::AliasEq(AliasEq {
                                        alias: AliasTy::Projection(proj),
                                        ty: _,
-                                    }) => proj.self_type_parameter(&Interner) == self,
+                                    }) => &proj.self_type_parameter(&Interner) == self,
                                    _ => false,
                                })
                                .collect::<Vec<_>>();
@@ -611,7 +633,7 @@ impl HirDisplay for Ty {
                    }
                }
            }
-            TyKind::BoundVar(idx) => write!(f, "?{}.{}", idx.debruijn.depth(), idx.index)?,
+            TyKind::BoundVar(idx) => idx.hir_fmt(f)?,
            TyKind::Dyn(dyn_ty) => {
                write_bounds_like_dyn_trait_with_prefix(
                    "dyn",
@@ -646,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(())
    }
@@ -665,9 +689,8 @@ impl HirDisplay for CallableSig {
        write!(f, ")")?;
        let ret = self.ret();
        if !ret.is_unit() {
-            let ret_display =
+            write!(f, " -> ")?;
-                ret.into_displayable(f.db, f.max_size, f.omit_verbose_types, f.display_target);
+            ret.hir_fmt(f)?;
-            write!(f, " -> {}", ret_display)?;
        }
        Ok(())
    }
@@ -724,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() {
+                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() {
@@ -766,6 +789,10 @@ fn write_bounds_like_dyn_trait(
                }
                ty.hir_fmt(f)?;
            }
+            // FIXME implement these
+            WhereClause::LifetimeOutlives(_) => {}
+            WhereClause::TypeOutlives(_) => {}
        }
        first = false;
    }
@@ -775,31 +802,29 @@ fn write_bounds_like_dyn_trait(
    Ok(())
 }
-impl TraitRef {
+fn fmt_trait_ref(tr: &TraitRef, f: &mut HirFormatter, use_as: bool) -> Result<(), HirDisplayError> {
-    fn hir_fmt_ext(&self, f: &mut HirFormatter, use_as: bool) -> Result<(), HirDisplayError> {
+    if f.should_truncate() {
-        if f.should_truncate() {
+        return write!(f, "{}", TYPE_HINT_TRUNCATION);
-            return write!(f, "{}", TYPE_HINT_TRUNCATION);
+    }
-        }
-        self.self_type_parameter(&Interner).hir_fmt(f)?;
+    tr.self_type_parameter(&Interner).hir_fmt(f)?;
-        if use_as {
+    if use_as {
-            write!(f, " as ")?;
+        write!(f, " as ")?;
-        } else {
+    } else {
-            write!(f, ": ")?;
+        write!(f, ": ")?;
-        }
-        write!(f, "{}", f.db.trait_data(self.hir_trait_id()).name)?;
-        if self.substitution.len(&Interner) > 1 {
-            write!(f, "<")?;
-            f.write_joined(&self.substitution.interned()[1..], ", ")?;
-            write!(f, ">")?;
-        }
-        Ok(())
    }
+    write!(f, "{}", f.db.trait_data(tr.hir_trait_id()).name)?;
+    if tr.substitution.len(&Interner) > 1 {
+        write!(f, "<")?;
+        f.write_joined(&tr.substitution.as_slice(&Interner)[1..], ", ")?;
+        write!(f, ">")?;
+    }
+    Ok(())
 }
 impl HirDisplay for TraitRef {
    fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
-        self.hir_fmt_ext(f, false)
+        fmt_trait_ref(self, f, false)
    }
 }
@@ -813,7 +838,7 @@ impl HirDisplay for WhereClause {
            WhereClause::Implemented(trait_ref) => trait_ref.hir_fmt(f)?,
            WhereClause::AliasEq(AliasEq { alias: AliasTy::Projection(projection_ty), ty }) => {
                write!(f, "<")?;
-                projection_ty.trait_ref(f.db).hir_fmt_ext(f, true)?;
+                fmt_trait_ref(&projection_ty.trait_ref(f.db), f, true)?;
                write!(
                    f,
                    ">::{} = ",
@@ -822,20 +847,44 @@ impl HirDisplay for WhereClause {
                ty.hir_fmt(f)?;
            }
            WhereClause::AliasEq(_) => write!(f, "{{error}}")?,
+            // FIXME implement these
+            WhereClause::TypeOutlives(..) => {}
+            WhereClause::LifetimeOutlives(..) => {}
        }
        Ok(())
    }
 }
+impl HirDisplay for LifetimeOutlives {
+    fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
+        self.a.hir_fmt(f)?;
+        write!(f, ": ")?;
+        self.b.hir_fmt(f)
+    }
+}
 impl HirDisplay for Lifetime {
    fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
+        self.interned().hir_fmt(f)
+    }
+}
+impl HirDisplay for LifetimeData {
+    fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
        match self {
-            Lifetime::Parameter(id) => {
+            LifetimeData::BoundVar(idx) => idx.hir_fmt(f),
+            LifetimeData::InferenceVar(_) => write!(f, "_"),
+            LifetimeData::Placeholder(idx) => {
+                let id = lt_from_placeholder_idx(f.db, *idx);
                let generics = generics(f.db.upcast(), id.parent);
                let param_data = &generics.params.lifetimes[id.local_id];
-                write!(f, "{}", &param_data.name)
+                write!(f, "{}", param_data.name)
            }
-            Lifetime::Static => write!(f, "'static"),
+            LifetimeData::Static => write!(f, "'static"),
+            LifetimeData::Empty(_) => Ok(()),
+            LifetimeData::Erased => Ok(()),
+            LifetimeData::Phantom(_, _) => Ok(()),
        }
    }
 }
@@ -846,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 1c3faf5cb..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, Interner, TyBuilder, 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.
@@ -131,10 +131,7 @@ pub struct InferenceResult {
    method_resolutions: FxHashMap<ExprId, FunctionId>,
    /// For each field access expr, records the field it resolves to.
    field_resolutions: FxHashMap<ExprId, FieldId>,
-    /// For each field in record literal, records the field it resolves to.
+    /// For each struct literal or pattern, records the variant it resolves to.
-    record_field_resolutions: FxHashMap<ExprId, FieldId>,
-    record_pat_field_resolutions: FxHashMap<PatId, FieldId>,
-    /// For each struct literal, records the variant it resolves to.
    variant_resolutions: FxHashMap<ExprOrPatId, VariantId>,
    /// For each associated item record what it resolves to
    assoc_resolutions: FxHashMap<ExprOrPatId, AssocItemId>,
@@ -153,12 +150,6 @@ impl InferenceResult {
    pub fn field_resolution(&self, expr: ExprId) -> Option<FieldId> {
        self.field_resolutions.get(&expr).copied()
    }
-    pub fn record_field_resolution(&self, expr: ExprId) -> Option<FieldId> {
-        self.record_field_resolutions.get(&expr).copied()
-    }
-    pub fn record_pat_field_resolution(&self, pat: PatId) -> Option<FieldId> {
-        self.record_pat_field_resolutions.get(&pat).copied()
-    }
    pub fn variant_resolution_for_expr(&self, id: ExprId) -> Option<VariantId> {
        self.variant_resolutions.get(&id.into()).copied()
    }
@@ -332,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) {
@@ -345,17 +336,24 @@ impl<'a> InferenceContext<'a> {
        self.last_obligations_check = Some(self.table.revision);
        let obligations = mem::replace(&mut self.obligations, Vec::new());
        for obligation in obligations {
-            let in_env = InEnvironment::new(self.trait_env.env.clone(), obligation.clone());
+            let in_env = InEnvironment::new(&self.trait_env.env, obligation.clone());
            let canonicalized = self.canonicalizer().canonicalize_obligation(in_env);
            let solution =
                self.db.trait_solve(self.resolver.krate().unwrap(), canonicalized.value.clone());
            match solution {
-                Some(Solution::Unique(substs)) => {
+                Some(Solution::Unique(canonical_subst)) => {
-                    canonicalized.apply_solution(self, substs.0);
+                    canonicalized.apply_solution(
+                        self,
+                        Canonical {
+                            binders: canonical_subst.binders,
+                            // FIXME: handle constraints
+                            value: canonical_subst.value.subst,
+                        },
+                    );
                }
                Some(Solution::Ambig(Guidance::Definite(substs))) => {
-                    canonicalized.apply_solution(self, substs.0);
+                    canonicalized.apply_solution(self, substs);
                    self.obligations.push(obligation);
                }
                Some(_) => {
@@ -436,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 {
@@ -489,36 +491,13 @@ impl<'a> InferenceContext<'a> {
                let generics = crate::utils::generics(self.db.upcast(), impl_id.into());
                let substs = generics.type_params_subst(self.db);
                let ty = self.db.impl_self_ty(impl_id).substitute(&Interner, &substs);
-                match unresolved {
+                self.resolve_variant_on_alias(ty, unresolved, path)
-                    None => {
-                        let variant = ty_variant(&ty);
-                        (ty, variant)
-                    }
-                    Some(1) => {
-                        let segment = path.mod_path().segments().last().unwrap();
-                        // this could be an enum variant or associated type
-                        if let Some((AdtId::EnumId(enum_id), _)) = ty.as_adt() {
-                            let enum_data = self.db.enum_data(enum_id);
-                            if let Some(local_id) = enum_data.variant(segment) {
-                                let variant = EnumVariantId { parent: enum_id, local_id };
-                                return (ty, Some(variant.into()));
-                            }
-                        }
-                        // FIXME potentially resolve assoc type
-                        (self.err_ty(), None)
-                    }
-                    Some(_) => {
-                        // FIXME diagnostic
-                        (self.err_ty(), None)
-                    }
-                }
            }
            TypeNs::TypeAliasId(it) => {
                let ty = TyBuilder::def_ty(self.db, it.into())
                    .fill(std::iter::repeat_with(|| self.table.new_type_var()))
                    .build();
-                let variant = ty_variant(&ty);
+                self.resolve_variant_on_alias(ty, unresolved, path)
-                forbid_unresolved_segments((ty, variant), unresolved)
            }
            TypeNs::AdtSelfType(_) => {
                // FIXME this could happen in array size expressions, once we're checking them
@@ -545,16 +524,43 @@ impl<'a> InferenceContext<'a> {
                (TyKind::Error.intern(&Interner), None)
            }
        }
+    }
-        fn ty_variant(ty: &Ty) -> Option<VariantId> {
+    fn resolve_variant_on_alias(
-            ty.as_adt().and_then(|(adt_id, _)| match adt_id {
+        &mut self,
-                AdtId::StructId(s) => Some(VariantId::StructId(s)),
+        ty: Ty,
-                AdtId::UnionId(u) => Some(VariantId::UnionId(u)),
+        unresolved: Option<usize>,
-                AdtId::EnumId(_) => {
+        path: &Path,
-                    // FIXME Error E0071, expected struct, variant or union type, found enum `Foo`
+    ) -> (Ty, Option<VariantId>) {
-                    None
+        match unresolved {
+            None => {
+                let variant = ty.as_adt().and_then(|(adt_id, _)| match adt_id {
+                    AdtId::StructId(s) => Some(VariantId::StructId(s)),
+                    AdtId::UnionId(u) => Some(VariantId::UnionId(u)),
+                    AdtId::EnumId(_) => {
+                        // FIXME Error E0071, expected struct, variant or union type, found enum `Foo`
+                        None
+                    }
+                });
+                (ty, variant)
+            }
+            Some(1) => {
+                let segment = path.mod_path().segments().last().unwrap();
+                // this could be an enum variant or associated type
+                if let Some((AdtId::EnumId(enum_id), _)) = ty.as_adt() {
+                    let enum_data = self.db.enum_data(enum_id);
+                    if let Some(local_id) = enum_data.variant(segment) {
+                        let variant = EnumVariantId { parent: enum_id, local_id };
+                        return (ty, Some(variant.into()));
+                    }
                }
-            })
+                // FIXME potentially resolve assoc type
+                (self.err_ty(), None)
+            }
+            Some(_) => {
+                // FIXME diagnostic
+                (self.err_ty(), None)
+            }
        }
    }
@@ -692,25 +698,6 @@ impl<'a> InferenceContext<'a> {
    }
 }
-/// 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 InferenceVar {
-    fn to_inner(self) -> unify::TypeVarId {
-        unify::TypeVarId(self.index)
-    }
-    fn from_inner(unify::TypeVarId(index): unify::TypeVarId) -> Self {
-        InferenceVar { index }
-    }
-}
 /// When inferring an expression, we propagate downward whatever type hint we
 /// are able in the form of an `Expectation`.
 #[derive(Clone, PartialEq, Eq, Debug)]
diff --git a/crates/hir_ty/src/infer/coerce.rs b/crates/hir_ty/src/infer/coerce.rs
index 32c273afc..1f463a425 100644
--- a/crates/hir_ty/src/infer/coerce.rs
+++ b/crates/hir_ty/src/infer/coerce.rs
@@ -7,7 +7,7 @@
 use chalk_ir::{cast::Cast, Mutability, TyVariableKind};
 use hir_def::lang_item::LangItemTarget;
-use crate::{autoderef, Interner, Solution, Ty, TyBuilder, TyKind};
+use crate::{autoderef, Canonical, Interner, Solution, Ty, TyBuilder, TyExt, TyKind};
 use super::{InEnvironment, InferenceContext};
@@ -71,17 +71,19 @@ 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`
            (TyKind::Ref(.., substs), &TyKind::Raw(m2 @ Mutability::Not, ..))
-            | (TyKind::Ref(Mutability::Mut, substs), &TyKind::Raw(m2, ..)) => {
+            | (TyKind::Ref(Mutability::Mut, _, substs), &TyKind::Raw(m2, ..)) => {
                from_ty = TyKind::Raw(m2, substs.clone()).intern(&Interner);
            }
@@ -111,7 +113,9 @@ impl<'a> InferenceContext<'a> {
        // Auto Deref if cannot coerce
        match (from_ty.kind(&Interner), to_ty.kind(&Interner)) {
            // FIXME: DerefMut
-            (TyKind::Ref(_, st1), TyKind::Ref(_, st2)) => self.unify_autoderef_behind_ref(st1, st2),
+            (TyKind::Ref(.., st1), TyKind::Ref(.., st2)) => {
+                self.unify_autoderef_behind_ref(st1, st2)
+            }
            // Otherwise, normal unify
            _ => self.unify(&from_ty, to_ty),
@@ -137,7 +141,7 @@ impl<'a> InferenceContext<'a> {
            b.push(from_ty.clone()).push(to_ty.clone()).build()
        };
-        let goal = InEnvironment::new(self.trait_env.env.clone(), trait_ref.cast(&Interner));
+        let goal = InEnvironment::new(&self.trait_env.env, trait_ref.cast(&Interner));
        let canonicalizer = self.canonicalizer();
        let canonicalized = canonicalizer.canonicalize_obligation(goal);
@@ -146,7 +150,14 @@ impl<'a> InferenceContext<'a> {
        match solution {
            Solution::Unique(v) => {
-                canonicalized.apply_solution(self, v.0);
+                canonicalized.apply_solution(
+                    self,
+                    Canonical {
+                        binders: v.binders,
+                        // FIXME handle constraints
+                        value: v.value.subst,
+                    },
+                );
            }
            _ => return None,
        };
diff --git a/crates/hir_ty/src/infer/expr.rs b/crates/hir_ty/src/infer/expr.rs
index 6966d26e7..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},
@@ -15,15 +15,16 @@ use stdx::always;
 use syntax::ast::RangeOp;
 use crate::{
-    autoderef,
+    autoderef, dummy_usize_const,
    lower::lower_to_chalk_mutability,
+    mapping::from_chalk,
    method_resolution, op,
    primitive::{self, UintTy},
-    to_chalk_trait_id,
+    static_lifetime, to_chalk_trait_id,
-    traits::{chalk::from_chalk, FnTrait},
+    traits::FnTrait,
-    utils::{generics, variant_data, Generics},
+    utils::{generics, Generics},
-    AdtId, Binders, CallableDefId, FnPointer, FnSig, InEnvironment, Interner, Rawness, Scalar,
+    AdtId, Binders, CallableDefId, FnPointer, FnSig, FnSubst, InEnvironment, Interner,
-    Substitution, TraitRef, Ty, TyBuilder, TyKind,
+    ProjectionTyExt, Rawness, Scalar, Substitution, TraitRef, Ty, TyBuilder, TyExt, TyKind,
 };
 use super::{
@@ -180,7 +181,8 @@ impl<'a> InferenceContext<'a> {
                let inner_ty = self.infer_expr(*body, &Expectation::none());
                let impl_trait_id = crate::ImplTraitId::AsyncBlockTypeImplTrait(self.owner, *body);
                let opaque_ty_id = self.db.intern_impl_trait_id(impl_trait_id).into();
-                TyKind::OpaqueType(opaque_ty_id, Substitution::single(inner_ty)).intern(&Interner)
+                TyKind::OpaqueType(opaque_ty_id, Substitution::from1(&Interner, inner_ty))
+                    .intern(&Interner)
            }
            Expr::Loop { body, label } => {
                self.breakables.push(BreakableContext {
@@ -259,14 +261,17 @@ impl<'a> InferenceContext<'a> {
                };
                sig_tys.push(ret_ty.clone());
                let sig_ty = TyKind::Function(FnPointer {
-                    num_args: sig_tys.len() - 1,
+                    num_binders: 0,
                    sig: FnSig { abi: (), safety: chalk_ir::Safety::Safe, variadic: false },
-                    substs: Substitution::from_iter(&Interner, sig_tys.clone()),
+                    substitution: FnSubst(
+                        Substitution::from_iter(&Interner, sig_tys.clone()).shifted_in(&Interner),
+                    ),
                })
                .intern(&Interner);
                let closure_id = self.db.intern_closure((self.owner, tgt_expr)).into();
                let closure_ty =
-                    TyKind::Closure(closure_id, Substitution::single(sig_ty)).intern(&Interner);
+                    TyKind::Closure(closure_id, Substitution::from1(&Interner, sig_ty))
+                        .intern(&Interner);
                // Eagerly try to relate the closure type with the expected
                // type, otherwise we often won't have enough information to
@@ -313,7 +318,13 @@ impl<'a> InferenceContext<'a> {
                self.normalize_associated_types_in(ret_ty)
            }
            Expr::MethodCall { receiver, args, method_name, generic_args } => self
-                .infer_method_call(tgt_expr, *receiver, &args, &method_name, generic_args.as_ref()),
+                .infer_method_call(
+                    tgt_expr,
+                    *receiver,
+                    &args,
+                    &method_name,
+                    generic_args.as_deref(),
+                ),
            Expr::Match { expr, arms } => {
                let input_ty = self.infer_expr(*expr, &Expectation::none());
@@ -394,16 +405,19 @@ impl<'a> InferenceContext<'a> {
                TyKind::Never.intern(&Interner)
            }
            Expr::RecordLit { path, fields, spread } => {
-                let (ty, def_id) = self.resolve_variant(path.as_ref());
+                let (ty, def_id) = self.resolve_variant(path.as_deref());
                if let Some(variant) = def_id {
                    self.write_variant_resolution(tgt_expr.into(), variant);
                }
                self.unify(&ty, &expected.ty);
-                let substs = ty.substs().cloned().unwrap_or_else(|| Substitution::empty(&Interner));
+                let substs = ty
+                    .as_adt()
+                    .map(|(_, s)| s.clone())
+                    .unwrap_or_else(|| Substitution::empty(&Interner));
                let field_types = def_id.map(|it| self.db.field_types(it)).unwrap_or_default();
-                let variant_data = def_id.map(|it| variant_data(self.db.upcast(), it));
+                let variant_data = def_id.map(|it| it.variant_data(self.db.upcast()));
                for field in fields.iter() {
                    let field_def =
                        variant_data.as_ref().and_then(|it| match it.field(&field.name) {
@@ -415,9 +429,6 @@ impl<'a> InferenceContext<'a> {
                                None
                            }
                        });
-                    if let Some(field_def) = field_def {
-                        self.result.record_field_resolutions.insert(field.expr, field_def);
-                    }
                    let field_ty = field_def.map_or(self.err_ty(), |it| {
                        field_types[it.local_id].clone().substitute(&Interner, &substs)
                    });
@@ -452,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)?;
@@ -523,7 +538,7 @@ impl<'a> InferenceContext<'a> {
                let inner_ty = self.infer_expr_inner(*expr, &expectation);
                match rawness {
                    Rawness::RawPtr => TyKind::Raw(mutability, inner_ty),
-                    Rawness::Ref => TyKind::Ref(mutability, inner_ty),
+                    Rawness::Ref => TyKind::Ref(mutability, static_lifetime(), inner_ty),
                }
                .intern(&Interner)
            }
@@ -698,7 +713,7 @@ impl<'a> InferenceContext<'a> {
            }
            Expr::Array(array) => {
                let elem_ty = match expected.ty.kind(&Interner) {
-                    TyKind::Array(st) | TyKind::Slice(st) => st.clone(),
+                    TyKind::Array(st, _) | TyKind::Slice(st) => st.clone(),
                    _ => self.table.new_type_var(),
                };
@@ -722,17 +737,19 @@ impl<'a> InferenceContext<'a> {
                    }
                }
-                TyKind::Array(elem_ty).intern(&Interner)
+                TyKind::Array(elem_ty, dummy_usize_const()).intern(&Interner)
            }
            Expr::Literal(lit) => match lit {
                Literal::Bool(..) => TyKind::Scalar(Scalar::Bool).intern(&Interner),
                Literal::String(..) => {
-                    TyKind::Ref(Mutability::Not, TyKind::Str.intern(&Interner)).intern(&Interner)
+                    TyKind::Ref(Mutability::Not, static_lifetime(), TyKind::Str.intern(&Interner))
+                        .intern(&Interner)
                }
                Literal::ByteString(..) => {
                    let byte_type = TyKind::Scalar(Scalar::Uint(UintTy::U8)).intern(&Interner);
-                    let array_type = TyKind::Array(byte_type).intern(&Interner);
+                    let array_type =
-                    TyKind::Ref(Mutability::Not, array_type).intern(&Interner)
+                        TyKind::Array(byte_type, dummy_usize_const()).intern(&Interner);
+                    TyKind::Ref(Mutability::Not, static_lifetime(), array_type).intern(&Interner)
                }
                Literal::Char(..) => TyKind::Scalar(Scalar::Char).intern(&Interner),
                Literal::Int(_v, ty) => match ty {
@@ -868,7 +885,9 @@ impl<'a> InferenceContext<'a> {
        // Apply autoref so the below unification works correctly
        // FIXME: return correct autorefs from lookup_method
        let actual_receiver_ty = match expected_receiver_ty.as_reference() {
-            Some((_, mutability)) => TyKind::Ref(mutability, derefed_receiver_ty).intern(&Interner),
+            Some((_, lifetime, mutability)) => {
+                TyKind::Ref(mutability, lifetime, derefed_receiver_ty).intern(&Interner)
+            }
            _ => derefed_receiver_ty,
        };
        self.unify(&expected_receiver_ty, &actual_receiver_ty);
@@ -962,8 +981,10 @@ impl<'a> InferenceContext<'a> {
                    if let AssocContainerId::TraitId(trait_) = f.lookup(self.db.upcast()).container
                    {
                        // construct a TraitRef
-                        let substs =
+                        let substs = crate::subst_prefix(
-                            parameters.prefix(generics(self.db.upcast(), trait_.into()).len());
+                            &*parameters,
+                            generics(self.db.upcast(), trait_.into()).len(),
+                        );
                        self.push_obligation(
                            TraitRef { trait_id: to_chalk_trait_id(trait_), substitution: substs }
                                .cast(&Interner),
diff --git a/crates/hir_ty/src/infer/pat.rs b/crates/hir_ty/src/infer/pat.rs
index 252ae914a..aea354cde 100644
--- a/crates/hir_ty/src/infer/pat.rs
+++ b/crates/hir_ty/src/infer/pat.rs
@@ -7,14 +7,13 @@ use chalk_ir::Mutability;
 use hir_def::{
    expr::{BindingAnnotation, Expr, Literal, Pat, PatId, RecordFieldPat},
    path::Path,
-    FieldId,
 };
 use hir_expand::name::Name;
 use super::{BindingMode, Expectation, InferenceContext};
 use crate::{
-    lower::lower_to_chalk_mutability, utils::variant_data, Interner, Substitution, Ty, TyBuilder,
+    lower::lower_to_chalk_mutability, static_lifetime, Interner, Substitution, Ty, TyBuilder,
-    TyKind,
+    TyExt, TyKind,
 };
 impl<'a> InferenceContext<'a> {
@@ -28,13 +27,14 @@ impl<'a> InferenceContext<'a> {
        ellipsis: Option<usize>,
    ) -> Ty {
        let (ty, def) = self.resolve_variant(path);
-        let var_data = def.map(|it| variant_data(self.db.upcast(), it));
+        let var_data = def.map(|it| it.variant_data(self.db.upcast()));
        if let Some(variant) = def {
            self.write_variant_resolution(id.into(), variant);
        }
        self.unify(&ty, expected);
-        let substs = ty.substs().cloned().unwrap_or_else(|| Substitution::empty(&Interner));
+        let substs =
+            ty.as_adt().map(|(_, s)| s.clone()).unwrap_or_else(|| Substitution::empty(&Interner));
        let field_tys = def.map(|it| self.db.field_types(it)).unwrap_or_default();
        let (pre, post) = match ellipsis {
@@ -68,23 +68,19 @@ impl<'a> InferenceContext<'a> {
        id: PatId,
    ) -> Ty {
        let (ty, def) = self.resolve_variant(path);
-        let var_data = def.map(|it| variant_data(self.db.upcast(), it));
+        let var_data = def.map(|it| it.variant_data(self.db.upcast()));
        if let Some(variant) = def {
            self.write_variant_resolution(id.into(), variant);
        }
        self.unify(&ty, expected);
-        let substs = ty.substs().cloned().unwrap_or_else(|| Substitution::empty(&Interner));
+        let substs =
+            ty.as_adt().map(|(_, s)| s.clone()).unwrap_or_else(|| Substitution::empty(&Interner));
        let field_tys = def.map(|it| self.db.field_types(it)).unwrap_or_default();
        for subpat in subpats {
            let matching_field = var_data.as_ref().and_then(|it| it.field(&subpat.name));
-            if let Some(local_id) = matching_field {
-                let field_def = FieldId { parent: def.unwrap(), local_id };
-                self.result.record_pat_field_resolutions.insert(subpat.pat, field_def);
-            }
            let expected_ty = matching_field.map_or(self.err_ty(), |field| {
                field_tys[field].clone().substitute(&Interner, &substs)
            });
@@ -104,7 +100,7 @@ impl<'a> InferenceContext<'a> {
        let body = Arc::clone(&self.body); // avoid borrow checker problem
        if is_non_ref_pat(&body, pat) {
-            while let Some((inner, mutability)) = expected.as_reference() {
+            while let Some((inner, _lifetime, mutability)) = expected.as_reference() {
                expected = inner;
                default_bm = match default_bm {
                    BindingMode::Move => BindingMode::Ref(mutability),
@@ -126,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(),
+                    Some(parameters) => &*parameters.as_slice(&Interner),
                    _ => &[],
                };
@@ -162,7 +158,7 @@ impl<'a> InferenceContext<'a> {
            Pat::Ref { pat, mutability } => {
                let mutability = lower_to_chalk_mutability(*mutability);
                let expectation = match expected.as_reference() {
-                    Some((inner_ty, exp_mut)) => {
+                    Some((inner_ty, _lifetime, exp_mut)) => {
                        if mutability != exp_mut {
                            // FIXME: emit type error?
                        }
@@ -171,10 +167,10 @@ impl<'a> InferenceContext<'a> {
                    _ => self.result.standard_types.unknown.clone(),
                };
                let subty = self.infer_pat(*pat, &expectation, default_bm);
-                TyKind::Ref(mutability, subty).intern(&Interner)
+                TyKind::Ref(mutability, static_lifetime(), subty).intern(&Interner)
            }
            Pat::TupleStruct { path: p, args: subpats, ellipsis } => self.infer_tuple_struct_pat(
-                p.as_ref(),
+                p.as_deref(),
                subpats,
                expected,
                default_bm,
@@ -182,7 +178,7 @@ impl<'a> InferenceContext<'a> {
                *ellipsis,
            ),
            Pat::Record { path: p, args: fields, ellipsis: _ } => {
-                self.infer_record_pat(p.as_ref(), fields, expected, default_bm, pat)
+                self.infer_record_pat(p.as_deref(), fields, expected, default_bm, pat)
            }
            Pat::Path(path) => {
                // FIXME use correct resolver for the surrounding expression
@@ -204,7 +200,8 @@ impl<'a> InferenceContext<'a> {
                let bound_ty = match mode {
                    BindingMode::Ref(mutability) => {
-                        TyKind::Ref(mutability, inner_ty.clone()).intern(&Interner)
+                        TyKind::Ref(mutability, static_lifetime(), inner_ty.clone())
+                            .intern(&Interner)
                    }
                    BindingMode::Move => inner_ty.clone(),
                };
@@ -213,17 +210,20 @@ impl<'a> InferenceContext<'a> {
                return inner_ty;
            }
            Pat::Slice { prefix, slice, suffix } => {
-                let (container_ty, elem_ty): (fn(_) -> _, _) = match expected.kind(&Interner) {
+                let elem_ty = match expected.kind(&Interner) {
-                    TyKind::Array(st) => (TyKind::Array, st.clone()),
+                    TyKind::Array(st, _) | TyKind::Slice(st) => st.clone(),
-                    TyKind::Slice(st) => (TyKind::Slice, st.clone()),
+                    _ => self.err_ty(),
-                    _ => (TyKind::Slice, self.err_ty()),
                };
                for pat_id in prefix.iter().chain(suffix) {
                    self.infer_pat(*pat_id, &elem_ty, default_bm);
                }
-                let pat_ty = container_ty(elem_ty).intern(&Interner);
+                let pat_ty = match expected.kind(&Interner) {
+                    TyKind::Array(_, const_) => TyKind::Array(elem_ty, const_.clone()),
+                    _ => TyKind::Slice(elem_ty),
+                }
+                .intern(&Interner);
                if let Some(slice_pat_id) = slice {
                    self.infer_pat(*slice_pat_id, &pat_ty, default_bm);
                }
@@ -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 14f705173..495282eba 100644
--- a/crates/hir_ty/src/infer/path.rs
+++ b/crates/hir_ty/src/infer/path.rs
@@ -10,7 +10,10 @@ use hir_def::{
 };
 use hir_expand::name::Name;
-use crate::{method_resolution, Interner, Substitution, Ty, TyBuilder, TyKind, ValueTyDefId};
+use crate::{
+    method_resolution, Interner, Substitution, TraitRefExt, Ty, TyBuilder, TyExt, TyKind,
+    ValueTyDefId,
+};
 use super::{ExprOrPatId, InferenceContext, TraitRef};
@@ -98,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 c90a16720..a887e20b0 100644
--- a/crates/hir_ty/src/infer/unify.rs
+++ b/crates/hir_ty/src/infer/unify.rs
@@ -2,13 +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,
+    fold_tys, static_lifetime, AliasEq, AliasTy, BoundVar, Canonical, CanonicalVarKinds,
-    InEnvironment, InferenceVar, Interner, Scalar, Substitution, Ty, TyKind, TypeWalk, WhereClause,
+    DebruijnIndex, FnPointer, FnSubst, InEnvironment, InferenceVar, Interner, Scalar, Substitution,
+    Ty, TyExt, TyKind, WhereClause,
 };
 impl<'a> InferenceContext<'a> {
@@ -33,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)>,
 }
@@ -47,11 +54,16 @@ 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 = var.to_inner();
+                    let inner = from_inference_var(var);
                    if self.var_stack.contains(&inner) {
                        // recursive type
                        return self.ctx.table.type_variable_table.fallback_value(var, kind);
@@ -65,7 +77,7 @@ impl<'a, 'b> Canonicalizer<'a, 'b> {
                        result
                    } else {
                        let root = self.ctx.table.var_unification_table.find(inner);
-                        let position = self.add(InferenceVar::from_inner(root), kind);
+                        let position = self.add(to_inference_var(root), kind);
                        TyKind::BoundVar(BoundVar::new(binders, position)).intern(&Interner)
                    }
                }
@@ -75,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()
@@ -102,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(
@@ -135,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"),
            }),
        );
@@ -207,16 +214,16 @@ impl TypeVariableTable {
    }
    pub(super) fn set_diverging(&mut self, iv: InferenceVar, diverging: bool) {
-        self.inner[iv.to_inner().0 as usize].diverging = diverging;
+        self.inner[from_inference_var(iv).0 as usize].diverging = diverging;
    }
    fn is_diverging(&mut self, iv: InferenceVar) -> bool {
-        self.inner[iv.to_inner().0 as usize].diverging
+        self.inner[from_inference_var(iv).0 as usize].diverging
    }
    fn fallback_value(&self, iv: InferenceVar, kind: TyVariableKind) -> Ty {
        match kind {
-            _ if self.inner[iv.to_inner().0 as usize].diverging => TyKind::Never,
+            _ if self.inner[from_inference_var(iv).0 as usize].diverging => TyKind::Never,
            TyVariableKind::General => TyKind::Error,
            TyVariableKind::Integer => TyKind::Scalar(Scalar::Int(IntTy::I32)),
            TyVariableKind::Float => TyKind::Scalar(Scalar::Float(FloatTy::F64)),
@@ -250,7 +257,7 @@ impl InferenceTable {
        self.type_variable_table.push(TypeVariableData { diverging });
        let key = self.var_unification_table.new_key(TypeVarValue::Unknown);
        assert_eq!(key.0 as usize, self.type_variable_table.inner.len() - 1);
-        TyKind::InferenceVar(InferenceVar::from_inner(key), kind).intern(&Interner)
+        TyKind::InferenceVar(to_inference_var(key), kind).intern(&Interner)
    }
    pub(crate) fn new_type_var(&mut self) -> Ty {
@@ -308,8 +315,8 @@ impl InferenceTable {
                (TyKind::Adt(_, substs1), TyKind::Adt(_, substs2))
                | (TyKind::FnDef(_, substs1), TyKind::FnDef(_, substs2))
                | (
-                    TyKind::Function(FnPointer { substs: substs1, .. }),
+                    TyKind::Function(FnPointer { substitution: FnSubst(substs1), .. }),
-                    TyKind::Function(FnPointer { substs: substs2, .. }),
+                    TyKind::Function(FnPointer { substitution: FnSubst(substs2), .. }),
                )
                | (TyKind::Tuple(_, substs1), TyKind::Tuple(_, substs2))
                | (TyKind::OpaqueType(_, substs1), TyKind::OpaqueType(_, substs2))
@@ -317,9 +324,11 @@ impl InferenceTable {
                | (TyKind::Closure(.., substs1), TyKind::Closure(.., substs2)) => {
                    self.unify_substs(substs1, substs2, depth + 1)
                }
-                (TyKind::Ref(_, ty1), TyKind::Ref(_, ty2))
+                (TyKind::Array(ty1, c1), TyKind::Array(ty2, c2)) if c1 == c2 => {
+                    self.unify_inner(ty1, ty2, depth + 1)
+                }
+                (TyKind::Ref(_, _, ty1), TyKind::Ref(_, _, ty2))
                | (TyKind::Raw(_, ty1), TyKind::Raw(_, ty2))
-                | (TyKind::Array(ty1), TyKind::Array(ty2))
                | (TyKind::Slice(ty1), TyKind::Slice(ty2)) => self.unify_inner(ty1, ty2, depth + 1),
                _ => true, /* we checked equals_ctor already */
            }
@@ -367,8 +376,12 @@ impl InferenceTable {
                == self.type_variable_table.is_diverging(*tv2) =>
            {
                // both type vars are unknown since we tried to resolve them
-                if !self.var_unification_table.unioned(tv1.to_inner(), tv2.to_inner()) {
+                if !self
-                    self.var_unification_table.union(tv1.to_inner(), tv2.to_inner());
+                    .var_unification_table
+                    .unioned(from_inference_var(*tv1), from_inference_var(*tv2))
+                {
+                    self.var_unification_table
+                        .union(from_inference_var(*tv1), from_inference_var(*tv2));
                    self.revision += 1;
                }
                true
@@ -405,7 +418,7 @@ impl InferenceTable {
            ) => {
                // the type var is unknown since we tried to resolve it
                self.var_unification_table.union_value(
-                    tv.to_inner(),
+                    from_inference_var(*tv),
                    TypeVarValue::Known(other.clone().intern(&Interner)),
                );
                self.revision += 1;
@@ -460,7 +473,7 @@ impl InferenceTable {
            }
            match ty.kind(&Interner) {
                TyKind::InferenceVar(tv, _) => {
-                    let inner = tv.to_inner();
+                    let inner = from_inference_var(*tv);
                    match self.var_unification_table.inlined_probe_value(inner).known() {
                        Some(known_ty) => {
                            // The known_ty can't be a type var itself
@@ -481,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 = tv.to_inner();
+            |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 = tv.to_inner();
+            |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,
+        )
    }
 }
@@ -553,6 +574,14 @@ impl UnifyKey for TypeVarId {
    }
 }
+fn from_inference_var(var: InferenceVar) -> TypeVarId {
+    TypeVarId(var.index())
+}
+fn to_inference_var(TypeVarId(index): TypeVarId) -> InferenceVar {
+    index.into()
+}
 /// The value of a type variable: either we already know the type, or we don't
 /// know it yet.
 #[derive(Clone, PartialEq, Eq, Debug)]
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 daf379ef8..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,35 +32,36 @@ mod test_db;
 use std::sync::Arc;
-use itertools::Itertools;
+use chalk_ir::{
-use smallvec::SmallVec;
+    fold::{Fold, Shift},
+    interner::HasInterner,
-use base_db::salsa;
+    UintTy,
-use hir_def::{
-    expr::ExprId, type_ref::Rawness, AssocContainerId, FunctionId, GenericDefId, HasModule, Lookup,
-    TraitId, TypeAliasId, TypeParamId,
 };
+use hir_def::{expr::ExprId, type_ref::Rawness, TypeParamId};
 use crate::{db::HirDatabase, display::HirDisplay, utils::generics};
 pub use autoderef::autoderef;
 pub use builder::TyBuilder;
-pub use chalk_ext::TyExt;
+pub use chalk_ext::*;
-pub use infer::{could_unify, InferenceResult, InferenceVar};
+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 mapping::{
+    const_from_placeholder_idx, from_assoc_type_id, from_chalk_trait_id, from_foreign_def_id,
+    from_placeholder_idx, lt_from_placeholder_idx, to_assoc_type_id, to_chalk_trait_id,
+    to_foreign_def_id, to_placeholder_idx,
+};
 pub use traits::TraitEnvironment;
-pub use types::*;
 pub use walk::TypeWalk;
 pub use chalk_ir::{
    cast::Cast, AdtId, BoundVar, DebruijnIndex, Mutability, Safety, Scalar, TyVariableKind,
 };
-pub use crate::traits::chalk::Interner;
 pub type ForeignDefId = chalk_ir::ForeignDefId<Interner>;
 pub type AssocTypeId = chalk_ir::AssocTypeId<Interner>;
 pub type FnDefId = chalk_ir::FnDefId<Interner>;
@@ -69,49 +72,53 @@ 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>;
+pub type LifetimeOutlives = chalk_ir::LifetimeOutlives<Interner>;
+pub type Const = chalk_ir::Const<Interner>;
+pub type ConstData = chalk_ir::ConstData<Interner>;
+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>;
-impl ProjectionTy {
+pub type QuantifiedWhereClause = Binders<WhereClause>;
-    pub fn trait_ref(&self, db: &dyn HirDatabase) -> TraitRef {
+pub type QuantifiedWhereClauses = chalk_ir::QuantifiedWhereClauses<Interner>;
-        TraitRef {
+pub type Canonical<T> = chalk_ir::Canonical<T>;
-            trait_id: to_chalk_trait_id(self.trait_(db)),
-            substitution: self.substitution.clone(),
-        }
-    }
-    pub fn self_type_parameter(&self, interner: &Interner) -> &Ty {
-        &self.substitution.interned()[0].assert_ty_ref(interner)
-    }
-    fn trait_(&self, db: &dyn HirDatabase) -> TraitId {
-        match from_assoc_type_id(self.associated_ty_id).lookup(db.upcast()).container {
-            AssocContainerId::TraitId(it) => it,
-            _ => panic!("projection ty without parent trait"),
-        }
-    }
-}
 pub type FnSig = chalk_ir::FnSig<Interner>;
-impl Substitution {
+pub type InEnvironment<T> = chalk_ir::InEnvironment<T>;
-    pub fn single(ty: Ty) -> Substitution {
+pub type DomainGoal = chalk_ir::DomainGoal<Interner>;
-        Substitution::intern({
+pub type AliasEq = chalk_ir::AliasEq<Interner>;
-            let mut v = SmallVec::new();
+pub type Solution = chalk_solve::Solution<Interner>;
-            v.push(ty.cast(&Interner));
+pub type ConstrainedSubst = chalk_ir::ConstrainedSubst<Interner>;
-            v
+pub type Guidance = chalk_solve::Guidance<Interner>;
-        })
+pub type WhereClause = chalk_ir::WhereClause<Interner>;
-    }
+// FIXME: get rid of this
-    pub fn prefix(&self, n: usize) -> Substitution {
+pub fn subst_prefix(s: &Substitution, n: usize) -> Substitution {
-        Substitution::intern(self.interned()[..std::cmp::min(self.len(&Interner), n)].into())
+    Substitution::from_iter(
-    }
+        &Interner,
+        s.as_slice(&Interner)[..std::cmp::min(s.len(&Interner), n)].iter().cloned(),
-    pub fn suffix(&self, n: usize) -> Substitution {
+    )
-        Substitution::intern(
-            self.interned()[self.len(&Interner) - std::cmp::min(self.len(&Interner), n)..].into(),
-        )
-    }
 }
 /// Return an index of a parameter in the generic type parameter list by it's id.
@@ -119,25 +126,17 @@ pub fn param_idx(db: &dyn HirDatabase, id: TypeParamId) -> Option<usize> {
    generics(db.upcast(), id.parent).param_idx(id)
 }
-impl<T> Binders<T> {
+pub(crate) fn wrap_empty_binders<T>(value: T) -> Binders<T>
-    pub fn wrap_empty(value: T) -> Self
+where
-    where
+    T: Fold<Interner, Result = T> + HasInterner<Interner = Interner>,
-        T: TypeWalk,
+{
-    {
+    Binders::empty(&Interner, value.shifted_in_from(&Interner, DebruijnIndex::ONE))
-        Binders::empty(&Interner, value.shifted_in_from(DebruijnIndex::ONE))
-    }
-}
-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)
-    }
 }
-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,
@@ -148,42 +147,18 @@ pub fn make_only_type_binders<T>(num_vars: usize, value: T) -> Binders<T> {
    )
 }
-impl TraitRef {
+// FIXME: get rid of this
-    pub fn self_type_parameter(&self, interner: &Interner) -> &Ty {
+pub fn make_canonical<T: HasInterner<Interner = Interner>>(
-        &self.substitution.at(interner, 0).assert_ty_ref(interner)
+    value: T,
-    }
+    kinds: impl IntoIterator<Item = TyVariableKind>,
+) -> Canonical<T> {
-    pub fn hir_trait_id(&self) -> TraitId {
+    let kinds = kinds.into_iter().map(|tk| {
-        from_chalk_trait_id(self.trait_id)
+        chalk_ir::CanonicalVarKind::new(
-    }
+            chalk_ir::VariableKind::Ty(tk),
-}
+            chalk_ir::UniverseIndex::ROOT,
+        )
-impl WhereClause {
+    });
-    pub fn is_implemented(&self) -> bool {
+    Canonical { value, binders: chalk_ir::CanonicalVarKinds::from_iter(&Interner, kinds) }
-        matches!(self, WhereClause::Implemented(_))
-    }
-    pub fn trait_ref(&self, db: &dyn HirDatabase) -> Option<TraitRef> {
-        match self {
-            WhereClause::Implemented(tr) => Some(tr.clone()),
-            WhereClause::AliasEq(AliasEq { alias: AliasTy::Projection(proj), .. }) => {
-                Some(proj.trait_ref(db))
-            }
-            WhereClause::AliasEq(_) => None,
-        }
-    }
-}
-impl<T> Canonical<T> {
-    pub fn new(value: T, kinds: impl IntoIterator<Item = TyVariableKind>) -> Self {
-        let kinds = kinds.into_iter().map(|tk| {
-            chalk_ir::CanonicalVarKind::new(
-                chalk_ir::VariableKind::Ty(tk),
-                chalk_ir::UniverseIndex::ROOT,
-            )
-        });
-        Self { value, binders: chalk_ir::CanonicalVarKinds::from_iter(&Interner, kinds) }
-    }
 }
 /// A function signature as seen by type inference: Several parameter types and
@@ -194,6 +169,8 @@ pub struct CallableSig {
    is_varargs: bool,
 }
+has_interner!(CallableSig);
 /// A polymorphic function signature.
 pub type PolyFnSig = Binders<CallableSig>;
@@ -207,11 +184,12 @@ impl CallableSig {
        CallableSig {
            // FIXME: what to do about lifetime params? -> return PolyFnSig
            params_and_return: fn_ptr
-                .substs
+                .substitution
                .clone()
-                .shifted_out_to(DebruijnIndex::ONE)
+                .shifted_out_to(&Interner, DebruijnIndex::ONE)
                .expect("unexpected lifetime vars in fn ptr")
-                .interned()
+                .0
+                .as_slice(&Interner)
                .iter()
                .map(|arg| arg.assert_ty_ref(&Interner).clone())
                .collect(),
@@ -228,275 +206,20 @@ impl CallableSig {
    }
 }
-impl Ty {
+impl Fold<Interner> for CallableSig {
-    pub fn as_reference(&self) -> Option<(&Ty, Mutability)> {
+    type Result = CallableSig;
-        match self.kind(&Interner) {
-            TyKind::Ref(mutability, ty) => Some((ty, *mutability)),
-            _ => None,
-        }
-    }
-    pub fn as_reference_or_ptr(&self) -> Option<(&Ty, Rawness, Mutability)> {
-        match self.kind(&Interner) {
-            TyKind::Ref(mutability, ty) => Some((ty, Rawness::Ref, *mutability)),
-            TyKind::Raw(mutability, ty) => Some((ty, Rawness::RawPtr, *mutability)),
-            _ => None,
-        }
-    }
-    pub fn strip_references(&self) -> &Ty {
-        let mut t: &Ty = self;
-        while let TyKind::Ref(_mutability, ty) = t.kind(&Interner) {
-            t = ty;
-        }
-        t
+    fn fold_with<'i>(
-    }
+        self,
+        folder: &mut dyn chalk_ir::fold::Folder<'i, Interner>,
-    pub fn as_adt(&self) -> Option<(hir_def::AdtId, &Substitution)> {
+        outer_binder: DebruijnIndex,
-        match self.kind(&Interner) {
+    ) -> chalk_ir::Fallible<Self::Result>
-            TyKind::Adt(AdtId(adt), parameters) => Some((*adt, parameters)),
+    where
-            _ => None,
+        Interner: 'i,
-        }
+    {
-    }
+        let vec = self.params_and_return.to_vec();
+        let folded = vec.fold_with(folder, outer_binder)?;
-    pub fn as_tuple(&self) -> Option<&Substitution> {
+        Ok(CallableSig { params_and_return: folded.into(), is_varargs: self.is_varargs })
-        match self.kind(&Interner) {
-            TyKind::Tuple(_, substs) => Some(substs),
-            _ => None,
-        }
-    }
-    pub fn as_generic_def(&self, db: &dyn HirDatabase) -> Option<GenericDefId> {
-        match *self.kind(&Interner) {
-            TyKind::Adt(AdtId(adt), ..) => Some(adt.into()),
-            TyKind::FnDef(callable, ..) => {
-                Some(db.lookup_intern_callable_def(callable.into()).into())
-            }
-            TyKind::AssociatedType(type_alias, ..) => Some(from_assoc_type_id(type_alias).into()),
-            TyKind::Foreign(type_alias, ..) => Some(from_foreign_def_id(type_alias).into()),
-            _ => None,
-        }
-    }
-    pub fn is_never(&self) -> bool {
-        matches!(self.kind(&Interner), TyKind::Never)
-    }
-    pub fn is_unknown(&self) -> bool {
-        matches!(self.kind(&Interner), TyKind::Error)
-    }
-    pub fn equals_ctor(&self, other: &Ty) -> bool {
-        match (self.kind(&Interner), other.kind(&Interner)) {
-            (TyKind::Adt(adt, ..), TyKind::Adt(adt2, ..)) => adt == adt2,
-            (TyKind::Slice(_), TyKind::Slice(_)) | (TyKind::Array(_), TyKind::Array(_)) => true,
-            (TyKind::FnDef(def_id, ..), TyKind::FnDef(def_id2, ..)) => def_id == def_id2,
-            (TyKind::OpaqueType(ty_id, ..), TyKind::OpaqueType(ty_id2, ..)) => ty_id == ty_id2,
-            (TyKind::AssociatedType(ty_id, ..), TyKind::AssociatedType(ty_id2, ..)) => {
-                ty_id == ty_id2
-            }
-            (TyKind::Foreign(ty_id, ..), TyKind::Foreign(ty_id2, ..)) => ty_id == ty_id2,
-            (TyKind::Closure(id1, _), TyKind::Closure(id2, _)) => id1 == id2,
-            (TyKind::Ref(mutability, ..), TyKind::Ref(mutability2, ..))
-            | (TyKind::Raw(mutability, ..), TyKind::Raw(mutability2, ..)) => {
-                mutability == mutability2
-            }
-            (
-                TyKind::Function(FnPointer { num_args, sig, .. }),
-                TyKind::Function(FnPointer { num_args: num_args2, sig: sig2, .. }),
-            ) => num_args == num_args2 && sig == sig2,
-            (TyKind::Tuple(cardinality, _), TyKind::Tuple(cardinality2, _)) => {
-                cardinality == cardinality2
-            }
-            (TyKind::Str, TyKind::Str) | (TyKind::Never, TyKind::Never) => true,
-            (TyKind::Scalar(scalar), TyKind::Scalar(scalar2)) => scalar == scalar2,
-            _ => false,
-        }
-    }
-    /// If this is a `dyn Trait` type, this returns the `Trait` part.
-    fn dyn_trait_ref(&self) -> Option<&TraitRef> {
-        match self.kind(&Interner) {
-            TyKind::Dyn(dyn_ty) => dyn_ty.bounds.skip_binders().interned().get(0).and_then(|b| {
-                match b.skip_binders() {
-                    WhereClause::Implemented(trait_ref) => Some(trait_ref),
-                    _ => None,
-                }
-            }),
-            _ => None,
-        }
-    }
-    /// If this is a `dyn Trait`, returns that trait.
-    pub fn dyn_trait(&self) -> Option<TraitId> {
-        self.dyn_trait_ref().map(|it| it.trait_id).map(from_chalk_trait_id)
-    }
-    fn builtin_deref(&self) -> Option<Ty> {
-        match self.kind(&Interner) {
-            TyKind::Ref(.., ty) => Some(ty.clone()),
-            TyKind::Raw(.., ty) => Some(ty.clone()),
-            _ => None,
-        }
-    }
-    pub fn callable_def(&self, db: &dyn HirDatabase) -> Option<CallableDefId> {
-        match self.kind(&Interner) {
-            &TyKind::FnDef(def, ..) => Some(db.lookup_intern_callable_def(def.into())),
-            _ => None,
-        }
-    }
-    pub fn as_fn_def(&self, db: &dyn HirDatabase) -> Option<FunctionId> {
-        if let Some(CallableDefId::FunctionId(func)) = self.callable_def(db) {
-            Some(func)
-        } else {
-            None
-        }
-    }
-    pub fn callable_sig(&self, db: &dyn HirDatabase) -> Option<CallableSig> {
-        match self.kind(&Interner) {
-            TyKind::Function(fn_ptr) => Some(CallableSig::from_fn_ptr(fn_ptr)),
-            TyKind::FnDef(def, parameters) => {
-                let callable_def = db.lookup_intern_callable_def((*def).into());
-                let sig = db.callable_item_signature(callable_def);
-                Some(sig.substitute(&Interner, &parameters))
-            }
-            TyKind::Closure(.., substs) => {
-                let sig_param = substs.at(&Interner, 0).assert_ty_ref(&Interner);
-                sig_param.callable_sig(db)
-            }
-            _ => None,
-        }
-    }
-    /// Returns the type parameters of this type if it has some (i.e. is an ADT
-    /// or function); so if `self` is `Option<u32>`, this returns the `u32`.
-    pub fn substs(&self) -> Option<&Substitution> {
-        match self.kind(&Interner) {
-            TyKind::Adt(_, substs)
-            | TyKind::FnDef(_, substs)
-            | TyKind::Function(FnPointer { substs, .. })
-            | TyKind::Tuple(_, substs)
-            | TyKind::OpaqueType(_, substs)
-            | TyKind::AssociatedType(_, substs)
-            | TyKind::Closure(.., substs) => Some(substs),
-            _ => None,
-        }
-    }
-    fn substs_mut(&mut self) -> Option<&mut Substitution> {
-        match self.interned_mut() {
-            TyKind::Adt(_, substs)
-            | TyKind::FnDef(_, substs)
-            | TyKind::Function(FnPointer { substs, .. })
-            | TyKind::Tuple(_, substs)
-            | TyKind::OpaqueType(_, substs)
-            | TyKind::AssociatedType(_, substs)
-            | TyKind::Closure(.., substs) => Some(substs),
-            _ => None,
-        }
-    }
-    pub fn impl_trait_bounds(&self, db: &dyn HirDatabase) -> Option<Vec<QuantifiedWhereClause>> {
-        match self.kind(&Interner) {
-            TyKind::OpaqueType(opaque_ty_id, ..) => {
-                match db.lookup_intern_impl_trait_id((*opaque_ty_id).into()) {
-                    ImplTraitId::AsyncBlockTypeImplTrait(def, _expr) => {
-                        let krate = def.module(db.upcast()).krate();
-                        if let Some(future_trait) = db
-                            .lang_item(krate, "future_trait".into())
-                            .and_then(|item| item.as_trait())
-                        {
-                            // This is only used by type walking.
-                            // Parameters will be walked outside, and projection predicate is not used.
-                            // So just provide the Future trait.
-                            let impl_bound = Binders::empty(
-                                &Interner,
-                                WhereClause::Implemented(TraitRef {
-                                    trait_id: to_chalk_trait_id(future_trait),
-                                    substitution: Substitution::empty(&Interner),
-                                }),
-                            );
-                            Some(vec![impl_bound])
-                        } else {
-                            None
-                        }
-                    }
-                    ImplTraitId::ReturnTypeImplTrait(..) => None,
-                }
-            }
-            TyKind::Alias(AliasTy::Opaque(opaque_ty)) => {
-                let predicates = match db.lookup_intern_impl_trait_id(opaque_ty.opaque_ty_id.into())
-                {
-                    ImplTraitId::ReturnTypeImplTrait(func, idx) => {
-                        db.return_type_impl_traits(func).map(|it| {
-                            let data = (*it)
-                                .as_ref()
-                                .map(|rpit| rpit.impl_traits[idx as usize].bounds.clone());
-                            data.substitute(&Interner, &opaque_ty.substitution)
-                        })
-                    }
-                    // It always has an parameter for Future::Output type.
-                    ImplTraitId::AsyncBlockTypeImplTrait(..) => unreachable!(),
-                };
-                predicates.map(|it| it.into_value_and_skipped_binders().0)
-            }
-            TyKind::Placeholder(idx) => {
-                let id = from_placeholder_idx(db, *idx);
-                let generic_params = db.generic_params(id.parent);
-                let param_data = &generic_params.types[id.local_id];
-                match param_data.provenance {
-                    hir_def::generics::TypeParamProvenance::ArgumentImplTrait => {
-                        let substs = TyBuilder::type_params_subst(db, id.parent);
-                        let predicates = db
-                            .generic_predicates(id.parent)
-                            .into_iter()
-                            .map(|pred| pred.clone().substitute(&Interner, &substs))
-                            .filter(|wc| match &wc.skip_binders() {
-                                WhereClause::Implemented(tr) => {
-                                    tr.self_type_parameter(&Interner) == self
-                                }
-                                WhereClause::AliasEq(AliasEq {
-                                    alias: AliasTy::Projection(proj),
-                                    ty: _,
-                                }) => proj.self_type_parameter(&Interner) == self,
-                                _ => false,
-                            })
-                            .collect_vec();
-                        Some(predicates)
-                    }
-                    _ => None,
-                }
-            }
-            _ => None,
-        }
-    }
-    pub fn associated_type_parent_trait(&self, db: &dyn HirDatabase) -> Option<TraitId> {
-        match self.kind(&Interner) {
-            TyKind::AssociatedType(id, ..) => {
-                match from_assoc_type_id(*id).lookup(db.upcast()).container {
-                    AssocContainerId::TraitId(trait_id) => Some(trait_id),
-                    _ => None,
-                }
-            }
-            TyKind::Alias(AliasTy::Projection(projection_ty)) => {
-                match from_assoc_type_id(projection_ty.associated_ty_id)
-                    .lookup(db.upcast())
-                    .container
-                {
-                    AssocContainerId::TraitId(trait_id) => Some(trait_id),
-                    _ => None,
-                }
-            }
-            _ => None,
-        }
    }
 }
@@ -511,45 +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 {
+pub fn dummy_usize_const() -> Const {
-    chalk_ir::AssocTypeId(salsa::InternKey::as_intern_id(&id))
+    let usize_ty = chalk_ir::TyKind::Scalar(Scalar::Uint(UintTy::Usize)).intern(&Interner);
+    chalk_ir::ConstData {
+        ty: usize_ty,
+        value: chalk_ir::ConstValue::Concrete(chalk_ir::ConcreteConst { interned: () }),
+    }
+    .intern(&Interner)
 }
-pub fn from_assoc_type_id(id: AssocTypeId) -> TypeAliasId {
+pub(crate) fn fold_free_vars<T: HasInterner<Interner = Interner> + Fold<Interner>>(
-    salsa::InternKey::from_intern_id(id.0)
+    t: T,
-}
+    f: impl FnMut(BoundVar, DebruijnIndex) -> Ty,
+) -> 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 from_placeholder_idx(db: &dyn HirDatabase, idx: PlaceholderIndex) -> TypeParamId {
+        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_type_param_id(interned_id)
-}
-pub fn to_placeholder_idx(db: &dyn HirDatabase, id: TypeParamId) -> PlaceholderIndex {
+        fn fold_free_var_ty(
-    let interned_id = db.intern_type_param_id(id);
+            &mut self,
-    PlaceholderIndex {
+            bound_var: BoundVar,
-        ui: chalk_ir::UniverseIndex::ROOT,
+            outer_binder: DebruijnIndex,
-        idx: salsa::InternKey::as_intern_id(&interned_id).as_usize(),
+        ) -> Fallible<Ty> {
+            Ok(self.0(bound_var, outer_binder))
+        }
    }
+    t.fold_with(&mut FreeVarFolder(f), DebruijnIndex::INNERMOST).expect("fold failed unexpectedly")
 }
-pub fn to_chalk_trait_id(id: TraitId) -> ChalkTraitId {
+pub(crate) fn fold_tys<T: HasInterner<Interner = Interner> + Fold<Interner>>(
-    chalk_ir::TraitId(salsa::InternKey::as_intern_id(&id))
+    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 from_chalk_trait_id(id: ChalkTraitId) -> TraitId {
+        fn interner(&self) -> &'i Interner {
-    salsa::InternKey::from_intern_id(id.0)
+            &Interner
+        }
+        fn fold_ty(&mut self, ty: Ty, outer_binder: DebruijnIndex) -> Fallible<Ty> {
+            let ty = ty.super_fold_with(self.as_dyn(), outer_binder)?;
+            Ok(self.0(ty, outer_binder))
+        }
+    }
+    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 48c26f471..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,16 +27,16 @@ use stdx::impl_from;
 use crate::{
    db::HirDatabase,
-    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,
+        all_super_trait_refs, associated_type_by_name_including_super_traits, generics, Generics,
-        variant_data, Generics,
    },
    AliasEq, AliasTy, Binders, BoundVar, CallableSig, DebruijnIndex, DynTy, FnPointer, FnSig,
-    ImplTraitId, OpaqueTy, PolyFnSig, ProjectionTy, QuantifiedWhereClause, QuantifiedWhereClauses,
+    FnSubst, ImplTraitId, Interner, OpaqueTy, PolyFnSig, ProjectionTy, QuantifiedWhereClause,
-    ReturnTypeImplTrait, ReturnTypeImplTraits, Substitution, TraitEnvironment, TraitRef, Ty,
+    QuantifiedWhereClauses, ReturnTypeImplTrait, ReturnTypeImplTraits, Substitution,
-    TyBuilder, TyKind, TypeWalk, WhereClause,
+    TraitEnvironment, TraitRef, TraitRefExt, Ty, TyBuilder, TyKind, WhereClause,
 };
 #[derive(Debug)]
@@ -166,7 +166,7 @@ impl<'a> TyLoweringContext<'a> {
            }
            TypeRef::Array(inner) => {
                let inner_ty = self.lower_ty(inner);
-                TyKind::Array(inner_ty).intern(&Interner)
+                TyKind::Array(inner_ty, dummy_usize_const()).intern(&Interner)
            }
            TypeRef::Slice(inner) => {
                let inner_ty = self.lower_ty(inner);
@@ -174,16 +174,19 @@ impl<'a> TyLoweringContext<'a> {
            }
            TypeRef::Reference(inner, _, mutability) => {
                let inner_ty = self.lower_ty(inner);
-                TyKind::Ref(lower_to_chalk_mutability(*mutability), inner_ty).intern(&Interner)
+                let lifetime = static_lifetime();
+                TyKind::Ref(lower_to_chalk_mutability(*mutability), lifetime, inner_ty)
+                    .intern(&Interner)
            }
            TypeRef::Placeholder => TyKind::Error.intern(&Interner),
            TypeRef::Fn(params, is_varargs) => {
-                let substs =
+                let substs = self.with_shifted_in(DebruijnIndex::ONE, |ctx| {
-                    Substitution::from_iter(&Interner, params.iter().map(|tr| self.lower_ty(tr)));
+                    Substitution::from_iter(&Interner, params.iter().map(|tr| ctx.lower_ty(tr)))
+                });
                TyKind::Function(FnPointer {
-                    num_args: substs.len(&Interner) - 1,
+                    num_binders: 0, // FIXME lower `for<'a> fn()` correctly
                    sig: FnSig { abi: (), safety: Safety::Safe, variadic: *is_varargs },
-                    substs,
+                    substitution: FnSubst(substs),
                })
                .intern(&Interner)
            }
@@ -197,7 +200,7 @@ impl<'a> TyLoweringContext<'a> {
                    )
                });
                let bounds = crate::make_only_type_binders(1, bounds);
-                TyKind::Dyn(DynTy { bounds }).intern(&Interner)
+                TyKind::Dyn(DynTy { bounds, lifetime: static_lifetime() }).intern(&Interner)
            }
            TypeRef::ImplTrait(bounds) => {
                match self.impl_trait_mode {
@@ -384,9 +387,12 @@ impl<'a> TyLoweringContext<'a> {
                            1,
                            QuantifiedWhereClauses::from_iter(
                                &Interner,
-                                Some(Binders::wrap_empty(WhereClause::Implemented(trait_ref))),
+                                Some(crate::wrap_empty_binders(WhereClause::Implemented(
+                                    trait_ref,
+                                ))),
                            ),
                        ),
+                        lifetime: static_lifetime(),
                    };
                    TyKind::Dyn(dyn_ty).intern(&Interner)
                };
@@ -483,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 {
@@ -720,7 +726,7 @@ impl<'a> TyLoweringContext<'a> {
        let trait_ref = match bound {
            TypeBound::Path(path) => {
                bindings = self.lower_trait_ref_from_path(path, Some(self_ty));
-                bindings.clone().map(WhereClause::Implemented).map(|b| Binders::wrap_empty(b))
+                bindings.clone().map(WhereClause::Implemented).map(|b| crate::wrap_empty_binders(b))
            }
            TypeBound::Lifetime(_) => None,
            TypeBound::Error => None,
@@ -767,7 +773,7 @@ impl<'a> TyLoweringContext<'a> {
                    let ty = self.lower_ty(type_ref);
                    let alias_eq =
                        AliasEq { alias: AliasTy::Projection(projection_ty.clone()), ty };
-                    preds.push(Binders::wrap_empty(WhereClause::AliasEq(alias_eq)));
+                    preds.push(crate::wrap_empty_binders(WhereClause::AliasEq(alias_eq)));
                }
                for bound in &binding.bounds {
                    preds.extend(self.lower_type_bound(
@@ -842,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,
@@ -873,7 +879,7 @@ pub(crate) fn field_types_query(
    db: &dyn HirDatabase,
    variant_id: VariantId,
 ) -> Arc<ArenaMap<LocalFieldId, Binders<Ty>>> {
-    let var_data = variant_data(db.upcast(), variant_id);
+    let var_data = variant_id.variant_data(db.upcast());
    let (resolver, def): (_, GenericDefId) = match variant_id {
        VariantId::StructId(it) => (it.resolver(db.upcast()), it.into()),
        VariantId::UnionId(it) => (it.resolver(db.upcast()), it.into()),
@@ -945,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));
        }
    }
@@ -969,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));
    }
@@ -1011,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)
        })
@@ -1302,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 19a1fa793..ece884241 100644
--- a/crates/hir_ty/src/method_resolution.rs
+++ b/crates/hir_ty/src/method_resolution.rs
@@ -8,62 +8,103 @@ use arrayvec::ArrayVec;
 use base_db::CrateId;
 use chalk_ir::{cast::Cast, Mutability, UniverseIndex};
 use hir_def::{
-    lang_item::LangItemTarget, AssocContainerId, AssocItemId, FunctionId, GenericDefId, HasModule,
+    lang_item::LangItemTarget, nameres::DefMap, AssocContainerId, AssocItemId, FunctionId,
-    ImplId, Lookup, ModuleId, TraitId,
+    GenericDefId, HasModule, ImplId, Lookup, ModuleId, TraitId,
 };
 use hir_expand::name::Name;
 use rustc_hash::{FxHashMap, FxHashSet};
+use stdx::always;
 use crate::{
    autoderef,
    db::HirDatabase,
    from_foreign_def_id,
    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, Ty, TyBuilder, TyKind,
+    Scalar, Substitution, TraitEnvironment, TraitRefExt, Ty, TyBuilder, 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.
-        let fp = match *ty.kind(&Interner) {
+    pub fn for_inherent_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::Scalar(scalar) => TyFingerprint::Scalar(*scalar),
-            TyKind::Adt(AdtId(adt), _) => TyFingerprint::Adt(adt),
+            TyKind::Adt(AdtId(adt), _) => TyFingerprint::Adt(*adt),
-            TyKind::Tuple(cardinality, _) => TyFingerprint::Tuple(cardinality),
+            TyKind::Raw(mutability, ..) => TyFingerprint::RawPtr(*mutability),
-            TyKind::Raw(mutability, ..) => TyFingerprint::RawPtr(mutability),
+            TyKind::Foreign(alias_id, ..) => TyFingerprint::ForeignType(*alias_id),
-            TyKind::Foreign(alias_id, ..) => TyFingerprint::ForeignType(alias_id),
-            TyKind::Function(FnPointer { num_args, sig, .. }) => {
-                TyFingerprint::FnPtr(num_args, 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] = [
@@ -99,25 +140,38 @@ impl TraitImpls {
        let mut impls = Self { map: FxHashMap::default() };
        let crate_def_map = db.crate_def_map(krate);
-        for (_module_id, module_data) in crate_def_map.modules() {
+        collect_def_map(db, &crate_def_map, &mut impls);
-            for impl_id in module_data.scope.impls() {
-                let target_trait = match db.impl_trait(impl_id) {
+        return Arc::new(impls);
-                    Some(tr) => tr.skip_binders().hir_trait_id(),
-                    None => continue,
+        fn collect_def_map(db: &dyn HirDatabase, def_map: &DefMap, impls: &mut TraitImpls) {
-                };
+            for (_module_id, module_data) in def_map.modules() {
-                let self_ty = db.impl_self_ty(impl_id);
+                for impl_id in module_data.scope.impls() {
-                let self_ty_fp = TyFingerprint::for_impl(self_ty.skip_binders());
+                    let target_trait = match db.impl_trait(impl_id) {
-                impls
+                        Some(tr) => tr.skip_binders().hir_trait_id(),
-                    .map
+                        None => continue,
-                    .entry(target_trait)
+                    };
-                    .or_default()
+                    let self_ty = db.impl_self_ty(impl_id);
-                    .entry(self_ty_fp)
+                    let self_ty_fp = TyFingerprint::for_trait_impl(self_ty.skip_binders());
-                    .or_default()
+                    impls
-                    .push(impl_id);
+                        .map
+                        .entry(target_trait)
+                        .or_default()
+                        .entry(self_ty_fp)
+                        .or_default()
+                        .push(impl_id);
+                }
+                // To better support custom derives, collect impls in all unnamed const items.
+                // const _: () = { ... };
+                for konst in module_data.scope.unnamed_consts() {
+                    let body = db.body(konst.into());
+                    for (_, block_def_map) in body.blocks(db.upcast()) {
+                        collect_def_map(db, &block_def_map, impls);
+                    }
+                }
            }
        }
-        Arc::new(impls)
    }
    pub(crate) fn trait_impls_in_deps_query(db: &dyn HirDatabase, krate: CrateId) -> Arc<Self> {
@@ -143,10 +197,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())
    }
@@ -201,17 +258,22 @@ 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());
+                always!(fp.is_some());
+                if let Some(fp) = fp {
                    map.entry(fp).or_default().push(impl_id);
                }
            }
        }
+        // NOTE: We're not collecting inherent impls from unnamed consts here, we intentionally only
+        // support trait impls there.
        Arc::new(Self { map })
    }
    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 => &[],
        }
@@ -222,15 +284,14 @@ impl InherentImpls {
    }
 }
-impl Ty {
+pub fn def_crates(
-    pub fn def_crates(
+    db: &dyn HirDatabase,
-        &self,
+    ty: &Ty,
-        db: &dyn HirDatabase,
+    cur_crate: CrateId,
-        cur_crate: CrateId,
+) -> Option<ArrayVec<CrateId, 2>> {
-    ) -> Option<ArrayVec<CrateId, 2>> {
+    // Types like slice can have inherent impls in several crates, (core and alloc).
-        // Types like slice can have inherent impls in several crates, (core and alloc).
+    // The corresponding impls are marked with lang items, so we can use them to find the required crates.
-        // The corresponding impls are marked with lang items, so we can use them to find the required crates.
+    macro_rules! lang_item_crate {
-        macro_rules! lang_item_crate {
            ($($name:expr),+ $(,)?) => {{
                let mut v = ArrayVec::<LangItemTarget, 2>::new();
                $(
@@ -240,51 +301,50 @@ impl Ty {
            }};
        }
-        let mod_to_crate_ids = |module: ModuleId| Some(std::iter::once(module.krate()).collect());
+    let mod_to_crate_ids = |module: ModuleId| Some(std::iter::once(module.krate()).collect());
-        let lang_item_targets = match self.kind(&Interner) {
+    let lang_item_targets = match ty.kind(&Interner) {
-            TyKind::Adt(AdtId(def_id), _) => {
+        TyKind::Adt(AdtId(def_id), _) => {
-                return mod_to_crate_ids(def_id.module(db.upcast()));
+            return mod_to_crate_ids(def_id.module(db.upcast()));
-            }
+        }
-            TyKind::Foreign(id) => {
+        TyKind::Foreign(id) => {
-                return mod_to_crate_ids(
+            return mod_to_crate_ids(
-                    from_foreign_def_id(*id).lookup(db.upcast()).module(db.upcast()),
+                from_foreign_def_id(*id).lookup(db.upcast()).module(db.upcast()),
-                );
+            );
-            }
+        }
-            TyKind::Scalar(Scalar::Bool) => lang_item_crate!("bool"),
+        TyKind::Scalar(Scalar::Bool) => lang_item_crate!("bool"),
-            TyKind::Scalar(Scalar::Char) => lang_item_crate!("char"),
+        TyKind::Scalar(Scalar::Char) => lang_item_crate!("char"),
-            TyKind::Scalar(Scalar::Float(f)) => match f {
+        TyKind::Scalar(Scalar::Float(f)) => match f {
-                // There are two lang items: one in libcore (fXX) and one in libstd (fXX_runtime)
+            // There are two lang items: one in libcore (fXX) and one in libstd (fXX_runtime)
-                FloatTy::F32 => lang_item_crate!("f32", "f32_runtime"),
+            FloatTy::F32 => lang_item_crate!("f32", "f32_runtime"),
-                FloatTy::F64 => lang_item_crate!("f64", "f64_runtime"),
+            FloatTy::F64 => lang_item_crate!("f64", "f64_runtime"),
-            },
+        },
-            &TyKind::Scalar(Scalar::Int(t)) => {
+        &TyKind::Scalar(Scalar::Int(t)) => {
-                lang_item_crate!(primitive::int_ty_to_string(t))
+            lang_item_crate!(primitive::int_ty_to_string(t))
-            }
+        }
-            &TyKind::Scalar(Scalar::Uint(t)) => {
+        &TyKind::Scalar(Scalar::Uint(t)) => {
-                lang_item_crate!(primitive::uint_ty_to_string(t))
+            lang_item_crate!(primitive::uint_ty_to_string(t))
-            }
+        }
-            TyKind::Str => lang_item_crate!("str_alloc", "str"),
+        TyKind::Str => lang_item_crate!("str_alloc", "str"),
-            TyKind::Slice(_) => lang_item_crate!("slice_alloc", "slice"),
+        TyKind::Slice(_) => lang_item_crate!("slice_alloc", "slice"),
-            TyKind::Raw(Mutability::Not, _) => lang_item_crate!("const_ptr"),
+        TyKind::Raw(Mutability::Not, _) => lang_item_crate!("const_ptr"),
-            TyKind::Raw(Mutability::Mut, _) => lang_item_crate!("mut_ptr"),
+        TyKind::Raw(Mutability::Mut, _) => lang_item_crate!("mut_ptr"),
-            TyKind::Dyn(_) => {
+        TyKind::Dyn(_) => {
-                return self.dyn_trait().and_then(|trait_| {
+            return ty.dyn_trait().and_then(|trait_| {
-                    mod_to_crate_ids(GenericDefId::TraitId(trait_).module(db.upcast()))
+                mod_to_crate_ids(GenericDefId::TraitId(trait_).module(db.upcast()))
-                });
+            });
-            }
+        }
-            _ => return None,
+        _ => return None,
-        };
+    };
-        let res = lang_item_targets
+    let res = lang_item_targets
-            .into_iter()
+        .into_iter()
-            .filter_map(|it| match it {
+        .filter_map(|it| match it {
-                LangItemTarget::ImplDefId(it) => Some(it),
+            LangItemTarget::ImplDefId(it) => Some(it),
-                _ => None,
+            _ => None,
-            })
+        })
-            .map(|it| it.lookup(db.upcast()).container.krate())
+        .map(|it| it.lookup(db.upcast()).container.krate())
-            .collect();
+        .collect();
-        Some(res)
+    Some(res)
-    }
 }
 /// Look up the method with the given name, returning the actual autoderefed
@@ -453,7 +513,8 @@ fn iterate_method_candidates_with_autoref(
    }
    let refed = Canonical {
        binders: deref_chain[0].binders.clone(),
-        value: TyKind::Ref(Mutability::Not, deref_chain[0].value.clone()).intern(&Interner),
+        value: TyKind::Ref(Mutability::Not, static_lifetime(), deref_chain[0].value.clone())
+            .intern(&Interner),
    };
    if iterate_method_candidates_by_receiver(
        &refed,
@@ -470,7 +531,8 @@ fn iterate_method_candidates_with_autoref(
    }
    let ref_muted = Canonical {
        binders: deref_chain[0].binders.clone(),
-        value: TyKind::Ref(Mutability::Mut, deref_chain[0].value.clone()).intern(&Interner),
+        value: TyKind::Ref(Mutability::Mut, static_lifetime(), deref_chain[0].value.clone())
+            .intern(&Interner),
    };
    if iterate_method_candidates_by_receiver(
        &ref_muted,
@@ -592,6 +654,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;
            }
@@ -609,7 +672,7 @@ fn iterate_inherent_methods(
    visible_from_module: Option<ModuleId>,
    callback: &mut dyn FnMut(&Ty, AssocItemId) -> bool,
 ) -> bool {
-    let def_crates = match self_ty.value.def_crates(db, krate) {
+    let def_crates = match def_crates(db, &self_ty.value, krate) {
        Some(k) => k,
        None => return false,
    };
@@ -709,8 +772,9 @@ pub(crate) fn inherent_impl_substs(
 ) -> Option<Substitution> {
    // we create a var for each type parameter of the impl; we need to keep in
    // mind here that `self_ty` might have vars of its own
+    let self_ty_vars = self_ty.binders.len(&Interner);
    let vars = TyBuilder::subst_for_def(db, impl_id)
-        .fill_with_bound_vars(DebruijnIndex::INNERMOST, self_ty.binders.len(&Interner))
+        .fill_with_bound_vars(DebruijnIndex::INNERMOST, self_ty_vars)
        .build();
    let self_ty_with_vars = db.impl_self_ty(impl_id).substitute(&Interner, &vars);
    let mut kinds = self_ty.binders.interned().to_vec();
@@ -725,33 +789,27 @@ pub(crate) fn inherent_impl_substs(
        binders: CanonicalVarKinds::from_iter(&Interner, kinds),
        value: (self_ty_with_vars, self_ty.value.clone()),
    };
-    let substs = super::infer::unify(&tys);
+    let substs = super::infer::unify(&tys)?;
    // We only want the substs for the vars we added, not the ones from self_ty.
    // Also, if any of the vars we added are still in there, we replace them by
    // Unknown. I think this can only really happen if self_ty contained
    // Unknown, and in that case we want the result to contain Unknown in those
    // places again.
-    substs
+    let suffix =
-        .map(|s| fallback_bound_vars(s.suffix(vars.len(&Interner)), self_ty.binders.len(&Interner)))
+        Substitution::from_iter(&Interner, substs.iter(&Interner).cloned().skip(self_ty_vars));
+    Some(fallback_bound_vars(suffix, self_ty_vars))
 }
 /// 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(
@@ -826,7 +884,7 @@ fn generic_implements_goal(
    let obligation = trait_ref.cast(&Interner);
    Canonical {
        binders: CanonicalVarKinds::from_iter(&Interner, kinds),
-        value: InEnvironment::new(env.env.clone(), obligation),
+        value: InEnvironment::new(&env.env, obligation),
    }
 }
@@ -837,7 +895,9 @@ fn autoderef_method_receiver(
 ) -> Vec<Canonical<Ty>> {
    let mut deref_chain: Vec<_> = autoderef::autoderef(db, Some(krate), ty).collect();
    // As a last step, we can do array unsizing (that's the only unsizing that rustc does for method receivers!)
-    if let Some(TyKind::Array(parameters)) = deref_chain.last().map(|ty| ty.value.kind(&Interner)) {
+    if let Some(TyKind::Array(parameters, _)) =
+        deref_chain.last().map(|ty| ty.value.kind(&Interner))
+    {
        let kinds = deref_chain.last().unwrap().binders.clone();
        let unsized_ty = TyKind::Slice(parameters.clone()).intern(&Interner);
        deref_chain.push(Canonical { value: unsized_ty, binders: kinds })
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/method_resolution.rs b/crates/hir_ty/src/tests/method_resolution.rs
index 61f18b0d2..4b2c82b41 100644
--- a/crates/hir_ty/src/tests/method_resolution.rs
+++ b/crates/hir_ty/src/tests/method_resolution.rs
@@ -1292,3 +1292,25 @@ mod b {
        "#]],
    )
 }
+#[test]
+fn impl_in_unnamed_const() {
+    check_types(
+        r#"
+struct S;
+trait Tr {
+    fn method(&self) -> u16;
+}
+const _: () = {
+    impl Tr for S {}
+};
+fn f() {
+    S.method();
+  //^^^^^^^^^^ u16
+}
+    "#,
+    );
+}
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/simple.rs b/crates/hir_ty/src/tests/simple.rs
index 361cd6302..84c5c05fd 100644
--- a/crates/hir_ty/src/tests/simple.rs
+++ b/crates/hir_ty/src/tests/simple.rs
@@ -2564,3 +2564,36 @@ fn f() {
    "#,
    )
 }
+#[test]
+fn infer_type_alias_variant() {
+    check_infer(
+        r#"
+type Qux = Foo;
+enum Foo {
+    Bar(i32),
+    Baz { baz: f32 }
+}
+fn f() {
+    match Foo::Bar(3) {
+        Qux::Bar(bar) => (),
+        Qux::Baz { baz } => (),
+    }
+}
+    "#,
+        expect![[r#"
+            72..166 '{     ...   } }': ()
+            78..164 'match ...     }': ()
+            84..92 'Foo::Bar': Bar(i32) -> Foo
+            84..95 'Foo::Bar(3)': Foo
+            93..94 '3': i32
+            106..119 'Qux::Bar(bar)': Foo
+            115..118 'bar': i32
+            123..125 '()': ()
+            135..151 'Qux::B... baz }': Foo
+            146..149 'baz': f32
+            155..157 '()': ()
+        "#]],
+    )
+}
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 c8883485c..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, SolutionVariables, 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,34 +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 {
-    let convert_subst = |subst: chalk_ir::Canonical<chalk_ir::Substitution<Interner>>| {
-        let result = from_chalk(db, subst);
-        SolutionVariables(result)
-    };
-    match solution {
-        chalk_solve::Solution::Unique(constr_subst) => {
-            let subst = chalk_ir::Canonical {
-                value: constr_subst.value.subst,
-                binders: constr_subst.binders,
-            };
-            Solution::Unique(convert_subst(subst))
-        }
-        chalk_solve::Solution::Ambig(chalk_solve::Guidance::Definite(subst)) => {
-            Solution::Ambig(Guidance::Definite(convert_subst(subst)))
-        }
-        chalk_solve::Solution::Ambig(chalk_solve::Guidance::Suggested(subst)) => {
-            Solution::Ambig(Guidance::Suggested(convert_subst(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 c3b148cab..000000000
--- a/crates/hir_ty/src/traits/chalk/mapping.rs
+++ /dev/null
@@ -1,572 +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, fold::shift::Shift, interner::HasInterner, LifetimeData};
-use chalk_solve::rust_ir;
-use base_db::salsa::InternKey;
-use hir_def::{GenericDefId, TypeAliasId};
-use crate::{
-    db::HirDatabase, primitive::UintTy, AliasTy, CallableDefId, Canonical, DomainGoal, FnPointer,
-    GenericArg, InEnvironment, OpaqueTy, ProjectionTy, QuantifiedWhereClause, Scalar, 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, ty) => ref_to_chalk(db, m, ty),
-            TyKind::Array(ty) => array_to_chalk(db, ty),
-            TyKind::Function(FnPointer { sig, substs, .. }) => {
-                let substitution = chalk_ir::FnSubst(substs.to_chalk(db).shifted_in(&Interner));
-                chalk_ir::TyKind::Function(chalk_ir::FnPointer {
-                    num_binders: 0,
-                    sig,
-                    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)) => {
-                let associated_ty_id = proj_ty.associated_ty_id;
-                let substitution = proj_ty.substitution.to_chalk(db);
-                chalk_ir::AliasTy::Projection(chalk_ir::ProjectionTy {
-                    associated_ty_id,
-                    substitution,
-                })
-                .cast(&Interner)
-                .intern(&Interner)
-            }
-            TyKind::Alias(AliasTy::Opaque(opaque_ty)) => {
-                let opaque_ty_id = opaque_ty.opaque_ty_id;
-                let substitution = opaque_ty.substitution.to_chalk(db);
-                chalk_ir::AliasTy::Opaque(chalk_ir::OpaqueTy { opaque_ty_id, substitution })
-                    .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: LifetimeData::Static.intern(&Interner),
-                };
-                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)),
-            chalk_ir::TyKind::Placeholder(idx) => TyKind::Placeholder(idx),
-            chalk_ir::TyKind::Alias(chalk_ir::AliasTy::Projection(proj)) => {
-                let associated_ty = proj.associated_ty_id;
-                let parameters = from_chalk(db, proj.substitution);
-                TyKind::Alias(AliasTy::Projection(ProjectionTy {
-                    associated_ty_id: associated_ty,
-                    substitution: parameters,
-                }))
-            }
-            chalk_ir::TyKind::Alias(chalk_ir::AliasTy::Opaque(opaque_ty)) => {
-                let opaque_ty_id = opaque_ty.opaque_ty_id;
-                let parameters = from_chalk(db, opaque_ty.substitution);
-                TyKind::Alias(AliasTy::Opaque(OpaqueTy { opaque_ty_id, substitution: parameters }))
-            }
-            chalk_ir::TyKind::Function(chalk_ir::FnPointer {
-                num_binders,
-                sig,
-                substitution,
-                ..
-            }) => {
-                assert_eq!(num_binders, 0);
-                let substs: Substitution = from_chalk(
-                    db,
-                    substitution.0.shifted_out(&Interner).expect("fn ptr should have no binders"),
-                );
-                TyKind::Function(FnPointer { num_args: (substs.len(&Interner) - 1), sig, substs })
-            }
-            chalk_ir::TyKind::BoundVar(idx) => TyKind::BoundVar(idx),
-            chalk_ir::TyKind::InferenceVar(_iv, _kind) => TyKind::Error,
-            chalk_ir::TyKind::Dyn(where_clauses) => {
-                assert_eq!(where_clauses.bounds.binders.len(&Interner), 1);
-                let bounds = where_clauses
-                    .bounds
-                    .skip_binders()
-                    .iter(&Interner)
-                    .map(|c| from_chalk(db, c.clone()));
-                TyKind::Dyn(crate::DynTy {
-                    bounds: crate::Binders::new(
-                        where_clauses.bounds.binders.clone(),
-                        crate::QuantifiedWhereClauses::from_iter(&Interner, bounds),
-                    ),
-                })
-            }
-            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) => {
-                TyKind::Ref(mutability, 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)
-    }
-}
-/// We currently don't model lifetimes, but Chalk does. So, we have to insert a
-/// fake lifetime here, because Chalks built-in logic may expect it to be there.
-fn ref_to_chalk(
-    db: &dyn HirDatabase,
-    mutability: chalk_ir::Mutability,
-    ty: Ty,
-) -> chalk_ir::Ty<Interner> {
-    let arg = ty.to_chalk(db);
-    let lifetime = LifetimeData::Static.intern(&Interner);
-    chalk_ir::TyKind::Ref(mutability, lifetime, arg).intern(&Interner)
-}
-/// We currently don't model constants, but Chalk does. So, we have to insert a
-/// fake constant here, because Chalks built-in logic may expect it to be there.
-fn array_to_chalk(db: &dyn HirDatabase, ty: Ty) -> chalk_ir::Ty<Interner> {
-    let arg = ty.to_chalk(db);
-    let usize_ty = chalk_ir::TyKind::Scalar(Scalar::Uint(UintTy::Usize)).intern(&Interner);
-    let const_ = chalk_ir::ConstData {
-        ty: usize_ty,
-        value: chalk_ir::ConstValue::Concrete(chalk_ir::ConcreteConst { interned: () }),
-    }
-    .intern(&Interner);
-    chalk_ir::TyKind::Array(arg, const_).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))
-    }
-}
-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 46c705a76..000000000
--- a/crates/hir_ty/src/types.rs
+++ /dev/null
@@ -1,475 +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::{CastTo, Caster},
-    BoundVar, Mutability, Scalar, TyVariableKind,
-};
-use hir_def::LifetimeParamId;
-use smallvec::SmallVec;
-use crate::{
-    AssocTypeId, CanonicalVarKinds, ChalkTraitId, ClosureId, FnDefId, FnSig, ForeignDefId,
-    InferenceVar, Interner, OpaqueTyId, PlaceholderIndex, TypeWalk, VariableKinds,
-};
-#[derive(Clone, PartialEq, Eq, Debug, Hash)]
-pub enum Lifetime {
-    Parameter(LifetimeParamId),
-    Static,
-}
-#[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,
-}
-#[derive(Clone, PartialEq, Eq, Debug, Hash)]
-pub struct DynTy {
-    /// The unknown self type.
-    pub bounds: Binders<QuantifiedWhereClauses>,
-}
-#[derive(Clone, PartialEq, Eq, Debug, Hash)]
-pub struct FnPointer {
-    pub num_args: usize,
-    pub sig: FnSig,
-    pub substs: 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),
-    /// 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, 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) -> &[GenericArg] {
-        &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 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: 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,
-}
-/// 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, 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 SolutionVariables(pub Canonical<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(SolutionVariables),
-    /// 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(SolutionVariables),
-    /// 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(SolutionVariables),
-    /// There's no useful information to feed back to type inference
-    Unknown,
-}
diff --git a/crates/hir_ty/src/utils.rs b/crates/hir_ty/src/utils.rs
index d11708299..5f6cb052a 100644
--- a/crates/hir_ty/src/utils.rs
+++ b/crates/hir_ty/src/utils.rs
@@ -1,10 +1,8 @@
 //! 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::{
-    adt::VariantData,
    db::DefDatabase,
    generics::{
        GenericParams, TypeParamData, TypeParamProvenance, WherePredicate, WherePredicateTypeTarget,
@@ -13,11 +11,11 @@ use hir_def::{
    path::Path,
    resolver::{HasResolver, TypeNs},
    type_ref::TypeRef,
-    AssocContainerId, GenericDefId, Lookup, TraitId, TypeAliasId, TypeParamId, VariantId,
+    AssocContainerId, GenericDefId, Lookup, TraitId, TypeAliasId, TypeParamId,
 };
 use hir_expand::name::{name, Name};
-use crate::{db::HirDatabase, Interner, Substitution, TraitRef, TyKind, TypeWalk, WhereClause};
+use crate::{db::HirDatabase, Interner, Substitution, TraitRef, TraitRefExt, TyKind, WhereClause};
 fn direct_super_traits(db: &dyn DefDatabase, trait_: TraitId) -> Vec<TraitId> {
    let resolver = trait_.resolver(db);
@@ -68,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,
@@ -136,25 +134,6 @@ pub(super) fn associated_type_by_name_including_super_traits(
    })
 }
-pub(super) fn variant_data(db: &dyn DefDatabase, var: VariantId) -> Arc<VariantData> {
-    match var {
-        VariantId::StructId(it) => db.struct_data(it).variant_data.clone(),
-        VariantId::UnionId(it) => db.union_data(it).variant_data.clone(),
-        VariantId::EnumVariantId(it) => {
-            db.enum_data(it.parent).variants[it.local_id].variant_data.clone()
-        }
-    }
-}
-/// 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 b85e6ab4d..6ef1d5336 100644
--- a/crates/hir_ty/src/walk.rs
+++ b/crates/hir_ty/src/walk.rs
@@ -1,130 +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, GenericArg, GenericArgData,
+    AliasEq, AliasTy, Binders, CallableSig, FnSubst, GenericArg, GenericArgData, Interner,
-    Interner, OpaqueTy, ProjectionTy, Substitution, TraitRef, Ty, TyKind, WhereClause,
+    OpaqueTy, ProjectionTy, Substitution, TraitRef, Ty, TyKind, 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
-    }
-    /// 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 {
@@ -145,47 +32,26 @@ impl TypeWalk for Ty {
                    p.walk(f);
                }
            }
-            TyKind::Slice(ty) | TyKind::Array(ty) | TyKind::Ref(_, ty) | TyKind::Raw(_, ty) => {
+            TyKind::Slice(ty)
+            | TyKind::Array(ty, _)
+            | TyKind::Ref(_, _, ty)
+            | TyKind::Raw(_, ty) => {
                ty.walk(f);
            }
-            _ => {
+            TyKind::Function(fn_pointer) => {
-                if let Some(substs) = self.substs() {
+                fn_pointer.substitution.0.walk(f);
-                    for t in substs.iter(&Interner) {
-                        t.walk(f);
-                    }
-                }
-            }
-        }
-        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) => {
+            TyKind::Adt(_, substs)
-                ty.walk_mut_binders(f, binders);
+            | TyKind::FnDef(_, substs)
-            }
+            | TyKind::Tuple(_, substs)
-            _ => {
+            | TyKind::OpaqueType(_, substs)
-                if let Some(substs) = self.substs_mut() {
+            | TyKind::AssociatedType(_, substs)
-                    substs.walk_mut_binders(f, binders);
+            | TyKind::Closure(.., substs) => {
-                }
+                substs.walk(f);
            }
+            _ => {}
        }
-        f(self, binders);
+        f(self);
    }
 }
@@ -195,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 {
@@ -241,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 {
@@ -260,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);
-            }
        }
    }
 }
@@ -282,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 {
@@ -327,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),
        }
    }
 }
@@ -348,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 {
@@ -368,16 +141,10 @@ impl TypeWalk for AliasEq {
            AliasTy::Opaque(opaque) => opaque.walk(f),
        }
    }
+}
-    fn walk_mut_binders(
+impl TypeWalk for FnSubst<Interner> {
-        &mut self,
+    fn walk(&self, f: &mut impl FnMut(&Ty)) {
-        f: &mut impl FnMut(&mut Ty, DebruijnIndex),
+        self.0.walk(f)
-        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),
-        }
    }
 }
diff --git a/crates/ide/src/diagnostics.rs b/crates/ide/src/diagnostics.rs
index dd42116a7..0ace80a1e 100644
--- a/crates/ide/src/diagnostics.rs
+++ b/crates/ide/src/diagnostics.rs
@@ -20,7 +20,7 @@ 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;
@@ -159,14 +159,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))
-                    d.message(),
+                    .with_code(Some(d.code())),
-                )
-                .with_fix(d.fix(&sema))
-                .with_code(Some(d.code())),
            );
        })
        .on::<hir::diagnostics::UnresolvedProcMacro, _>(|d| {
diff --git a/crates/ide/src/expand_macro.rs b/crates/ide/src/expand_macro.rs
index 9eeabbeda..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,24 +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 => format!("}}\n{}", "  ".repeat(indent)),
+            R_CURLY => {
-            T![;] => format!(";\n{}", "  ".repeat(indent)),
+                res.push_str("}\n");
-            T![->] => " -> ".to_string(),
+                res.extend(iter::repeat(" ").take(2 * indent));
-            T![=] => " = ".to_string(),
+            }
-            T![=>] => " => ".to_string(),
+            LIFETIME_IDENT if is_next(|it| it == IDENT, true) => {
-            _ => token.text().to_string(),
+                res.push_str(token.text());
-        };
+                res.push(' ');
+            }
+            T![;] => {
+                res.push_str(";\n");
+                res.extend(iter::repeat(" ").take(2 * indent));
+            }
+            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/folding_ranges.rs b/crates/ide/src/folding_ranges.rs
index 153726ce8..2b9ed123c 100644
--- a/crates/ide/src/folding_ranges.rs
+++ b/crates/ide/src/folding_ranges.rs
@@ -19,6 +19,7 @@ pub enum FoldKind {
    Region,
    Consts,
    Statics,
+    Array,
 }
 #[derive(Debug)]
@@ -119,6 +120,7 @@ fn fold_kind(kind: SyntaxKind) -> Option<FoldKind> {
    match kind {
        COMMENT => Some(FoldKind::Comment),
        ARG_LIST | PARAM_LIST => Some(FoldKind::ArgList),
+        ARRAY_EXPR => Some(FoldKind::Array),
        ASSOC_ITEM_LIST
        | RECORD_FIELD_LIST
        | RECORD_PAT_FIELD_LIST
@@ -269,6 +271,7 @@ mod tests {
                FoldKind::Region => "region",
                FoldKind::Consts => "consts",
                FoldKind::Statics => "statics",
+                FoldKind::Array => "array",
            };
            assert_eq!(kind, &attr.unwrap());
        }
@@ -465,6 +468,20 @@ fn foo<fold arglist>(
    }
    #[test]
+    fn fold_multiline_array() {
+        check(
+            r#"
+const FOO: [usize; 4] = <fold array>[
+    1,
+    2,
+    3,
+    4,
+]</fold>;
+"#,
+        )
+    }
+    #[test]
    fn fold_region() {
        check(
            r#"
diff --git a/crates/ide/src/syntax_highlighting/highlight.rs b/crates/ide/src/syntax_highlighting/highlight.rs
index 5ccb84714..e921784bf 100644
--- a/crates/ide/src/syntax_highlighting/highlight.rs
+++ b/crates/ide/src/syntax_highlighting/highlight.rs
@@ -323,8 +323,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/tests.rs b/crates/ide/src/syntax_highlighting/tests.rs
index 1b02857ec..de2d22ac7 100644
--- a/crates/ide/src/syntax_highlighting/tests.rs
+++ b/crates/ide/src/syntax_highlighting/tests.rs
@@ -1,5 +1,8 @@
+use std::time::Instant;
 use expect_test::{expect_file, ExpectFile};
 use ide_db::SymbolKind;
+use stdx::format_to;
 use test_utils::{bench, bench_fixture, skip_slow_tests};
 use crate::{fixture, FileRange, HlTag, TextRange};
@@ -258,6 +261,99 @@ fn benchmark_syntax_highlighting_long_struct() {
 }
 #[test]
+fn syntax_highlighting_not_quadratic() {
+    if skip_slow_tests() {
+        return;
+    }
+    let mut measures = Vec::new();
+    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();
+        measures.push((n as f64, elapsed.as_millis() as f64))
+    }
+    assert_linear(&measures)
+}
+/// Checks that a set of measurements looks like a liner 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
+fn assert_linear(xy: &[(f64, f64)]) {
+    let (mut xs, mut ys): (Vec<_>, Vec<_>) = xy.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;
+    let mut 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!(plot, "{:.3} {:.3} {:.3}\n", x, y, y_pred);
+    }
+    let rmse = (se / xs.len() as f64).sqrt();
+    format_to!(plot, "\nrmse = {:.3} max error = {:.3}", rmse, max_error);
+    assert!(rmse < 0.05 && max_error < 0.1 && a > -0.1, "\nLooks quadratic\n{}", plot);
+    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)
+    }
+}
+#[test]
 fn benchmark_syntax_highlighting_parser() {
    if skip_slow_tests() {
        return;
diff --git a/crates/ide/src/typing.rs b/crates/ide/src/typing.rs
index 11408d445..1378048e5 100644
--- a/crates/ide/src/typing.rs
+++ b/crates/ide/src/typing.rs
@@ -22,18 +22,19 @@ use ide_db::{
 use syntax::{
    algo::find_node_at_offset,
    ast::{self, edit::IndentLevel, AstToken},
-    AstNode, SourceFile,
+    AstNode, Parse, SourceFile,
    SyntaxKind::{FIELD_EXPR, METHOD_CALL_EXPR},
    TextRange, TextSize,
 };
-use text_edit::TextEdit;
+use text_edit::{Indel, TextEdit};
 use crate::SourceChange;
 pub(crate) use on_enter::on_enter;
-pub(crate) const TRIGGER_CHARS: &str = ".=>";
+// Don't forget to add new trigger characters to `server_capabilities` in `caps.rs`.
+pub(crate) const TRIGGER_CHARS: &str = ".=>{";
 // Feature: On Typing Assists
 //
@@ -41,6 +42,7 @@ pub(crate) const TRIGGER_CHARS: &str = ".=>";
 //
 // - typing `let =` tries to smartly add `;` if `=` is followed by an existing expression
 // - typing `.` in a chain method call auto-indents
+// - typing `{` in front of an expression inserts a closing `}` after the expression
 //
 // VS Code::
 //
@@ -57,28 +59,79 @@ pub(crate) fn on_char_typed(
    position: FilePosition,
    char_typed: char,
 ) -> Option<SourceChange> {
-    assert!(TRIGGER_CHARS.contains(char_typed));
+    if !stdx::always!(TRIGGER_CHARS.contains(char_typed)) {
-    let file = &db.parse(position.file_id).tree();
+        return None;
-    assert_eq!(file.syntax().text().char_at(position.offset), Some(char_typed));
+    }
+    let file = &db.parse(position.file_id);
+    if !stdx::always!(file.tree().syntax().text().char_at(position.offset) == Some(char_typed)) {
+        return None;
+    }
    let edit = on_char_typed_inner(file, position.offset, char_typed)?;
    Some(SourceChange::from_text_edit(position.file_id, edit))
 }
-fn on_char_typed_inner(file: &SourceFile, offset: TextSize, char_typed: char) -> Option<TextEdit> {
+fn on_char_typed_inner(
-    assert!(TRIGGER_CHARS.contains(char_typed));
+    file: &Parse<SourceFile>,
+    offset: TextSize,
+    char_typed: char,
+) -> Option<TextEdit> {
+    if !stdx::always!(TRIGGER_CHARS.contains(char_typed)) {
+        return None;
+    }
    match char_typed {
-        '.' => on_dot_typed(file, offset),
+        '.' => on_dot_typed(&file.tree(), offset),
-        '=' => on_eq_typed(file, offset),
+        '=' => on_eq_typed(&file.tree(), offset),
-        '>' => on_arrow_typed(file, offset),
+        '>' => on_arrow_typed(&file.tree(), offset),
+        '{' => on_opening_brace_typed(file, offset),
        _ => unreachable!(),
    }
 }
+/// Inserts a closing `}` when the user types an opening `{`, wrapping an existing expression in a
+/// block.
+fn on_opening_brace_typed(file: &Parse<SourceFile>, offset: TextSize) -> Option<TextEdit> {
+    if !stdx::always!(file.tree().syntax().text().char_at(offset) == Some('{')) {
+        return None;
+    }
+    let brace_token = file.tree().syntax().token_at_offset(offset).right_biased()?;
+    // Remove the `{` to get a better parse tree, and reparse
+    let file = file.reparse(&Indel::delete(brace_token.text_range()));
+    let mut expr: ast::Expr = find_node_at_offset(file.tree().syntax(), offset)?;
+    if expr.syntax().text_range().start() != offset {
+        return None;
+    }
+    // Enclose the outermost expression starting at `offset`
+    while let Some(parent) = expr.syntax().parent() {
+        if parent.text_range().start() != expr.syntax().text_range().start() {
+            break;
+        }
+        match ast::Expr::cast(parent) {
+            Some(parent) => expr = parent,
+            None => break,
+        }
+    }
+    // If it's a statement in a block, we don't know how many statements should be included
+    if ast::ExprStmt::can_cast(expr.syntax().parent()?.kind()) {
+        return None;
+    }
+    // Insert `}` right after the expression.
+    Some(TextEdit::insert(expr.syntax().text_range().end() + TextSize::of("{"), "}".to_string()))
+}
 /// Returns an edit which should be applied after `=` was typed. Primarily,
 /// this works when adding `let =`.
 // FIXME: use a snippet completion instead of this hack here.
 fn on_eq_typed(file: &SourceFile, offset: TextSize) -> Option<TextEdit> {
-    assert_eq!(file.syntax().text().char_at(offset), Some('='));
+    if !stdx::always!(file.syntax().text().char_at(offset) == Some('=')) {
+        return None;
+    }
    let let_stmt: ast::LetStmt = find_node_at_offset(file.syntax(), offset)?;
    if let_stmt.semicolon_token().is_some() {
        return None;
@@ -100,7 +153,9 @@ fn on_eq_typed(file: &SourceFile, offset: TextSize) -> Option<TextEdit> {
 /// Returns an edit which should be applied when a dot ('.') is typed on a blank line, indenting the line appropriately.
 fn on_dot_typed(file: &SourceFile, offset: TextSize) -> Option<TextEdit> {
-    assert_eq!(file.syntax().text().char_at(offset), Some('.'));
+    if !stdx::always!(file.syntax().text().char_at(offset) == Some('.')) {
+        return None;
+    }
    let whitespace =
        file.syntax().token_at_offset(offset).left_biased().and_then(ast::Whitespace::cast)?;
@@ -129,7 +184,9 @@ fn on_dot_typed(file: &SourceFile, offset: TextSize) -> Option<TextEdit> {
 /// Adds a space after an arrow when `fn foo() { ... }` is turned into `fn foo() -> { ... }`
 fn on_arrow_typed(file: &SourceFile, offset: TextSize) -> Option<TextEdit> {
    let file_text = file.syntax().text();
-    assert_eq!(file_text.char_at(offset), Some('>'));
+    if !stdx::always!(file_text.char_at(offset) == Some('>')) {
+        return None;
+    }
    let after_arrow = offset + TextSize::of('>');
    if file_text.char_at(after_arrow) != Some('{') {
        return None;
@@ -152,7 +209,7 @@ mod tests {
        let edit = TextEdit::insert(offset, char_typed.to_string());
        edit.apply(&mut before);
        let parse = SourceFile::parse(&before);
-        on_char_typed_inner(&parse.tree(), offset, char_typed).map(|it| {
+        on_char_typed_inner(&parse, offset, char_typed).map(|it| {
            it.apply(&mut before);
            before.to_string()
        })
@@ -373,4 +430,85 @@ fn main() {
    fn adds_space_after_return_type() {
        type_char('>', "fn foo() -$0{ 92 }", "fn foo() -> { 92 }")
    }
+    #[test]
+    fn adds_closing_brace() {
+        type_char(
+            '{',
+            r#"
+fn f() { match () { _ => $0() } }
+            "#,
+            r#"
+fn f() { match () { _ => {()} } }
+            "#,
+        );
+        type_char(
+            '{',
+            r#"
+fn f() { $0() }
+            "#,
+            r#"
+fn f() { {()} }
+            "#,
+        );
+        type_char(
+            '{',
+            r#"
+fn f() { let x = $0(); }
+            "#,
+            r#"
+fn f() { let x = {()}; }
+            "#,
+        );
+        type_char(
+            '{',
+            r#"
+fn f() { let x = $0a.b(); }
+            "#,
+            r#"
+fn f() { let x = {a.b()}; }
+            "#,
+        );
+        type_char(
+            '{',
+            r#"
+const S: () = $0();
+fn f() {}
+            "#,
+            r#"
+const S: () = {()};
+fn f() {}
+            "#,
+        );
+        type_char(
+            '{',
+            r#"
+const S: () = $0a.b();
+fn f() {}
+            "#,
+            r#"
+const S: () = {a.b()};
+fn f() {}
+            "#,
+        );
+        type_char(
+            '{',
+            r#"
+fn f() {
+    match x {
+        0 => $0(),
+        1 => (),
+    }
+}
+            "#,
+            r#"
+fn f() {
+    match x {
+        0 => {()},
+        1 => (),
+    }
+}
+            "#,
+        );
+    }
 }
diff --git a/crates/ide/src/typing/on_enter.rs b/crates/ide/src/typing/on_enter.rs
index 9144681bf..6f1ce3689 100644
--- a/crates/ide/src/typing/on_enter.rs
+++ b/crates/ide/src/typing/on_enter.rs
@@ -18,6 +18,7 @@ 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 `//!`
 //
 // This action needs to be assigned to shortcut explicitly.
 //
@@ -187,6 +188,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"
diff --git a/crates/ide_assists/src/handlers/remove_dbg.rs b/crates/ide_assists/src/handlers/remove_dbg.rs
index 6114091f2..c8226550f 100644
--- a/crates/ide_assists/src/handlers/remove_dbg.rs
+++ b/crates/ide_assists/src/handlers/remove_dbg.rs
@@ -1,5 +1,5 @@
 use syntax::{
-    ast::{self, AstNode},
+    ast::{self, AstNode, AstToken},
    match_ast, SyntaxElement, TextRange, TextSize, T,
 };
@@ -24,7 +24,39 @@ pub(crate) fn remove_dbg(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
    let macro_call = ctx.find_node_at_offset::<ast::MacroCall>()?;
    let new_contents = adjusted_macro_contents(&macro_call)?;
-    let macro_text_range = macro_call.syntax().text_range();
+    let parent = macro_call.syntax().parent();
+    let macro_text_range = if let Some(it) = parent.as_ref() {
+        if new_contents.is_empty() {
+            match_ast! {
+                match it {
+                    ast::BlockExpr(_it) => {
+                        macro_call.syntax()
+                            .prev_sibling_or_token()
+                            .and_then(whitespace_start)
+                            .map(|start| TextRange::new(start, macro_call.syntax().text_range().end()))
+                            .unwrap_or(macro_call.syntax().text_range())
+                    },
+                    ast::ExprStmt(it) => {
+                        let start = it
+                            .syntax()
+                            .prev_sibling_or_token()
+                            .and_then(whitespace_start)
+                            .unwrap_or(it.syntax().text_range().start());
+                        let end = it.syntax().text_range().end();
+                        TextRange::new(start, end)
+                    },
+                    _ => macro_call.syntax().text_range()
+                }
+            }
+        } else {
+            macro_call.syntax().text_range()
+        }
+    } else {
+        macro_call.syntax().text_range()
+    };
    let macro_end = if macro_call.semicolon_token().is_some() {
        macro_text_range.end() - TextSize::of(';')
    } else {
@@ -36,11 +68,22 @@ pub(crate) fn remove_dbg(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
        "Remove dbg!()",
        macro_text_range,
        |builder| {
-            builder.replace(TextRange::new(macro_text_range.start(), macro_end), new_contents);
+            builder.replace(
+                TextRange::new(macro_text_range.start(), macro_end),
+                if new_contents.is_empty() && parent.and_then(ast::LetStmt::cast).is_some() {
+                    ast::make::expr_unit().to_string()
+                } else {
+                    new_contents
+                },
+            );
        },
    )
 }
+fn whitespace_start(it: SyntaxElement) -> Option<TextSize> {
+    Some(it.into_token().and_then(ast::Whitespace::cast)?.syntax().text_range().start())
+}
 fn adjusted_macro_contents(macro_call: &ast::MacroCall) -> Option<String> {
    let contents = get_valid_macrocall_contents(&macro_call, "dbg")?;
    let macro_text_with_brackets = macro_call.token_tree()?.syntax().text();
@@ -94,15 +137,11 @@ fn get_valid_macrocall_contents(
    let mut contents_between_brackets = children_with_tokens.collect::<Vec<_>>();
    let last_child = contents_between_brackets.pop()?;
-    if contents_between_brackets.is_empty() {
+    match (first_child.kind(), last_child.kind()) {
-        None
+        (T!['('], T![')']) | (T!['['], T![']']) | (T!['{'], T!['}']) => {
-    } else {
+            Some(contents_between_brackets)
-        match (first_child.kind(), last_child.kind()) {
-            (T!['('], T![')']) | (T!['['], T![']']) | (T!['{'], T!['}']) => {
-                Some(contents_between_brackets)
-            }
-            _ => None,
        }
+        _ => None,
    }
 }
@@ -418,4 +457,48 @@ fn main() {
 }"#,
        );
    }
+    #[test]
+    fn test_remove_empty_dbg() {
+        check_assist(remove_dbg, r#"fn foo() { $0dbg!(); }"#, r#"fn foo() { }"#);
+        check_assist(
+            remove_dbg,
+            r#"
+fn foo() {
+    $0dbg!();
+}
+"#,
+            r#"
+fn foo() {
+}
+"#,
+        );
+        check_assist(
+            remove_dbg,
+            r#"
+fn foo() {
+    let test = $0dbg!();
+}"#,
+            r#"
+fn foo() {
+    let test = ();
+}"#,
+        );
+        check_assist(
+            remove_dbg,
+            r#"
+fn foo() {
+    let t = {
+        println!("Hello, world");
+        $0dbg!()
+    };
+}"#,
+            r#"
+fn foo() {
+    let t = {
+        println!("Hello, world");
+    };
+}"#,
+        );
+    }
 }
diff --git a/crates/ide_completion/src/completions/flyimport.rs b/crates/ide_completion/src/completions/flyimport.rs
index 1ad017198..9ace13e41 100644
--- a/crates/ide_completion/src/completions/flyimport.rs
+++ b/crates/ide_completion/src/completions/flyimport.rs
@@ -113,6 +113,7 @@ pub(crate) fn import_on_the_fly(acc: &mut Completions, ctx: &CompletionContext)
    if ctx.use_item_syntax.is_some()
        || ctx.attribute_under_caret.is_some()
        || ctx.mod_declaration_under_caret.is_some()
+        || ctx.record_lit_syntax.is_some()
    {
        return None;
    }
@@ -1034,4 +1035,46 @@ fn main() {
            expect![[]],
        );
    }
+    #[test]
+    fn no_fuzzy_during_fields_of_record_lit_syntax() {
+        check(
+            r#"
+mod m {
+    pub fn some_fn() -> i32 {
+        42
+    }
+}
+struct Foo {
+    some_field: i32,
+}
+fn main() {
+    let _ = Foo { so$0 };
+}
+"#,
+            expect![[]],
+        );
+    }
+    #[test]
+    fn fuzzy_after_fields_of_record_lit_syntax() {
+        check(
+            r#"
+mod m {
+    pub fn some_fn() -> i32 {
+        42
+    }
+}
+struct Foo {
+    some_field: i32,
+}
+fn main() {
+    let _ = Foo { some_field: so$0 };
+}
+"#,
+            expect![[r#"
+                fn some_fn() (m::some_fn) fn() -> i32
+            "#]],
+        );
+    }
 }
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/ide_db/src/apply_change.rs b/crates/ide_db/src/apply_change.rs
index 111e9325a..6c67425d7 100644
--- a/crates/ide_db/src/apply_change.rs
+++ b/crates/ide_db/src/apply_change.rs
@@ -152,6 +152,10 @@ impl RootDatabase {
            hir::db::FileItemTreeQuery
            hir::db::BlockDefMapQuery
            hir::db::CrateDefMapQueryQuery
+            hir::db::FieldsAttrsQuery
+            hir::db::VariantsAttrsQuery
+            hir::db::FieldsAttrsSourceMapQuery
+            hir::db::VariantsAttrsSourceMapQuery
            hir::db::StructDataQuery
            hir::db::UnionDataQuery
            hir::db::EnumDataQuery
diff --git a/crates/paths/src/lib.rs b/crates/paths/src/lib.rs
index 22011cb33..f09ad37e3 100644
--- a/crates/paths/src/lib.rs
+++ b/crates/paths/src/lib.rs
@@ -1,6 +1,7 @@
 //! Thin wrappers around `std::path`, distinguishing between absolute and
 //! relative paths.
 use std::{
+    borrow::Borrow,
    convert::{TryFrom, TryInto},
    ops,
    path::{Component, Path, PathBuf},
@@ -35,6 +36,12 @@ impl AsRef<AbsPath> for AbsPathBuf {
    }
 }
+impl Borrow<AbsPath> for AbsPathBuf {
+    fn borrow(&self) -> &AbsPath {
+        self.as_path()
+    }
+}
 impl TryFrom<PathBuf> for AbsPathBuf {
    type Error = PathBuf;
    fn try_from(path_buf: PathBuf) -> Result<AbsPathBuf, PathBuf> {
diff --git a/crates/project_model/src/build_data.rs b/crates/project_model/src/build_data.rs
index f7050be4e..0d4d39fef 100644
--- a/crates/project_model/src/build_data.rs
+++ b/crates/project_model/src/build_data.rs
@@ -13,12 +13,12 @@ use cargo_metadata::{BuildScript, Message};
 use itertools::Itertools;
 use paths::{AbsPath, AbsPathBuf};
 use rustc_hash::FxHashMap;
-use stdx::JodChild;
+use stdx::{format_to, JodChild};
 use crate::{cfg_flag::CfgFlag, CargoConfig};
 #[derive(Debug, Clone, Default, PartialEq, Eq)]
-pub(crate) struct BuildData {
+pub(crate) struct PackageBuildData {
    /// List of config flags defined by this package's build script
    pub(crate) cfgs: Vec<CfgFlag>,
    /// List of cargo-related environment variables with their value
@@ -32,6 +32,17 @@ pub(crate) struct BuildData {
    pub(crate) proc_macro_dylib_path: Option<AbsPathBuf>,
 }
+#[derive(Debug, Default, PartialEq, Eq, Clone)]
+pub(crate) struct WorkspaceBuildData {
+    per_package: FxHashMap<String, PackageBuildData>,
+    error: Option<String>,
+}
+#[derive(Debug, Default, PartialEq, Eq, Clone)]
+pub struct BuildDataResult {
+    per_workspace: FxHashMap<AbsPathBuf, WorkspaceBuildData>,
+}
 #[derive(Clone, Debug)]
 pub(crate) struct BuildDataConfig {
    cargo_toml: AbsPathBuf,
@@ -52,13 +63,6 @@ pub struct BuildDataCollector {
    configs: FxHashMap<AbsPathBuf, BuildDataConfig>,
 }
-#[derive(Debug, Default, PartialEq, Eq)]
-pub struct BuildDataResult {
-    data: FxHashMap<AbsPathBuf, BuildDataMap>,
-}
-pub(crate) type BuildDataMap = FxHashMap<String, BuildData>;
 impl BuildDataCollector {
    pub(crate) fn add_config(&mut self, workspace_root: &AbsPath, config: BuildDataConfig) {
        self.configs.insert(workspace_root.to_path_buf(), config);
@@ -67,7 +71,7 @@ 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.data.insert(
+            res.per_workspace.insert(
                path.clone(),
                collect_from_workspace(
                    &config.cargo_toml,
@@ -81,9 +85,28 @@ impl BuildDataCollector {
    }
 }
+impl WorkspaceBuildData {
+    pub(crate) fn get(&self, package_id: &str) -> Option<&PackageBuildData> {
+        self.per_package.get(package_id)
+    }
+}
 impl BuildDataResult {
-    pub(crate) fn get(&self, root: &AbsPath) -> Option<&BuildDataMap> {
+    pub(crate) fn get(&self, workspace_root: &AbsPath) -> Option<&WorkspaceBuildData> {
-        self.data.get(&root.to_path_buf())
+        self.per_workspace.get(workspace_root)
+    }
+    pub fn error(&self) -> Option<String> {
+        let mut buf = String::new();
+        for (_workspace_root, build_data) in &self.per_workspace {
+            if let Some(err) = &build_data.error {
+                format_to!(buf, "cargo check failed:\n{}", err);
+            }
+        }
+        if buf.is_empty() {
+            return None;
+        }
+        Some(buf)
    }
 }
@@ -102,7 +125,7 @@ fn collect_from_workspace(
    cargo_features: &CargoConfig,
    packages: &Vec<cargo_metadata::Package>,
    progress: &dyn Fn(String),
-) -> Result<BuildDataMap> {
+) -> Result<WorkspaceBuildData> {
    let mut cmd = Command::new(toolchain::cargo());
    cmd.args(&["check", "--workspace", "--message-format=json", "--manifest-path"])
        .arg(cargo_toml.as_ref());
@@ -130,13 +153,13 @@ fn collect_from_workspace(
        }
    }
-    cmd.stdout(Stdio::piped()).stderr(Stdio::null()).stdin(Stdio::null());
+    cmd.stdout(Stdio::piped()).stderr(Stdio::piped()).stdin(Stdio::null());
    let mut child = cmd.spawn().map(JodChild)?;
    let child_stdout = child.stdout.take().unwrap();
    let stdout = BufReader::new(child_stdout);
-    let mut res = BuildDataMap::default();
+    let mut res = WorkspaceBuildData::default();
    for message in cargo_metadata::Message::parse_stream(stdout).flatten() {
        match message {
            Message::BuildScriptExecuted(BuildScript {
@@ -154,16 +177,17 @@ fn collect_from_workspace(
                    }
                    acc
                };
-                let res = res.entry(package_id.repr.clone()).or_default();
+                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()));
-                    res.out_dir = Some(out_dir);
+                    package_build_data.out_dir = Some(out_dir);
-                    res.cfgs = cfgs;
+                    package_build_data.cfgs = cfgs;
                }
-                res.envs = env;
+                package_build_data.envs = env;
            }
            Message::CompilerArtifact(message) => {
                progress(format!("metadata {}", message.target.name));
@@ -173,8 +197,9 @@ fn collect_from_workspace(
                    // Skip rmeta file
                    if let Some(filename) = message.filenames.iter().find(|name| is_dylib(name)) {
                        let filename = AbsPathBuf::assert(PathBuf::from(&filename));
-                        let res = res.entry(package_id.repr.clone()).or_default();
+                        let package_build_data =
-                        res.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);
                    }
                }
            }
@@ -188,16 +213,25 @@ fn collect_from_workspace(
    }
    for package in packages {
-        let build_data = res.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, build_data);
+        inject_cargo_env(package, package_build_data);
-        if let Some(out_dir) = &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!()
            if let Some(out_dir) = out_dir.to_str().map(|s| s.to_owned()) {
-                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()?;
+    if !output.status.success() {
+        let mut stderr = String::from_utf8(output.stderr).unwrap_or_default();
+        if stderr.is_empty() {
+            stderr = "cargo check failed".to_string();
+        }
+        res.error = Some(stderr)
+    }
    Ok(res)
 }
@@ -212,7 +246,7 @@ fn is_dylib(path: &Utf8Path) -> bool {
 /// Recreates the compile-time environment variables that Cargo sets.
 ///
 /// Should be synced with <https://doc.rust-lang.org/cargo/reference/environment-variables.html#environment-variables-cargo-sets-for-crates>
-fn inject_cargo_env(package: &cargo_metadata::Package, build_data: &mut BuildData) {
+fn inject_cargo_env(package: &cargo_metadata::Package, build_data: &mut PackageBuildData) {
    let env = &mut build_data.envs;
    // FIXME: Missing variables:
diff --git a/crates/project_model/src/workspace.rs b/crates/project_model/src/workspace.rs
index 1b53fcc30..2fcd0f8fa 100644
--- a/crates/project_model/src/workspace.rs
+++ b/crates/project_model/src/workspace.rs
@@ -12,7 +12,7 @@ use proc_macro_api::ProcMacroClient;
 use rustc_hash::{FxHashMap, FxHashSet};
 use crate::{
-    build_data::{BuildData, BuildDataMap, BuildDataResult},
+    build_data::{BuildDataResult, PackageBuildData, WorkspaceBuildData},
    cargo_workspace,
    cfg_flag::CfgFlag,
    rustc_cfg,
@@ -354,10 +354,10 @@ fn cargo_to_crate_graph(
    proc_macro_loader: &dyn Fn(&Path) -> Vec<ProcMacro>,
    load: &mut dyn FnMut(&AbsPath) -> Option<FileId>,
    cargo: &CargoWorkspace,
-    build_data_map: Option<&BuildDataMap>,
+    build_data_map: Option<&WorkspaceBuildData>,
    sysroot: &Sysroot,
    rustc: &Option<CargoWorkspace>,
-    rustc_build_data_map: Option<&BuildDataMap>,
+    rustc_build_data_map: Option<&WorkspaceBuildData>,
 ) -> CrateGraph {
    let _p = profile::span("cargo_to_crate_graph");
    let mut crate_graph = CrateGraph::default();
@@ -464,7 +464,7 @@ fn handle_rustc_crates(
    rustc_workspace: &CargoWorkspace,
    load: &mut dyn FnMut(&AbsPath) -> Option<FileId>,
    crate_graph: &mut CrateGraph,
-    rustc_build_data_map: Option<&FxHashMap<String, BuildData>>,
+    rustc_build_data_map: Option<&WorkspaceBuildData>,
    cfg_options: &CfgOptions,
    proc_macro_loader: &dyn Fn(&Path) -> Vec<ProcMacro>,
    pkg_to_lib_crate: &mut FxHashMap<la_arena::Idx<crate::PackageData>, CrateId>,
@@ -555,7 +555,7 @@ fn handle_rustc_crates(
 fn add_target_crate_root(
    crate_graph: &mut CrateGraph,
    pkg: &cargo_workspace::PackageData,
-    build_data: Option<&BuildData>,
+    build_data: Option<&PackageBuildData>,
    cfg_options: &CfgOptions,
    proc_macro_loader: &dyn Fn(&Path) -> Vec<ProcMacro>,
    file_id: FileId,
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/src/caps.rs b/crates/rust-analyzer/src/caps.rs
index 7a5bcb8c7..3c87782f2 100644
--- a/crates/rust-analyzer/src/caps.rs
+++ b/crates/rust-analyzer/src/caps.rs
@@ -57,7 +57,7 @@ pub fn server_capabilities(client_caps: &ClientCapabilities) -> ServerCapabiliti
        document_range_formatting_provider: None,
        document_on_type_formatting_provider: Some(DocumentOnTypeFormattingOptions {
            first_trigger_character: "=".to_string(),
-            more_trigger_character: Some(vec![".".to_string(), ">".to_string()]),
+            more_trigger_character: Some(vec![".".to_string(), ">".to_string(), "{".to_string()]),
        }),
        selection_range_provider: Some(SelectionRangeProviderCapability::Simple(true)),
        folding_range_provider: Some(FoldingRangeProviderCapability::Simple(true)),
diff --git a/crates/rust-analyzer/src/cli/analysis_stats.rs b/crates/rust-analyzer/src/cli/analysis_stats.rs
index 18fd7ea74..fe9f273b0 100644
--- a/crates/rust-analyzer/src/cli/analysis_stats.rs
+++ b/crates/rust-analyzer/src/cli/analysis_stats.rs
@@ -12,7 +12,7 @@ use hir::{
    AssocItem, Crate, Function, HasSource, HirDisplay, ModuleDef,
 };
 use hir_def::FunctionId;
-use hir_ty::TypeWalk;
+use hir_ty::{TyExt, TypeWalk};
 use ide::{AnalysisHost, RootDatabase};
 use ide_db::base_db::{
    salsa::{self, ParallelDatabase},
diff --git a/crates/rust-analyzer/src/config.rs b/crates/rust-analyzer/src/config.rs
index cda272fd4..f809667e9 100644
--- a/crates/rust-analyzer/src/config.rs
+++ b/crates/rust-analyzer/src/config.rs
@@ -445,8 +445,8 @@ impl Config {
    pub fn hover_actions(&self) -> bool {
        self.experimental("hoverActions")
    }
-    pub fn status_notification(&self) -> bool {
+    pub fn server_status_notification(&self) -> bool {
-        self.experimental("statusNotification")
+        self.experimental("serverStatusNotification")
    }
    pub fn publish_diagnostics(&self) -> bool {
@@ -656,6 +656,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/global_state.rs b/crates/rust-analyzer/src/global_state.rs
index 8679c8599..adeb7a97e 100644
--- a/crates/rust-analyzer/src/global_state.rs
+++ b/crates/rust-analyzer/src/global_state.rs
@@ -23,6 +23,7 @@ use crate::{
    document::DocumentData,
    from_proto,
    line_index::{LineEndings, LineIndex},
+    lsp_ext,
    main_loop::Task,
    op_queue::OpQueue,
    reload::SourceRootConfig,
@@ -32,20 +33,6 @@ use crate::{
    Result,
 };
-#[derive(Eq, PartialEq, Copy, Clone)]
-pub(crate) enum Status {
-    Loading,
-    Ready { partial: bool },
-    Invalid,
-    NeedsReload,
-}
-impl Default for Status {
-    fn default() -> Self {
-        Status::Loading
-    }
-}
 // Enforces drop order
 pub(crate) struct Handle<H, C> {
    pub(crate) handle: H,
@@ -67,26 +54,36 @@ pub(crate) struct GlobalState {
    req_queue: ReqQueue,
    pub(crate) task_pool: Handle<TaskPool<Task>, Receiver<Task>>,
    pub(crate) loader: Handle<Box<dyn vfs::loader::Handle>, Receiver<vfs::loader::Message>>,
-    pub(crate) vfs_config_version: u32,
-    pub(crate) flycheck: Vec<FlycheckHandle>,
-    pub(crate) flycheck_sender: Sender<flycheck::Message>,
-    pub(crate) flycheck_receiver: Receiver<flycheck::Message>,
    pub(crate) config: Arc<Config>,
    pub(crate) analysis_host: AnalysisHost,
    pub(crate) diagnostics: DiagnosticCollection,
    pub(crate) mem_docs: FxHashMap<VfsPath, DocumentData>,
    pub(crate) semantic_tokens_cache: Arc<Mutex<FxHashMap<Url, SemanticTokens>>>,
-    pub(crate) vfs: Arc<RwLock<(vfs::Vfs, FxHashMap<FileId, LineEndings>)>>,
    pub(crate) shutdown_requested: bool,
-    pub(crate) status: Status,
+    pub(crate) last_reported_status: Option<lsp_ext::ServerStatusParams>,
    pub(crate) source_root_config: SourceRootConfig,
    pub(crate) proc_macro_client: Option<ProcMacroClient>,
-    pub(crate) workspaces: Arc<Vec<ProjectWorkspace>>,
+    pub(crate) flycheck: Vec<FlycheckHandle>,
-    pub(crate) fetch_workspaces_queue: OpQueue<(), ()>,
+    pub(crate) flycheck_sender: Sender<flycheck::Message>,
+    pub(crate) flycheck_receiver: Receiver<flycheck::Message>,
+    pub(crate) vfs: Arc<RwLock<(vfs::Vfs, FxHashMap<FileId, LineEndings>)>>,
+    pub(crate) vfs_config_version: u32,
+    pub(crate) vfs_progress_config_version: u32,
+    pub(crate) vfs_progress_n_total: usize,
+    pub(crate) vfs_progress_n_done: usize,
+    /// For both `workspaces` and `workspace_build_data`, the field stores the
+    /// data we actually use, while the `OpQueue` stores the result of the last
+    /// fetch.
+    ///
+    /// If the fetch (partially) fails, we do not update the values.
+    pub(crate) workspaces: Arc<Vec<ProjectWorkspace>>,
+    pub(crate) fetch_workspaces_queue: OpQueue<(), Vec<anyhow::Result<ProjectWorkspace>>>,
    pub(crate) workspace_build_data: Option<BuildDataResult>,
-    pub(crate) fetch_build_data_queue: OpQueue<BuildDataCollector, ()>,
+    pub(crate) fetch_build_data_queue:
+        OpQueue<BuildDataCollector, Option<anyhow::Result<BuildDataResult>>>,
    latest_requests: Arc<RwLock<LatestRequests>>,
 }
@@ -124,25 +121,32 @@ impl GlobalState {
        GlobalState {
            sender,
            req_queue: ReqQueue::default(),
-            vfs_config_version: 0,
            task_pool,
            loader,
-            flycheck: Vec::new(),
-            flycheck_sender,
-            flycheck_receiver,
            config: Arc::new(config),
            analysis_host,
            diagnostics: Default::default(),
            mem_docs: FxHashMap::default(),
            semantic_tokens_cache: Arc::new(Default::default()),
-            vfs: Arc::new(RwLock::new((vfs::Vfs::default(), FxHashMap::default()))),
            shutdown_requested: false,
-            status: Status::default(),
+            last_reported_status: None,
            source_root_config: SourceRootConfig::default(),
            proc_macro_client: None,
+            flycheck: Vec::new(),
+            flycheck_sender,
+            flycheck_receiver,
+            vfs: Arc::new(RwLock::new((vfs::Vfs::default(), FxHashMap::default()))),
+            vfs_config_version: 0,
+            vfs_progress_config_version: 0,
+            vfs_progress_n_total: 0,
+            vfs_progress_n_done: 0,
            workspaces: Arc::new(Vec::new()),
            fetch_workspaces_queue: OpQueue::default(),
            workspace_build_data: None,
            fetch_build_data_queue: OpQueue::default(),
            latest_requests: Default::default(),
        }
diff --git a/crates/rust-analyzer/src/handlers.rs b/crates/rust-analyzer/src/handlers.rs
index 4d10a2ead..edfa42eb5 100644
--- a/crates/rust-analyzer/src/handlers.rs
+++ b/crates/rust-analyzer/src/handlers.rs
@@ -231,7 +231,6 @@ pub(crate) fn handle_on_enter(
    Ok(Some(edit))
 }
-// Don't forget to add new trigger characters to `ServerCapabilities` in `caps.rs`.
 pub(crate) fn handle_on_type_formatting(
    snap: GlobalStateSnapshot,
    params: lsp_types::DocumentOnTypeFormattingParams,
@@ -665,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 {
diff --git a/crates/rust-analyzer/src/lsp_ext.rs b/crates/rust-analyzer/src/lsp_ext.rs
index 0e1fec209..81a6f22f1 100644
--- a/crates/rust-analyzer/src/lsp_ext.rs
+++ b/crates/rust-analyzer/src/lsp_ext.rs
@@ -241,26 +241,26 @@ pub struct SsrParams {
    pub selections: Vec<lsp_types::Range>,
 }
-pub enum StatusNotification {}
+pub enum ServerStatusNotification {}
-#[derive(Serialize, Deserialize)]
+impl Notification for ServerStatusNotification {
-#[serde(rename_all = "camelCase")]
+    type Params = ServerStatusParams;
-pub enum Status {
+    const METHOD: &'static str = "experimental/serverStatus";
-    Loading,
-    ReadyPartial,
-    Ready,
-    NeedsReload,
-    Invalid,
 }
-#[derive(Deserialize, Serialize)]
+#[derive(Deserialize, Serialize, PartialEq, Eq, Clone)]
-pub struct StatusParams {
+pub struct ServerStatusParams {
-    pub status: Status,
+    pub health: Health,
+    pub quiescent: bool,
+    pub message: Option<String>,
 }
-impl Notification for StatusNotification {
+#[derive(Serialize, Deserialize, Clone, Copy, PartialEq, Eq)]
-    type Params = StatusParams;
+#[serde(rename_all = "camelCase")]
-    const METHOD: &'static str = "rust-analyzer/status";
+pub enum Health {
+    Ok,
+    Warning,
+    Error,
 }
 pub enum CodeActionRequest {}
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 e88f16cc1..47c6c6d77 100644
--- a/crates/rust-analyzer/src/main_loop.rs
+++ b/crates/rust-analyzer/src/main_loop.rs
@@ -2,6 +2,7 @@
 //! requests/replies and notifications back to the client.
 use std::{
    env, fmt,
+    sync::Arc,
    time::{Duration, Instant},
 };
@@ -12,6 +13,7 @@ use ide::{Canceled, FileId};
 use ide_db::base_db::VfsPath;
 use lsp_server::{Connection, Notification, Request, Response};
 use lsp_types::notification::Notification as _;
+use project_model::BuildDataCollector;
 use vfs::ChangeKind;
 use crate::{
@@ -19,7 +21,7 @@ use crate::{
    dispatch::{NotificationDispatcher, RequestDispatcher},
    document::DocumentData,
    from_proto,
-    global_state::{file_id_to_url, url_to_file_id, GlobalState, Status},
+    global_state::{file_id_to_url, url_to_file_id, GlobalState},
    handlers, lsp_ext,
    lsp_utils::{apply_document_changes, is_canceled, notification_is, Progress},
    reload::{BuildDataProgress, ProjectWorkspaceProgress},
@@ -187,7 +189,7 @@ impl GlobalState {
            log::info!("task queue len: {}", task_queue_len);
        }
-        let mut new_status = self.status;
+        let was_quiescent = self.is_quiescent();
        match event {
            Event::Lsp(msg) => match msg {
                lsp_server::Message::Request(req) => self.on_request(loop_start, req)?,
@@ -227,11 +229,24 @@ impl GlobalState {
                                    (Progress::Report, Some(msg))
                                }
                                ProjectWorkspaceProgress::End(workspaces) => {
-                                    self.fetch_workspaces_completed();
+                                    self.fetch_workspaces_completed(workspaces);
-                                    self.switch_workspaces(workspaces, None);
+                                    let old = Arc::clone(&self.workspaces);
+                                    self.switch_workspaces();
+                                    let workspaces_updated = !Arc::ptr_eq(&old, &self.workspaces);
+                                    if self.config.run_build_scripts() && workspaces_updated {
+                                        let mut collector = BuildDataCollector::default();
+                                        for ws in self.workspaces.iter() {
+                                            ws.collect_build_data_configs(&mut collector);
+                                        }
+                                        self.fetch_build_data_request(collector)
+                                    }
                                    (Progress::End, None)
                                }
                            };
                            self.report_progress("fetching", state, msg, None);
                        }
                        Task::FetchBuildData(progress) => {
@@ -240,19 +255,21 @@ impl GlobalState {
                                BuildDataProgress::Report(msg) => {
                                    (Some(Progress::Report), Some(msg))
                                }
-                                BuildDataProgress::End(collector) => {
+                                BuildDataProgress::End(build_data_result) => {
-                                    self.fetch_build_data_completed();
+                                    self.fetch_build_data_completed(build_data_result);
-                                    let workspaces =
-                                        (*self.workspaces).clone().into_iter().map(Ok).collect();
+                                    self.switch_workspaces();
-                                    self.switch_workspaces(workspaces, Some(collector));
                                    (Some(Progress::End), None)
                                }
                            };
                            if let Some(state) = state {
                                self.report_progress("loading", state, msg, None);
                            }
                        }
                    }
                    // Coalesce multiple task events into one loop turn
                    task = match self.task_pool.receiver.try_recv() {
                        Ok(task) => task,
@@ -298,30 +315,25 @@ impl GlobalState {
                        }
                        vfs::loader::Message::Progress { n_total, n_done, config_version } => {
                            always!(config_version <= self.vfs_config_version);
-                            if n_total == 0 {
-                                new_status = Status::Invalid;
+                            self.vfs_progress_config_version = config_version;
+                            self.vfs_progress_n_total = n_total;
+                            self.vfs_progress_n_done = n_done;
+                            let state = if n_done == 0 {
+                                Progress::Begin
+                            } else if n_done < n_total {
+                                Progress::Report
                            } else {
-                                let state = if n_done == 0 {
+                                assert_eq!(n_done, n_total);
-                                    new_status = Status::Loading;
+                                Progress::End
-                                    Progress::Begin
+                            };
-                                } else if n_done < n_total {
+                            self.report_progress(
-                                    Progress::Report
+                                "roots scanned",
-                                } else {
+                                state,
-                                    assert_eq!(n_done, n_total);
+                                Some(format!("{}/{}", n_done, n_total)),
-                                    new_status = Status::Ready {
+                                Some(Progress::fraction(n_done, n_total)),
-                                        partial: self.config.run_build_scripts()
+                            )
-                                            && self.workspace_build_data.is_none()
-                                            || config_version < self.vfs_config_version,
-                                    };
-                                    Progress::End
-                                };
-                                self.report_progress(
-                                    "roots scanned",
-                                    state,
-                                    Some(format!("{}/{}", n_done, n_total)),
-                                    Some(Progress::fraction(n_done, n_total)),
-                                )
-                            }
                        }
                    }
                    // Coalesce many VFS event into a single loop turn
@@ -397,18 +409,14 @@ impl GlobalState {
        }
        let state_changed = self.process_changes();
-        let prev_status = self.status;
-        if prev_status != new_status {
+        if self.is_quiescent() && !was_quiescent {
-            self.transition(new_status);
-        }
-        let is_ready = matches!(self.status, Status::Ready { .. });
-        if prev_status == Status::Loading && is_ready {
            for flycheck in &self.flycheck {
                flycheck.update();
            }
        }
-        if is_ready && (state_changed || prev_status == Status::Loading) {
+        if self.is_quiescent() && (!was_quiescent || state_changed) {
            self.update_file_notifications_on_threadpool();
            // Refresh semantic tokens if the client supports it.
@@ -437,9 +445,13 @@ impl GlobalState {
            }
        }
-        self.fetch_workspaces_if_needed();
+        if self.config.cargo_autoreload() {
+            self.fetch_workspaces_if_needed();
+        }
        self.fetch_build_data_if_needed();
+        self.report_new_status_if_needed();
        let loop_duration = loop_start.elapsed();
        if loop_duration > Duration::from_millis(100) {
            log::warn!("overly long loop turn: {:?}", loop_duration);
@@ -466,18 +478,23 @@ impl GlobalState {
            return Ok(());
        }
-        if self.status == Status::Loading && req.method != "shutdown" {
+        // Avoid flashing a bunch of unresolved references during initial load.
+        if self.workspaces.is_empty() && !self.is_quiescent() {
            self.respond(lsp_server::Response::new_err(
                req.id,
                // FIXME: i32 should impl From<ErrorCode> (from() guarantees lossless conversion)
                lsp_server::ErrorCode::ContentModified as i32,
-                "Rust Analyzer is still loading...".to_owned(),
+                "waiting for cargo metadata or cargo check".to_owned(),
            ));
            return Ok(());
        }
        RequestDispatcher { req: Some(req), global_state: self }
-            .on_sync::<lsp_ext::ReloadWorkspace>(|s, ()| Ok(s.fetch_workspaces_request()))?
+            .on_sync::<lsp_ext::ReloadWorkspace>(|s, ()| {
+                s.fetch_workspaces_request();
+                s.fetch_workspaces_if_needed();
+                Ok(())
+            })?
            .on_sync::<lsp_ext::JoinLines>(|s, p| handlers::handle_join_lines(s.snapshot(), p))?
            .on_sync::<lsp_ext::OnEnter>(|s, p| handlers::handle_on_enter(s.snapshot(), p))?
            .on_sync::<lsp_types::request::Shutdown>(|s, ()| {
diff --git a/crates/rust-analyzer/src/op_queue.rs b/crates/rust-analyzer/src/op_queue.rs
index f71b718bc..1d612a933 100644
--- a/crates/rust-analyzer/src/op_queue.rs
+++ b/crates/rust-analyzer/src/op_queue.rs
@@ -2,27 +2,27 @@
 //! at a time.
 pub(crate) struct OpQueue<Args, Output> {
-    op_scheduled: Option<Args>,
+    op_requested: Option<Args>,
    op_in_progress: bool,
    last_op_result: Output,
 }
 impl<Args, Output: Default> Default for OpQueue<Args, Output> {
    fn default() -> Self {
-        Self { op_scheduled: None, op_in_progress: false, last_op_result: Default::default() }
+        Self { op_requested: None, op_in_progress: false, last_op_result: Default::default() }
    }
 }
 impl<Args, Output> OpQueue<Args, Output> {
    pub(crate) fn request_op(&mut self, data: Args) {
-        self.op_scheduled = Some(data);
+        self.op_requested = Some(data);
    }
    pub(crate) fn should_start_op(&mut self) -> Option<Args> {
        if self.op_in_progress {
            return None;
        }
-        self.op_in_progress = self.op_scheduled.is_some();
+        self.op_in_progress = self.op_requested.is_some();
-        self.op_scheduled.take()
+        self.op_requested.take()
    }
    pub(crate) fn op_completed(&mut self, result: Output) {
        assert!(self.op_in_progress);
@@ -34,4 +34,10 @@ impl<Args, Output> OpQueue<Args, Output> {
    pub(crate) fn last_op_result(&self) -> &Output {
        &self.last_op_result
    }
+    pub(crate) fn op_in_progress(&self) -> bool {
+        self.op_in_progress
+    }
+    pub(crate) fn op_requested(&self) -> bool {
+        self.op_requested.is_some()
+    }
 }
diff --git a/crates/rust-analyzer/src/reload.rs b/crates/rust-analyzer/src/reload.rs
index d12f891bb..d0cc1b61a 100644
--- a/crates/rust-analyzer/src/reload.rs
+++ b/crates/rust-analyzer/src/reload.rs
@@ -9,11 +9,10 @@ use vfs::{file_set::FileSetConfig, AbsPath, AbsPathBuf, ChangeKind};
 use crate::{
    config::{Config, FilesWatcher, LinkedProject},
-    global_state::{GlobalState, Status},
+    global_state::GlobalState,
    lsp_ext,
    main_loop::Task,
 };
-use lsp_ext::StatusParams;
 #[derive(Debug)]
 pub(crate) enum ProjectWorkspaceProgress {
@@ -30,6 +29,13 @@ pub(crate) enum BuildDataProgress {
 }
 impl GlobalState {
+    pub(crate) fn is_quiescent(&self) -> bool {
+        !(self.fetch_workspaces_queue.op_in_progress()
+            || self.fetch_build_data_queue.op_in_progress()
+            || self.vfs_progress_config_version < self.vfs_config_version
+            || self.vfs_progress_n_done < self.vfs_progress_n_total)
+    }
    pub(crate) fn update_configuration(&mut self, config: Config) {
        let _p = profile::span("GlobalState::update_configuration");
        let old_config = mem::replace(&mut self.config, Arc::new(config));
@@ -46,25 +52,17 @@ impl GlobalState {
        if !changes.iter().any(|(path, kind)| is_interesting(path, *kind)) {
            return;
        }
-        match self.status {
-            Status::Loading | Status::NeedsReload => return,
-            Status::Ready { .. } | Status::Invalid => (),
-        }
        log::info!(
-            "Reloading workspace because of the following changes: {}",
+            "Requesting workspace reload because of the following changes: {}",
            itertools::join(
                changes
                    .iter()
                    .filter(|(path, kind)| is_interesting(path, *kind))
-                    .map(|(path, kind)| format!("{}/{:?}", path.display(), kind)),
+                    .map(|(path, kind)| format!("{}: {:?}", path.display(), kind)),
                ", "
            )
        );
-        if self.config.cargo_autoreload() {
+        self.fetch_workspaces_request();
-            self.fetch_workspaces_request();
-        } else {
-            self.transition(Status::NeedsReload);
-        }
        fn is_interesting(path: &AbsPath, change_kind: ChangeKind) -> bool {
            const IMPLICIT_TARGET_FILES: &[&str] = &["build.rs", "src/main.rs", "src/lib.rs"];
@@ -101,46 +99,38 @@ impl GlobalState {
            false
        }
    }
-    pub(crate) fn transition(&mut self, new_status: Status) {
+    pub(crate) fn report_new_status_if_needed(&mut self) {
-        self.status = new_status;
+        if !self.config.server_status_notification() {
-        if self.config.status_notification() {
+            return;
-            let lsp_status = match new_status {
-                Status::Loading => lsp_ext::Status::Loading,
-                Status::Ready { partial: true } => lsp_ext::Status::ReadyPartial,
-                Status::Ready { partial: false } => lsp_ext::Status::Ready,
-                Status::Invalid => lsp_ext::Status::Invalid,
-                Status::NeedsReload => lsp_ext::Status::NeedsReload,
-            };
-            self.send_notification::<lsp_ext::StatusNotification>(StatusParams {
-                status: lsp_status,
-            });
        }
-    }
-    pub(crate) fn fetch_build_data_request(&mut self, build_data_collector: BuildDataCollector) {
-        self.fetch_build_data_queue.request_op(build_data_collector);
-    }
-    pub(crate) fn fetch_build_data_if_needed(&mut self) {
+        let mut status = lsp_ext::ServerStatusParams {
-        let mut build_data_collector = match self.fetch_build_data_queue.should_start_op() {
+            health: lsp_ext::Health::Ok,
-            Some(it) => it,
+            quiescent: self.is_quiescent(),
-            None => return,
+            message: None,
        };
-        self.task_pool.handle.spawn_with_sender(move |sender| {
-            sender.send(Task::FetchBuildData(BuildDataProgress::Begin)).unwrap();
-            let progress = {
+        if let Some(error) = self.build_data_error() {
-                let sender = sender.clone();
+            status.health = lsp_ext::Health::Warning;
-                move |msg| {
+            status.message = Some(error)
-                    sender.send(Task::FetchBuildData(BuildDataProgress::Report(msg))).unwrap()
+        }
-                }
+        if !self.config.cargo_autoreload()
-            };
+            && self.is_quiescent()
-            let res = build_data_collector.collect(&progress);
+            && self.fetch_workspaces_queue.op_requested()
-            sender.send(Task::FetchBuildData(BuildDataProgress::End(res))).unwrap();
+        {
-        });
+            status.health = lsp_ext::Health::Warning;
-    }
+            status.message = Some("Workspace reload required".to_string())
-    pub(crate) fn fetch_build_data_completed(&mut self) {
+        }
-        self.fetch_build_data_queue.op_completed(())
+        if let Some(error) = self.fetch_workspace_error() {
+            status.health = lsp_ext::Health::Error;
+            status.message = Some(error)
+        }
+        if self.last_reported_status.as_ref() != Some(&status) {
+            self.last_reported_status = Some(status.clone());
+            self.send_notification::<lsp_ext::ServerStatusNotification>(status);
+        }
    }
    pub(crate) fn fetch_workspaces_request(&mut self) {
@@ -194,54 +184,71 @@ impl GlobalState {
            }
        });
    }
-    pub(crate) fn fetch_workspaces_completed(&mut self) {
+    pub(crate) fn fetch_workspaces_completed(
-        self.fetch_workspaces_queue.op_completed(())
+        &mut self,
+        workspaces: Vec<anyhow::Result<ProjectWorkspace>>,
+    ) {
+        self.fetch_workspaces_queue.op_completed(workspaces)
+    }
+    pub(crate) fn fetch_build_data_request(&mut self, build_data_collector: BuildDataCollector) {
+        self.fetch_build_data_queue.request_op(build_data_collector);
    }
+    pub(crate) fn fetch_build_data_if_needed(&mut self) {
+        let mut build_data_collector = match self.fetch_build_data_queue.should_start_op() {
+            Some(it) => it,
+            None => return,
+        };
+        self.task_pool.handle.spawn_with_sender(move |sender| {
+            sender.send(Task::FetchBuildData(BuildDataProgress::Begin)).unwrap();
-    pub(crate) fn switch_workspaces(
+            let progress = {
+                let sender = sender.clone();
+                move |msg| {
+                    sender.send(Task::FetchBuildData(BuildDataProgress::Report(msg))).unwrap()
+                }
+            };
+            let res = build_data_collector.collect(&progress);
+            sender.send(Task::FetchBuildData(BuildDataProgress::End(res))).unwrap();
+        });
+    }
+    pub(crate) fn fetch_build_data_completed(
        &mut self,
-        workspaces: Vec<anyhow::Result<ProjectWorkspace>>,
+        build_data: anyhow::Result<BuildDataResult>,
-        workspace_build_data: Option<anyhow::Result<BuildDataResult>>,
    ) {
-        let _p = profile::span("GlobalState::switch_workspaces");
+        self.fetch_build_data_queue.op_completed(Some(build_data))
-        log::info!("will switch workspaces: {:?}", workspaces);
+    }
-        let mut has_errors = false;
+    pub(crate) fn switch_workspaces(&mut self) {
-        let workspaces = workspaces
+        let _p = profile::span("GlobalState::switch_workspaces");
-            .into_iter()
+        log::info!("will switch workspaces");
-            .filter_map(|res| {
-                res.map_err(|err| {
-                    has_errors = true;
-                    log::error!("failed to load workspace: {:#}", err);
-                    if self.workspaces.is_empty() {
-                        self.show_message(
-                            lsp_types::MessageType::Error,
-                            format!("rust-analyzer failed to load workspace: {:#}", err),
-                        );
-                    }
-                })
-                .ok()
-            })
-            .collect::<Vec<_>>();
-        let workspace_build_data = match workspace_build_data {
+        if let Some(error_message) = self.fetch_workspace_error() {
-            Some(Ok(it)) => Some(it),
+            log::error!("failed to switch workspaces: {}", error_message);
-            Some(Err(err)) => {
+            self.show_message(lsp_types::MessageType::Error, error_message);
-                log::error!("failed to fetch build data: {:#}", err);
+            if !self.workspaces.is_empty() {
-                self.show_message(
-                    lsp_types::MessageType::Error,
-                    format!("rust-analyzer failed to fetch build data: {:#}", err),
-                );
                return;
            }
-            None => None,
+        }
-        };
-        if *self.workspaces == workspaces && self.workspace_build_data == workspace_build_data {
+        if let Some(error_message) = self.build_data_error() {
-            return;
+            log::error!("failed to switch build data: {}", error_message);
+            self.show_message(lsp_types::MessageType::Error, error_message);
        }
-        if !self.workspaces.is_empty() && has_errors {
+        let workspaces = self
+            .fetch_workspaces_queue
+            .last_op_result()
+            .iter()
+            .filter_map(|res| res.as_ref().ok().cloned())
+            .collect::<Vec<_>>();
+        let workspace_build_data = match self.fetch_build_data_queue.last_op_result() {
+            Some(Ok(it)) => Some(it.clone()),
+            None | Some(Err(_)) => None,
+        };
+        if *self.workspaces == workspaces && self.workspace_build_data == workspace_build_data {
            return;
        }
@@ -337,14 +344,6 @@ impl GlobalState {
        };
        change.set_crate_graph(crate_graph);
-        if self.config.run_build_scripts() && workspace_build_data.is_none() {
-            let mut collector = BuildDataCollector::default();
-            for ws in &workspaces {
-                ws.collect_build_data_configs(&mut collector);
-            }
-            self.fetch_build_data_request(collector)
-        }
        self.source_root_config = project_folders.source_root_config;
        self.workspaces = Arc::new(workspaces);
        self.workspace_build_data = workspace_build_data;
@@ -355,6 +354,32 @@ impl GlobalState {
        log::info!("did switch workspaces");
    }
+    fn fetch_workspace_error(&self) -> Option<String> {
+        let mut buf = String::new();
+        for ws in self.fetch_workspaces_queue.last_op_result() {
+            if let Err(err) = ws {
+                stdx::format_to!(buf, "rust-analyzer failed to load workspace: {:#}\n", err);
+            }
+        }
+        if buf.is_empty() {
+            return None;
+        }
+        Some(buf)
+    }
+    fn build_data_error(&self) -> Option<String> {
+        match self.fetch_build_data_queue.last_op_result() {
+            Some(Err(err)) => {
+                Some(format!("rust-analyzer failed to fetch build data: {:#}\n", err))
+            }
+            Some(Ok(data)) => data.error(),
+            None => None,
+        }
+    }
    fn reload_flycheck(&mut self) {
        let _p = profile::span("GlobalState::reload_flycheck");
        let config = match self.config.flycheck() {
diff --git a/crates/rust-analyzer/src/to_proto.rs b/crates/rust-analyzer/src/to_proto.rs
index c3820944b..9fac562ff 100644
--- a/crates/rust-analyzer/src/to_proto.rs
+++ b/crates/rust-analyzer/src/to_proto.rs
@@ -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()),
@@ -497,7 +515,8 @@ pub(crate) fn folding_range(
        | FoldKind::Block
        | FoldKind::ArgList
        | FoldKind::Consts
-        | FoldKind::Statics => None,
+        | FoldKind::Statics
+        | FoldKind::Array => None,
    };
    let range = range(line_index, fold.range);
@@ -1135,7 +1154,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/support.rs b/crates/rust-analyzer/tests/rust-analyzer/support.rs
index 95bf26f01..8d68f1b7d 100644
--- a/crates/rust-analyzer/tests/rust-analyzer/support.rs
+++ b/crates/rust-analyzer/tests/rust-analyzer/support.rs
@@ -103,7 +103,7 @@ impl<'a> Project<'a> {
                    ..Default::default()
                }),
                experimental: Some(json!({
-                    "statusNotification": true,
+                    "serverStatusNotification": true,
                })),
                ..Default::default()
            },
@@ -213,13 +213,12 @@ impl Server {
    }
    pub(crate) fn wait_until_workspace_is_loaded(self) -> Server {
        self.wait_for_message_cond(1, &|msg: &Message| match msg {
-            Message::Notification(n) if n.method == "rust-analyzer/status" => {
+            Message::Notification(n) if n.method == "experimental/serverStatus" => {
                let status = n
                    .clone()
-                    .extract::<lsp_ext::StatusParams>("rust-analyzer/status")
+                    .extract::<lsp_ext::ServerStatusParams>("experimental/serverStatus")
-                    .unwrap()
+                    .unwrap();
-                    .status;
+                status.quiescent
-                matches!(status, lsp_ext::Status::Ready)
            }
            _ => false,
        })
diff --git a/crates/stdx/src/lib.rs b/crates/stdx/src/lib.rs
index d26be4853..b0a18d58d 100644
--- a/crates/stdx/src/lib.rs
+++ b/crates/stdx/src/lib.rs
@@ -178,6 +178,7 @@ where
    start..start + len
 }
+#[repr(transparent)]
 pub struct JodChild(pub process::Child);
 impl ops::Deref for JodChild {
@@ -200,6 +201,13 @@ impl Drop for JodChild {
    }
 }
+impl JodChild {
+    pub fn into_inner(self) -> process::Child {
+        // SAFETY: repr transparent
+        unsafe { std::mem::transmute::<JodChild, process::Child>(self) }
+    }
+}
 #[cfg(test)]
 mod tests {
    use super::*;
diff --git a/crates/syntax/Cargo.toml b/crates/syntax/Cargo.toml
index 10024366e..f09cdf28a 100644
--- a/crates/syntax/Cargo.toml
+++ b/crates/syntax/Cargo.toml
@@ -14,7 +14,7 @@ doctest = false
 cov-mark = { version = "1.1", features = ["thread-local"] }
 itertools = "0.10.0"
 rowan = "0.13.0-pre.3"
-rustc_lexer = { version = "710.0.0", package = "rustc-ap-rustc_lexer" }
+rustc_lexer = { version = "714.0.0", package = "rustc-ap-rustc_lexer" }
 rustc-hash = "1.1.0"
 arrayvec = "0.7"
 once_cell = "1.3.1"
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/fixture.rs b/crates/test_utils/src/fixture.rs
index 6bc824e94..099baeca2 100644
--- a/crates/test_utils/src/fixture.rs
+++ b/crates/test_utils/src/fixture.rs
@@ -1,5 +1,65 @@
 //! Defines `Fixture` -- a convenient way to describe the initial state of
 //! rust-analyzer database from a single string.
+//!
+//! Fixtures are strings containing rust source code with optional metadata.
+//! A fixture without metadata is parsed into a single source file.
+//! Use this to test functionality local to one file.
+//!
+//! Simple Example:
+//! ```
+//! r#"
+//! fn main() {
+//!     println!("Hello World")
+//! }
+//! "#
+//! ```
+//!
+//! Metadata can be added to a fixture after a `//-` comment.
+//! The basic form is specifying filenames,
+//! which is also how to define multiple files in a single test fixture
+//!
+//! Example using two files in the same crate:
+//! ```
+//! "
+//! //- /main.rs
+//! mod foo;
+//! fn main() {
+//!     foo::bar();
+//! }
+//!
+//! //- /foo.rs
+//! pub fn bar() {}
+//! "
+//! ```
+//!
+//! Example using two crates with one file each, with one crate depending on the other:
+//! ```
+//! r#"
+//! //- /main.rs crate:a deps:b
+//! fn main() {
+//!     b::foo();
+//! }
+//! //- /lib.rs crate:b
+//! pub fn b() {
+//!     println!("Hello World")
+//! }
+//! "#
+//! ```
+//!
+//! Metadata allows specifying all settings and variables
+//! that are available in a real rust project:
+//! - crate names via `crate:cratename`
+//! - dependencies via `deps:dep1,dep2`
+//! - configuration settings via `cfg:dbg=false,opt_level=2`
+//! - environment variables via `env:PATH=/bin,RUST_LOG=debug`
+//!
+//! Example using all available metadata:
+//! ```
+//! "
+//! //- /lib.rs crate:foo deps:bar,baz cfg:foo=a,bar=b env:OUTDIR=path/to,OTHER=foo
+//! fn insert_source_code_here() {}
+//! "
+//! ```
 use rustc_hash::FxHashMap;
 use stdx::{lines_with_ends, split_once, trim_indent};
@@ -24,7 +84,7 @@ impl Fixture {
    ///  //- some meta
    ///  line 1
    ///  line 2
-    ///  // - other meta
+    ///  //- other meta
    ///  ```
    pub fn parse(ra_fixture: &str) -> Vec<Fixture> {
        let fixture = trim_indent(ra_fixture);
diff --git a/crates/vfs/Cargo.toml b/crates/vfs/Cargo.toml
index c318a68f7..894944b18 100644
--- a/crates/vfs/Cargo.toml
+++ b/crates/vfs/Cargo.toml
@@ -14,3 +14,4 @@ rustc-hash = "1.0"
 fst = "0.4"
 paths = { path = "../paths", version = "0.0.0" }
+indexmap = "1.6.2"
diff --git a/crates/vfs/src/path_interner.rs b/crates/vfs/src/path_interner.rs
index 2189e5e25..6e049f0d4 100644
--- a/crates/vfs/src/path_interner.rs
+++ b/crates/vfs/src/path_interner.rs
@@ -1,15 +1,22 @@
 //! Maps paths to compact integer ids. We don't care about clearings paths which
 //! no longer exist -- the assumption is total size of paths we ever look at is
 //! not too big.
-use rustc_hash::FxHashMap;
+use std::hash::BuildHasherDefault;
+use indexmap::IndexSet;
+use rustc_hash::FxHasher;
 use crate::{FileId, VfsPath};
 /// Structure to map between [`VfsPath`] and [`FileId`].
-#[derive(Default)]
 pub(crate) struct PathInterner {
-    map: FxHashMap<VfsPath, FileId>,
+    map: IndexSet<VfsPath, BuildHasherDefault<FxHasher>>,
-    vec: Vec<VfsPath>,
+}
+impl Default for PathInterner {
+    fn default() -> Self {
+        Self { map: IndexSet::default() }
+    }
 }
 impl PathInterner {
@@ -17,7 +24,7 @@ impl PathInterner {
    ///
    /// If `path` does not exists in `self`, returns [`None`].
    pub(crate) fn get(&self, path: &VfsPath) -> Option<FileId> {
-        self.map.get(path).copied()
+        self.map.get_index_of(path).map(|i| FileId(i as u32))
    }
    /// Insert `path` in `self`.
@@ -25,13 +32,9 @@ impl PathInterner {
    /// - If `path` already exists in `self`, returns its associated id;
    /// - Else, returns a newly allocated id.
    pub(crate) fn intern(&mut self, path: VfsPath) -> FileId {
-        if let Some(id) = self.get(&path) {
+        let (id, _added) = self.map.insert_full(path);
-            return id;
+        assert!(id < u32::MAX as usize);
-        }
+        FileId(id as u32)
-        let id = FileId(self.vec.len() as u32);
-        self.map.insert(path.clone(), id);
-        self.vec.push(path);
-        id
    }
    /// Returns the path corresponding to `id`.
@@ -40,6 +43,6 @@ impl PathInterner {
    ///
    /// Panics if `id` does not exists in `self`.
    pub(crate) fn lookup(&self, id: FileId) -> &VfsPath {
-        &self.vec[id.0 as usize]
+        self.map.get_index(id.0 as usize).unwrap()
    }
 }