29 files changed, 2072 insertions, 1219 deletions
diff --git a/crates/hir_ty/src/autoderef.rs b/crates/hir_ty/src/autoderef.rs
index f8e9db9ae..2c07494a9 100644
--- a/crates/hir_ty/src/autoderef.rs
+++ b/crates/hir_ty/src/autoderef.rs
@@ -6,14 +6,15 @@
 use std::iter::successors;
 use base_db::CrateId;
-use chalk_ir::cast::Cast;
+use chalk_ir::{cast::Cast, fold::Fold, interner::HasInterner, VariableKind};
 use hir_def::lang_item::LangItemTarget;
 use hir_expand::name::name;
 use log::{info, warn};
 use crate::{
-    db::HirDatabase, AliasEq, AliasTy, BoundVar, Canonical, CanonicalVarKinds, DebruijnIndex,
+    db::HirDatabase, static_lifetime, AliasEq, AliasTy, BoundVar, Canonical, CanonicalVarKinds,
-    InEnvironment, Interner, ProjectionTyExt, Solution, Ty, TyBuilder, TyKind,
+    DebruijnIndex, InEnvironment, Interner, ProjectionTyExt, Solution, Substitution, Ty, TyBuilder,
+    TyKind,
 };
 const AUTODEREF_RECURSION_LIMIT: usize = 10;
@@ -35,6 +36,7 @@ pub(crate) fn deref(
    krate: CrateId,
    ty: InEnvironment<&Canonical<Ty>>,
 ) -> Option<Canonical<Ty>> {
+    let _p = profile::span("deref");
    if let Some(derefed) = builtin_deref(&ty.goal.value) {
        Some(Canonical { value: derefed, binders: ty.goal.binders.clone() })
    } else {
@@ -55,6 +57,7 @@ fn deref_by_trait(
    krate: CrateId,
    ty: InEnvironment<&Canonical<Ty>>,
 ) -> Option<Canonical<Ty>> {
+    let _p = profile::span("deref_by_trait");
    let deref_trait = match db.lang_item(krate, "deref".into())? {
        LangItemTarget::TraitId(it) => it,
        _ => return None,
@@ -103,7 +106,7 @@ fn deref_by_trait(
        binders: CanonicalVarKinds::from_iter(
            &Interner,
            ty.goal.binders.iter(&Interner).cloned().chain(Some(chalk_ir::WithKind::new(
-                chalk_ir::VariableKind::Ty(chalk_ir::TyVariableKind::General),
+                VariableKind::Ty(chalk_ir::TyVariableKind::General),
                chalk_ir::UniverseIndex::ROOT,
            ))),
        ),
@@ -136,7 +139,9 @@ fn deref_by_trait(
                    return None;
                }
            }
-            Some(Canonical {
+            // FIXME: we remove lifetime variables here since they can confuse
+            // the method resolution code later
+            Some(fixup_lifetime_variables(Canonical {
                value: vars
                    .value
                    .subst
@@ -144,7 +149,7 @@ fn deref_by_trait(
                    .assert_ty_ref(&Interner)
                    .clone(),
                binders: vars.binders.clone(),
-            })
+            }))
        }
        Solution::Ambig(_) => {
            info!("Ambiguous solution for derefing {:?}: {:?}", ty.goal, solution);
@@ -152,3 +157,32 @@ fn deref_by_trait(
        }
    }
 }
+fn fixup_lifetime_variables<T: Fold<Interner, Result = T> + HasInterner<Interner = Interner>>(
+    c: Canonical<T>,
+) -> Canonical<T> {
+    // Removes lifetime variables from the Canonical, replacing them by static lifetimes.
+    let mut i = 0;
+    let subst = Substitution::from_iter(
+        &Interner,
+        c.binders.iter(&Interner).map(|vk| match vk.kind {
+            VariableKind::Ty(_) => {
+                let index = i;
+                i += 1;
+                BoundVar::new(DebruijnIndex::INNERMOST, index).to_ty(&Interner).cast(&Interner)
+            }
+            VariableKind::Lifetime => static_lifetime().cast(&Interner),
+            VariableKind::Const(_) => unimplemented!(),
+        }),
+    );
+    let binders = CanonicalVarKinds::from_iter(
+        &Interner,
+        c.binders.iter(&Interner).filter(|vk| match vk.kind {
+            VariableKind::Ty(_) => true,
+            VariableKind::Lifetime => false,
+            VariableKind::Const(_) => true,
+        }),
+    );
+    let value = subst.apply(c.value, &Interner);
+    Canonical { binders, value }
+}
diff --git a/crates/hir_ty/src/chalk_cast.rs b/crates/hir_ty/src/chalk_cast.rs
deleted file mode 100644
index f27dee3fd..000000000
--- a/crates/hir_ty/src/chalk_cast.rs
+++ /dev/null
@@ -1,16 +0,0 @@
-//! Implementations of the Chalk `Cast` trait for our types.
-use chalk_ir::interner::HasInterner;
-use crate::{CallableSig, ReturnTypeImplTraits};
-macro_rules! has_interner {
-    ($t:ty) => {
-        impl HasInterner for $t {
-            type Interner = crate::Interner;
-        }
-    };
-}
-has_interner!(CallableSig);
-has_interner!(ReturnTypeImplTraits);
diff --git a/crates/hir_ty/src/traits/chalk.rs b/crates/hir_ty/src/chalk_db.rs
index b8c390b2e..8f054d06b 100644
--- a/crates/hir_ty/src/traits/chalk.rs
+++ b/crates/hir_ty/src/chalk_db.rs
@@ -1,50 +1,47 @@
-//! Conversion code from/to Chalk.
+//! The implementation of `RustIrDatabase` for Chalk, which provides information
+//! about the code that Chalk needs.
 use std::sync::Arc;
 use log::debug;
-use chalk_ir::{fold::shift::Shift, CanonicalVarKinds};
+use chalk_ir::{cast::Cast, fold::shift::Shift, CanonicalVarKinds};
 use chalk_solve::rust_ir::{self, OpaqueTyDatumBound, WellKnownTrait};
-use base_db::{salsa::InternKey, CrateId};
+use base_db::CrateId;
 use hir_def::{
    lang_item::{lang_attr, LangItemTarget},
-    AssocContainerId, AssocItemId, HasModule, Lookup, TypeAliasId,
+    AssocContainerId, AssocItemId, GenericDefId, HasModule, Lookup, TypeAliasId,
 };
 use hir_expand::name::name;
-use super::ChalkContext;
 use crate::{
    db::HirDatabase,
    display::HirDisplay,
-    from_assoc_type_id, make_only_type_binders,
+    from_assoc_type_id, from_chalk_trait_id, make_only_type_binders,
+    mapping::{from_chalk, ToChalk, TypeAliasAsValue},
    method_resolution::{TyFingerprint, ALL_FLOAT_FPS, ALL_INT_FPS},
    to_assoc_type_id, to_chalk_trait_id,
+    traits::ChalkContext,
    utils::generics,
-    AliasEq, AliasTy, BoundVar, CallableDefId, DebruijnIndex, FnDefId, ProjectionTy, Substitution,
+    AliasEq, AliasTy, BoundVar, CallableDefId, DebruijnIndex, FnDefId, Interner, ProjectionTy,
-    TraitRef, TraitRefExt, Ty, TyBuilder, TyExt, TyKind, WhereClause,
+    ProjectionTyExt, QuantifiedWhereClause, Substitution, TraitRef, TraitRefExt, Ty, TyBuilder,
+    TyExt, TyKind, WhereClause,
 };
-use mapping::{convert_where_clauses, generic_predicate_to_inline_bound, TypeAliasAsValue};
-pub use self::interner::Interner;
+pub(crate) type AssociatedTyDatum = chalk_solve::rust_ir::AssociatedTyDatum<Interner>;
-pub(crate) use self::interner::*;
+pub(crate) type TraitDatum = chalk_solve::rust_ir::TraitDatum<Interner>;
+pub(crate) type StructDatum = chalk_solve::rust_ir::AdtDatum<Interner>;
-pub(super) mod tls;
+pub(crate) type ImplDatum = chalk_solve::rust_ir::ImplDatum<Interner>;
-mod interner;
+pub(crate) type OpaqueTyDatum = chalk_solve::rust_ir::OpaqueTyDatum<Interner>;
-mod mapping;
+pub(crate) type AssocTypeId = chalk_ir::AssocTypeId<Interner>;
-pub(crate) trait ToChalk {
+pub(crate) type TraitId = chalk_ir::TraitId<Interner>;
-    type Chalk;
+pub(crate) type AdtId = chalk_ir::AdtId<Interner>;
-    fn to_chalk(self, db: &dyn HirDatabase) -> Self::Chalk;
+pub(crate) type ImplId = chalk_ir::ImplId<Interner>;
-    fn from_chalk(db: &dyn HirDatabase, chalk: Self::Chalk) -> Self;
+pub(crate) type AssociatedTyValueId = chalk_solve::rust_ir::AssociatedTyValueId<Interner>;
-}
+pub(crate) type AssociatedTyValue = chalk_solve::rust_ir::AssociatedTyValue<Interner>;
+pub(crate) type FnDefDatum = chalk_solve::rust_ir::FnDefDatum<Interner>;
-pub(crate) fn from_chalk<T, ChalkT>(db: &dyn HirDatabase, chalk: ChalkT) -> T
+pub(crate) type Variances = chalk_ir::Variances<Interner>;
-where
-    T: ToChalk<Chalk = ChalkT>,
-{
-    T::from_chalk(db, chalk)
-}
 impl<'a> chalk_solve::RustIrDatabase<Interner> for ChalkContext<'a> {
    fn associated_ty_data(&self, id: AssocTypeId) -> Arc<AssociatedTyDatum> {
@@ -82,7 +79,7 @@ impl<'a> chalk_solve::RustIrDatabase<Interner> for ChalkContext<'a> {
        binders: &CanonicalVarKinds<Interner>,
    ) -> Vec<ImplId> {
        debug!("impls_for_trait {:?}", trait_id);
-        let trait_: hir_def::TraitId = from_chalk(self.db, trait_id);
+        let trait_: hir_def::TraitId = from_chalk_trait_id(trait_id);
        let ty: Ty = parameters[0].assert_ty_ref(&Interner).clone();
@@ -101,7 +98,7 @@ impl<'a> chalk_solve::RustIrDatabase<Interner> for ChalkContext<'a> {
            None
        }
-        let self_ty_fp = TyFingerprint::for_impl(&ty);
+        let self_ty_fp = TyFingerprint::for_trait_impl(&ty);
        let fps: &[TyFingerprint] = match binder_kind(&ty, binders) {
            Some(chalk_ir::TyVariableKind::Integer) => &ALL_INT_FPS,
            Some(chalk_ir::TyVariableKind::Float) => &ALL_FLOAT_FPS,
@@ -164,7 +161,7 @@ impl<'a> chalk_solve::RustIrDatabase<Interner> for ChalkContext<'a> {
            Some(LangItemTarget::TraitId(trait_)) => trait_,
            _ => return None,
        };
-        Some(trait_.to_chalk(self.db))
+        Some(to_chalk_trait_id(trait_))
    }
    fn program_clauses_for_env(
@@ -311,7 +308,7 @@ impl<'a> chalk_solve::RustIrDatabase<Interner> for ChalkContext<'a> {
    }
    fn trait_name(&self, trait_id: chalk_ir::TraitId<Interner>) -> String {
-        let id = from_chalk(self.db, trait_id);
+        let id = from_chalk_trait_id(trait_id);
        self.db.trait_data(id).name.to_string()
    }
    fn adt_name(&self, chalk_ir::AdtId(adt_id): AdtId) -> String {
@@ -416,7 +413,7 @@ pub(crate) fn trait_datum_query(
    trait_id: TraitId,
 ) -> Arc<TraitDatum> {
    debug!("trait_datum {:?}", trait_id);
-    let trait_: hir_def::TraitId = from_chalk(db, trait_id);
+    let trait_ = from_chalk_trait_id(trait_id);
    let trait_data = db.trait_data(trait_);
    debug!("trait {:?} = {:?}", trait_id, trait_data.name);
    let generic_params = generics(db.upcast(), trait_.into());
@@ -679,38 +676,65 @@ pub(crate) fn adt_variance_query(
    )
 }
-impl From<FnDefId> for crate::db::InternedCallableDefId {
+pub(super) fn convert_where_clauses(
-    fn from(fn_def_id: FnDefId) -> Self {
+    db: &dyn HirDatabase,
-        InternKey::from_intern_id(fn_def_id.0)
+    def: GenericDefId,
-    }
+    substs: &Substitution,
-}
+) -> Vec<chalk_ir::QuantifiedWhereClause<Interner>> {
+    let generic_predicates = db.generic_predicates(def);
-impl From<crate::db::InternedCallableDefId> for FnDefId {
+    let mut result = Vec::with_capacity(generic_predicates.len());
-    fn from(callable_def_id: crate::db::InternedCallableDefId) -> Self {
+    for pred in generic_predicates.iter() {
-        chalk_ir::FnDefId(callable_def_id.as_intern_id())
+        result.push(pred.clone().substitute(&Interner, substs));
-    }
+    }
-}
+    result
-impl From<OpaqueTyId> for crate::db::InternedOpaqueTyId {
-    fn from(id: OpaqueTyId) -> Self {
-        InternKey::from_intern_id(id.0)
-    }
-}
-impl From<crate::db::InternedOpaqueTyId> for OpaqueTyId {
-    fn from(id: crate::db::InternedOpaqueTyId) -> Self {
-        chalk_ir::OpaqueTyId(id.as_intern_id())
-    }
-}
-impl From<chalk_ir::ClosureId<Interner>> for crate::db::InternedClosureId {
-    fn from(id: chalk_ir::ClosureId<Interner>) -> Self {
-        Self::from_intern_id(id.0)
-    }
 }
-impl From<crate::db::InternedClosureId> for chalk_ir::ClosureId<Interner> {
+pub(super) fn generic_predicate_to_inline_bound(
-    fn from(id: crate::db::InternedClosureId) -> Self {
+    db: &dyn HirDatabase,
-        chalk_ir::ClosureId(id.as_intern_id())
+    pred: &QuantifiedWhereClause,
+    self_ty: &Ty,
+) -> Option<chalk_ir::Binders<rust_ir::InlineBound<Interner>>> {
+    // An InlineBound is like a GenericPredicate, except the self type is left out.
+    // We don't have a special type for this, but Chalk does.
+    let self_ty_shifted_in = self_ty.clone().shifted_in_from(&Interner, DebruijnIndex::ONE);
+    let (pred, binders) = pred.as_ref().into_value_and_skipped_binders();
+    match pred {
+        WhereClause::Implemented(trait_ref) => {
+            if trait_ref.self_type_parameter(&Interner) != self_ty_shifted_in {
+                // we can only convert predicates back to type bounds if they
+                // have the expected self type
+                return None;
+            }
+            let args_no_self = trait_ref.substitution.as_slice(&Interner)[1..]
+                .iter()
+                .map(|ty| ty.clone().cast(&Interner))
+                .collect();
+            let trait_bound = rust_ir::TraitBound { trait_id: trait_ref.trait_id, args_no_self };
+            Some(chalk_ir::Binders::new(binders, rust_ir::InlineBound::TraitBound(trait_bound)))
+        }
+        WhereClause::AliasEq(AliasEq { alias: AliasTy::Projection(projection_ty), ty }) => {
+            if projection_ty.self_type_parameter(&Interner) != self_ty_shifted_in {
+                return None;
+            }
+            let trait_ = projection_ty.trait_(db);
+            let args_no_self = projection_ty.substitution.as_slice(&Interner)[1..]
+                .iter()
+                .map(|ty| ty.clone().cast(&Interner))
+                .collect();
+            let alias_eq_bound = rust_ir::AliasEqBound {
+                value: ty.clone(),
+                trait_bound: rust_ir::TraitBound {
+                    trait_id: to_chalk_trait_id(trait_),
+                    args_no_self,
+                },
+                associated_ty_id: projection_ty.associated_ty_id,
+                parameters: Vec::new(), // FIXME we don't support generic associated types yet
+            };
+            Some(chalk_ir::Binders::new(
+                binders,
+                rust_ir::InlineBound::AliasEqBound(alias_eq_bound),
+            ))
+        }
+        _ => None,
    }
 }
diff --git a/crates/hir_ty/src/chalk_ext.rs b/crates/hir_ty/src/chalk_ext.rs
index 28ed3aac6..8c4542956 100644
--- a/crates/hir_ty/src/chalk_ext.rs
+++ b/crates/hir_ty/src/chalk_ext.rs
@@ -75,7 +75,7 @@ impl TyExt for Ty {
    }
    fn as_reference(&self) -> Option<(&Ty, Lifetime, Mutability)> {
        match self.kind(&Interner) {
-            TyKind::Ref(mutability, lifetime, ty) => Some((ty, *lifetime, *mutability)),
+            TyKind::Ref(mutability, lifetime, ty) => Some((ty, lifetime.clone(), *mutability)),
            _ => None,
        }
    }
diff --git a/crates/hir_ty/src/db.rs b/crates/hir_ty/src/db.rs
index 326c20240..9da0a02e3 100644
--- a/crates/hir_ty/src/db.rs
+++ b/crates/hir_ty/src/db.rs
@@ -1,4 +1,5 @@
-//! FIXME: write short doc here
+//! The home of `HirDatabase`, which is the Salsa database containing all the
+//! type inference-related queries.
 use std::sync::Arc;
@@ -10,9 +11,9 @@ use hir_def::{
 use la_arena::ArenaMap;
 use crate::{
+    chalk_db,
    method_resolution::{InherentImpls, TraitImpls},
-    traits::chalk,
+    Binders, CallableDefId, FnDefId, ImplTraitId, InferenceResult, Interner, PolyFnSig,
-    Binders, CallableDefId, FnDefId, ImplTraitId, InferenceResult, PolyFnSig,
    QuantifiedWhereClause, ReturnTypeImplTraits, TraitRef, Ty, TyDefId, ValueTyDefId,
 };
 use hir_expand::name::Name;
@@ -69,6 +70,7 @@ pub trait HirDatabase: DefDatabase + Upcast<dyn DefDatabase> {
    fn trait_environment(&self, def: GenericDefId) -> Arc<crate::TraitEnvironment>;
    #[salsa::invoke(crate::lower::generic_defaults_query)]
+    #[salsa::cycle(crate::lower::generic_defaults_recover)]
    fn generic_defaults(&self, def: GenericDefId) -> Arc<[Binders<Ty>]>;
    #[salsa::invoke(InherentImpls::inherent_impls_in_crate_query)]
@@ -94,47 +96,60 @@ pub trait HirDatabase: DefDatabase + Upcast<dyn DefDatabase> {
    #[salsa::interned]
    fn intern_closure(&self, id: (DefWithBodyId, ExprId)) -> InternedClosureId;
-    #[salsa::invoke(chalk::associated_ty_data_query)]
+    #[salsa::invoke(chalk_db::associated_ty_data_query)]
-    fn associated_ty_data(&self, id: chalk::AssocTypeId) -> Arc<chalk::AssociatedTyDatum>;
+    fn associated_ty_data(&self, id: chalk_db::AssocTypeId) -> Arc<chalk_db::AssociatedTyDatum>;
-    #[salsa::invoke(chalk::trait_datum_query)]
+    #[salsa::invoke(chalk_db::trait_datum_query)]
-    fn trait_datum(&self, krate: CrateId, trait_id: chalk::TraitId) -> Arc<chalk::TraitDatum>;
+    fn trait_datum(&self, krate: CrateId, trait_id: chalk_db::TraitId)
+        -> Arc<chalk_db::TraitDatum>;
-    #[salsa::invoke(chalk::struct_datum_query)]
+    #[salsa::invoke(chalk_db::struct_datum_query)]
-    fn struct_datum(&self, krate: CrateId, struct_id: chalk::AdtId) -> Arc<chalk::StructDatum>;
+    fn struct_datum(
+        &self,
+        krate: CrateId,
+        struct_id: chalk_db::AdtId,
+    ) -> Arc<chalk_db::StructDatum>;
-    #[salsa::invoke(crate::traits::chalk::impl_datum_query)]
+    #[salsa::invoke(chalk_db::impl_datum_query)]
-    fn impl_datum(&self, krate: CrateId, impl_id: chalk::ImplId) -> Arc<chalk::ImplDatum>;
+    fn impl_datum(&self, krate: CrateId, impl_id: chalk_db::ImplId) -> Arc<chalk_db::ImplDatum>;
-    #[salsa::invoke(crate::traits::chalk::fn_def_datum_query)]
+    #[salsa::invoke(chalk_db::fn_def_datum_query)]
-    fn fn_def_datum(&self, krate: CrateId, fn_def_id: FnDefId) -> Arc<chalk::FnDefDatum>;
+    fn fn_def_datum(&self, krate: CrateId, fn_def_id: FnDefId) -> Arc<chalk_db::FnDefDatum>;
-    #[salsa::invoke(crate::traits::chalk::fn_def_variance_query)]
+    #[salsa::invoke(chalk_db::fn_def_variance_query)]
-    fn fn_def_variance(&self, krate: CrateId, fn_def_id: FnDefId) -> chalk::Variances;
+    fn fn_def_variance(&self, krate: CrateId, fn_def_id: FnDefId) -> chalk_db::Variances;
-    #[salsa::invoke(crate::traits::chalk::adt_variance_query)]
+    #[salsa::invoke(chalk_db::adt_variance_query)]
-    fn adt_variance(&self, krate: CrateId, adt_id: chalk::AdtId) -> chalk::Variances;
+    fn adt_variance(&self, krate: CrateId, adt_id: chalk_db::AdtId) -> chalk_db::Variances;
-    #[salsa::invoke(crate::traits::chalk::associated_ty_value_query)]
+    #[salsa::invoke(chalk_db::associated_ty_value_query)]
    fn associated_ty_value(
        &self,
        krate: CrateId,
-        id: chalk::AssociatedTyValueId,
+        id: chalk_db::AssociatedTyValueId,
-    ) -> Arc<chalk::AssociatedTyValue>;
+    ) -> Arc<chalk_db::AssociatedTyValue>;
-    #[salsa::invoke(crate::traits::trait_solve_query)]
+    #[salsa::invoke(trait_solve_wait)]
+    #[salsa::transparent]
    fn trait_solve(
        &self,
        krate: CrateId,
        goal: crate::Canonical<crate::InEnvironment<crate::DomainGoal>>,
    ) -> Option<crate::Solution>;
-    #[salsa::invoke(crate::traits::chalk::program_clauses_for_chalk_env_query)]
+    #[salsa::invoke(crate::traits::trait_solve_query)]
+    fn trait_solve_query(
+        &self,
+        krate: CrateId,
+        goal: crate::Canonical<crate::InEnvironment<crate::DomainGoal>>,
+    ) -> Option<crate::Solution>;
+    #[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> {
@@ -150,6 +165,15 @@ fn infer_wait(db: &dyn HirDatabase, def: DefWithBodyId) -> Arc<InferenceResult>
    db.infer_query(def)
 }
+fn trait_solve_wait(
+    db: &dyn HirDatabase,
+    krate: CrateId,
+    goal: crate::Canonical<crate::InEnvironment<crate::DomainGoal>>,
+) -> Option<crate::Solution> {
+    let _p = profile::span("trait_solve::wait");
+    db.trait_solve_query(krate, goal)
+}
 #[test]
 fn hir_database_is_object_safe() {
    fn _assert_object_safe(_: &dyn HirDatabase) {}
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/decl_check.rs b/crates/hir_ty/src/diagnostics/decl_check.rs
index 1c9f9ede7..075dc4131 100644
--- a/crates/hir_ty/src/diagnostics/decl_check.rs
+++ b/crates/hir_ty/src/diagnostics/decl_check.rs
@@ -35,6 +35,8 @@ use crate::{
 };
 mod allow {
+    pub(super) const BAD_STYLE: &str = "bad_style";
+    pub(super) const NONSTANDARD_STYLE: &str = "nonstandard_style";
    pub(super) const NON_SNAKE_CASE: &str = "non_snake_case";
    pub(super) const NON_UPPER_CASE_GLOBAL: &str = "non_upper_case_globals";
    pub(super) const NON_CAMEL_CASE_TYPES: &str = "non_camel_case_types";
@@ -83,10 +85,39 @@ impl<'a, 'b> DeclValidator<'a, 'b> {
    }
    /// Checks whether not following the convention is allowed for this item.
-    ///
+    fn allowed(&self, id: AttrDefId, allow_name: &str, recursing: bool) -> bool {
-    /// Currently this method doesn't check parent attributes.
+        let is_allowed = |def_id| {
-    fn allowed(&self, id: AttrDefId, allow_name: &str) -> bool {
+            let attrs = self.db.attrs(def_id);
-        self.db.attrs(id).by_key("allow").tt_values().any(|tt| tt.to_string().contains(allow_name))
+            // don't bug the user about directly no_mangle annotated stuff, they can't do anything about it
+            (!recursing && attrs.by_key("no_mangle").exists())
+                || attrs.by_key("allow").tt_values().any(|tt| {
+                    let allows = tt.to_string();
+                    allows.contains(allow_name)
+                        || allows.contains(allow::BAD_STYLE)
+                        || allows.contains(allow::NONSTANDARD_STYLE)
+                })
+        };
+        is_allowed(id)
+            // go upwards one step or give up
+            || match id {
+                AttrDefId::ModuleId(m) => m.containing_module(self.db.upcast()).map(|v| v.into()),
+                AttrDefId::FunctionId(f) => Some(f.lookup(self.db.upcast()).container.into()),
+                AttrDefId::StaticId(sid) => Some(sid.lookup(self.db.upcast()).container.into()),
+                AttrDefId::ConstId(cid) => Some(cid.lookup(self.db.upcast()).container.into()),
+                AttrDefId::TraitId(tid) => Some(tid.lookup(self.db.upcast()).container.into()),
+                AttrDefId::ImplId(iid) => Some(iid.lookup(self.db.upcast()).container.into()),
+                // These warnings should not explore macro definitions at all
+                AttrDefId::MacroDefId(_) => None,
+                // Will never occur under an enum/struct/union/type alias
+                AttrDefId::AdtId(_) => None,
+                AttrDefId::FieldId(_) => None,
+                AttrDefId::EnumVariantId(_) => None,
+                AttrDefId::TypeAliasId(_) => None,
+                AttrDefId::GenericParamId(_) => None,
+            }
+            .map(|mid| self.allowed(mid, allow_name, true))
+            .unwrap_or(false)
    }
    fn validate_func(&mut self, func: FunctionId) {
@@ -109,7 +140,7 @@ impl<'a, 'b> DeclValidator<'a, 'b> {
        }
        // Check whether non-snake case identifiers are allowed for this function.
-        if self.allowed(func.into(), allow::NON_SNAKE_CASE) {
+        if self.allowed(func.into(), allow::NON_SNAKE_CASE, false) {
            return;
        }
@@ -328,8 +359,9 @@ impl<'a, 'b> DeclValidator<'a, 'b> {
    fn validate_struct(&mut self, struct_id: StructId) {
        let data = self.db.struct_data(struct_id);
-        let non_camel_case_allowed = self.allowed(struct_id.into(), allow::NON_CAMEL_CASE_TYPES);
+        let non_camel_case_allowed =
-        let non_snake_case_allowed = self.allowed(struct_id.into(), allow::NON_SNAKE_CASE);
+            self.allowed(struct_id.into(), allow::NON_CAMEL_CASE_TYPES, false);
+        let non_snake_case_allowed = self.allowed(struct_id.into(), allow::NON_SNAKE_CASE, false);
        // Check the structure name.
        let struct_name = data.name.to_string();
@@ -461,7 +493,7 @@ impl<'a, 'b> DeclValidator<'a, 'b> {
        let data = self.db.enum_data(enum_id);
        // Check whether non-camel case names are allowed for this enum.
-        if self.allowed(enum_id.into(), allow::NON_CAMEL_CASE_TYPES) {
+        if self.allowed(enum_id.into(), allow::NON_CAMEL_CASE_TYPES, false) {
            return;
        }
@@ -584,7 +616,7 @@ impl<'a, 'b> DeclValidator<'a, 'b> {
    fn validate_const(&mut self, const_id: ConstId) {
        let data = self.db.const_data(const_id);
-        if self.allowed(const_id.into(), allow::NON_UPPER_CASE_GLOBAL) {
+        if self.allowed(const_id.into(), allow::NON_UPPER_CASE_GLOBAL, false) {
            return;
        }
@@ -632,7 +664,7 @@ impl<'a, 'b> DeclValidator<'a, 'b> {
            return;
        }
-        if self.allowed(static_id.into(), allow::NON_UPPER_CASE_GLOBAL) {
+        if self.allowed(static_id.into(), allow::NON_UPPER_CASE_GLOBAL, false) {
            return;
        }
@@ -867,23 +899,116 @@ fn main() {
    fn allow_attributes() {
        check_diagnostics(
            r#"
-            #[allow(non_snake_case)]
+#[allow(non_snake_case)]
-    fn NonSnakeCaseName(SOME_VAR: u8) -> u8{
+fn NonSnakeCaseName(SOME_VAR: u8) -> u8{
-        let OtherVar = SOME_VAR + 1;
+    // cov_flags generated output from elsewhere in this file
-        OtherVar
+    extern "C" {
+        #[no_mangle]
+        static lower_case: u8;
    }
-    #[allow(non_snake_case, non_camel_case_types)]
+    let OtherVar = SOME_VAR + 1;
-    pub struct some_type {
+    OtherVar
-        SOME_FIELD: u8,
+}
-        SomeField: u16,
+#[allow(nonstandard_style)]
+mod CheckNonstandardStyle {
+    fn HiImABadFnName() {}
+}
+#[allow(bad_style)]
+mod CheckBadStyle {
+    fn HiImABadFnName() {}
+}
+mod F {
+    #![allow(non_snake_case)]
+    fn CheckItWorksWithModAttr(BAD_NAME_HI: u8) {}
+}
+#[allow(non_snake_case, non_camel_case_types)]
+pub struct some_type {
+    SOME_FIELD: u8,
+    SomeField: u16,
+}
+#[allow(non_upper_case_globals)]
+pub const some_const: u8 = 10;
+#[allow(non_upper_case_globals)]
+pub static SomeStatic: u8 = 10;
+    "#,
+        );
    }
-    #[allow(non_upper_case_globals)]
+    #[test]
-    pub const some_const: u8 = 10;
+    fn allow_attributes_crate_attr() {
+        check_diagnostics(
+            r#"
+#![allow(non_snake_case)]
-    #[allow(non_upper_case_globals)]
+mod F {
-    pub static SomeStatic: u8 = 10;
+    fn CheckItWorksWithCrateAttr(BAD_NAME_HI: u8) {}
+}
+    "#,
+        );
+    }
+    #[test]
+    #[ignore]
+    fn bug_trait_inside_fn() {
+        // FIXME:
+        // This is broken, and in fact, should not even be looked at by this
+        // lint in the first place. There's weird stuff going on in the
+        // collection phase.
+        // It's currently being brought in by:
+        // * validate_func on `a` recursing into modules
+        // * then it finds the trait and then the function while iterating
+        //   through modules
+        // * then validate_func is called on Dirty
+        // * ... which then proceeds to look at some unknown module taking no
+        //   attrs from either the impl or the fn a, and then finally to the root
+        //   module
+        //
+        // It should find the attribute on the trait, but it *doesn't even see
+        // the trait* as far as I can tell.
+        check_diagnostics(
+            r#"
+trait T { fn a(); }
+struct U {}
+impl T for U {
+    fn a() {
+        // this comes out of bitflags, mostly
+        #[allow(non_snake_case)]
+        trait __BitFlags {
+            const HiImAlsoBad: u8 = 2;
+            #[inline]
+            fn Dirty(&self) -> bool {
+                false
+            }
+        }
+    }
+}
+    "#,
+        );
+    }
+    #[test]
+    #[ignore]
+    fn bug_traits_arent_checked() {
+        // FIXME: Traits and functions in traits aren't currently checked by
+        // r-a, even though rustc will complain about them.
+        check_diagnostics(
+            r#"
+trait BAD_TRAIT {
+    // ^^^^^^^^^ Trait `BAD_TRAIT` should have CamelCase name, e.g. `BadTrait`
+    fn BAD_FUNCTION();
+    // ^^^^^^^^^^^^ Function `BAD_FUNCTION` should have snake_case name, e.g. `bad_function`
+    fn BadFunction();
+    // ^^^^^^^^^^^^ Function `BadFunction` should have snake_case name, e.g. `bad_function`
+}
    "#,
        );
    }
diff --git a/crates/hir_ty/src/display.rs b/crates/hir_ty/src/display.rs
index d7a3977e5..4fb7d9cf2 100644
--- a/crates/hir_ty/src/display.rs
+++ b/crates/hir_ty/src/display.rs
@@ -1,4 +1,6 @@
-//! FIXME: write short doc here
+//! The `HirDisplay` trait, which serves two purposes: Turning various bits from
+//! HIR back into source code, and just displaying them for debugging/testing
+//! purposes.
 use std::{
    array,
@@ -7,6 +9,7 @@ use std::{
 use chalk_ir::BoundVar;
 use hir_def::{
+    body,
    db::DefDatabase,
    find_path,
    generics::TypeParamProvenance,
@@ -16,15 +19,15 @@ use hir_def::{
    visibility::Visibility,
    AssocContainerId, Lookup, ModuleId, TraitId,
 };
-use hir_expand::name::Name;
+use hir_expand::{hygiene::Hygiene, name::Name};
 use crate::{
    const_from_placeholder_idx, db::HirDatabase, from_assoc_type_id, from_foreign_def_id,
-    from_placeholder_idx, lt_from_placeholder_idx, primitive, subst_prefix, to_assoc_type_id,
+    from_placeholder_idx, lt_from_placeholder_idx, mapping::from_chalk, primitive, subst_prefix,
-    traits::chalk::from_chalk, utils::generics, AdtId, AliasEq, AliasTy, CallableDefId,
+    to_assoc_type_id, utils::generics, AdtId, AliasEq, AliasTy, CallableDefId, CallableSig, Const,
-    CallableSig, Const, ConstValue, DomainGoal, GenericArg, ImplTraitId, Interner, Lifetime,
+    ConstValue, DomainGoal, GenericArg, ImplTraitId, Interner, Lifetime, LifetimeData,
-    LifetimeData, LifetimeOutlives, Mutability, OpaqueTy, ProjectionTy, ProjectionTyExt,
+    LifetimeOutlives, Mutability, OpaqueTy, ProjectionTy, ProjectionTyExt, QuantifiedWhereClause,
-    QuantifiedWhereClause, Scalar, TraitRef, TraitRefExt, Ty, TyExt, TyKind, WhereClause,
+    Scalar, TraitRef, TraitRefExt, Ty, TyExt, TyKind, WhereClause,
 };
 pub struct HirFormatter<'a> {
@@ -265,7 +268,7 @@ impl HirDisplay for ProjectionTy {
        write!(f, " as {}", trait_.name)?;
        if self.substitution.len(&Interner) > 1 {
            write!(f, "<")?;
-            f.write_joined(&self.substitution.interned()[1..], ", ")?;
+            f.write_joined(&self.substitution.as_slice(&Interner)[1..], ", ")?;
            write!(f, ">")?;
        }
        write!(f, ">::{}", f.db.type_alias_data(from_assoc_type_id(self.associated_ty_id)).name)?;
@@ -416,7 +419,7 @@ impl HirDisplay for Ty {
                    write!(f, ",)")?;
                } else {
                    write!(f, "(")?;
-                    f.write_joined(&*substs.interned(), ", ")?;
+                    f.write_joined(&*substs.as_slice(&Interner), ", ")?;
                    write!(f, ")")?;
                }
            }
@@ -444,7 +447,7 @@ impl HirDisplay for Ty {
                    // We print all params except implicit impl Trait params. Still a bit weird; should we leave out parent and self?
                    if total_len > 0 {
                        write!(f, "<")?;
-                        f.write_joined(&parameters.interned()[..total_len], ", ")?;
+                        f.write_joined(&parameters.as_slice(&Interner)[..total_len], ", ")?;
                        write!(f, ">")?;
                    }
                }
@@ -491,7 +494,7 @@ impl HirDisplay for Ty {
                            .map(|generic_def_id| f.db.generic_defaults(generic_def_id))
                            .filter(|defaults| !defaults.is_empty())
                        {
-                            None => parameters.interned().as_ref(),
+                            None => parameters.as_slice(&Interner),
                            Some(default_parameters) => {
                                let mut default_from = 0;
                                for (i, parameter) in parameters.iter(&Interner).enumerate() {
@@ -515,11 +518,11 @@ impl HirDisplay for Ty {
                                        }
                                    }
                                }
-                                &parameters.interned()[0..default_from]
+                                &parameters.as_slice(&Interner)[0..default_from]
                            }
                        }
                    } else {
-                        parameters.interned().as_ref()
+                        parameters.as_slice(&Interner)
                    };
                    if !parameters_to_write.is_empty() {
                        write!(f, "<")?;
@@ -542,7 +545,7 @@ impl HirDisplay for Ty {
                    write!(f, "{}::{}", trait_.name, type_alias_data.name)?;
                    if parameters.len(&Interner) > 0 {
                        write!(f, "<")?;
-                        f.write_joined(&*parameters.interned(), ", ")?;
+                        f.write_joined(&*parameters.as_slice(&Interner), ", ")?;
                        write!(f, ">")?;
                    }
                } else {
@@ -749,13 +752,13 @@ fn write_bounds_like_dyn_trait(
                // existential) here, which is the only thing that's
                // possible in actual Rust, and hence don't print it
                write!(f, "{}", f.db.trait_data(trait_).name)?;
-                if let [_, params @ ..] = &*trait_ref.substitution.interned().as_slice() {
+                if let [_, params @ ..] = &*trait_ref.substitution.as_slice(&Interner) {
                    if is_fn_trait {
                        if let Some(args) =
                            params.first().and_then(|it| it.assert_ty_ref(&Interner).as_tuple())
                        {
                            write!(f, "(")?;
-                            f.write_joined(&*args.interned(), ", ")?;
+                            f.write_joined(args.as_slice(&Interner), ", ")?;
                            write!(f, ")")?;
                        }
                    } else if !params.is_empty() {
@@ -814,7 +817,7 @@ fn fmt_trait_ref(tr: &TraitRef, f: &mut HirFormatter, use_as: bool) -> Result<()
    write!(f, "{}", f.db.trait_data(tr.hir_trait_id()).name)?;
    if tr.substitution.len(&Interner) > 1 {
        write!(f, "<")?;
-        f.write_joined(&tr.substitution.interned()[1..], ", ")?;
+        f.write_joined(&tr.substitution.as_slice(&Interner)[1..], ", ")?;
        write!(f, ">")?;
    }
    Ok(())
@@ -995,6 +998,18 @@ impl HirDisplay for TypeRef {
                write!(f, "dyn ")?;
                f.write_joined(bounds, " + ")?;
            }
+            TypeRef::Macro(macro_call) => {
+                let macro_call = macro_call.to_node(f.db.upcast());
+                let ctx = body::LowerCtx::with_hygiene(&Hygiene::new_unhygienic());
+                match macro_call.path() {
+                    Some(path) => match Path::from_src(path, &ctx) {
+                        Some(path) => path.hir_fmt(f)?,
+                        None => write!(f, "{{macro}}")?,
+                    },
+                    None => write!(f, "{{macro}}")?,
+                }
+                write!(f, "!(..)")?;
+            }
            TypeRef::Error => write!(f, "{{error}}")?,
        }
        Ok(())
diff --git a/crates/hir_ty/src/infer/expr.rs b/crates/hir_ty/src/infer/expr.rs
index cbbfa8b5c..50497eecb 100644
--- a/crates/hir_ty/src/infer/expr.rs
+++ b/crates/hir_ty/src/infer/expr.rs
@@ -17,10 +17,11 @@ use syntax::ast::RangeOp;
 use crate::{
    autoderef, dummy_usize_const,
    lower::lower_to_chalk_mutability,
+    mapping::from_chalk,
    method_resolution, op,
    primitive::{self, UintTy},
    static_lifetime, to_chalk_trait_id,
-    traits::{chalk::from_chalk, FnTrait},
+    traits::FnTrait,
    utils::{generics, Generics},
    AdtId, Binders, CallableDefId, FnPointer, FnSig, FnSubst, InEnvironment, Interner,
    ProjectionTyExt, Rawness, Scalar, Substitution, TraitRef, Ty, TyBuilder, TyExt, TyKind,
@@ -462,7 +463,11 @@ impl<'a> InferenceContext<'a> {
                    };
                    match canonicalized.decanonicalize_ty(derefed_ty.value).kind(&Interner) {
                        TyKind::Tuple(_, substs) => name.as_tuple_index().and_then(|idx| {
-                            substs.interned().get(idx).map(|a| a.assert_ty_ref(&Interner)).cloned()
+                            substs
+                                .as_slice(&Interner)
+                                .get(idx)
+                                .map(|a| a.assert_ty_ref(&Interner))
+                                .cloned()
                        }),
                        TyKind::Adt(AdtId(hir_def::AdtId::StructId(s)), parameters) => {
                            let local_id = self.db.struct_data(*s).variant_data.field(name)?;
diff --git a/crates/hir_ty/src/infer/pat.rs b/crates/hir_ty/src/infer/pat.rs
index a41e8e116..aea354cde 100644
--- a/crates/hir_ty/src/infer/pat.rs
+++ b/crates/hir_ty/src/infer/pat.rs
@@ -122,7 +122,7 @@ impl<'a> InferenceContext<'a> {
        let ty = match &body[pat] {
            &Pat::Tuple { ref args, ellipsis } => {
                let expectations = match expected.as_tuple() {
-                    Some(parameters) => &*parameters.interned().as_slice(),
+                    Some(parameters) => &*parameters.as_slice(&Interner),
                    _ => &[],
                };
@@ -242,7 +242,7 @@ impl<'a> InferenceContext<'a> {
                    let (inner_ty, alloc_ty) = match expected.as_adt() {
                        Some((adt, subst)) if adt == box_adt => (
                            subst.at(&Interner, 0).assert_ty_ref(&Interner).clone(),
-                            subst.interned().get(1).and_then(|a| a.ty(&Interner).cloned()),
+                            subst.as_slice(&Interner).get(1).and_then(|a| a.ty(&Interner).cloned()),
                        ),
                        _ => (self.result.standard_types.unknown.clone(), None),
                    };
diff --git a/crates/hir_ty/src/infer/path.rs b/crates/hir_ty/src/infer/path.rs
index f8955aa32..495282eba 100644
--- a/crates/hir_ty/src/infer/path.rs
+++ b/crates/hir_ty/src/infer/path.rs
@@ -101,7 +101,7 @@ impl<'a> InferenceContext<'a> {
        let substs = ctx.substs_from_path(path, typable, true);
        let ty = TyBuilder::value_ty(self.db, typable)
            .use_parent_substs(&parent_substs)
-            .fill(substs.interned()[parent_substs.len(&Interner)..].iter().cloned())
+            .fill(substs.as_slice(&Interner)[parent_substs.len(&Interner)..].iter().cloned())
            .build();
        Some(ty)
    }
diff --git a/crates/hir_ty/src/infer/unify.rs b/crates/hir_ty/src/infer/unify.rs
index a887e20b0..d8e0b4320 100644
--- a/crates/hir_ty/src/infer/unify.rs
+++ b/crates/hir_ty/src/infer/unify.rs
@@ -332,6 +332,10 @@ impl InferenceTable {
                | (TyKind::Slice(ty1), TyKind::Slice(ty2)) => self.unify_inner(ty1, ty2, depth + 1),
                _ => true, /* we checked equals_ctor already */
            }
+        } else if let (TyKind::Closure(.., substs1), TyKind::Closure(.., substs2)) =
+            (ty1.kind(&Interner), ty2.kind(&Interner))
+        {
+            self.unify_substs(substs1, substs2, depth + 1)
        } else {
            self.unify_inner_trivial(&ty1, &ty2, depth)
        }
diff --git a/crates/hir_ty/src/traits/chalk/interner.rs b/crates/hir_ty/src/interner.rs
index bd9395b7e..a1656115d 100644
--- a/crates/hir_ty/src/traits/chalk/interner.rs
+++ b/crates/hir_ty/src/interner.rs
@@ -1,61 +1,83 @@
 //! Implementation of the Chalk `Interner` trait, which allows customizing the
 //! representation of the various objects Chalk deals with (types, goals etc.).
-use super::tls;
+use crate::{chalk_db, tls, GenericArg};
 use base_db::salsa::InternId;
-use chalk_ir::{GenericArg, Goal, GoalData};
+use chalk_ir::{Goal, GoalData};
-use hir_def::TypeAliasId;
+use hir_def::{
+    intern::{impl_internable, InternStorage, Internable, Interned},
+    TypeAliasId,
+};
 use smallvec::SmallVec;
 use std::{fmt, sync::Arc};
 #[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
 pub struct Interner;
-pub(crate) type AssocTypeId = chalk_ir::AssocTypeId<Interner>;
+#[derive(PartialEq, Eq, Hash, Debug)]
-pub(crate) type AssociatedTyDatum = chalk_solve::rust_ir::AssociatedTyDatum<Interner>;
+pub struct InternedWrapper<T>(T);
-pub(crate) type TraitId = chalk_ir::TraitId<Interner>;
-pub(crate) type TraitDatum = chalk_solve::rust_ir::TraitDatum<Interner>;
+impl<T> std::ops::Deref for InternedWrapper<T> {
-pub(crate) type AdtId = chalk_ir::AdtId<Interner>;
+    type Target = T;
-pub(crate) type StructDatum = chalk_solve::rust_ir::AdtDatum<Interner>;
-pub(crate) type ImplId = chalk_ir::ImplId<Interner>;
+    fn deref(&self) -> &Self::Target {
-pub(crate) type ImplDatum = chalk_solve::rust_ir::ImplDatum<Interner>;
+        &self.0
-pub(crate) type AssociatedTyValueId = chalk_solve::rust_ir::AssociatedTyValueId<Interner>;
+    }
-pub(crate) type AssociatedTyValue = chalk_solve::rust_ir::AssociatedTyValue<Interner>;
+}
-pub(crate) type FnDefDatum = chalk_solve::rust_ir::FnDefDatum<Interner>;
-pub(crate) type OpaqueTyId = chalk_ir::OpaqueTyId<Interner>;
+impl_internable!(
-pub(crate) type OpaqueTyDatum = chalk_solve::rust_ir::OpaqueTyDatum<Interner>;
+    InternedWrapper<Vec<chalk_ir::VariableKind<Interner>>>,
-pub(crate) type Variances = chalk_ir::Variances<Interner>;
+    InternedWrapper<SmallVec<[GenericArg; 2]>>,
+    InternedWrapper<chalk_ir::TyData<Interner>>,
+    InternedWrapper<chalk_ir::LifetimeData<Interner>>,
+    InternedWrapper<chalk_ir::ConstData<Interner>>,
+    InternedWrapper<Vec<chalk_ir::CanonicalVarKind<Interner>>>,
+    InternedWrapper<Vec<chalk_ir::ProgramClause<Interner>>>,
+    InternedWrapper<Vec<chalk_ir::QuantifiedWhereClause<Interner>>>,
+    InternedWrapper<Vec<chalk_ir::Variance>>,
+);
 impl chalk_ir::interner::Interner for Interner {
-    type InternedType = Arc<chalk_ir::TyData<Self>>;
+    type InternedType = Interned<InternedWrapper<chalk_ir::TyData<Interner>>>;
-    type InternedLifetime = chalk_ir::LifetimeData<Self>;
+    type InternedLifetime = Interned<InternedWrapper<chalk_ir::LifetimeData<Self>>>;
-    type InternedConst = Arc<chalk_ir::ConstData<Self>>;
+    type InternedConst = Interned<InternedWrapper<chalk_ir::ConstData<Self>>>;
    type InternedConcreteConst = ();
    type InternedGenericArg = chalk_ir::GenericArgData<Self>;
    type InternedGoal = Arc<GoalData<Self>>;
    type InternedGoals = Vec<Goal<Self>>;
-    type InternedSubstitution = SmallVec<[GenericArg<Self>; 2]>;
+    type InternedSubstitution = Interned<InternedWrapper<SmallVec<[GenericArg; 2]>>>;
-    type InternedProgramClause = Arc<chalk_ir::ProgramClauseData<Self>>;
+    type InternedProgramClause = chalk_ir::ProgramClauseData<Self>;
-    type InternedProgramClauses = Arc<[chalk_ir::ProgramClause<Self>]>;
+    type InternedProgramClauses = Interned<InternedWrapper<Vec<chalk_ir::ProgramClause<Self>>>>;
-    type InternedQuantifiedWhereClauses = Vec<chalk_ir::QuantifiedWhereClause<Self>>;
+    type InternedQuantifiedWhereClauses =
-    type InternedVariableKinds = Vec<chalk_ir::VariableKind<Self>>;
+        Interned<InternedWrapper<Vec<chalk_ir::QuantifiedWhereClause<Self>>>>;
-    type InternedCanonicalVarKinds = Vec<chalk_ir::CanonicalVarKind<Self>>;
+    type InternedVariableKinds = Interned<InternedWrapper<Vec<chalk_ir::VariableKind<Interner>>>>;
+    type InternedCanonicalVarKinds =
+        Interned<InternedWrapper<Vec<chalk_ir::CanonicalVarKind<Self>>>>;
    type InternedConstraints = Vec<chalk_ir::InEnvironment<chalk_ir::Constraint<Self>>>;
-    type InternedVariances = Arc<[chalk_ir::Variance]>;
+    type InternedVariances = Interned<InternedWrapper<Vec<chalk_ir::Variance>>>;
    type DefId = InternId;
    type InternedAdtId = hir_def::AdtId;
    type Identifier = TypeAliasId;
    type FnAbi = ();
-    fn debug_adt_id(type_kind_id: AdtId, fmt: &mut fmt::Formatter<'_>) -> Option<fmt::Result> {
+    fn debug_adt_id(
+        type_kind_id: chalk_db::AdtId,
+        fmt: &mut fmt::Formatter<'_>,
+    ) -> Option<fmt::Result> {
        tls::with_current_program(|prog| Some(prog?.debug_struct_id(type_kind_id, fmt)))
    }
-    fn debug_trait_id(type_kind_id: TraitId, fmt: &mut fmt::Formatter<'_>) -> Option<fmt::Result> {
+    fn debug_trait_id(
+        type_kind_id: chalk_db::TraitId,
+        fmt: &mut fmt::Formatter<'_>,
+    ) -> Option<fmt::Result> {
        tls::with_current_program(|prog| Some(prog?.debug_trait_id(type_kind_id, fmt)))
    }
-    fn debug_assoc_type_id(id: AssocTypeId, fmt: &mut fmt::Formatter<'_>) -> Option<fmt::Result> {
+    fn debug_assoc_type_id(
+        id: chalk_db::AssocTypeId,
+        fmt: &mut fmt::Formatter<'_>,
+    ) -> Option<fmt::Result> {
        tls::with_current_program(|prog| Some(prog?.debug_assoc_type_id(id, fmt)))
    }
@@ -99,7 +121,7 @@ impl chalk_ir::interner::Interner for Interner {
    }
    fn debug_generic_arg(
-        parameter: &GenericArg<Interner>,
+        parameter: &GenericArg,
        fmt: &mut fmt::Formatter<'_>,
    ) -> Option<fmt::Result> {
        tls::with_current_program(|prog| Some(prog?.debug_generic_arg(parameter, fmt)))
@@ -194,30 +216,30 @@ impl chalk_ir::interner::Interner for Interner {
    fn intern_ty(&self, kind: chalk_ir::TyKind<Self>) -> Self::InternedType {
        let flags = kind.compute_flags(self);
-        Arc::new(chalk_ir::TyData { kind, flags })
+        Interned::new(InternedWrapper(chalk_ir::TyData { kind, flags }))
    }
    fn ty_data<'a>(&self, ty: &'a Self::InternedType) -> &'a chalk_ir::TyData<Self> {
-        ty
+        &ty.0
    }
    fn intern_lifetime(&self, lifetime: chalk_ir::LifetimeData<Self>) -> Self::InternedLifetime {
-        lifetime
+        Interned::new(InternedWrapper(lifetime))
    }
    fn lifetime_data<'a>(
        &self,
        lifetime: &'a Self::InternedLifetime,
    ) -> &'a chalk_ir::LifetimeData<Self> {
-        lifetime
+        &lifetime.0
    }
    fn intern_const(&self, constant: chalk_ir::ConstData<Self>) -> Self::InternedConst {
-        Arc::new(constant)
+        Interned::new(InternedWrapper(constant))
    }
    fn const_data<'a>(&self, constant: &'a Self::InternedConst) -> &'a chalk_ir::ConstData<Self> {
-        constant
+        &constant.0
    }
    fn const_eq(
@@ -264,23 +286,23 @@ impl chalk_ir::interner::Interner for Interner {
    fn intern_substitution<E>(
        &self,
-        data: impl IntoIterator<Item = Result<GenericArg<Self>, E>>,
+        data: impl IntoIterator<Item = Result<GenericArg, E>>,
    ) -> Result<Self::InternedSubstitution, E> {
-        data.into_iter().collect()
+        Ok(Interned::new(InternedWrapper(data.into_iter().collect::<Result<_, _>>()?)))
    }
    fn substitution_data<'a>(
        &self,
        substitution: &'a Self::InternedSubstitution,
-    ) -> &'a [GenericArg<Self>] {
+    ) -> &'a [GenericArg] {
-        substitution
+        &substitution.as_ref().0
    }
    fn intern_program_clause(
        &self,
        data: chalk_ir::ProgramClauseData<Self>,
    ) -> Self::InternedProgramClause {
-        Arc::new(data)
+        data
    }
    fn program_clause_data<'a>(
@@ -294,7 +316,7 @@ impl chalk_ir::interner::Interner for Interner {
        &self,
        data: impl IntoIterator<Item = Result<chalk_ir::ProgramClause<Self>, E>>,
    ) -> Result<Self::InternedProgramClauses, E> {
-        data.into_iter().collect()
+        Ok(Interned::new(InternedWrapper(data.into_iter().collect::<Result<_, _>>()?)))
    }
    fn program_clauses_data<'a>(
@@ -308,7 +330,7 @@ impl chalk_ir::interner::Interner for Interner {
        &self,
        data: impl IntoIterator<Item = Result<chalk_ir::QuantifiedWhereClause<Self>, E>>,
    ) -> Result<Self::InternedQuantifiedWhereClauses, E> {
-        data.into_iter().collect()
+        Ok(Interned::new(InternedWrapper(data.into_iter().collect::<Result<_, _>>()?)))
    }
    fn quantified_where_clauses_data<'a>(
@@ -322,21 +344,21 @@ impl chalk_ir::interner::Interner for Interner {
        &self,
        data: impl IntoIterator<Item = Result<chalk_ir::VariableKind<Self>, E>>,
    ) -> Result<Self::InternedVariableKinds, E> {
-        data.into_iter().collect()
+        Ok(Interned::new(InternedWrapper(data.into_iter().collect::<Result<_, _>>()?)))
    }
    fn variable_kinds_data<'a>(
        &self,
        parameter_kinds: &'a Self::InternedVariableKinds,
    ) -> &'a [chalk_ir::VariableKind<Self>] {
-        &parameter_kinds
+        &parameter_kinds.as_ref().0
    }
    fn intern_canonical_var_kinds<E>(
        &self,
        data: impl IntoIterator<Item = Result<chalk_ir::CanonicalVarKind<Self>, E>>,
    ) -> Result<Self::InternedCanonicalVarKinds, E> {
-        data.into_iter().collect()
+        Ok(Interned::new(InternedWrapper(data.into_iter().collect::<Result<_, _>>()?)))
    }
    fn canonical_var_kinds_data<'a>(
@@ -376,7 +398,7 @@ impl chalk_ir::interner::Interner for Interner {
        &self,
        data: impl IntoIterator<Item = Result<chalk_ir::Variance, E>>,
    ) -> Result<Self::InternedVariances, E> {
-        data.into_iter().collect()
+        Ok(Interned::new(InternedWrapper(data.into_iter().collect::<Result<_, _>>()?)))
    }
    fn variances_data<'a>(
@@ -390,3 +412,12 @@ impl chalk_ir::interner::Interner for Interner {
 impl chalk_ir::interner::HasInterner for Interner {
    type Interner = Self;
 }
+#[macro_export]
+macro_rules! has_interner {
+    ($t:ty) => {
+        impl HasInterner for $t {
+            type Interner = crate::Interner;
+        }
+    };
+}
diff --git a/crates/hir_ty/src/lib.rs b/crates/hir_ty/src/lib.rs
index 874c95411..0505fa4ae 100644
--- a/crates/hir_ty/src/lib.rs
+++ b/crates/hir_ty/src/lib.rs
@@ -7,21 +7,23 @@ macro_rules! eprintln {
 }
 mod autoderef;
-pub mod primitive;
-pub mod traits;
-pub mod method_resolution;
-mod op;
-mod lower;
-pub(crate) mod infer;
-pub(crate) mod utils;
-mod chalk_cast;
-mod chalk_ext;
 mod builder;
+mod chalk_db;
+mod chalk_ext;
+mod infer;
+mod interner;
+mod lower;
+mod mapping;
+mod op;
+mod tls;
+mod utils;
 mod walk;
-pub mod display;
 pub mod db;
 pub mod diagnostics;
+pub mod display;
+pub mod method_resolution;
+pub mod primitive;
+pub mod traits;
 #[cfg(test)]
 mod tests;
@@ -30,16 +32,12 @@ mod test_db;
 use std::sync::Arc;
-use base_db::salsa;
 use chalk_ir::{
    fold::{Fold, Shift},
    interner::HasInterner,
    UintTy,
 };
-use hir_def::{
+use hir_def::{expr::ExprId, type_ref::Rawness, TypeParamId};
-    expr::ExprId, type_ref::Rawness, ConstParamId, LifetimeParamId, TraitId, TypeAliasId,
-    TypeParamId,
-};
 use crate::{db::HirDatabase, display::HirDisplay, utils::generics};
@@ -47,11 +45,18 @@ pub use autoderef::autoderef;
 pub use builder::TyBuilder;
 pub use chalk_ext::*;
 pub use infer::{could_unify, InferenceResult};
+pub use interner::Interner;
 pub use lower::{
    associated_type_shorthand_candidates, callable_item_sig, CallableDefId, ImplTraitLoweringMode,
    TyDefId, TyLoweringContext, ValueTyDefId,
 };
-pub use traits::{chalk::Interner, TraitEnvironment};
+pub use mapping::{
+    const_from_placeholder_idx, from_assoc_type_id, from_chalk_trait_id, from_foreign_def_id,
+    from_placeholder_idx, lt_from_placeholder_idx, to_assoc_type_id, to_chalk_trait_id,
+    to_foreign_def_id, to_placeholder_idx,
+};
+pub use traits::TraitEnvironment;
+pub use utils::all_super_traits;
 pub use walk::TypeWalk;
 pub use chalk_ir::{
@@ -94,6 +99,10 @@ pub type ConstValue = chalk_ir::ConstValue<Interner>;
 pub type ConcreteConst = chalk_ir::ConcreteConst<Interner>;
 pub type ChalkTraitId = chalk_ir::TraitId<Interner>;
+pub type TraitRef = chalk_ir::TraitRef<Interner>;
+pub type QuantifiedWhereClause = Binders<WhereClause>;
+pub type QuantifiedWhereClauses = chalk_ir::QuantifiedWhereClauses<Interner>;
+pub type Canonical<T> = chalk_ir::Canonical<T>;
 pub type FnSig = chalk_ir::FnSig<Interner>;
@@ -109,7 +118,7 @@ pub type WhereClause = chalk_ir::WhereClause<Interner>;
 pub fn subst_prefix(s: &Substitution, n: usize) -> Substitution {
    Substitution::from_iter(
        &Interner,
-        s.interned()[..std::cmp::min(s.len(&Interner), n)].iter().cloned(),
+        s.as_slice(&Interner)[..std::cmp::min(s.len(&Interner), n)].iter().cloned(),
    )
 }
@@ -118,14 +127,14 @@ pub fn param_idx(db: &dyn HirDatabase, id: TypeParamId) -> Option<usize> {
    generics(db.upcast(), id.parent).param_idx(id)
 }
-pub fn wrap_empty_binders<T>(value: T) -> Binders<T>
+pub(crate) fn wrap_empty_binders<T>(value: T) -> Binders<T>
 where
    T: Fold<Interner, Result = T> + HasInterner<Interner = Interner>,
 {
    Binders::empty(&Interner, value.shifted_in_from(&Interner, DebruijnIndex::ONE))
 }
-pub fn make_only_type_binders<T: HasInterner<Interner = Interner>>(
+pub(crate) fn make_only_type_binders<T: HasInterner<Interner = Interner>>(
    num_vars: usize,
    value: T,
 ) -> Binders<T> {
@@ -153,14 +162,6 @@ pub fn make_canonical<T: HasInterner<Interner = Interner>>(
    Canonical { value, binders: chalk_ir::CanonicalVarKinds::from_iter(&Interner, kinds) }
 }
-pub type TraitRef = chalk_ir::TraitRef<Interner>;
-pub type QuantifiedWhereClause = Binders<WhereClause>;
-pub type QuantifiedWhereClauses = chalk_ir::QuantifiedWhereClauses<Interner>;
-pub type Canonical<T> = chalk_ir::Canonical<T>;
 /// A function signature as seen by type inference: Several parameter types and
 /// one return type.
 #[derive(Clone, PartialEq, Eq, Debug)]
@@ -169,6 +170,8 @@ pub struct CallableSig {
    is_varargs: bool,
 }
+has_interner!(CallableSig);
 /// A polymorphic function signature.
 pub type PolyFnSig = Binders<CallableSig>;
@@ -187,7 +190,7 @@ impl CallableSig {
                .shifted_out_to(&Interner, DebruijnIndex::ONE)
                .expect("unexpected lifetime vars in fn ptr")
                .0
-                .interned()
+                .as_slice(&Interner)
                .iter()
                .map(|arg| arg.assert_ty_ref(&Interner).clone())
                .collect(),
@@ -232,61 +235,13 @@ pub struct ReturnTypeImplTraits {
    pub(crate) impl_traits: Vec<ReturnTypeImplTrait>,
 }
+has_interner!(ReturnTypeImplTraits);
 #[derive(Clone, PartialEq, Eq, Debug, Hash)]
 pub(crate) struct ReturnTypeImplTrait {
    pub(crate) bounds: Binders<Vec<QuantifiedWhereClause>>,
 }
-pub fn to_foreign_def_id(id: TypeAliasId) -> ForeignDefId {
-    chalk_ir::ForeignDefId(salsa::InternKey::as_intern_id(&id))
-}
-pub fn from_foreign_def_id(id: ForeignDefId) -> TypeAliasId {
-    salsa::InternKey::from_intern_id(id.0)
-}
-pub fn to_assoc_type_id(id: TypeAliasId) -> AssocTypeId {
-    chalk_ir::AssocTypeId(salsa::InternKey::as_intern_id(&id))
-}
-pub fn from_assoc_type_id(id: AssocTypeId) -> TypeAliasId {
-    salsa::InternKey::from_intern_id(id.0)
-}
-pub fn from_placeholder_idx(db: &dyn HirDatabase, idx: PlaceholderIndex) -> TypeParamId {
-    assert_eq!(idx.ui, chalk_ir::UniverseIndex::ROOT);
-    let interned_id = salsa::InternKey::from_intern_id(salsa::InternId::from(idx.idx));
-    db.lookup_intern_type_param_id(interned_id)
-}
-pub fn to_placeholder_idx(db: &dyn HirDatabase, id: TypeParamId) -> PlaceholderIndex {
-    let interned_id = db.intern_type_param_id(id);
-    PlaceholderIndex {
-        ui: chalk_ir::UniverseIndex::ROOT,
-        idx: salsa::InternKey::as_intern_id(&interned_id).as_usize(),
-    }
-}
-pub fn lt_from_placeholder_idx(db: &dyn HirDatabase, idx: PlaceholderIndex) -> LifetimeParamId {
-    assert_eq!(idx.ui, chalk_ir::UniverseIndex::ROOT);
-    let interned_id = salsa::InternKey::from_intern_id(salsa::InternId::from(idx.idx));
-    db.lookup_intern_lifetime_param_id(interned_id)
-}
-pub fn const_from_placeholder_idx(db: &dyn HirDatabase, idx: PlaceholderIndex) -> ConstParamId {
-    assert_eq!(idx.ui, chalk_ir::UniverseIndex::ROOT);
-    let interned_id = salsa::InternKey::from_intern_id(salsa::InternId::from(idx.idx));
-    db.lookup_intern_const_param_id(interned_id)
-}
-pub fn to_chalk_trait_id(id: TraitId) -> ChalkTraitId {
-    chalk_ir::TraitId(salsa::InternKey::as_intern_id(&id))
-}
-pub fn from_chalk_trait_id(id: ChalkTraitId) -> TraitId {
-    salsa::InternKey::from_intern_id(id.0)
-}
 pub fn static_lifetime() -> Lifetime {
    LifetimeData::Static.intern(&Interner)
 }
diff --git a/crates/hir_ty/src/lower.rs b/crates/hir_ty/src/lower.rs
index 8a22d9ea3..c99dd8d0a 100644
--- a/crates/hir_ty/src/lower.rs
+++ b/crates/hir_ty/src/lower.rs
@@ -5,12 +5,14 @@
 //!  - Building the type for an item: This happens through the `type_for_def` query.
 //!
 //! This usually involves resolving names, collecting generic arguments etc.
+use std::cell::{Cell, RefCell};
 use std::{iter, sync::Arc};
 use base_db::CrateId;
 use chalk_ir::{cast::Cast, fold::Shift, interner::HasInterner, Mutability, Safety};
 use hir_def::{
    adt::StructKind,
+    body::{Expander, LowerCtx},
    builtin_type::BuiltinType,
    generics::{TypeParamProvenance, WherePredicate, WherePredicateTypeTarget},
    path::{GenericArg, Path, PathSegment, PathSegments},
@@ -20,20 +22,22 @@ use hir_def::{
    GenericDefId, HasModule, ImplId, LocalFieldId, Lookup, StaticId, StructId, TraitId,
    TypeAliasId, TypeParamId, UnionId, VariantId,
 };
-use hir_expand::name::Name;
+use hir_expand::{name::Name, ExpandResult};
 use la_arena::ArenaMap;
 use smallvec::SmallVec;
 use stdx::impl_from;
+use syntax::ast;
 use crate::{
    db::HirDatabase,
-    dummy_usize_const, static_lifetime, to_assoc_type_id, to_chalk_trait_id, to_placeholder_idx,
+    dummy_usize_const,
-    traits::chalk::{Interner, ToChalk},
+    mapping::ToChalk,
+    static_lifetime, to_assoc_type_id, to_chalk_trait_id, to_placeholder_idx,
    utils::{
        all_super_trait_refs, associated_type_by_name_including_super_traits, generics, Generics,
    },
    AliasEq, AliasTy, Binders, BoundVar, CallableSig, DebruijnIndex, DynTy, FnPointer, FnSig,
-    FnSubst, ImplTraitId, OpaqueTy, PolyFnSig, ProjectionTy, QuantifiedWhereClause,
+    FnSubst, ImplTraitId, Interner, OpaqueTy, PolyFnSig, ProjectionTy, QuantifiedWhereClause,
    QuantifiedWhereClauses, ReturnTypeImplTrait, ReturnTypeImplTraits, Substitution,
    TraitEnvironment, TraitRef, TraitRefExt, Ty, TyBuilder, TyKind, WhereClause,
 };
@@ -49,7 +53,7 @@ pub struct TyLoweringContext<'a> {
    /// possible currently, so this should be fine for now.
    pub type_param_mode: TypeParamLoweringMode,
    pub impl_trait_mode: ImplTraitLoweringMode,
-    impl_trait_counter: std::cell::Cell<u16>,
+    impl_trait_counter: Cell<u16>,
    /// When turning `impl Trait` into opaque types, we have to collect the
    /// bounds at the same time to get the IDs correct (without becoming too
    /// complicated). I don't like using interior mutability (as for the
@@ -58,16 +62,17 @@ pub struct TyLoweringContext<'a> {
    /// we're grouping the mutable data (the counter and this field) together
    /// with the immutable context (the references to the DB and resolver).
    /// Splitting this up would be a possible fix.
-    opaque_type_data: std::cell::RefCell<Vec<ReturnTypeImplTrait>>,
+    opaque_type_data: RefCell<Vec<ReturnTypeImplTrait>>,
+    expander: RefCell<Option<Expander>>,
 }
 impl<'a> TyLoweringContext<'a> {
    pub fn new(db: &'a dyn HirDatabase, resolver: &'a Resolver) -> Self {
-        let impl_trait_counter = std::cell::Cell::new(0);
+        let impl_trait_counter = Cell::new(0);
        let impl_trait_mode = ImplTraitLoweringMode::Disallowed;
        let type_param_mode = TypeParamLoweringMode::Placeholder;
        let in_binders = DebruijnIndex::INNERMOST;
-        let opaque_type_data = std::cell::RefCell::new(Vec::new());
+        let opaque_type_data = RefCell::new(Vec::new());
        Self {
            db,
            resolver,
@@ -76,6 +81,7 @@ impl<'a> TyLoweringContext<'a> {
            impl_trait_counter,
            type_param_mode,
            opaque_type_data,
+            expander: RefCell::new(None),
        }
    }
@@ -85,15 +91,18 @@ impl<'a> TyLoweringContext<'a> {
        f: impl FnOnce(&TyLoweringContext) -> T,
    ) -> T {
        let opaque_ty_data_vec = self.opaque_type_data.replace(Vec::new());
+        let expander = self.expander.replace(None);
        let new_ctx = Self {
            in_binders: debruijn,
-            impl_trait_counter: std::cell::Cell::new(self.impl_trait_counter.get()),
+            impl_trait_counter: Cell::new(self.impl_trait_counter.get()),
-            opaque_type_data: std::cell::RefCell::new(opaque_ty_data_vec),
+            opaque_type_data: RefCell::new(opaque_ty_data_vec),
+            expander: RefCell::new(expander),
            ..*self
        };
        let result = f(&new_ctx);
        self.impl_trait_counter.set(new_ctx.impl_trait_counter.get());
        self.opaque_type_data.replace(new_ctx.opaque_type_data.into_inner());
+        self.expander.replace(new_ctx.expander.into_inner());
        result
    }
@@ -286,6 +295,53 @@ impl<'a> TyLoweringContext<'a> {
                    }
                }
            }
+            TypeRef::Macro(macro_call) => {
+                let (expander, recursion_start) = {
+                    let mut expander = self.expander.borrow_mut();
+                    if expander.is_some() {
+                        (Some(expander), false)
+                    } else {
+                        if let Some(module_id) = self.resolver.module() {
+                            *expander = Some(Expander::new(
+                                self.db.upcast(),
+                                macro_call.file_id,
+                                module_id,
+                            ));
+                            (Some(expander), true)
+                        } else {
+                            (None, false)
+                        }
+                    }
+                };
+                let ty = if let Some(mut expander) = expander {
+                    let expander_mut = expander.as_mut().unwrap();
+                    let macro_call = macro_call.to_node(self.db.upcast());
+                    match expander_mut.enter_expand::<ast::Type>(self.db.upcast(), macro_call) {
+                        Ok(ExpandResult { value: Some((mark, expanded)), .. }) => {
+                            let ctx =
+                                LowerCtx::new(self.db.upcast(), expander_mut.current_file_id());
+                            let type_ref = TypeRef::from_ast(&ctx, expanded);
+                            drop(expander);
+                            let ty = self.lower_ty(&type_ref);
+                            self.expander
+                                .borrow_mut()
+                                .as_mut()
+                                .unwrap()
+                                .exit(self.db.upcast(), mark);
+                            Some(ty)
+                        }
+                        _ => None,
+                    }
+                } else {
+                    None
+                };
+                if recursion_start {
+                    *self.expander.borrow_mut() = None;
+                }
+                ty.unwrap_or_else(|| TyKind::Error.intern(&Interner))
+            }
            TypeRef::Error => TyKind::Error.intern(&Interner),
        };
        (ty, res)
@@ -358,17 +414,16 @@ impl<'a> TyLoweringContext<'a> {
                    self.lower_trait_ref_from_resolved_path(trait_, resolved_segment, self_ty);
                let ty = if remaining_segments.len() == 1 {
                    let segment = remaining_segments.first().unwrap();
-                    let found = associated_type_by_name_including_super_traits(
+                    let found = self
-                        self.db,
+                        .db
-                        trait_ref,
+                        .trait_data(trait_ref.hir_trait_id())
-                        &segment.name,
+                        .associated_type_by_name(&segment.name);
-                    );
                    match found {
-                        Some((super_trait_ref, associated_ty)) => {
+                        Some(associated_ty) => {
                            // FIXME handle type parameters on the segment
                            TyKind::Alias(AliasTy::Projection(ProjectionTy {
                                associated_ty_id: to_assoc_type_id(associated_ty),
-                                substitution: super_trait_ref.substitution,
+                                substitution: trait_ref.substitution,
                            }))
                            .intern(&Interner)
                        }
@@ -1033,6 +1088,27 @@ pub(crate) fn generic_defaults_query(
    defaults
 }
+pub(crate) fn generic_defaults_recover(
+    db: &dyn HirDatabase,
+    _cycle: &[String],
+    def: &GenericDefId,
+) -> Arc<[Binders<Ty>]> {
+    let generic_params = generics(db.upcast(), *def);
+    // we still need one default per parameter
+    let defaults = generic_params
+        .iter()
+        .enumerate()
+        .map(|(idx, _)| {
+            let ty = TyKind::Error.intern(&Interner);
+            crate::make_only_type_binders(idx, ty)
+        })
+        .collect();
+    defaults
+}
 fn fn_sig_for_fn(db: &dyn HirDatabase, def: FunctionId) -> PolyFnSig {
    let data = db.function_data(def);
    let resolver = def.resolver(db.upcast());
diff --git a/crates/hir_ty/src/mapping.rs b/crates/hir_ty/src/mapping.rs
new file mode 100644
index 000000000..5e86fafe5
--- /dev/null
+++ b/crates/hir_ty/src/mapping.rs
@@ -0,0 +1,154 @@
+//! This module contains the implementations of the `ToChalk` trait, which
+//! handles conversion between our data types and their corresponding types in
+//! Chalk (in both directions); plus some helper functions for more specialized
+//! conversions.
+use chalk_solve::rust_ir;
+use base_db::salsa::{self, InternKey};
+use hir_def::{ConstParamId, LifetimeParamId, TraitId, TypeAliasId, TypeParamId};
+use crate::{
+    chalk_db, db::HirDatabase, AssocTypeId, CallableDefId, ChalkTraitId, FnDefId, ForeignDefId,
+    Interner, OpaqueTyId, PlaceholderIndex,
+};
+pub(crate) trait ToChalk {
+    type Chalk;
+    fn to_chalk(self, db: &dyn HirDatabase) -> Self::Chalk;
+    fn from_chalk(db: &dyn HirDatabase, chalk: Self::Chalk) -> Self;
+}
+pub(crate) fn from_chalk<T, ChalkT>(db: &dyn HirDatabase, chalk: ChalkT) -> T
+where
+    T: ToChalk<Chalk = ChalkT>,
+{
+    T::from_chalk(db, chalk)
+}
+impl ToChalk for hir_def::ImplId {
+    type Chalk = chalk_db::ImplId;
+    fn to_chalk(self, _db: &dyn HirDatabase) -> chalk_db::ImplId {
+        chalk_ir::ImplId(self.as_intern_id())
+    }
+    fn from_chalk(_db: &dyn HirDatabase, impl_id: chalk_db::ImplId) -> hir_def::ImplId {
+        InternKey::from_intern_id(impl_id.0)
+    }
+}
+impl ToChalk for CallableDefId {
+    type Chalk = FnDefId;
+    fn to_chalk(self, db: &dyn HirDatabase) -> FnDefId {
+        db.intern_callable_def(self).into()
+    }
+    fn from_chalk(db: &dyn HirDatabase, fn_def_id: FnDefId) -> CallableDefId {
+        db.lookup_intern_callable_def(fn_def_id.into())
+    }
+}
+pub(crate) struct TypeAliasAsValue(pub(crate) TypeAliasId);
+impl ToChalk for TypeAliasAsValue {
+    type Chalk = chalk_db::AssociatedTyValueId;
+    fn to_chalk(self, _db: &dyn HirDatabase) -> chalk_db::AssociatedTyValueId {
+        rust_ir::AssociatedTyValueId(self.0.as_intern_id())
+    }
+    fn from_chalk(
+        _db: &dyn HirDatabase,
+        assoc_ty_value_id: chalk_db::AssociatedTyValueId,
+    ) -> TypeAliasAsValue {
+        TypeAliasAsValue(TypeAliasId::from_intern_id(assoc_ty_value_id.0))
+    }
+}
+impl From<FnDefId> for crate::db::InternedCallableDefId {
+    fn from(fn_def_id: FnDefId) -> Self {
+        InternKey::from_intern_id(fn_def_id.0)
+    }
+}
+impl From<crate::db::InternedCallableDefId> for FnDefId {
+    fn from(callable_def_id: crate::db::InternedCallableDefId) -> Self {
+        chalk_ir::FnDefId(callable_def_id.as_intern_id())
+    }
+}
+impl From<OpaqueTyId> for crate::db::InternedOpaqueTyId {
+    fn from(id: OpaqueTyId) -> Self {
+        InternKey::from_intern_id(id.0)
+    }
+}
+impl From<crate::db::InternedOpaqueTyId> for OpaqueTyId {
+    fn from(id: crate::db::InternedOpaqueTyId) -> Self {
+        chalk_ir::OpaqueTyId(id.as_intern_id())
+    }
+}
+impl From<chalk_ir::ClosureId<Interner>> for crate::db::InternedClosureId {
+    fn from(id: chalk_ir::ClosureId<Interner>) -> Self {
+        Self::from_intern_id(id.0)
+    }
+}
+impl From<crate::db::InternedClosureId> for chalk_ir::ClosureId<Interner> {
+    fn from(id: crate::db::InternedClosureId) -> Self {
+        chalk_ir::ClosureId(id.as_intern_id())
+    }
+}
+pub fn to_foreign_def_id(id: TypeAliasId) -> ForeignDefId {
+    chalk_ir::ForeignDefId(salsa::InternKey::as_intern_id(&id))
+}
+pub fn from_foreign_def_id(id: ForeignDefId) -> TypeAliasId {
+    salsa::InternKey::from_intern_id(id.0)
+}
+pub fn to_assoc_type_id(id: TypeAliasId) -> AssocTypeId {
+    chalk_ir::AssocTypeId(salsa::InternKey::as_intern_id(&id))
+}
+pub fn from_assoc_type_id(id: AssocTypeId) -> TypeAliasId {
+    salsa::InternKey::from_intern_id(id.0)
+}
+pub fn from_placeholder_idx(db: &dyn HirDatabase, idx: PlaceholderIndex) -> TypeParamId {
+    assert_eq!(idx.ui, chalk_ir::UniverseIndex::ROOT);
+    let interned_id = salsa::InternKey::from_intern_id(salsa::InternId::from(idx.idx));
+    db.lookup_intern_type_param_id(interned_id)
+}
+pub fn to_placeholder_idx(db: &dyn HirDatabase, id: TypeParamId) -> PlaceholderIndex {
+    let interned_id = db.intern_type_param_id(id);
+    PlaceholderIndex {
+        ui: chalk_ir::UniverseIndex::ROOT,
+        idx: salsa::InternKey::as_intern_id(&interned_id).as_usize(),
+    }
+}
+pub fn lt_from_placeholder_idx(db: &dyn HirDatabase, idx: PlaceholderIndex) -> LifetimeParamId {
+    assert_eq!(idx.ui, chalk_ir::UniverseIndex::ROOT);
+    let interned_id = salsa::InternKey::from_intern_id(salsa::InternId::from(idx.idx));
+    db.lookup_intern_lifetime_param_id(interned_id)
+}
+pub fn const_from_placeholder_idx(db: &dyn HirDatabase, idx: PlaceholderIndex) -> ConstParamId {
+    assert_eq!(idx.ui, chalk_ir::UniverseIndex::ROOT);
+    let interned_id = salsa::InternKey::from_intern_id(salsa::InternId::from(idx.idx));
+    db.lookup_intern_const_param_id(interned_id)
+}
+pub fn to_chalk_trait_id(id: TraitId) -> ChalkTraitId {
+    chalk_ir::TraitId(salsa::InternKey::as_intern_id(&id))
+}
+pub fn from_chalk_trait_id(id: ChalkTraitId) -> TraitId {
+    salsa::InternKey::from_intern_id(id.0)
+}
diff --git a/crates/hir_ty/src/method_resolution.rs b/crates/hir_ty/src/method_resolution.rs
index be3e4f09a..48bbcfd9f 100644
--- a/crates/hir_ty/src/method_resolution.rs
+++ b/crates/hir_ty/src/method_resolution.rs
@@ -21,32 +21,36 @@ use crate::{
    primitive::{self, FloatTy, IntTy, UintTy},
    static_lifetime,
    utils::all_super_traits,
-    AdtId, Canonical, CanonicalVarKinds, DebruijnIndex, FnPointer, FnSig, ForeignDefId,
+    AdtId, Canonical, CanonicalVarKinds, DebruijnIndex, ForeignDefId, InEnvironment, Interner,
-    InEnvironment, Interner, Scalar, Substitution, TraitEnvironment, TraitRefExt, Ty, TyBuilder,
+    Scalar, Substitution, TraitEnvironment, TraitRefExt, Ty, TyBuilder, TyExt, TyKind,
-    TyExt, TyKind,
 };
 /// This is used as a key for indexing impls.
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 pub enum TyFingerprint {
+    // These are lang item impls:
    Str,
    Slice,
    Array,
    Never,
    RawPtr(Mutability),
    Scalar(Scalar),
+    // These can have user-defined impls:
    Adt(hir_def::AdtId),
    Dyn(TraitId),
-    Tuple(usize),
    ForeignType(ForeignDefId),
-    FnPtr(usize, FnSig),
+    // These only exist for trait impls
+    Unit,
+    Unnameable,
+    Function(u32),
 }
 impl TyFingerprint {
-    /// Creates a TyFingerprint for looking up an impl. Only certain types can
+    /// Creates a TyFingerprint for looking up an inherent impl. Only certain
-    /// have impls: if we have some `struct S`, we can have an `impl S`, but not
+    /// types can have inherent impls: if we have some `struct S`, we can have
-    /// `impl &S`. Hence, this will return `None` for reference types and such.
+    /// an `impl S`, but not `impl &S`. Hence, this will return `None` for
-    pub fn for_impl(ty: &Ty) -> Option<TyFingerprint> {
+    /// reference types and such.
+    pub fn for_inherent_impl(ty: &Ty) -> Option<TyFingerprint> {
        let fp = match ty.kind(&Interner) {
            TyKind::Str => TyFingerprint::Str,
            TyKind::Never => TyFingerprint::Never,
@@ -54,17 +58,52 @@ impl TyFingerprint {
            TyKind::Array(..) => TyFingerprint::Array,
            TyKind::Scalar(scalar) => TyFingerprint::Scalar(*scalar),
            TyKind::Adt(AdtId(adt), _) => TyFingerprint::Adt(*adt),
-            TyKind::Tuple(cardinality, _) => TyFingerprint::Tuple(*cardinality),
            TyKind::Raw(mutability, ..) => TyFingerprint::RawPtr(*mutability),
            TyKind::Foreign(alias_id, ..) => TyFingerprint::ForeignType(*alias_id),
-            TyKind::Function(FnPointer { sig, substitution: substs, .. }) => {
-                TyFingerprint::FnPtr(substs.0.len(&Interner) - 1, *sig)
-            }
            TyKind::Dyn(_) => ty.dyn_trait().map(|trait_| TyFingerprint::Dyn(trait_))?,
            _ => return None,
        };
        Some(fp)
    }
+    /// Creates a TyFingerprint for looking up a trait impl.
+    pub fn for_trait_impl(ty: &Ty) -> Option<TyFingerprint> {
+        let fp = match ty.kind(&Interner) {
+            TyKind::Str => TyFingerprint::Str,
+            TyKind::Never => TyFingerprint::Never,
+            TyKind::Slice(..) => TyFingerprint::Slice,
+            TyKind::Array(..) => TyFingerprint::Array,
+            TyKind::Scalar(scalar) => TyFingerprint::Scalar(*scalar),
+            TyKind::Adt(AdtId(adt), _) => TyFingerprint::Adt(*adt),
+            TyKind::Raw(mutability, ..) => TyFingerprint::RawPtr(*mutability),
+            TyKind::Foreign(alias_id, ..) => TyFingerprint::ForeignType(*alias_id),
+            TyKind::Dyn(_) => ty.dyn_trait().map(|trait_| TyFingerprint::Dyn(trait_))?,
+            TyKind::Ref(_, _, ty) => return TyFingerprint::for_trait_impl(ty),
+            TyKind::Tuple(_, subst) => {
+                let first_ty = subst.interned().get(0).map(|arg| arg.assert_ty_ref(&Interner));
+                if let Some(ty) = first_ty {
+                    return TyFingerprint::for_trait_impl(ty);
+                } else {
+                    TyFingerprint::Unit
+                }
+            }
+            TyKind::AssociatedType(_, _)
+            | TyKind::OpaqueType(_, _)
+            | TyKind::FnDef(_, _)
+            | TyKind::Closure(_, _)
+            | TyKind::Generator(..)
+            | TyKind::GeneratorWitness(..) => TyFingerprint::Unnameable,
+            TyKind::Function(fn_ptr) => {
+                TyFingerprint::Function(fn_ptr.substitution.0.len(&Interner) as u32)
+            }
+            TyKind::Alias(_)
+            | TyKind::Placeholder(_)
+            | TyKind::BoundVar(_)
+            | TyKind::InferenceVar(_, _)
+            | TyKind::Error => return None,
+        };
+        Some(fp)
+    }
 }
 pub(crate) const ALL_INT_FPS: [TyFingerprint; 12] = [
@@ -112,7 +151,7 @@ impl TraitImpls {
                        None => continue,
                    };
                    let self_ty = db.impl_self_ty(impl_id);
-                    let self_ty_fp = TyFingerprint::for_impl(self_ty.skip_binders());
+                    let self_ty_fp = TyFingerprint::for_trait_impl(self_ty.skip_binders());
                    impls
                        .map
                        .entry(target_trait)
@@ -157,10 +196,13 @@ impl TraitImpls {
    }
    /// Queries all trait impls for the given type.
-    pub fn for_self_ty(&self, fp: TyFingerprint) -> impl Iterator<Item = ImplId> + '_ {
+    pub fn for_self_ty_without_blanket_impls(
+        &self,
+        fp: TyFingerprint,
+    ) -> impl Iterator<Item = ImplId> + '_ {
        self.map
            .values()
-            .flat_map(move |impls| impls.get(&None).into_iter().chain(impls.get(&Some(fp))))
+            .flat_map(move |impls| impls.get(&Some(fp)).into_iter())
            .flat_map(|it| it.iter().copied())
    }
@@ -204,31 +246,43 @@ pub struct InherentImpls {
 impl InherentImpls {
    pub(crate) fn inherent_impls_in_crate_query(db: &dyn HirDatabase, krate: CrateId) -> Arc<Self> {
-        let mut map: FxHashMap<_, Vec<_>> = FxHashMap::default();
+        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 data = db.impl_data(impl_id);
+        return Arc::new(impls);
-                if data.target_trait.is_some() {
-                    continue;
+        fn collect_def_map(db: &dyn HirDatabase, def_map: &DefMap, impls: &mut InherentImpls) {
+            for (_module_id, module_data) in def_map.modules() {
+                for impl_id in module_data.scope.impls() {
+                    let data = db.impl_data(impl_id);
+                    if data.target_trait.is_some() {
+                        continue;
+                    }
+                    let self_ty = db.impl_self_ty(impl_id);
+                    let fp = TyFingerprint::for_inherent_impl(self_ty.skip_binders());
+                    if let Some(fp) = fp {
+                        impls.map.entry(fp).or_default().push(impl_id);
+                    }
+                    // `fp` should only be `None` in error cases (either erroneous code or incomplete name resolution)
                }
-                let self_ty = db.impl_self_ty(impl_id);
+                // To better support custom derives, collect impls in all unnamed const items.
-                if let Some(fp) = TyFingerprint::for_impl(self_ty.skip_binders()) {
+                // const _: () = { ... };
-                    map.entry(fp).or_default().push(impl_id);
+                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);
+                    }
                }
            }
        }
-        // 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 => &[],
        }
@@ -609,6 +663,7 @@ fn iterate_trait_method_candidates(
                }
            }
            known_implemented = true;
+            // FIXME: we shouldn't be ignoring the binders here
            if callback(&self_ty.value, *item) {
                return true;
            }
diff --git a/crates/hir_ty/src/op.rs b/crates/hir_ty/src/op.rs
index 0491c5cb4..0222de2bc 100644
--- a/crates/hir_ty/src/op.rs
+++ b/crates/hir_ty/src/op.rs
@@ -9,21 +9,55 @@ pub(super) fn binary_op_return_ty(op: BinaryOp, lhs_ty: Ty, rhs_ty: Ty) -> Ty {
        BinaryOp::LogicOp(_) | BinaryOp::CmpOp(_) => TyKind::Scalar(Scalar::Bool).intern(&Interner),
        BinaryOp::Assignment { .. } => TyBuilder::unit(),
        BinaryOp::ArithOp(ArithOp::Shl) | BinaryOp::ArithOp(ArithOp::Shr) => {
-            match lhs_ty.kind(&Interner) {
+            // all integer combinations are valid here
+            if matches!(
+                lhs_ty.kind(&Interner),
                TyKind::Scalar(Scalar::Int(_))
-                | TyKind::Scalar(Scalar::Uint(_))
+                    | TyKind::Scalar(Scalar::Uint(_))
-                | TyKind::Scalar(Scalar::Float(_)) => lhs_ty,
+                    | TyKind::InferenceVar(_, TyVariableKind::Integer)
-                TyKind::InferenceVar(_, TyVariableKind::Integer)
+            ) && matches!(
-                | TyKind::InferenceVar(_, TyVariableKind::Float) => lhs_ty,
+                rhs_ty.kind(&Interner),
-                _ => TyKind::Error.intern(&Interner),
+                TyKind::Scalar(Scalar::Int(_))
+                    | TyKind::Scalar(Scalar::Uint(_))
+                    | TyKind::InferenceVar(_, TyVariableKind::Integer)
+            ) {
+                lhs_ty
+            } else {
+                TyKind::Error.intern(&Interner)
            }
        }
-        BinaryOp::ArithOp(_) => match rhs_ty.kind(&Interner) {
+        BinaryOp::ArithOp(_) => match (lhs_ty.kind(&Interner), rhs_ty.kind(&Interner)) {
-            TyKind::Scalar(Scalar::Int(_))
+            // (int, int) | (uint, uint) | (float, float)
-            | TyKind::Scalar(Scalar::Uint(_))
+            (TyKind::Scalar(Scalar::Int(_)), TyKind::Scalar(Scalar::Int(_)))
-            | TyKind::Scalar(Scalar::Float(_)) => rhs_ty,
+            | (TyKind::Scalar(Scalar::Uint(_)), TyKind::Scalar(Scalar::Uint(_)))
-            TyKind::InferenceVar(_, TyVariableKind::Integer)
+            | (TyKind::Scalar(Scalar::Float(_)), TyKind::Scalar(Scalar::Float(_))) => rhs_ty,
-            | TyKind::InferenceVar(_, TyVariableKind::Float) => rhs_ty,
+            // ({int}, int) | ({int}, uint)
+            (TyKind::InferenceVar(_, TyVariableKind::Integer), TyKind::Scalar(Scalar::Int(_)))
+            | (TyKind::InferenceVar(_, TyVariableKind::Integer), TyKind::Scalar(Scalar::Uint(_))) => {
+                rhs_ty
+            }
+            // (int, {int}) | (uint, {int})
+            (TyKind::Scalar(Scalar::Int(_)), TyKind::InferenceVar(_, TyVariableKind::Integer))
+            | (TyKind::Scalar(Scalar::Uint(_)), TyKind::InferenceVar(_, TyVariableKind::Integer)) => {
+                lhs_ty
+            }
+            // ({float} | float)
+            (TyKind::InferenceVar(_, TyVariableKind::Float), TyKind::Scalar(Scalar::Float(_))) => {
+                rhs_ty
+            }
+            // (float, {float})
+            (TyKind::Scalar(Scalar::Float(_)), TyKind::InferenceVar(_, TyVariableKind::Float)) => {
+                lhs_ty
+            }
+            // ({int}, {int}) | ({float}, {float})
+            (
+                TyKind::InferenceVar(_, TyVariableKind::Integer),
+                TyKind::InferenceVar(_, TyVariableKind::Integer),
+            )
+            | (
+                TyKind::InferenceVar(_, TyVariableKind::Float),
+                TyKind::InferenceVar(_, TyVariableKind::Float),
+            ) => rhs_ty,
            _ => TyKind::Error.intern(&Interner),
        },
    }
diff --git a/crates/hir_ty/src/primitive.rs b/crates/hir_ty/src/primitive.rs
index 2449addfb..d7f48c69a 100644
--- a/crates/hir_ty/src/primitive.rs
+++ b/crates/hir_ty/src/primitive.rs
@@ -1,7 +1,4 @@
-//! Defines primitive types, which have a couple of peculiarities:
+//! A few helper functions for dealing with primitives.
-//!
-//! * during type inference, they can be uncertain (ie, `let x = 92;`)
-//! * they don't belong to any particular crate.
 pub use chalk_ir::{FloatTy, IntTy, UintTy};
 pub use hir_def::builtin_type::{BuiltinFloat, BuiltinInt, BuiltinUint};
diff --git a/crates/hir_ty/src/tests/macros.rs b/crates/hir_ty/src/tests/macros.rs
index 86e3d8b86..6588aa46c 100644
--- a/crates/hir_ty/src/tests/macros.rs
+++ b/crates/hir_ty/src/tests/macros.rs
@@ -1065,12 +1065,211 @@ fn macro_in_arm() {
        }
        "#,
        expect![[r#"
+            !0..2 '()': ()
            51..110 '{     ...  }; }': ()
            61..62 'x': u32
            65..107 'match ...     }': u32
            71..73 '()': ()
-            84..91 'unit!()': ()
            95..100 '92u32': u32
        "#]],
    );
 }
+#[test]
+fn macro_in_type_alias_position() {
+    check_infer(
+        r#"
+        macro_rules! U32 {
+            () => { u32 };
+        }
+        trait Foo {
+            type Ty;
+        }
+        impl<T> Foo for T {
+            type Ty = U32!();
+        }
+        type TayTo = U32!();
+        fn testy() {
+            let a: <() as Foo>::Ty;
+            let b: TayTo;
+        }
+        "#,
+        expect![[r#"
+            147..196 '{     ...yTo; }': ()
+            157..158 'a': u32
+            185..186 'b': u32
+        "#]],
+    );
+}
+#[test]
+fn nested_macro_in_type_alias_position() {
+    check_infer(
+        r#"
+        macro_rules! U32Inner2 {
+            () => { u32 };
+        }
+        macro_rules! U32Inner1 {
+            () => { U32Inner2!() };
+        }
+        macro_rules! U32 {
+            () => { U32Inner1!() };
+        }
+        trait Foo {
+            type Ty;
+        }
+        impl<T> Foo for T {
+            type Ty = U32!();
+        }
+        type TayTo = U32!();
+        fn testy() {
+            let a: <() as Foo>::Ty;
+            let b: TayTo;
+        }
+        "#,
+        expect![[r#"
+            259..308 '{     ...yTo; }': ()
+            269..270 'a': u32
+            297..298 'b': u32
+        "#]],
+    );
+}
+#[test]
+fn macros_in_type_alias_position_generics() {
+    check_infer(
+        r#"
+        struct Foo<A, B>(A, B);
+        macro_rules! U32 {
+            () => { u32 };
+        }
+        macro_rules! Bar {
+            () => { Foo<U32!(), U32!()> };
+        }
+        trait Moo {
+            type Ty;
+        }
+        impl<T> Moo for T {
+            type Ty = Bar!();
+        }
+        type TayTo = Bar!();
+        fn main() {
+            let a: <() as Moo>::Ty;
+            let b: TayTo;
+        }
+        "#,
+        expect![[r#"
+            228..277 '{     ...yTo; }': ()
+            238..239 'a': Foo<u32, u32>
+            266..267 'b': Foo<u32, u32>
+        "#]],
+    );
+}
+#[test]
+fn macros_in_type_position() {
+    check_infer(
+        r#"
+        struct Foo<A, B>(A, B);
+        macro_rules! U32 {
+            () => { u32 };
+        }
+        macro_rules! Bar {
+            () => { Foo<U32!(), U32!()> };
+        }
+        fn main() {
+            let a: Bar!();
+        }
+        "#,
+        expect![[r#"
+            133..155 '{     ...!(); }': ()
+            143..144 'a': Foo<u32, u32>
+        "#]],
+    );
+}
+#[test]
+fn macros_in_type_generics() {
+    check_infer(
+        r#"
+        struct Foo<A, B>(A, B);
+        macro_rules! U32 {
+            () => { u32 };
+        }
+        macro_rules! Bar {
+            () => { Foo<U32!(), U32!()> };
+        }
+        trait Moo {
+            type Ty;
+        }
+        impl<T> Moo for T {
+            type Ty = Foo<Bar!(), Bar!()>;
+        }
+        type TayTo = Foo<Bar!(), U32!()>;
+        fn main() {
+            let a: <() as Moo>::Ty;
+            let b: TayTo;
+        }
+        "#,
+        expect![[r#"
+            254..303 '{     ...yTo; }': ()
+            264..265 'a': Foo<Foo<u32, u32>, Foo<u32, u32>>
+            292..293 'b': Foo<Foo<u32, u32>, u32>
+        "#]],
+    );
+}
+#[test]
+fn infinitely_recursive_macro_type() {
+    check_infer(
+        r#"
+        struct Bar<T, X>(T, X);
+        macro_rules! Foo {
+            () => { Foo!() }
+        }
+        macro_rules! U32 {
+            () => { u32 }
+        }
+        type A = Foo!();
+        type B = Bar<Foo!(), U32!()>;
+        fn main() {
+            let a: A;
+            let b: B;
+        }
+        "#,
+        expect![[r#"
+            166..197 '{     ...: B; }': ()
+            176..177 'a': {unknown}
+            190..191 'b': Bar<{unknown}, u32>
+        "#]],
+    );
+}
diff --git a/crates/hir_ty/src/tests/method_resolution.rs b/crates/hir_ty/src/tests/method_resolution.rs
index 4b2c82b41..a4c132bc5 100644
--- a/crates/hir_ty/src/tests/method_resolution.rs
+++ b/crates/hir_ty/src/tests/method_resolution.rs
@@ -1294,7 +1294,7 @@ mod b {
 }
 #[test]
-fn impl_in_unnamed_const() {
+fn trait_impl_in_unnamed_const() {
    check_types(
        r#"
 struct S;
@@ -1314,3 +1314,38 @@ fn f() {
    "#,
    );
 }
+#[test]
+fn inherent_impl_in_unnamed_const() {
+    check_types(
+        r#"
+struct S;
+const _: () = {
+    impl S {
+        fn method(&self) -> u16 { 0 }
+        pub(super) fn super_method(&self) -> u16 { 0 }
+        pub(crate) fn crate_method(&self) -> u16 { 0 }
+        pub fn pub_method(&self) -> u16 { 0 }
+    }
+};
+fn f() {
+    S.method();
+  //^^^^^^^^^^ u16
+    S.super_method();
+  //^^^^^^^^^^^^^^^^ u16
+    S.crate_method();
+  //^^^^^^^^^^^^^^^^ u16
+    S.pub_method();
+  //^^^^^^^^^^^^^^ u16
+}
+    "#,
+    );
+}
diff --git a/crates/hir_ty/src/tests/patterns.rs b/crates/hir_ty/src/tests/patterns.rs
index 85a28e76b..f514b3efe 100644
--- a/crates/hir_ty/src/tests/patterns.rs
+++ b/crates/hir_ty/src/tests/patterns.rs
@@ -1,6 +1,6 @@
 use expect_test::expect;
-use super::{check_infer, check_infer_with_mismatches};
+use super::{check_infer, check_infer_with_mismatches, check_types};
 #[test]
 fn infer_pattern() {
@@ -825,3 +825,29 @@ fn foo(foo: Foo) {
        "#]],
    );
 }
+#[test]
+fn macro_pat() {
+    check_types(
+        r#"
+macro_rules! pat {
+    ($name:ident) => { Enum::Variant1($name) }
+}
+enum Enum {
+    Variant1(u8),
+    Variant2,
+}
+fn f(e: Enum) {
+    match e {
+        pat!(bind) => {
+            bind;
+          //^^^^ u8
+        }
+        Enum::Variant2 => {}
+    }
+}
+    "#,
+    )
+}
diff --git a/crates/hir_ty/src/tests/regression.rs b/crates/hir_ty/src/tests/regression.rs
index b69f86050..d14f5c9bb 100644
--- a/crates/hir_ty/src/tests/regression.rs
+++ b/crates/hir_ty/src/tests/regression.rs
@@ -974,3 +974,79 @@ 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();
+          //^^^^^^^^^^^^^^^^^^^ ()
+        }
+        "#,
+    )
+}
+#[test]
+fn issue_8686() {
+    check_infer(
+        r#"
+pub trait Try: FromResidual {
+    type Output;
+    type Residual;
+}
+pub trait FromResidual<R = <Self as Try>::Residual> {
+     fn from_residual(residual: R) -> Self;
+}
+struct ControlFlow<B, C>;
+impl<B, C> Try for ControlFlow<B, C> {
+    type Output = C;
+    type Residual = ControlFlow<B, !>;
+}
+impl<B, C> FromResidual for ControlFlow<B, C> {
+    fn from_residual(r: ControlFlow<B, !>) -> Self { ControlFlow }
+}
+fn test() {
+    ControlFlow::from_residual(ControlFlow::<u32, !>);
+}
+        "#,
+        expect![[r#"
+            144..152 'residual': R
+            365..366 'r': ControlFlow<B, !>
+            395..410 '{ ControlFlow }': ControlFlow<B, C>
+            397..408 'ControlFlow': ControlFlow<B, C>
+            424..482 '{     ...!>); }': ()
+            430..456 'Contro...sidual': fn from_residual<ControlFlow<u32, {unknown}>, ControlFlow<u32, !>>(ControlFlow<u32, !>) -> ControlFlow<u32, {unknown}>
+            430..479 'Contro...2, !>)': ControlFlow<u32, {unknown}>
+            457..478 'Contro...32, !>': ControlFlow<u32, !>
+        "#]],
+    );
+}
diff --git a/crates/hir_ty/src/tests/simple.rs b/crates/hir_ty/src/tests/simple.rs
index 84c5c05fd..0eefd70f2 100644
--- a/crates/hir_ty/src/tests/simple.rs
+++ b/crates/hir_ty/src/tests/simple.rs
@@ -1029,6 +1029,42 @@ fn infer_in_elseif() {
 }
 #[test]
+fn infer_closure_unify() {
+    check_infer(
+        r#"
+        fn foo(f: bool) {
+            let a = |x| x;
+            let b = |x| x;
+            let id = if f { a } else { b };
+            id(123);
+        }
+        "#,
+        expect![[r#"
+            7..8 'f': bool
+            16..106 '{     ...23); }': ()
+            26..27 'a': |i32| -> i32
+            30..35 '|x| x': |i32| -> i32
+            31..32 'x': i32
+            34..35 'x': i32
+            45..46 'b': |i32| -> i32
+            49..54 '|x| x': |i32| -> i32
+            50..51 'x': i32
+            53..54 'x': i32
+            64..66 'id': |i32| -> i32
+            69..90 'if f {... { b }': |i32| -> i32
+            72..73 'f': bool
+            74..79 '{ a }': |i32| -> i32
+            76..77 'a': |i32| -> i32
+            85..90 '{ b }': |i32| -> i32
+            87..88 'b': |i32| -> i32
+            96..98 'id': |i32| -> i32
+            96..103 'id(123)': i32
+            99..102 '123': i32
+        "#]],
+    )
+}
+#[test]
 fn infer_if_match_with_return() {
    check_infer(
        r#"
@@ -1765,6 +1801,24 @@ fn main() {
 }
 #[test]
+fn shadowing_primitive_with_inner_items() {
+    check_types(
+        r#"
+struct i32;
+struct Foo;
+impl i32 { fn foo(&self) -> Foo { Foo } }
+fn main() {
+    fn inner() {}
+    let x: i32 = i32;
+    x.foo();
+        //^ Foo
+}"#,
+    );
+}
+#[test]
 fn not_shadowing_primitive_by_module() {
    check_types(
        r#"
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 1cda72d22..9936d0803 100644
--- a/crates/hir_ty/src/traits.rs
+++ b/crates/hir_ty/src/traits.rs
@@ -1,28 +1,26 @@
 //! Trait solving using Chalk.
 use std::env::var;
-use base_db::CrateId;
 use chalk_ir::cast::Cast;
 use chalk_solve::{logging_db::LoggingRustIrDatabase, Solver};
+use base_db::CrateId;
 use hir_def::{lang_item::LangItemTarget, TraitId};
 use stdx::panic_context;
 use crate::{
    db::HirDatabase, AliasEq, AliasTy, Canonical, DomainGoal, Guidance, HirDisplay, InEnvironment,
-    Solution, TraitRefExt, Ty, TyKind, WhereClause,
+    Interner, Solution, TraitRefExt, Ty, TyKind, WhereClause,
 };
-use self::chalk::Interner;
-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> {
@@ -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
 }
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 7818f6387..000000000
--- a/crates/hir_ty/src/traits/chalk/mapping.rs
+++ /dev/null
@@ -1,131 +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;
-use chalk_solve::rust_ir;
-use base_db::salsa::InternKey;
-use hir_def::{GenericDefId, TypeAliasId};
-use crate::{
-    db::HirDatabase, AliasTy, CallableDefId, ProjectionTyExt, QuantifiedWhereClause, Substitution,
-    Ty, WhereClause,
-};
-use super::interner::*;
-use super::*;
-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))
-    }
-}
-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));
-    }
-    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(&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.interned()[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.interned()[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: 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/utils.rs b/crates/hir_ty/src/utils.rs
index 5f6cb052a..2f490fb92 100644
--- a/crates/hir_ty/src/utils.rs
+++ b/crates/hir_ty/src/utils.rs
@@ -1,6 +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::iter;
 use chalk_ir::{fold::Shift, BoundVar, DebruijnIndex};
 use hir_def::{
    db::DefDatabase,
@@ -14,8 +16,12 @@ use hir_def::{
    AssocContainerId, GenericDefId, Lookup, TraitId, TypeAliasId, TypeParamId,
 };
 use hir_expand::name::{name, Name};
+use rustc_hash::FxHashSet;
-use crate::{db::HirDatabase, Interner, Substitution, TraitRef, TraitRefExt, TyKind, WhereClause};
+use crate::{
+    db::HirDatabase, ChalkTraitId, Interner, Substitution, TraitRef, TraitRefExt, TyKind,
+    WhereClause,
+};
 fn direct_super_traits(db: &dyn DefDatabase, trait_: TraitId) -> Vec<TraitId> {
    let resolver = trait_.resolver(db);
@@ -78,7 +84,7 @@ fn direct_super_trait_refs(db: &dyn HirDatabase, trait_ref: &TraitRef) -> Vec<Tr
 /// Returns an iterator over the whole super trait hierarchy (including the
 /// trait itself).
-pub(super) fn all_super_traits(db: &dyn DefDatabase, trait_: TraitId) -> Vec<TraitId> {
+pub fn all_super_traits(db: &dyn DefDatabase, trait_: TraitId) -> Vec<TraitId> {
    // we need to take care a bit here to avoid infinite loops in case of cycles
    // (i.e. if we have `trait A: B; trait B: A;`)
    let mut result = vec![trait_];
@@ -102,25 +108,35 @@ pub(super) fn all_super_traits(db: &dyn DefDatabase, trait_: TraitId) -> Vec<Tra
 /// `all_super_traits` is that we keep track of type parameters; for example if
 /// we have `Self: Trait<u32, i32>` and `Trait<T, U>: OtherTrait<U>` we'll get
 /// `Self: OtherTrait<i32>`.
-pub(super) fn all_super_trait_refs(db: &dyn HirDatabase, trait_ref: TraitRef) -> Vec<TraitRef> {
+pub(super) fn all_super_trait_refs(db: &dyn HirDatabase, trait_ref: TraitRef) -> SuperTraits {
-    // FIXME: replace by Chalk's `super_traits`, maybe make this a query
+    SuperTraits { db, seen: iter::once(trait_ref.trait_id).collect(), stack: vec![trait_ref] }
+}
-    // we need to take care a bit here to avoid infinite loops in case of cycles
+pub(super) struct SuperTraits<'a> {
-    // (i.e. if we have `trait A: B; trait B: A;`)
+    db: &'a dyn HirDatabase,
-    let mut result = vec![trait_ref];
+    stack: Vec<TraitRef>,
-    let mut i = 0;
+    seen: FxHashSet<ChalkTraitId>,
-    while i < result.len() {
+}
-        let t = &result[i];
-        // yeah this is quadratic, but trait hierarchies should be flat
+impl<'a> SuperTraits<'a> {
-        // enough that this doesn't matter
+    fn elaborate(&mut self, trait_ref: &TraitRef) {
-        for tt in direct_super_trait_refs(db, t) {
+        let mut trait_refs = direct_super_trait_refs(self.db, trait_ref);
-            if !result.iter().any(|tr| tr.trait_id == tt.trait_id) {
+        trait_refs.retain(|tr| !self.seen.contains(&tr.trait_id));
-                result.push(tt);
+        self.stack.extend(trait_refs);
-            }
+    }
+}
+impl<'a> Iterator for SuperTraits<'a> {
+    type Item = TraitRef;
+    fn next(&mut self) -> Option<Self::Item> {
+        if let Some(next) = self.stack.pop() {
+            self.elaborate(&next);
+            Some(next)
+        } else {
+            None
        }
-        i += 1;
    }
-    result
 }
 pub(super) fn associated_type_by_name_including_super_traits(
@@ -128,7 +144,7 @@ pub(super) fn associated_type_by_name_including_super_traits(
    trait_ref: TraitRef,
    name: &Name,
 ) -> Option<(TraitRef, TypeAliasId)> {
-    all_super_trait_refs(db, trait_ref).into_iter().find_map(|t| {
+    all_super_trait_refs(db, trait_ref).find_map(|t| {
        let assoc_type = db.trait_data(t.hir_trait_id()).associated_type_by_name(name)?;
        Some((t, assoc_type))
    })