diff --git a/crates/hir-ty/src/builder.rs b/crates/hir-ty/src/builder.rs
index 706bbe856c67..5c4eb8475bbc 100644
--- a/crates/hir-ty/src/builder.rs
+++ b/crates/hir-ty/src/builder.rs
@@ -1,15 +1,14 @@
 //! `TyBuilder`, a helper for building instances of `Ty` and related types.
 
 use chalk_ir::{
-    AdtId, DebruijnIndex, Scalar,
-    cast::{Cast, CastTo, Caster},
+    DebruijnIndex, Scalar,
+    cast::{Cast, Caster},
 };
-use hir_def::{GenericDefId, GenericParamId, TraitId, TypeAliasId, builtin_type::BuiltinType};
+use hir_def::{GenericDefId, GenericParamId, TraitId, builtin_type::BuiltinType};
 use smallvec::SmallVec;
 
 use crate::{
-    BoundVar, CallableSig, GenericArg, GenericArgData, Interner, ProjectionTy, Substitution,
-    TraitRef, Ty, TyDefId, TyExt, TyKind,
+    BoundVar, GenericArg, GenericArgData, Interner, Substitution, TraitRef, Ty, TyKind,
     consteval::unknown_const_as_generic,
     db::HirDatabase,
     error_lifetime,
@@ -19,18 +18,18 @@ use crate::{
         DbInterner, EarlyBinder,
         mapping::{ChalkToNextSolver, NextSolverToChalk},
     },
-    primitive, to_assoc_type_id, to_chalk_trait_id,
+    primitive, to_chalk_trait_id,
 };
 
 #[derive(Debug, Clone, PartialEq, Eq)]
-pub enum ParamKind {
+pub(crate) enum ParamKind {
     Type,
     Lifetime,
     Const(Ty),
 }
 
 /// This is a builder for `Ty` or anything that needs a `Substitution`.
-pub struct TyBuilder<D> {
+pub(crate) struct TyBuilder<D> {
     /// The `data` field is used to keep track of what we're building (e.g. an
     /// ADT, a `TraitRef`, ...).
     data: D,
@@ -60,10 +59,6 @@ impl<D> TyBuilder<D> {
         Self { data, vec: SmallVec::with_capacity(param_kinds.len()), param_kinds, parent_subst }
     }
 
-    fn new_empty(data: D) -> Self {
-        TyBuilder::new(data, SmallVec::new(), None)
-    }
-
     fn build_internal(self) -> (D, Substitution) {
         assert_eq!(
             self.vec.len(),
@@ -83,35 +78,15 @@ impl<D> TyBuilder<D> {
         (self.data, subst)
     }
 
-    pub fn build_into_subst(self) -> Substitution {
-        self.build_internal().1
-    }
-
-    pub fn push(mut self, arg: impl CastTo<GenericArg>) -> Self {
-        assert!(self.remaining() > 0);
-        let arg = arg.cast(Interner);
-        let expected_kind = &self.param_kinds[self.vec.len()];
-
-        let arg_kind = match arg.data(Interner) {
-            GenericArgData::Ty(_) => ParamKind::Type,
-            GenericArgData::Lifetime(_) => panic!("Got lifetime in TyBuilder::push"),
-            GenericArgData::Const(c) => {
-                let c = c.data(Interner);
-                ParamKind::Const(c.ty.clone())
-            }
-        };
-        assert_eq!(*expected_kind, arg_kind);
-
-        self.vec.push(arg);
-
-        self
-    }
-
-    pub fn remaining(&self) -> usize {
+    pub(crate) fn remaining(&self) -> usize {
         self.param_kinds.len() - self.vec.len()
     }
 
-    pub fn fill_with_bound_vars(self, debruijn: DebruijnIndex, starting_from: usize) -> Self {
+    pub(crate) fn fill_with_bound_vars(
+        self,
+        debruijn: DebruijnIndex,
+        starting_from: usize,
+    ) -> Self {
         // self.fill is inlined to make borrow checker happy
         let mut this = self;
         let other = &this.param_kinds[this.vec.len()..];
@@ -129,22 +104,6 @@ impl<D> TyBuilder<D> {
         this
     }
 
-    pub fn fill_with_unknown(self) -> Self {
-        let interner = DbInterner::conjure();
-        // self.fill is inlined to make borrow checker happy
-        let mut this = self;
-        let filler = this.param_kinds[this.vec.len()..].iter().map(|x| match x {
-            ParamKind::Type => TyKind::Error.intern(Interner).cast(Interner),
-            ParamKind::Const(ty) => {
-                unknown_const_as_generic(ty.to_nextsolver(interner)).to_chalk(interner)
-            }
-            ParamKind::Lifetime => error_lifetime().cast(Interner),
-        });
-        this.vec.extend(filler.casted(Interner));
-        assert_eq!(this.remaining(), 0);
-        this
-    }
-
     #[tracing::instrument(skip_all)]
     pub(crate) fn fill_with_inference_vars(self, table: &mut InferenceTable<'_>) -> Self {
         self.fill(|x| {
@@ -157,7 +116,7 @@ impl<D> TyBuilder<D> {
         })
     }
 
-    pub fn fill(mut self, filler: impl FnMut(&ParamKind) -> GenericArg) -> Self {
+    pub(crate) fn fill(mut self, filler: impl FnMut(&ParamKind) -> GenericArg) -> Self {
         self.vec.extend(self.param_kinds[self.vec.len()..].iter().map(filler));
         assert_eq!(self.remaining(), 0);
         self
@@ -174,28 +133,11 @@ impl<D> TyBuilder<D> {
 }
 
 impl TyBuilder<()> {
-    pub fn unit() -> Ty {
-        TyKind::Tuple(0, Substitution::empty(Interner)).intern(Interner)
-    }
-
-    // FIXME: rustc's ty is dependent on the adt type, maybe we need to do that as well
-    pub fn discr_ty() -> Ty {
-        TyKind::Scalar(chalk_ir::Scalar::Int(chalk_ir::IntTy::I128)).intern(Interner)
-    }
-
-    pub fn bool() -> Ty {
-        TyKind::Scalar(chalk_ir::Scalar::Bool).intern(Interner)
-    }
-
-    pub fn usize() -> Ty {
+    pub(crate) fn usize() -> Ty {
         TyKind::Scalar(chalk_ir::Scalar::Uint(chalk_ir::UintTy::Usize)).intern(Interner)
     }
 
-    pub fn fn_ptr(sig: CallableSig) -> Ty {
-        TyKind::Function(sig.to_fn_ptr()).intern(Interner)
-    }
-
-    pub fn builtin(builtin: BuiltinType) -> Ty {
+    pub(crate) fn builtin(builtin: BuiltinType) -> Ty {
         match builtin {
             BuiltinType::Char => TyKind::Scalar(Scalar::Char).intern(Interner),
             BuiltinType::Bool => TyKind::Scalar(Scalar::Bool).intern(Interner),
@@ -212,16 +154,10 @@ impl TyBuilder<()> {
         }
     }
 
-    pub fn slice(argument: Ty) -> Ty {
-        TyKind::Slice(argument).intern(Interner)
-    }
-
-    pub fn placeholder_subst(db: &dyn HirDatabase, def: impl Into<GenericDefId>) -> Substitution {
-        let params = generics(db, def.into());
-        params.placeholder_subst(db)
-    }
-
-    pub fn unknown_subst(db: &dyn HirDatabase, def: impl Into<GenericDefId>) -> Substitution {
+    pub(crate) fn unknown_subst(
+        db: &dyn HirDatabase,
+        def: impl Into<GenericDefId>,
+    ) -> Substitution {
         let interner = DbInterner::conjure();
         let params = generics(db, def.into());
         Substitution::from_iter(
@@ -239,7 +175,7 @@ impl TyBuilder<()> {
     }
 
     #[tracing::instrument(skip_all)]
-    pub fn subst_for_def(
+    pub(crate) fn subst_for_def(
         db: &dyn HirDatabase,
         def: impl Into<GenericDefId>,
         parent_subst: Option<Substitution>,
@@ -257,114 +193,25 @@ impl TyBuilder<()> {
         TyBuilder::new((), params, parent_subst)
     }
 
-    pub fn build(self) -> Substitution {
+    pub(crate) fn build(self) -> Substitution {
         let ((), subst) = self.build_internal();
         subst
     }
 }
 
-impl TyBuilder<hir_def::AdtId> {
-    pub fn adt(db: &dyn HirDatabase, def: hir_def::AdtId) -> TyBuilder<hir_def::AdtId> {
-        TyBuilder::subst_for_def(db, def, None).with_data(def)
-    }
-
-    pub fn fill_with_defaults(
-        mut self,
-        db: &dyn HirDatabase,
-        mut fallback: impl FnMut() -> Ty,
-    ) -> Self {
-        let interner = DbInterner::conjure();
-        // Note that we're building ADT, so we never have parent generic parameters.
-        let defaults = db.generic_defaults(self.data.into());
-
-        if let Some(defaults) = defaults.get(self.vec.len()..) {
-            for default_ty in defaults {
-                // NOTE(skip_binders): we only check if the arg type is error type.
-                if let Some(x) = default_ty.skip_binders().ty(Interner)
-                    && x.is_unknown()
-                {
-                    self.vec.push(fallback().cast(Interner));
-                    continue;
-                }
-                // Each default can only depend on the previous parameters.
-                self.vec.push(default_ty.clone().substitute(Interner, &*self.vec).cast(Interner));
-            }
-        }
-
-        // The defaults may be missing if no param has default, so fill that.
-        let filler = self.param_kinds[self.vec.len()..].iter().map(|x| match x {
-            ParamKind::Type => fallback().cast(Interner),
-            ParamKind::Const(ty) => {
-                unknown_const_as_generic(ty.to_nextsolver(interner)).to_chalk(interner)
-            }
-            ParamKind::Lifetime => error_lifetime().cast(Interner),
-        });
-        self.vec.extend(filler.casted(Interner));
-
-        self
-    }
-
-    pub fn build(self) -> Ty {
-        let (adt, subst) = self.build_internal();
-        TyKind::Adt(AdtId(adt), subst).intern(Interner)
-    }
-}
-
-pub struct Tuple(usize);
-impl TyBuilder<Tuple> {
-    pub fn tuple(size: usize) -> TyBuilder<Tuple> {
-        TyBuilder::new(Tuple(size), std::iter::repeat_n(ParamKind::Type, size).collect(), None)
-    }
-
-    pub fn build(self) -> Ty {
-        let (Tuple(size), subst) = self.build_internal();
-        TyKind::Tuple(size, subst).intern(Interner)
-    }
-
-    pub fn tuple_with<I>(elements: I) -> Ty
-    where
-        I: IntoIterator<Item = Ty>,
-        <I as IntoIterator>::IntoIter: ExactSizeIterator,
-    {
-        let elements = elements.into_iter();
-        let len = elements.len();
-        let mut b =
-            TyBuilder::new(Tuple(len), std::iter::repeat_n(ParamKind::Type, len).collect(), None);
-        for e in elements {
-            b = b.push(e);
-        }
-        b.build()
-    }
-}
-
 impl TyBuilder<TraitId> {
-    pub fn trait_ref(db: &dyn HirDatabase, def: TraitId) -> TyBuilder<TraitId> {
+    pub(crate) fn trait_ref(db: &dyn HirDatabase, def: TraitId) -> TyBuilder<TraitId> {
         TyBuilder::subst_for_def(db, def, None).with_data(def)
     }
 
-    pub fn build(self) -> TraitRef {
+    pub(crate) fn build(self) -> TraitRef {
         let (trait_id, substitution) = self.build_internal();
         TraitRef { trait_id: to_chalk_trait_id(trait_id), substitution }
     }
 }
 
-impl TyBuilder<TypeAliasId> {
-    pub fn assoc_type_projection(
-        db: &dyn HirDatabase,
-        def: TypeAliasId,
-        parent_subst: Option<Substitution>,
-    ) -> TyBuilder<TypeAliasId> {
-        TyBuilder::subst_for_def(db, def, parent_subst).with_data(def)
-    }
-
-    pub fn build(self) -> ProjectionTy {
-        let (type_alias, substitution) = self.build_internal();
-        ProjectionTy { associated_ty_id: to_assoc_type_id(type_alias), substitution }
-    }
-}
-
 impl<'db, T: rustc_type_ir::TypeFoldable<DbInterner<'db>>> TyBuilder<EarlyBinder<'db, T>> {
-    pub fn build(self, interner: DbInterner<'db>) -> T {
+    pub(crate) fn build(self, interner: DbInterner<'db>) -> T {
         let (b, subst) = self.build_internal();
         let args: crate::next_solver::GenericArgs<'db> = subst.to_nextsolver(interner);
         b.instantiate(interner, args)
@@ -372,24 +219,7 @@ impl<'db, T: rustc_type_ir::TypeFoldable<DbInterner<'db>>> TyBuilder<EarlyBinder
 }
 
 impl<'db> TyBuilder<EarlyBinder<'db, crate::next_solver::Ty<'db>>> {
-    pub fn def_ty(
-        db: &'db dyn HirDatabase,
-        def: TyDefId,
-        parent_subst: Option<Substitution>,
-    ) -> TyBuilder<EarlyBinder<'db, crate::next_solver::Ty<'db>>> {
-        let poly_ty = db.ty(def);
-        let id: GenericDefId = match def {
-            TyDefId::BuiltinType(_) => {
-                assert!(parent_subst.is_none());
-                return TyBuilder::new_empty(poly_ty);
-            }
-            TyDefId::AdtId(id) => id.into(),
-            TyDefId::TypeAliasId(id) => id.into(),
-        };
-        TyBuilder::subst_for_def(db, id, parent_subst).with_data(poly_ty)
-    }
-
-    pub fn impl_self_ty(
+    pub(crate) fn impl_self_ty(
         db: &'db dyn HirDatabase,
         def: hir_def::ImplId,
     ) -> TyBuilder<EarlyBinder<'db, crate::next_solver::Ty<'db>>> {
diff --git a/crates/hir-ty/src/chalk_ext.rs b/crates/hir-ty/src/chalk_ext.rs
index e9960374c6f5..a315f699ddaa 100644
--- a/crates/hir-ty/src/chalk_ext.rs
+++ b/crates/hir-ty/src/chalk_ext.rs
@@ -1,118 +1,13 @@
 //! Various extensions traits for Chalk types.
 
-use chalk_ir::Mutability;
-use hir_def::{FunctionId, ItemContainerId, Lookup, TraitId};
+use hir_def::{ItemContainerId, Lookup, TraitId};
 
 use crate::{
-    AdtId, Binders, CallableDefId, CallableSig, DynTy, Interner, Lifetime, ProjectionTy,
-    Substitution, ToChalk, TraitRef, Ty, TyKind, TypeFlags, WhereClause, db::HirDatabase,
+    Binders, DynTy, Interner, ProjectionTy, Substitution, TraitRef, Ty, db::HirDatabase,
     from_assoc_type_id, from_chalk_trait_id, generics::generics, to_chalk_trait_id,
-    utils::ClosureSubst,
 };
 
-pub(crate) trait TyExt {
-    fn is_unit(&self) -> bool;
-    fn is_unknown(&self) -> bool;
-    fn contains_unknown(&self) -> bool;
-
-    fn as_adt(&self) -> Option<(hir_def::AdtId, &Substitution)>;
-    fn as_tuple(&self) -> Option<&Substitution>;
-    fn as_fn_def(&self, db: &dyn HirDatabase) -> Option<FunctionId>;
-    fn as_reference(&self) -> Option<(&Ty, Lifetime, Mutability)>;
-
-    fn callable_def(&self, db: &dyn HirDatabase) -> Option<CallableDefId>;
-    fn callable_sig(&self, db: &dyn HirDatabase) -> Option<CallableSig>;
-
-    fn strip_references(&self) -> &Ty;
-
-    /// If this is a `dyn Trait`, returns that trait.
-    fn dyn_trait(&self) -> Option<TraitId>;
-}
-
-impl TyExt for Ty {
-    fn is_unit(&self) -> bool {
-        matches!(self.kind(Interner), TyKind::Tuple(0, _))
-    }
-
-    fn is_unknown(&self) -> bool {
-        matches!(self.kind(Interner), TyKind::Error)
-    }
-
-    fn contains_unknown(&self) -> bool {
-        self.data(Interner).flags.contains(TypeFlags::HAS_ERROR)
-    }
-
-    fn as_adt(&self) -> Option<(hir_def::AdtId, &Substitution)> {
-        match self.kind(Interner) {
-            TyKind::Adt(AdtId(adt), parameters) => Some((*adt, parameters)),
-            _ => None,
-        }
-    }
-
-    fn as_tuple(&self) -> Option<&Substitution> {
-        match self.kind(Interner) {
-            TyKind::Tuple(_, substs) => Some(substs),
-            _ => None,
-        }
-    }
-
-    fn as_fn_def(&self, db: &dyn HirDatabase) -> Option<FunctionId> {
-        match self.callable_def(db) {
-            Some(CallableDefId::FunctionId(func)) => Some(func),
-            Some(CallableDefId::StructId(_) | CallableDefId::EnumVariantId(_)) | None => None,
-        }
-    }
-
-    fn as_reference(&self) -> Option<(&Ty, Lifetime, Mutability)> {
-        match self.kind(Interner) {
-            TyKind::Ref(mutability, lifetime, ty) => Some((ty, lifetime.clone(), *mutability)),
-            _ => None,
-        }
-    }
-
-    fn callable_def(&self, db: &dyn HirDatabase) -> Option<CallableDefId> {
-        match self.kind(Interner) {
-            &TyKind::FnDef(def, ..) => Some(ToChalk::from_chalk(db, def)),
-            _ => None,
-        }
-    }
-
-    fn callable_sig(&self, db: &dyn HirDatabase) -> Option<CallableSig> {
-        match self.kind(Interner) {
-            TyKind::Function(fn_ptr) => Some(CallableSig::from_fn_ptr(fn_ptr)),
-            TyKind::FnDef(def, parameters) => Some(CallableSig::from_def(db, *def, parameters)),
-            TyKind::Closure(.., substs) => ClosureSubst(substs).sig_ty(db).callable_sig(db),
-            _ => None,
-        }
-    }
-
-    fn dyn_trait(&self) -> Option<TraitId> {
-        let trait_ref = match self.kind(Interner) {
-            // The principal trait bound should be the first element of the bounds. This is an
-            // invariant ensured by `TyLoweringContext::lower_dyn_trait()`.
-            // FIXME: dyn types may not have principal trait and we don't want to return auto trait
-            // here.
-            TyKind::Dyn(dyn_ty) => dyn_ty.bounds.skip_binders().interned().first().and_then(|b| {
-                match b.skip_binders() {
-                    WhereClause::Implemented(trait_ref) => Some(trait_ref),
-                    _ => None,
-                }
-            }),
-            _ => None,
-        }?;
-        Some(from_chalk_trait_id(trait_ref.trait_id))
-    }
-
-    fn strip_references(&self) -> &Ty {
-        let mut t: &Ty = self;
-        while let TyKind::Ref(_mutability, _lifetime, ty) = t.kind(Interner) {
-            t = ty;
-        }
-        t
-    }
-}
-
-pub trait ProjectionTyExt {
+pub(crate) trait ProjectionTyExt {
     fn trait_ref(&self, db: &dyn HirDatabase) -> TraitRef;
     fn trait_(&self, db: &dyn HirDatabase) -> TraitId;
     fn self_type_parameter(&self, db: &dyn HirDatabase) -> Ty;
@@ -157,7 +52,7 @@ impl DynTyExt for DynTy {
     }
 }
 
-pub trait TraitRefExt {
+pub(crate) trait TraitRefExt {
     fn hir_trait_id(&self) -> TraitId;
 }
 
diff --git a/crates/hir-ty/src/consteval.rs b/crates/hir-ty/src/consteval.rs
index 002e0823b9d1..761d72243e9f 100644
--- a/crates/hir-ty/src/consteval.rs
+++ b/crates/hir-ty/src/consteval.rs
@@ -5,13 +5,12 @@ mod tests;
 
 use base_db::Crate;
 use hir_def::{
-    EnumVariantId, GeneralConstId,
+    EnumVariantId, GeneralConstId, HasModule, StaticId,
     expr_store::{Body, HygieneId, path::Path},
     hir::{Expr, ExprId},
     resolver::{Resolver, ValueNs},
     type_ref::LiteralConstRef,
 };
-use hir_def::{HasModule, StaticId};
 use hir_expand::Lookup;
 use rustc_type_ir::{UnevaluatedConst, inherent::IntoKind};
 use stdx::never;
diff --git a/crates/hir-ty/src/db.rs b/crates/hir-ty/src/db.rs
index 4b33c8a84a81..7ad76f35b1f2 100644
--- a/crates/hir-ty/src/db.rs
+++ b/crates/hir-ty/src/db.rs
@@ -24,7 +24,6 @@ use crate::{
     lower::{Diagnostics, GenericDefaults, GenericPredicates},
     method_resolution::{InherentImpls, TraitImpls, TyFingerprint},
     mir::{BorrowckResult, MirBody, MirLowerError},
-    traits::NextTraitSolveResult,
 };
 
 #[query_group::query_group]
@@ -96,6 +95,7 @@ pub trait HirDatabase: DefDatabase + std::fmt::Debug {
     ) -> Result<i128, ConstEvalError<'db>>;
 
     #[salsa::invoke(crate::method_resolution::lookup_impl_method_query)]
+    #[salsa::transparent]
     fn lookup_impl_method<'db>(
         &'db self,
         env: Arc<TraitEnvironment<'db>>,
@@ -322,23 +322,6 @@ pub trait HirDatabase: DefDatabase + std::fmt::Debug {
     )]
     fn variances_of(&self, def: GenericDefId) -> Option<Arc<[crate::variance::Variance]>>;
 
-    #[salsa::invoke(crate::traits::normalize_projection_query)]
-    #[salsa::transparent]
-    fn normalize_projection(
-        &self,
-        projection: crate::ProjectionTy,
-        env: Arc<TraitEnvironment<'_>>,
-    ) -> Ty;
-
-    #[salsa::invoke(crate::traits::trait_solve_query)]
-    #[salsa::transparent]
-    fn trait_solve(
-        &self,
-        krate: Crate,
-        block: Option<BlockId>,
-        goal: crate::Canonical<crate::InEnvironment<crate::Goal>>,
-    ) -> NextTraitSolveResult;
-
     // next trait solver
 
     #[salsa::invoke(crate::lower_nextsolver::const_param_ty_query)]
diff --git a/crates/hir-ty/src/diagnostics/expr.rs b/crates/hir-ty/src/diagnostics/expr.rs
index 7b6fb994ecaf..0eca0c09d690 100644
--- a/crates/hir-ty/src/diagnostics/expr.rs
+++ b/crates/hir-ty/src/diagnostics/expr.rs
@@ -15,6 +15,7 @@ use intern::sym;
 use itertools::Itertools;
 use rustc_hash::FxHashSet;
 use rustc_pattern_analysis::constructor::Constructor;
+use rustc_type_ir::inherent::{AdtDef, IntoKind};
 use syntax::{
     AstNode,
     ast::{self, UnaryOp},
@@ -23,16 +24,18 @@ use tracing::debug;
 use triomphe::Arc;
 use typed_arena::Arena;
 
-use crate::next_solver::DbInterner;
-use crate::next_solver::mapping::NextSolverToChalk;
 use crate::{
-    Adjust, InferenceResult, Interner, TraitEnvironment, Ty, TyExt, TyKind,
+    Adjust, InferenceResult, TraitEnvironment,
     db::HirDatabase,
     diagnostics::match_check::{
         self,
         pat_analysis::{self, DeconstructedPat, MatchCheckCtx, WitnessPat},
     },
     display::{DisplayTarget, HirDisplay},
+    next_solver::{
+        DbInterner, Ty, TyKind, TypingMode,
+        infer::{DbInternerInferExt, InferCtxt},
+    },
 };
 
 pub(crate) use hir_def::{
@@ -77,6 +80,8 @@ impl BodyValidationDiagnostic {
         let body = db.body(owner);
         let env = db.trait_environment_for_body(owner);
         let interner = DbInterner::new_with(db, Some(env.krate), env.block);
+        let infcx =
+            interner.infer_ctxt().build(TypingMode::typeck_for_body(interner, owner.into()));
         let mut validator = ExprValidator {
             owner,
             body,
@@ -84,9 +89,9 @@ impl BodyValidationDiagnostic {
             diagnostics: Vec::new(),
             validate_lints,
             env,
-            interner,
+            infcx,
         };
-        validator.validate_body(db);
+        validator.validate_body();
         validator.diagnostics
     }
 }
@@ -98,11 +103,17 @@ struct ExprValidator<'db> {
     env: Arc<TraitEnvironment<'db>>,
     diagnostics: Vec<BodyValidationDiagnostic>,
     validate_lints: bool,
-    interner: DbInterner<'db>,
+    infcx: InferCtxt<'db>,
 }
 
 impl<'db> ExprValidator<'db> {
-    fn validate_body(&mut self, db: &'db dyn HirDatabase) {
+    #[inline]
+    fn db(&self) -> &'db dyn HirDatabase {
+        self.infcx.interner.db
+    }
+
+    fn validate_body(&mut self) {
+        let db = self.db();
         let mut filter_map_next_checker = None;
         // we'll pass &mut self while iterating over body.exprs, so they need to be disjoint
         let body = Arc::clone(&self.body);
@@ -124,19 +135,19 @@ impl<'db> ExprValidator<'db> {
 
             match expr {
                 Expr::Match { expr, arms } => {
-                    self.validate_match(id, *expr, arms, db);
+                    self.validate_match(id, *expr, arms);
                 }
                 Expr::Call { .. } | Expr::MethodCall { .. } => {
-                    self.validate_call(db, id, expr, &mut filter_map_next_checker);
+                    self.validate_call(id, expr, &mut filter_map_next_checker);
                 }
                 Expr::Closure { body: body_expr, .. } => {
                     self.check_for_trailing_return(*body_expr, &body);
                 }
                 Expr::If { .. } => {
-                    self.check_for_unnecessary_else(id, expr, db);
+                    self.check_for_unnecessary_else(id, expr);
                 }
                 Expr::Block { .. } | Expr::Async { .. } | Expr::Unsafe { .. } => {
-                    self.validate_block(db, expr);
+                    self.validate_block(expr);
                 }
                 _ => {}
             }
@@ -157,10 +168,9 @@ impl<'db> ExprValidator<'db> {
 
     fn validate_call(
         &mut self,
-        db: &dyn HirDatabase,
         call_id: ExprId,
         expr: &Expr,
-        filter_map_next_checker: &mut Option<FilterMapNextChecker>,
+        filter_map_next_checker: &mut Option<FilterMapNextChecker<'db>>,
     ) {
         if !self.validate_lints {
             return;
@@ -176,8 +186,9 @@ impl<'db> ExprValidator<'db> {
                 None => return,
             };
 
-            let checker = filter_map_next_checker
-                .get_or_insert_with(|| FilterMapNextChecker::new(&self.owner.resolver(db), db));
+            let checker = filter_map_next_checker.get_or_insert_with(|| {
+                FilterMapNextChecker::new(&self.owner.resolver(self.db()), self.db())
+            });
 
             if checker.check(call_id, receiver, &callee).is_some() {
                 self.diagnostics.push(BodyValidationDiagnostic::ReplaceFilterMapNextWithFindMap {
@@ -186,27 +197,20 @@ impl<'db> ExprValidator<'db> {
             }
 
             if let Some(receiver_ty) = self.infer.type_of_expr_with_adjust(*receiver) {
-                checker.prev_receiver_ty = Some(receiver_ty.to_chalk(self.interner));
+                checker.prev_receiver_ty = Some(receiver_ty);
             }
         }
     }
 
-    fn validate_match(
-        &mut self,
-        match_expr: ExprId,
-        scrutinee_expr: ExprId,
-        arms: &[MatchArm],
-        db: &dyn HirDatabase,
-    ) {
+    fn validate_match(&mut self, match_expr: ExprId, scrutinee_expr: ExprId, arms: &[MatchArm]) {
         let Some(scrut_ty) = self.infer.type_of_expr_with_adjust(scrutinee_expr) else {
             return;
         };
-        let scrut_ty = scrut_ty.to_chalk(self.interner);
-        if scrut_ty.contains_unknown() {
+        if scrut_ty.references_non_lt_error() {
             return;
         }
 
-        let cx = MatchCheckCtx::new(self.owner.module(db), self.owner, db, self.env.clone());
+        let cx = MatchCheckCtx::new(self.owner.module(self.db()), &self.infcx, self.env.clone());
 
         let pattern_arena = Arena::new();
         let mut m_arms = Vec::with_capacity(arms.len());
@@ -217,8 +221,7 @@ impl<'db> ExprValidator<'db> {
             let Some(pat_ty) = self.infer.type_of_pat_with_adjust(arm.pat) else {
                 return;
             };
-            let pat_ty = pat_ty.to_chalk(self.interner);
-            if pat_ty.contains_unknown() {
+            if pat_ty.references_non_lt_error() {
                 return;
             }
 
@@ -235,14 +238,14 @@ impl<'db> ExprValidator<'db> {
             if (pat_ty == scrut_ty
                 || scrut_ty
                     .as_reference()
-                    .map(|(match_expr_ty, ..)| *match_expr_ty == pat_ty)
+                    .map(|(match_expr_ty, ..)| match_expr_ty == pat_ty)
                     .unwrap_or(false))
                 && types_of_subpatterns_do_match(arm.pat, &self.body, &self.infer)
             {
                 // If we had a NotUsefulMatchArm diagnostic, we could
                 // check the usefulness of each pattern as we added it
                 // to the matrix here.
-                let pat = self.lower_pattern(&cx, arm.pat, db, &mut has_lowering_errors);
+                let pat = self.lower_pattern(&cx, arm.pat, &mut has_lowering_errors);
                 let m_arm = pat_analysis::MatchArm {
                     pat: pattern_arena.alloc(pat),
                     has_guard: arm.guard.is_some(),
@@ -258,15 +261,12 @@ impl<'db> ExprValidator<'db> {
             return;
         }
 
-        let known_valid_scrutinee = Some(self.is_known_valid_scrutinee(scrutinee_expr, db));
-        let report = match cx.compute_match_usefulness(
-            m_arms.as_slice(),
-            scrut_ty.clone(),
-            known_valid_scrutinee,
-        ) {
-            Ok(report) => report,
-            Err(()) => return,
-        };
+        let known_valid_scrutinee = Some(self.is_known_valid_scrutinee(scrutinee_expr));
+        let report =
+            match cx.compute_match_usefulness(m_arms.as_slice(), scrut_ty, known_valid_scrutinee) {
+                Ok(report) => report,
+                Err(()) => return,
+            };
 
         // FIXME Report unreachable arms
         // https://github.com/rust-lang/rust/blob/f31622a50/compiler/rustc_mir_build/src/thir/pattern/check_match.rs#L200
@@ -277,10 +277,10 @@ impl<'db> ExprValidator<'db> {
                 match_expr,
                 uncovered_patterns: missing_match_arms(
                     &cx,
-                    &scrut_ty,
+                    scrut_ty,
                     witnesses,
                     m_arms.is_empty(),
-                    self.owner.krate(db),
+                    self.owner.krate(self.db()),
                 ),
             });
         }
@@ -291,7 +291,9 @@ impl<'db> ExprValidator<'db> {
     // While the above function in rustc uses thir exprs, r-a doesn't have them.
     // So, the logic here is getting same result as "hir lowering + match with lowered thir"
     // with "hir only"
-    fn is_known_valid_scrutinee(&self, scrutinee_expr: ExprId, db: &dyn HirDatabase) -> bool {
+    fn is_known_valid_scrutinee(&self, scrutinee_expr: ExprId) -> bool {
+        let db = self.db();
+
         if self
             .infer
             .expr_adjustments
@@ -311,20 +313,18 @@ impl<'db> ExprValidator<'db> {
                 );
                 value_or_partial.is_none_or(|v| !matches!(v, ValueNs::StaticId(_)))
             }
-            Expr::Field { expr, .. } => {
-                match self.infer.type_of_expr[*expr].to_chalk(self.interner).kind(Interner) {
-                    TyKind::Adt(adt, ..) if matches!(adt.0, AdtId::UnionId(_)) => false,
-                    _ => self.is_known_valid_scrutinee(*expr, db),
-                }
-            }
-            Expr::Index { base, .. } => self.is_known_valid_scrutinee(*base, db),
-            Expr::Cast { expr, .. } => self.is_known_valid_scrutinee(*expr, db),
+            Expr::Field { expr, .. } => match self.infer.type_of_expr[*expr].kind() {
+                TyKind::Adt(adt, ..) if matches!(adt.def_id().0, AdtId::UnionId(_)) => false,
+                _ => self.is_known_valid_scrutinee(*expr),
+            },
+            Expr::Index { base, .. } => self.is_known_valid_scrutinee(*base),
+            Expr::Cast { expr, .. } => self.is_known_valid_scrutinee(*expr),
             Expr::Missing => false,
             _ => true,
         }
     }
 
-    fn validate_block(&mut self, db: &dyn HirDatabase, expr: &Expr) {
+    fn validate_block(&mut self, expr: &Expr) {
         let (Expr::Block { statements, .. }
         | Expr::Async { statements, .. }
         | Expr::Unsafe { statements, .. }) = expr
@@ -332,7 +332,7 @@ impl<'db> ExprValidator<'db> {
             return;
         };
         let pattern_arena = Arena::new();
-        let cx = MatchCheckCtx::new(self.owner.module(db), self.owner, db, self.env.clone());
+        let cx = MatchCheckCtx::new(self.owner.module(self.db()), &self.infcx, self.env.clone());
         for stmt in &**statements {
             let &Statement::Let { pat, initializer, else_branch: None, .. } = stmt else {
                 continue;
@@ -342,13 +342,12 @@ impl<'db> ExprValidator<'db> {
             }
             let Some(initializer) = initializer else { continue };
             let Some(ty) = self.infer.type_of_expr_with_adjust(initializer) else { continue };
-            let ty = ty.to_chalk(self.interner);
-            if ty.contains_unknown() {
+            if ty.references_non_lt_error() {
                 continue;
             }
 
             let mut have_errors = false;
-            let deconstructed_pat = self.lower_pattern(&cx, pat, db, &mut have_errors);
+            let deconstructed_pat = self.lower_pattern(&cx, pat, &mut have_errors);
 
             // optimization, wildcard trivially hold
             if have_errors || matches!(deconstructed_pat.ctor(), Constructor::Wildcard) {
@@ -360,7 +359,7 @@ impl<'db> ExprValidator<'db> {
                 has_guard: false,
                 arm_data: (),
             };
-            let report = match cx.compute_match_usefulness(&[match_arm], ty.clone(), None) {
+            let report = match cx.compute_match_usefulness(&[match_arm], ty, None) {
                 Ok(v) => v,
                 Err(e) => {
                     debug!(?e, "match usefulness error");
@@ -373,24 +372,23 @@ impl<'db> ExprValidator<'db> {
                     pat,
                     uncovered_patterns: missing_match_arms(
                         &cx,
-                        &ty,
+                        ty,
                         witnesses,
                         false,
-                        self.owner.krate(db),
+                        self.owner.krate(self.db()),
                     ),
                 });
             }
         }
     }
 
-    fn lower_pattern<'p>(
+    fn lower_pattern<'a>(
         &self,
-        cx: &MatchCheckCtx<'p>,
+        cx: &MatchCheckCtx<'a, 'db>,
         pat: PatId,
-        db: &dyn HirDatabase,
         have_errors: &mut bool,
-    ) -> DeconstructedPat<'p> {
-        let mut patcx = match_check::PatCtxt::new(db, &self.infer, &self.body);
+    ) -> DeconstructedPat<'a, 'db> {
+        let mut patcx = match_check::PatCtxt::new(self.db(), &self.infer, &self.body);
         let pattern = patcx.lower_pattern(pat);
         let pattern = cx.lower_pat(&pattern);
         if !patcx.errors.is_empty() {
@@ -434,7 +432,7 @@ impl<'db> ExprValidator<'db> {
         }
     }
 
-    fn check_for_unnecessary_else(&mut self, id: ExprId, expr: &Expr, db: &dyn HirDatabase) {
+    fn check_for_unnecessary_else(&mut self, id: ExprId, expr: &Expr) {
         if !self.validate_lints {
             return;
         }
@@ -453,11 +451,11 @@ impl<'db> ExprValidator<'db> {
                     && last_then_expr_ty.is_never()
                 {
                     // Only look at sources if the then branch diverges and we have an else branch.
-                    let source_map = db.body_with_source_map(self.owner).1;
+                    let source_map = self.db().body_with_source_map(self.owner).1;
                     let Ok(source_ptr) = source_map.expr_syntax(id) else {
                         return;
                     };
-                    let root = source_ptr.file_syntax(db);
+                    let root = source_ptr.file_syntax(self.db());
                     let either::Left(ast::Expr::IfExpr(if_expr)) = source_ptr.value.to_node(&root)
                     else {
                         return;
@@ -491,15 +489,15 @@ impl<'db> ExprValidator<'db> {
     }
 }
 
-struct FilterMapNextChecker {
+struct FilterMapNextChecker<'db> {
     filter_map_function_id: Option<hir_def::FunctionId>,
     next_function_id: Option<hir_def::FunctionId>,
     prev_filter_map_expr_id: Option<ExprId>,
-    prev_receiver_ty: Option<chalk_ir::Ty<Interner>>,
+    prev_receiver_ty: Option<Ty<'db>>,
 }
 
-impl FilterMapNextChecker {
-    fn new(resolver: &hir_def::resolver::Resolver<'_>, db: &dyn HirDatabase) -> Self {
+impl<'db> FilterMapNextChecker<'db> {
+    fn new(resolver: &hir_def::resolver::Resolver<'db>, db: &'db dyn HirDatabase) -> Self {
         // Find and store the FunctionIds for Iterator::filter_map and Iterator::next
         let (next_function_id, filter_map_function_id) = match LangItem::IteratorNext
             .resolve_function(db, resolver.krate())
@@ -639,15 +637,19 @@ fn types_of_subpatterns_do_match(pat: PatId, body: &Body, infer: &InferenceResul
     !has_type_mismatches
 }
 
-fn missing_match_arms<'p>(
-    cx: &MatchCheckCtx<'p>,
-    scrut_ty: &Ty,
-    witnesses: Vec<WitnessPat<'p>>,
+fn missing_match_arms<'a, 'db>(
+    cx: &MatchCheckCtx<'a, 'db>,
+    scrut_ty: Ty<'a>,
+    witnesses: Vec<WitnessPat<'a, 'db>>,
     arms_is_empty: bool,
     krate: Crate,
 ) -> String {
-    struct DisplayWitness<'a, 'p>(&'a WitnessPat<'p>, &'a MatchCheckCtx<'p>, DisplayTarget);
-    impl fmt::Display for DisplayWitness<'_, '_> {
+    struct DisplayWitness<'a, 'b, 'db>(
+        &'a WitnessPat<'b, 'db>,
+        &'a MatchCheckCtx<'b, 'db>,
+        DisplayTarget,
+    );
+    impl fmt::Display for DisplayWitness<'_, '_, '_> {
         fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
             let DisplayWitness(witness, cx, display_target) = *self;
             let pat = cx.hoist_witness_pat(witness);
diff --git a/crates/hir-ty/src/diagnostics/match_check.rs b/crates/hir-ty/src/diagnostics/match_check.rs
index af541ffa342e..80b65ace77cd 100644
--- a/crates/hir-ty/src/diagnostics/match_check.rs
+++ b/crates/hir-ty/src/diagnostics/match_check.rs
@@ -9,7 +9,6 @@ mod pat_util;
 
 pub(crate) mod pat_analysis;
 
-use chalk_ir::Mutability;
 use hir_def::{
     AdtId, EnumVariantId, LocalFieldId, Lookup, VariantId,
     expr_store::{Body, path::Path},
@@ -17,16 +16,16 @@ use hir_def::{
     item_tree::FieldsShape,
 };
 use hir_expand::name::Name;
+use rustc_type_ir::inherent::{IntoKind, SliceLike};
 use span::Edition;
-use stdx::{always, never};
+use stdx::{always, never, variance::PhantomCovariantLifetime};
 
-use crate::next_solver::DbInterner;
-use crate::next_solver::mapping::NextSolverToChalk;
 use crate::{
-    InferenceResult, Interner, Substitution, Ty, TyExt, TyKind,
+    InferenceResult,
     db::HirDatabase,
     display::{HirDisplay, HirDisplayError, HirFormatter},
     infer::BindingMode,
+    next_solver::{GenericArgs, Mutability, Ty, TyKind},
 };
 
 use self::pat_util::EnumerateAndAdjustIterator;
@@ -41,46 +40,46 @@ pub(crate) enum PatternError {
 }
 
 #[derive(Clone, Debug, PartialEq)]
-pub(crate) struct FieldPat {
+pub(crate) struct FieldPat<'db> {
     pub(crate) field: LocalFieldId,
-    pub(crate) pattern: Pat,
+    pub(crate) pattern: Pat<'db>,
 }
 
 #[derive(Clone, Debug, PartialEq)]
-pub(crate) struct Pat {
-    pub(crate) ty: Ty,
-    pub(crate) kind: Box<PatKind>,
+pub(crate) struct Pat<'db> {
+    pub(crate) ty: Ty<'db>,
+    pub(crate) kind: Box<PatKind<'db>>,
 }
 
 /// Close relative to `rustc_mir_build::thir::pattern::PatKind`
 #[derive(Clone, Debug, PartialEq)]
-pub(crate) enum PatKind {
+pub(crate) enum PatKind<'db> {
     Wild,
     Never,
 
     /// `x`, `ref x`, `x @ P`, etc.
     Binding {
         name: Name,
-        subpattern: Option<Pat>,
+        subpattern: Option<Pat<'db>>,
     },
 
     /// `Foo(...)` or `Foo{...}` or `Foo`, where `Foo` is a variant name from an ADT with
     /// multiple variants.
     Variant {
-        substs: Substitution,
+        substs: GenericArgs<'db>,
         enum_variant: EnumVariantId,
-        subpatterns: Vec<FieldPat>,
+        subpatterns: Vec<FieldPat<'db>>,
     },
 
     /// `(...)`, `Foo(...)`, `Foo{...}`, or `Foo`, where `Foo` is a variant name from an ADT with
     /// a single variant.
     Leaf {
-        subpatterns: Vec<FieldPat>,
+        subpatterns: Vec<FieldPat<'db>>,
     },
 
     /// `&P`, `&mut P`, etc.
     Deref {
-        subpattern: Pat,
+        subpattern: Pat<'db>,
     },
 
     // FIXME: for now, only bool literals are implemented
@@ -91,28 +90,27 @@ pub(crate) enum PatKind {
     /// An or-pattern, e.g. `p | q`.
     /// Invariant: `pats.len() >= 2`.
     Or {
-        pats: Vec<Pat>,
+        pats: Vec<Pat<'db>>,
     },
 }
 
-pub(crate) struct PatCtxt<'db> {
+pub(crate) struct PatCtxt<'a, 'db> {
     db: &'db dyn HirDatabase,
-    infer: &'db InferenceResult<'db>,
-    body: &'db Body,
+    infer: &'a InferenceResult<'db>,
+    body: &'a Body,
     pub(crate) errors: Vec<PatternError>,
-    interner: DbInterner<'db>,
 }
 
-impl<'a> PatCtxt<'a> {
+impl<'a, 'db> PatCtxt<'a, 'db> {
     pub(crate) fn new(
-        db: &'a dyn HirDatabase,
-        infer: &'a InferenceResult<'a>,
+        db: &'db dyn HirDatabase,
+        infer: &'a InferenceResult<'db>,
         body: &'a Body,
     ) -> Self {
-        Self { db, infer, body, errors: Vec::new(), interner: DbInterner::new_with(db, None, None) }
+        Self { db, infer, body, errors: Vec::new() }
     }
 
-    pub(crate) fn lower_pattern(&mut self, pat: PatId) -> Pat {
+    pub(crate) fn lower_pattern(&mut self, pat: PatId) -> Pat<'db> {
         // XXX(iDawer): Collecting pattern adjustments feels imprecise to me.
         // When lowering of & and box patterns are implemented this should be tested
         // in a manner of `match_ergonomics_issue_9095` test.
@@ -121,15 +119,12 @@ impl<'a> PatCtxt<'a> {
         let unadjusted_pat = self.lower_pattern_unadjusted(pat);
         self.infer.pat_adjustments.get(&pat).map(|it| &**it).unwrap_or_default().iter().rev().fold(
             unadjusted_pat,
-            |subpattern, ref_ty| Pat {
-                ty: ref_ty.to_chalk(self.interner).clone(),
-                kind: Box::new(PatKind::Deref { subpattern }),
-            },
+            |subpattern, ref_ty| Pat { ty: *ref_ty, kind: Box::new(PatKind::Deref { subpattern }) },
         )
     }
 
-    fn lower_pattern_unadjusted(&mut self, pat: PatId) -> Pat {
-        let mut ty = self.infer[pat].to_chalk(self.interner);
+    fn lower_pattern_unadjusted(&mut self, pat: PatId) -> Pat<'db> {
+        let mut ty = self.infer[pat];
         let variant = self.infer.variant_resolution_for_pat(pat);
 
         let kind = match self.body[pat] {
@@ -142,8 +137,8 @@ impl<'a> PatCtxt<'a> {
             }
 
             hir_def::hir::Pat::Tuple { ref args, ellipsis } => {
-                let arity = match *ty.kind(Interner) {
-                    TyKind::Tuple(arity, _) => arity,
+                let arity = match ty.kind() {
+                    TyKind::Tuple(tys) => tys.len(),
                     _ => {
                         never!("unexpected type for tuple pattern: {:?}", ty);
                         self.errors.push(PatternError::UnexpectedType);
@@ -156,10 +151,10 @@ impl<'a> PatCtxt<'a> {
 
             hir_def::hir::Pat::Bind { id, subpat, .. } => {
                 let bm = self.infer.binding_modes[pat];
-                ty = self.infer[id].to_chalk(self.interner);
+                ty = self.infer[id];
                 let name = &self.body[id].name;
-                match (bm, ty.kind(Interner)) {
-                    (BindingMode::Ref(_), TyKind::Ref(.., rty)) => ty = rty.clone(),
+                match (bm, ty.kind()) {
+                    (BindingMode::Ref(_), TyKind::Ref(_, rty, _)) => ty = rty,
                     (BindingMode::Ref(_), _) => {
                         never!(
                             "`ref {}` has wrong type {:?}",
@@ -167,7 +162,7 @@ impl<'a> PatCtxt<'a> {
                             ty
                         );
                         self.errors.push(PatternError::UnexpectedType);
-                        return Pat { ty: ty.clone(), kind: PatKind::Wild.into() };
+                        return Pat { ty, kind: PatKind::Wild.into() };
                     }
                     _ => (),
                 }
@@ -177,7 +172,7 @@ impl<'a> PatCtxt<'a> {
             hir_def::hir::Pat::TupleStruct { ref args, ellipsis, .. } if variant.is_some() => {
                 let expected_len = variant.unwrap().fields(self.db).fields().len();
                 let subpatterns = self.lower_tuple_subpats(args, expected_len, ellipsis);
-                self.lower_variant_or_leaf(pat, &ty, subpatterns)
+                self.lower_variant_or_leaf(pat, ty, subpatterns)
             }
 
             hir_def::hir::Pat::Record { ref args, .. } if variant.is_some() => {
@@ -193,7 +188,7 @@ impl<'a> PatCtxt<'a> {
                     })
                     .collect();
                 match subpatterns {
-                    Some(subpatterns) => self.lower_variant_or_leaf(pat, &ty, subpatterns),
+                    Some(subpatterns) => self.lower_variant_or_leaf(pat, ty, subpatterns),
                     None => {
                         self.errors.push(PatternError::MissingField);
                         PatKind::Wild
@@ -213,7 +208,7 @@ impl<'a> PatCtxt<'a> {
             }
         };
 
-        Pat { ty: ty.clone(), kind: Box::new(kind) }
+        Pat { ty, kind: Box::new(kind) }
     }
 
     fn lower_tuple_subpats(
@@ -221,7 +216,7 @@ impl<'a> PatCtxt<'a> {
         pats: &[PatId],
         expected_len: usize,
         ellipsis: Option<u32>,
-    ) -> Vec<FieldPat> {
+    ) -> Vec<FieldPat<'db>> {
         if pats.len() > expected_len {
             self.errors.push(PatternError::ExtraFields);
             return Vec::new();
@@ -236,28 +231,28 @@ impl<'a> PatCtxt<'a> {
             .collect()
     }
 
-    fn lower_patterns(&mut self, pats: &[PatId]) -> Vec<Pat> {
+    fn lower_patterns(&mut self, pats: &[PatId]) -> Vec<Pat<'db>> {
         pats.iter().map(|&p| self.lower_pattern(p)).collect()
     }
 
-    fn lower_opt_pattern(&mut self, pat: Option<PatId>) -> Option<Pat> {
+    fn lower_opt_pattern(&mut self, pat: Option<PatId>) -> Option<Pat<'db>> {
         pat.map(|p| self.lower_pattern(p))
     }
 
     fn lower_variant_or_leaf(
         &mut self,
         pat: PatId,
-        ty: &Ty,
-        subpatterns: Vec<FieldPat>,
-    ) -> PatKind {
+        ty: Ty<'db>,
+        subpatterns: Vec<FieldPat<'db>>,
+    ) -> PatKind<'db> {
         match self.infer.variant_resolution_for_pat(pat) {
             Some(variant_id) => {
                 if let VariantId::EnumVariantId(enum_variant) = variant_id {
-                    let substs = match ty.kind(Interner) {
-                        TyKind::Adt(_, substs) => substs.clone(),
+                    let substs = match ty.kind() {
+                        TyKind::Adt(_, substs) => substs,
                         kind => {
                             always!(
-                                matches!(kind, TyKind::FnDef(..) | TyKind::Error),
+                                matches!(kind, TyKind::FnDef(..) | TyKind::Error(_)),
                                 "inappropriate type for def: {:?}",
                                 ty
                             );
@@ -277,13 +272,13 @@ impl<'a> PatCtxt<'a> {
         }
     }
 
-    fn lower_path(&mut self, pat: PatId, _path: &Path) -> Pat {
-        let ty = self.infer[pat].to_chalk(self.interner);
+    fn lower_path(&mut self, pat: PatId, _path: &Path) -> Pat<'db> {
+        let ty = self.infer[pat];
 
-        let pat_from_kind = |kind| Pat { ty: ty.clone(), kind: Box::new(kind) };
+        let pat_from_kind = |kind| Pat { ty, kind: Box::new(kind) };
 
         match self.infer.variant_resolution_for_pat(pat) {
-            Some(_) => pat_from_kind(self.lower_variant_or_leaf(pat, &ty, Vec::new())),
+            Some(_) => pat_from_kind(self.lower_variant_or_leaf(pat, ty, Vec::new())),
             None => {
                 self.errors.push(PatternError::UnresolvedVariant);
                 pat_from_kind(PatKind::Wild)
@@ -291,7 +286,7 @@ impl<'a> PatCtxt<'a> {
         }
     }
 
-    fn lower_lit(&mut self, expr: hir_def::hir::ExprId) -> PatKind {
+    fn lower_lit(&mut self, expr: hir_def::hir::ExprId) -> PatKind<'db> {
         use hir_def::hir::{Expr, Literal::Bool};
 
         match self.body[expr] {
@@ -304,8 +299,8 @@ impl<'a> PatCtxt<'a> {
     }
 }
 
-impl HirDisplay for Pat {
-    fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
+impl<'db> HirDisplay<'db> for Pat<'db> {
+    fn hir_fmt(&self, f: &mut HirFormatter<'_, 'db>) -> Result<(), HirDisplayError> {
         match &*self.kind {
             PatKind::Wild => write!(f, "_"),
             PatKind::Never => write!(f, "!"),
@@ -361,7 +356,7 @@ impl HirDisplay for Pat {
                             .filter(|p| !matches!(*p.pattern.kind, PatKind::Wild))
                             .map(|p| {
                                 printed += 1;
-                                WriteWith(|f| {
+                                WriteWith::new(|f| {
                                     write!(
                                         f,
                                         "{}: ",
@@ -387,7 +382,7 @@ impl HirDisplay for Pat {
                 if num_fields != 0 || variant.is_none() {
                     write!(f, "(")?;
                     let subpats = (0..num_fields).map(|i| {
-                        WriteWith(move |f| {
+                        WriteWith::new(move |f| {
                             let fid = LocalFieldId::from_raw((i as u32).into());
                             if let Some(p) = subpatterns.get(i)
                                 && p.field == fid
@@ -402,7 +397,7 @@ impl HirDisplay for Pat {
                         })
                     });
                     f.write_joined(subpats, ", ")?;
-                    if let (TyKind::Tuple(..), 1) = (self.ty.kind(Interner), num_fields) {
+                    if let (TyKind::Tuple(..), 1) = (self.ty.kind(), num_fields) {
                         write!(f, ",")?;
                     }
                     write!(f, ")")?;
@@ -411,8 +406,8 @@ impl HirDisplay for Pat {
                 Ok(())
             }
             PatKind::Deref { subpattern } => {
-                match self.ty.kind(Interner) {
-                    &TyKind::Ref(mutbl, ..) => {
+                match self.ty.kind() {
+                    TyKind::Ref(.., mutbl) => {
                         write!(f, "&{}", if mutbl == Mutability::Mut { "mut " } else { "" })?
                     }
                     _ => never!("{:?} is a bad Deref pattern type", self.ty),
@@ -425,15 +420,24 @@ impl HirDisplay for Pat {
     }
 }
 
-struct WriteWith<F>(F)
+struct WriteWith<'db, F>(F, PhantomCovariantLifetime<'db>)
+where
+    F: Fn(&mut HirFormatter<'_, 'db>) -> Result<(), HirDisplayError>;
+
+impl<'db, F> WriteWith<'db, F>
 where
-    F: Fn(&mut HirFormatter<'_>) -> Result<(), HirDisplayError>;
+    F: Fn(&mut HirFormatter<'_, 'db>) -> Result<(), HirDisplayError>,
+{
+    fn new(f: F) -> Self {
+        Self(f, PhantomCovariantLifetime::new())
+    }
+}
 
-impl<F> HirDisplay for WriteWith<F>
+impl<'db, F> HirDisplay<'db> for WriteWith<'db, F>
 where
-    F: Fn(&mut HirFormatter<'_>) -> Result<(), HirDisplayError>,
+    F: Fn(&mut HirFormatter<'_, 'db>) -> Result<(), HirDisplayError>,
 {
-    fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
+    fn hir_fmt(&self, f: &mut HirFormatter<'_, 'db>) -> Result<(), HirDisplayError> {
         (self.0)(f)
     }
 }
diff --git a/crates/hir-ty/src/diagnostics/match_check/pat_analysis.rs b/crates/hir-ty/src/diagnostics/match_check/pat_analysis.rs
index eb20d3c51ff4..f0efadeafcea 100644
--- a/crates/hir-ty/src/diagnostics/match_check/pat_analysis.rs
+++ b/crates/hir-ty/src/diagnostics/match_check/pat_analysis.rs
@@ -1,24 +1,27 @@
 //! Interface with `rustc_pattern_analysis`.
 
-use std::cell::LazyCell;
-use std::fmt;
+use std::{cell::LazyCell, fmt};
 
-use hir_def::{DefWithBodyId, EnumId, EnumVariantId, HasModule, LocalFieldId, ModuleId, VariantId};
+use hir_def::{EnumId, EnumVariantId, HasModule, LocalFieldId, ModuleId, VariantId};
 use intern::sym;
 use rustc_pattern_analysis::{
     IndexVec, PatCx, PrivateUninhabitedField,
     constructor::{Constructor, ConstructorSet, VariantVisibility},
     usefulness::{PlaceValidity, UsefulnessReport, compute_match_usefulness},
 };
+use rustc_type_ir::inherent::{AdtDef, IntoKind, SliceLike};
 use smallvec::{SmallVec, smallvec};
 use stdx::never;
 use triomphe::Arc;
 
 use crate::{
-    AdtId, Interner, Scalar, TraitEnvironment, Ty, TyExt, TyKind,
+    TraitEnvironment,
     db::HirDatabase,
-    infer::normalize,
     inhabitedness::{is_enum_variant_uninhabited_from, is_ty_uninhabited_from},
+    next_solver::{
+        Ty, TyKind,
+        infer::{InferCtxt, traits::ObligationCause},
+    },
 };
 
 use super::{FieldPat, Pat, PatKind};
@@ -26,10 +29,12 @@ use super::{FieldPat, Pat, PatKind};
 use Constructor::*;
 
 // Re-export r-a-specific versions of all these types.
-pub(crate) type DeconstructedPat<'db> =
-    rustc_pattern_analysis::pat::DeconstructedPat<MatchCheckCtx<'db>>;
-pub(crate) type MatchArm<'db> = rustc_pattern_analysis::MatchArm<'db, MatchCheckCtx<'db>>;
-pub(crate) type WitnessPat<'db> = rustc_pattern_analysis::pat::WitnessPat<MatchCheckCtx<'db>>;
+pub(crate) type DeconstructedPat<'a, 'db> =
+    rustc_pattern_analysis::pat::DeconstructedPat<MatchCheckCtx<'a, 'db>>;
+pub(crate) type MatchArm<'a, 'b, 'db> =
+    rustc_pattern_analysis::MatchArm<'b, MatchCheckCtx<'a, 'db>>;
+pub(crate) type WitnessPat<'a, 'db> =
+    rustc_pattern_analysis::pat::WitnessPat<MatchCheckCtx<'a, 'db>>;
 
 /// [Constructor] uses this in unimplemented variants.
 /// It allows porting match expressions from upstream algorithm without losing semantics.
@@ -65,37 +70,37 @@ impl rustc_pattern_analysis::Idx for EnumVariantContiguousIndex {
 }
 
 #[derive(Clone)]
-pub(crate) struct MatchCheckCtx<'db> {
+pub(crate) struct MatchCheckCtx<'a, 'db> {
     module: ModuleId,
-    body: DefWithBodyId,
     pub(crate) db: &'db dyn HirDatabase,
     exhaustive_patterns: bool,
     env: Arc<TraitEnvironment<'db>>,
+    infcx: &'a InferCtxt<'db>,
 }
 
-impl<'db> MatchCheckCtx<'db> {
+impl<'a, 'db> MatchCheckCtx<'a, 'db> {
     pub(crate) fn new(
         module: ModuleId,
-        body: DefWithBodyId,
-        db: &'db dyn HirDatabase,
+        infcx: &'a InferCtxt<'db>,
         env: Arc<TraitEnvironment<'db>>,
     ) -> Self {
+        let db = infcx.interner.db;
         let def_map = module.crate_def_map(db);
         let exhaustive_patterns = def_map.is_unstable_feature_enabled(&sym::exhaustive_patterns);
-        Self { module, body, db, exhaustive_patterns, env }
+        Self { module, db, exhaustive_patterns, env, infcx }
     }
 
-    pub(crate) fn compute_match_usefulness(
+    pub(crate) fn compute_match_usefulness<'b>(
         &self,
-        arms: &[MatchArm<'db>],
-        scrut_ty: Ty,
+        arms: &[MatchArm<'a, 'b, 'db>],
+        scrut_ty: Ty<'db>,
         known_valid_scrutinee: Option<bool>,
-    ) -> Result<UsefulnessReport<'db, Self>, ()> {
-        if scrut_ty.contains_unknown() {
+    ) -> Result<UsefulnessReport<'b, Self>, ()> {
+        if scrut_ty.references_non_lt_error() {
             return Err(());
         }
         for arm in arms {
-            if arm.pat.ty().contains_unknown() {
+            if arm.pat.ty().references_non_lt_error() {
                 return Err(());
             }
         }
@@ -106,8 +111,8 @@ impl<'db> MatchCheckCtx<'db> {
         compute_match_usefulness(self, arms, scrut_ty, place_validity, complexity_limit)
     }
 
-    fn is_uninhabited(&self, ty: &Ty) -> bool {
-        is_ty_uninhabited_from(self.db, ty, self.module, self.env.clone())
+    fn is_uninhabited(&self, ty: Ty<'db>) -> bool {
+        is_ty_uninhabited_from(self.infcx, ty, self.module, self.env.clone())
     }
 
     /// Returns whether the given ADT is from another crate declared `#[non_exhaustive]`.
@@ -140,23 +145,27 @@ impl<'db> MatchCheckCtx<'db> {
     // This lists the fields of a variant along with their types.
     fn list_variant_fields(
         &self,
-        ty: &Ty,
+        ty: Ty<'db>,
         variant: VariantId,
-    ) -> impl Iterator<Item = (LocalFieldId, Ty)> {
+    ) -> impl Iterator<Item = (LocalFieldId, Ty<'db>)> {
         let (_, substs) = ty.as_adt().unwrap();
 
-        let field_tys = self.db.field_types(variant);
+        let field_tys = self.db.field_types_ns(variant);
         let fields_len = variant.fields(self.db).fields().len() as u32;
 
         (0..fields_len).map(|idx| LocalFieldId::from_raw(idx.into())).map(move |fid| {
-            let ty = field_tys[fid].clone().substitute(Interner, substs);
-            let ty = normalize(self.db, self.db.trait_environment_for_body(self.body), ty);
+            let ty = field_tys[fid].instantiate(self.infcx.interner, substs);
+            let ty = self
+                .infcx
+                .at(&ObligationCause::dummy(), self.env.env)
+                .deeply_normalize(ty)
+                .unwrap_or(ty);
             (fid, ty)
         })
     }
 
-    pub(crate) fn lower_pat(&self, pat: &Pat) -> DeconstructedPat<'db> {
-        let singleton = |pat: DeconstructedPat<'db>| vec![pat.at_index(0)];
+    pub(crate) fn lower_pat(&self, pat: &Pat<'db>) -> DeconstructedPat<'a, 'db> {
+        let singleton = |pat: DeconstructedPat<'a, 'db>| vec![pat.at_index(0)];
         let ctor;
         let mut fields: Vec<_>;
         let arity;
@@ -169,7 +178,7 @@ impl<'db> MatchCheckCtx<'db> {
                 arity = 0;
             }
             PatKind::Deref { subpattern } => {
-                ctor = match pat.ty.kind(Interner) {
+                ctor = match pat.ty.kind() {
                     TyKind::Ref(..) => Ref,
                     _ => {
                         never!("pattern has unexpected type: pat: {:?}, ty: {:?}", pat, &pat.ty);
@@ -187,12 +196,13 @@ impl<'db> MatchCheckCtx<'db> {
                         self.lower_pat(&pat.pattern).at_index(idx as usize)
                     })
                     .collect();
-                match pat.ty.kind(Interner) {
-                    TyKind::Tuple(_, substs) => {
+                match pat.ty.kind() {
+                    TyKind::Tuple(substs) => {
                         ctor = Struct;
-                        arity = substs.len(Interner);
+                        arity = substs.len();
                     }
-                    &TyKind::Adt(AdtId(adt), _) => {
+                    TyKind::Adt(adt_def, _) => {
+                        let adt = adt_def.def_id().0;
                         ctor = match pat.kind.as_ref() {
                             PatKind::Leaf { .. } if matches!(adt, hir_def::AdtId::UnionId(_)) => {
                                 UnionField
@@ -240,15 +250,15 @@ impl<'db> MatchCheckCtx<'db> {
                 arity = pats.len();
             }
         }
-        DeconstructedPat::new(ctor, fields, arity, pat.ty.clone(), ())
+        DeconstructedPat::new(ctor, fields, arity, pat.ty, ())
     }
 
-    pub(crate) fn hoist_witness_pat(&self, pat: &WitnessPat<'db>) -> Pat {
+    pub(crate) fn hoist_witness_pat(&self, pat: &WitnessPat<'a, 'db>) -> Pat<'db> {
         let mut subpatterns = pat.iter_fields().map(|p| self.hoist_witness_pat(p));
         let kind = match pat.ctor() {
             &Bool(value) => PatKind::LiteralBool { value },
             IntRange(_) => unimplemented!(),
-            Struct | Variant(_) | UnionField => match pat.ty().kind(Interner) {
+            Struct | Variant(_) | UnionField => match pat.ty().kind() {
                 TyKind::Tuple(..) => PatKind::Leaf {
                     subpatterns: subpatterns
                         .zip(0u32..)
@@ -259,15 +269,16 @@ impl<'db> MatchCheckCtx<'db> {
                         .collect(),
                 },
                 TyKind::Adt(adt, substs) => {
-                    let variant = Self::variant_id_for_adt(self.db, pat.ctor(), adt.0).unwrap();
+                    let variant =
+                        Self::variant_id_for_adt(self.db, pat.ctor(), adt.def_id().0).unwrap();
                     let subpatterns = self
-                        .list_variant_fields(pat.ty(), variant)
+                        .list_variant_fields(*pat.ty(), variant)
                         .zip(subpatterns)
                         .map(|((field, _ty), pattern)| FieldPat { field, pattern })
                         .collect();
 
                     if let VariantId::EnumVariantId(enum_variant) = variant {
-                        PatKind::Variant { substs: substs.clone(), enum_variant, subpatterns }
+                        PatKind::Variant { substs, enum_variant, subpatterns }
                     } else {
                         PatKind::Leaf { subpatterns }
                     }
@@ -293,13 +304,13 @@ impl<'db> MatchCheckCtx<'db> {
                 PatKind::Wild
             }
         };
-        Pat { ty: pat.ty().clone(), kind: Box::new(kind) }
+        Pat { ty: *pat.ty(), kind: Box::new(kind) }
     }
 }
 
-impl PatCx for MatchCheckCtx<'_> {
+impl<'a, 'db> PatCx for MatchCheckCtx<'a, 'db> {
     type Error = ();
-    type Ty = Ty;
+    type Ty = Ty<'db>;
     type VariantIdx = EnumVariantContiguousIndex;
     type StrLit = Void;
     type ArmData = ();
@@ -315,10 +326,11 @@ impl PatCx for MatchCheckCtx<'_> {
         ty: &Self::Ty,
     ) -> usize {
         match ctor {
-            Struct | Variant(_) | UnionField => match *ty.kind(Interner) {
-                TyKind::Tuple(arity, ..) => arity,
-                TyKind::Adt(AdtId(adt), ..) => {
-                    let variant = Self::variant_id_for_adt(self.db, ctor, adt).unwrap();
+            Struct | Variant(_) | UnionField => match ty.kind() {
+                TyKind::Tuple(tys) => tys.len(),
+                TyKind::Adt(adt_def, ..) => {
+                    let variant =
+                        Self::variant_id_for_adt(self.db, ctor, adt_def.def_id().0).unwrap();
                     variant.fields(self.db).fields().len()
                 }
                 _ => {
@@ -346,24 +358,24 @@ impl PatCx for MatchCheckCtx<'_> {
     ) -> impl ExactSizeIterator<Item = (Self::Ty, PrivateUninhabitedField)> {
         let single = |ty| smallvec![(ty, PrivateUninhabitedField(false))];
         let tys: SmallVec<[_; 2]> = match ctor {
-            Struct | Variant(_) | UnionField => match ty.kind(Interner) {
-                TyKind::Tuple(_, substs) => {
-                    let tys = substs.iter(Interner).map(|ty| ty.assert_ty_ref(Interner));
-                    tys.cloned().map(|ty| (ty, PrivateUninhabitedField(false))).collect()
+            Struct | Variant(_) | UnionField => match ty.kind() {
+                TyKind::Tuple(substs) => {
+                    substs.iter().map(|ty| (ty, PrivateUninhabitedField(false))).collect()
                 }
-                TyKind::Ref(.., rty) => single(rty.clone()),
-                &TyKind::Adt(AdtId(adt), ..) => {
+                TyKind::Ref(_, rty, _) => single(rty),
+                TyKind::Adt(adt_def, ..) => {
+                    let adt = adt_def.def_id().0;
                     let variant = Self::variant_id_for_adt(self.db, ctor, adt).unwrap();
 
                     let visibilities = LazyCell::new(|| self.db.field_visibilities(variant));
 
-                    self.list_variant_fields(ty, variant)
+                    self.list_variant_fields(*ty, variant)
                         .map(move |(fid, ty)| {
                             let is_visible = || {
                                 matches!(adt, hir_def::AdtId::EnumId(..))
                                     || visibilities[fid].is_visible_from(self.db, self.module)
                             };
-                            let is_uninhabited = self.is_uninhabited(&ty);
+                            let is_uninhabited = self.is_uninhabited(ty);
                             let private_uninhabited = is_uninhabited && !is_visible();
                             (ty, PrivateUninhabitedField(private_uninhabited))
                         })
@@ -371,14 +383,14 @@ impl PatCx for MatchCheckCtx<'_> {
                 }
                 ty_kind => {
                     never!("Unexpected type for `{:?}` constructor: {:?}", ctor, ty_kind);
-                    single(ty.clone())
+                    single(*ty)
                 }
             },
-            Ref => match ty.kind(Interner) {
-                TyKind::Ref(.., rty) => single(rty.clone()),
+            Ref => match ty.kind() {
+                TyKind::Ref(_, rty, _) => single(rty),
                 ty_kind => {
                     never!("Unexpected type for `{:?}` constructor: {:?}", ctor, ty_kind);
-                    single(ty.clone())
+                    single(*ty)
                 }
             },
             Slice(_) => unreachable!("Found a `Slice` constructor in match checking"),
@@ -414,42 +426,51 @@ impl PatCx for MatchCheckCtx<'_> {
         // returned list of constructors.
         // Invariant: this is empty if and only if the type is uninhabited (as determined by
         // `cx.is_uninhabited()`).
-        Ok(match ty.kind(Interner) {
-            TyKind::Scalar(Scalar::Bool) => ConstructorSet::Bool,
-            TyKind::Scalar(Scalar::Char) => unhandled(),
-            TyKind::Scalar(Scalar::Int(..) | Scalar::Uint(..)) => unhandled(),
+        Ok(match ty.kind() {
+            TyKind::Bool => ConstructorSet::Bool,
+            TyKind::Char => unhandled(),
+            TyKind::Int(..) | TyKind::Uint(..) => unhandled(),
             TyKind::Array(..) | TyKind::Slice(..) => unhandled(),
-            &TyKind::Adt(AdtId(adt @ hir_def::AdtId::EnumId(enum_id)), ref subst) => {
-                let enum_data = enum_id.enum_variants(cx.db);
-                let is_declared_nonexhaustive = cx.is_foreign_non_exhaustive(adt);
-
-                if enum_data.variants.is_empty() && !is_declared_nonexhaustive {
-                    ConstructorSet::NoConstructors
-                } else {
-                    let mut variants = IndexVec::with_capacity(enum_data.variants.len());
-                    for &(variant, _, _) in enum_data.variants.iter() {
-                        let is_uninhabited = is_enum_variant_uninhabited_from(
-                            cx.db,
-                            variant,
-                            subst,
-                            cx.module,
-                            self.env.clone(),
-                        );
-                        let visibility = if is_uninhabited {
-                            VariantVisibility::Empty
+            TyKind::Adt(adt_def, subst) => {
+                let adt = adt_def.def_id().0;
+                match adt {
+                    hir_def::AdtId::EnumId(enum_id) => {
+                        let enum_data = enum_id.enum_variants(cx.db);
+                        let is_declared_nonexhaustive = cx.is_foreign_non_exhaustive(adt);
+
+                        if enum_data.variants.is_empty() && !is_declared_nonexhaustive {
+                            ConstructorSet::NoConstructors
                         } else {
-                            VariantVisibility::Visible
-                        };
-                        variants.push(visibility);
-                    }
+                            let mut variants = IndexVec::with_capacity(enum_data.variants.len());
+                            for &(variant, _, _) in enum_data.variants.iter() {
+                                let is_uninhabited = is_enum_variant_uninhabited_from(
+                                    cx.infcx,
+                                    variant,
+                                    subst,
+                                    cx.module,
+                                    self.env.clone(),
+                                );
+                                let visibility = if is_uninhabited {
+                                    VariantVisibility::Empty
+                                } else {
+                                    VariantVisibility::Visible
+                                };
+                                variants.push(visibility);
+                            }
 
-                    ConstructorSet::Variants { variants, non_exhaustive: is_declared_nonexhaustive }
+                            ConstructorSet::Variants {
+                                variants,
+                                non_exhaustive: is_declared_nonexhaustive,
+                            }
+                        }
+                    }
+                    hir_def::AdtId::UnionId(_) => ConstructorSet::Union,
+                    hir_def::AdtId::StructId(_) => {
+                        ConstructorSet::Struct { empty: cx.is_uninhabited(*ty) }
+                    }
                 }
             }
-            TyKind::Adt(AdtId(hir_def::AdtId::UnionId(_)), _) => ConstructorSet::Union,
-            TyKind::Adt(..) | TyKind::Tuple(..) => {
-                ConstructorSet::Struct { empty: cx.is_uninhabited(ty) }
-            }
+            TyKind::Tuple(..) => ConstructorSet::Struct { empty: cx.is_uninhabited(*ty) },
             TyKind::Ref(..) => ConstructorSet::Ref,
             TyKind::Never => ConstructorSet::NoConstructors,
             // This type is one for which we cannot list constructors, like `str` or `f64`.
@@ -492,14 +513,14 @@ impl PatCx for MatchCheckCtx<'_> {
 
     fn report_mixed_deref_pat_ctors(
         &self,
-        _deref_pat: &DeconstructedPat<'_>,
-        _normal_pat: &DeconstructedPat<'_>,
+        _deref_pat: &DeconstructedPat<'a, 'db>,
+        _normal_pat: &DeconstructedPat<'a, 'db>,
     ) {
         // FIXME(deref_patterns): This could report an error comparable to the one in rustc.
     }
 }
 
-impl fmt::Debug for MatchCheckCtx<'_> {
+impl fmt::Debug for MatchCheckCtx<'_, '_> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("MatchCheckCtx").finish()
     }
diff --git a/crates/hir-ty/src/diagnostics/unsafe_check.rs b/crates/hir-ty/src/diagnostics/unsafe_check.rs
index 31100e17f846..53524d66a33c 100644
--- a/crates/hir-ty/src/diagnostics/unsafe_check.rs
+++ b/crates/hir-ty/src/diagnostics/unsafe_check.rs
@@ -5,22 +5,21 @@ use std::mem;
 
 use either::Either;
 use hir_def::{
-    AdtId, DefWithBodyId, FieldId, FunctionId, VariantId,
+    AdtId, CallableDefId, DefWithBodyId, FieldId, FunctionId, VariantId,
     expr_store::{Body, path::Path},
     hir::{AsmOperand, Expr, ExprId, ExprOrPatId, InlineAsmKind, Pat, PatId, Statement, UnaryOp},
     resolver::{HasResolver, ResolveValueResult, Resolver, ValueNs},
     signatures::StaticFlags,
     type_ref::Rawness,
 };
+use rustc_type_ir::inherent::IntoKind;
 use span::Edition;
 
-use crate::next_solver::DbInterner;
-use crate::next_solver::mapping::NextSolverToChalk;
-use crate::utils::TargetFeatureIsSafeInTarget;
 use crate::{
-    InferenceResult, Interner, TargetFeatures, TyExt, TyKind,
+    InferenceResult, TargetFeatures,
     db::HirDatabase,
-    utils::{is_fn_unsafe_to_call, target_feature_is_safe_in_target},
+    next_solver::{CallableIdWrapper, TyKind, abi::Safety},
+    utils::{TargetFeatureIsSafeInTarget, is_fn_unsafe_to_call, target_feature_is_safe_in_target},
 };
 
 #[derive(Debug, Default)]
@@ -151,7 +150,6 @@ struct UnsafeVisitor<'db> {
     /// On some targets (WASM), calling safe functions with `#[target_feature]` is always safe, even when
     /// the target feature is not enabled. This flag encodes that.
     target_feature_is_safe: TargetFeatureIsSafeInTarget,
-    interner: DbInterner<'db>,
 }
 
 impl<'db> UnsafeVisitor<'db> {
@@ -186,7 +184,6 @@ impl<'db> UnsafeVisitor<'db> {
             def_target_features,
             edition,
             target_feature_is_safe,
-            interner: DbInterner::new_with(db, None, None),
         }
     }
 
@@ -289,12 +286,14 @@ impl<'db> UnsafeVisitor<'db> {
         let inside_assignment = mem::replace(&mut self.inside_assignment, false);
         match expr {
             &Expr::Call { callee, .. } => {
-                let callee = self.infer[callee].to_chalk(self.interner);
-                if let Some(func) = callee.as_fn_def(self.db) {
+                let callee = self.infer[callee];
+                if let TyKind::FnDef(CallableIdWrapper(CallableDefId::FunctionId(func)), _) =
+                    callee.kind()
+                {
                     self.check_call(current, func);
                 }
-                if let TyKind::Function(fn_ptr) = callee.kind(Interner)
-                    && fn_ptr.sig.safety == chalk_ir::Safety::Unsafe
+                if let TyKind::FnPtr(_, hdr) = callee.kind()
+                    && hdr.safety == Safety::Unsafe
                 {
                     self.on_unsafe_op(current.into(), UnsafetyReason::UnsafeFnCall);
                 }
@@ -342,7 +341,7 @@ impl<'db> UnsafeVisitor<'db> {
                 }
             }
             Expr::UnaryOp { expr, op: UnaryOp::Deref } => {
-                if let TyKind::Raw(..) = &self.infer[*expr].to_chalk(self.interner).kind(Interner) {
+                if let TyKind::RawPtr(..) = self.infer[*expr].kind() {
                     self.on_unsafe_op(current.into(), UnsafetyReason::RawPtrDeref);
                 }
             }
diff --git a/crates/hir-ty/src/display.rs b/crates/hir-ty/src/display.rs
index bcd93c6699cc..210e1ac52e58 100644
--- a/crates/hir-ty/src/display.rs
+++ b/crates/hir-ty/src/display.rs
@@ -8,7 +8,6 @@ use std::{
 };
 
 use base_db::Crate;
-use chalk_ir::{BoundVar, Safety, TyKind};
 use either::Either;
 use hir_def::{
     FindPathConfig, GeneralConstId, GenericDefId, HasModule, LocalFieldId, Lookup, ModuleDefId,
@@ -36,39 +35,33 @@ use rustc_apfloat::{
     Float,
     ieee::{Half as f16, Quad as f128},
 };
+use rustc_ast_ir::FloatTy;
 use rustc_hash::FxHashSet;
 use rustc_type_ir::{
-    AliasTyKind, CoroutineArgsParts, RegionKind,
-    inherent::{AdtDef, GenericArgs as _, IntoKind, SliceLike},
+    AliasTyKind, CoroutineArgsParts, RegionKind, Upcast,
+    inherent::{AdtDef, GenericArgs as _, IntoKind, SliceLike, Term as _, Ty as _, Tys as _},
 };
 use smallvec::SmallVec;
 use span::Edition;
 use stdx::never;
 use triomphe::Arc;
 
-use crate::next_solver::infer::traits::ObligationCause;
-use crate::next_solver::{infer::DbInternerInferExt, mapping::NextSolverToChalk};
 use crate::{
-    AliasEq, AliasTy, Binders, CallableDefId, CallableSig, ConcreteConst, Const, ConstScalar,
-    ConstValue, DomainGoal, FnAbi, GenericArg, ImplTraitId, Interner, Lifetime, LifetimeData,
-    LifetimeOutlives, MemoryMap, OpaqueTy, ProjectionTy, ProjectionTyExt, QuantifiedWhereClause,
-    TraitEnvironment, TraitRef, TraitRefExt, Ty, TyExt, WhereClause, consteval,
+    CallableDefId, FnAbi, ImplTraitId, MemoryMap, TraitEnvironment, consteval,
     db::{HirDatabase, InternedClosure},
-    from_assoc_type_id, from_placeholder_idx,
     generics::generics,
-    infer::normalize,
     layout::Layout,
-    lt_from_placeholder_idx,
     mir::pad16,
     next_solver::{
-        BoundExistentialPredicate, DbInterner, GenericArgs, SolverDefId,
-        mapping::{
-            ChalkToNextSolver, convert_args_for_result, convert_const_for_result,
-            convert_region_for_result, convert_ty_for_result,
-        },
+        AliasTy, Clause, ClauseKind, Const, ConstKind, DbInterner, EarlyBinder,
+        ExistentialPredicate, FnSig, GenericArg, GenericArgs, PolyFnSig, Region, SolverDefId, Term,
+        TraitRef, Ty, TyKind, TypingMode,
+        abi::Safety,
+        infer::{DbInternerInferExt, traits::ObligationCause},
+        mapping::ChalkToNextSolver,
     },
-    primitive, to_assoc_type_id,
-    utils::{self, ClosureSubst, detect_variant_from_bytes},
+    primitive,
+    utils::{self, detect_variant_from_bytes},
 };
 
 pub trait HirWrite: fmt::Write {
@@ -82,9 +75,10 @@ impl HirWrite for String {}
 // `core::Formatter` will ignore metadata
 impl HirWrite for fmt::Formatter<'_> {}
 
-pub struct HirFormatter<'a> {
+pub struct HirFormatter<'a, 'db> {
     /// The database handle
-    pub db: &'a dyn HirDatabase,
+    pub db: &'db dyn HirDatabase,
+    pub interner: DbInterner<'db>,
     /// The sink to write into
     fmt: &'a mut dyn HirWrite,
     /// A buffer to intercept writes with, this allows us to track the overall size of the formatted output.
@@ -103,7 +97,7 @@ pub struct HirFormatter<'a> {
     display_lifetimes: DisplayLifetime,
     display_kind: DisplayKind,
     display_target: DisplayTarget,
-    bounds_formatting_ctx: BoundsFormattingCtx,
+    bounds_formatting_ctx: BoundsFormattingCtx<'db>,
 }
 
 // FIXME: To consider, ref and dyn trait lifetimes can be omitted if they are `'_`, path args should
@@ -121,7 +115,7 @@ pub enum DisplayLifetime {
 }
 
 #[derive(Default)]
-enum BoundsFormattingCtx {
+enum BoundsFormattingCtx<'db> {
     Entered {
         /// We can have recursive bounds like the following case:
         /// ```ignore
@@ -131,14 +125,14 @@ enum BoundsFormattingCtx {
         /// ```
         /// So, record the projection types met while formatting bounds and
         //. prevent recursing into their bounds to avoid infinite loops.
-        projection_tys_met: FxHashSet<ProjectionTy>,
+        projection_tys_met: FxHashSet<AliasTy<'db>>,
     },
     #[default]
     Exited,
 }
 
-impl BoundsFormattingCtx {
-    fn contains(&mut self, proj: &ProjectionTy) -> bool {
+impl<'db> BoundsFormattingCtx<'db> {
+    fn contains(&self, proj: &AliasTy<'db>) -> bool {
         match self {
             BoundsFormattingCtx::Entered { projection_tys_met } => {
                 projection_tys_met.contains(proj)
@@ -148,7 +142,7 @@ impl BoundsFormattingCtx {
     }
 }
 
-impl HirFormatter<'_> {
+impl<'db> HirFormatter<'_, 'db> {
     fn start_location_link(&mut self, location: ModuleDefId) {
         self.fmt.start_location_link(location);
     }
@@ -159,7 +153,7 @@ impl HirFormatter<'_> {
 
     fn format_bounds_with<T, F: FnOnce(&mut Self) -> T>(
         &mut self,
-        target: ProjectionTy,
+        target: AliasTy<'db>,
         format_bounds: F,
     ) -> T {
         match self.bounds_formatting_ctx {
@@ -181,52 +175,28 @@ impl HirFormatter<'_> {
         }
     }
 
-    fn render_lifetime(&self, lifetime: &Lifetime) -> bool {
+    fn render_region(&self, lifetime: Region<'db>) -> bool {
         match self.display_lifetimes {
             DisplayLifetime::Always => true,
-            DisplayLifetime::OnlyStatic => matches!(***lifetime.interned(), LifetimeData::Static),
+            DisplayLifetime::OnlyStatic => matches!(lifetime.kind(), RegionKind::ReStatic),
             DisplayLifetime::OnlyNamed => {
-                matches!(***lifetime.interned(), LifetimeData::Placeholder(_))
-            }
-            DisplayLifetime::OnlyNamedOrStatic => matches!(
-                ***lifetime.interned(),
-                LifetimeData::Static | LifetimeData::Placeholder(_)
-            ),
-            DisplayLifetime::Never => false,
-        }
-    }
-
-    fn render_region(&self, lifetime: crate::next_solver::Region<'_>) -> bool {
-        match self.display_lifetimes {
-            DisplayLifetime::Always => true,
-            DisplayLifetime::OnlyStatic => {
-                matches!(lifetime.kind(), rustc_type_ir::RegionKind::ReStatic)
+                matches!(lifetime.kind(), RegionKind::ReEarlyParam(_))
             }
-            DisplayLifetime::OnlyNamed => {
-                matches!(
-                    lifetime.kind(),
-                    rustc_type_ir::RegionKind::RePlaceholder(_)
-                        | rustc_type_ir::RegionKind::ReEarlyParam(_)
-                )
+            DisplayLifetime::OnlyNamedOrStatic => {
+                matches!(lifetime.kind(), RegionKind::ReStatic | RegionKind::ReEarlyParam(_))
             }
-            DisplayLifetime::OnlyNamedOrStatic => matches!(
-                lifetime.kind(),
-                rustc_type_ir::RegionKind::ReStatic
-                    | rustc_type_ir::RegionKind::RePlaceholder(_)
-                    | rustc_type_ir::RegionKind::ReEarlyParam(_)
-            ),
             DisplayLifetime::Never => false,
         }
     }
 }
 
-pub trait HirDisplay {
-    fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError>;
+pub trait HirDisplay<'db> {
+    fn hir_fmt(&self, f: &mut HirFormatter<'_, 'db>) -> Result<(), HirDisplayError>;
 
     /// Returns a `Display`able type that is human-readable.
     fn into_displayable<'a>(
         &'a self,
-        db: &'a dyn HirDatabase,
+        db: &'db dyn HirDatabase,
         max_size: Option<usize>,
         limited_size: Option<usize>,
         omit_verbose_types: bool,
@@ -234,7 +204,7 @@ pub trait HirDisplay {
         display_kind: DisplayKind,
         closure_style: ClosureStyle,
         show_container_bounds: bool,
-    ) -> HirDisplayWrapper<'a, Self>
+    ) -> HirDisplayWrapper<'a, 'db, Self>
     where
         Self: Sized,
     {
@@ -260,9 +230,9 @@ pub trait HirDisplay {
     /// Use this for showing types to the user (e.g. diagnostics)
     fn display<'a>(
         &'a self,
-        db: &'a dyn HirDatabase,
+        db: &'db dyn HirDatabase,
         display_target: DisplayTarget,
-    ) -> HirDisplayWrapper<'a, Self>
+    ) -> HirDisplayWrapper<'a, 'db, Self>
     where
         Self: Sized,
     {
@@ -284,10 +254,10 @@ pub trait HirDisplay {
     /// Use this for showing types to the user where space is constrained (e.g. doc popups)
     fn display_truncated<'a>(
         &'a self,
-        db: &'a dyn HirDatabase,
+        db: &'db dyn HirDatabase,
         max_size: Option<usize>,
         display_target: DisplayTarget,
-    ) -> HirDisplayWrapper<'a, Self>
+    ) -> HirDisplayWrapper<'a, 'db, Self>
     where
         Self: Sized,
     {
@@ -309,10 +279,10 @@ pub trait HirDisplay {
     /// Use this for showing definitions which may contain too many items, like `trait`, `struct`, `enum`
     fn display_limited<'a>(
         &'a self,
-        db: &'a dyn HirDatabase,
+        db: &'db dyn HirDatabase,
         limited_size: Option<usize>,
         display_target: DisplayTarget,
-    ) -> HirDisplayWrapper<'a, Self>
+    ) -> HirDisplayWrapper<'a, 'db, Self>
     where
         Self: Sized,
     {
@@ -334,13 +304,16 @@ pub trait HirDisplay {
     /// Use this when generating code (e.g. assists)
     fn display_source_code<'a>(
         &'a self,
-        db: &'a dyn HirDatabase,
+        db: &'db dyn HirDatabase,
         module_id: ModuleId,
         allow_opaque: bool,
     ) -> Result<String, DisplaySourceCodeError> {
         let mut result = String::new();
+        let interner =
+            DbInterner::new_with(db, Some(module_id.krate()), module_id.containing_block());
         match self.hir_fmt(&mut HirFormatter {
             db,
+            interner,
             fmt: &mut result,
             buf: String::with_capacity(20),
             curr_size: 0,
@@ -364,9 +337,9 @@ pub trait HirDisplay {
     /// Returns a String representation of `self` for test purposes
     fn display_test<'a>(
         &'a self,
-        db: &'a dyn HirDatabase,
+        db: &'db dyn HirDatabase,
         display_target: DisplayTarget,
-    ) -> HirDisplayWrapper<'a, Self>
+    ) -> HirDisplayWrapper<'a, 'db, Self>
     where
         Self: Sized,
     {
@@ -388,10 +361,10 @@ pub trait HirDisplay {
     /// the container for functions
     fn display_with_container_bounds<'a>(
         &'a self,
-        db: &'a dyn HirDatabase,
+        db: &'db dyn HirDatabase,
         show_container_bounds: bool,
         display_target: DisplayTarget,
-    ) -> HirDisplayWrapper<'a, Self>
+    ) -> HirDisplayWrapper<'a, 'db, Self>
     where
         Self: Sized,
     {
@@ -410,7 +383,7 @@ pub trait HirDisplay {
     }
 }
 
-impl HirFormatter<'_> {
+impl<'db> HirFormatter<'_, 'db> {
     pub fn krate(&self) -> Crate {
         self.display_target.krate
     }
@@ -419,7 +392,7 @@ impl HirFormatter<'_> {
         self.display_target.edition
     }
 
-    pub fn write_joined<T: HirDisplay>(
+    pub fn write_joined<T: HirDisplay<'db>>(
         &mut self,
         iter: impl IntoIterator<Item = T>,
         sep: &str,
@@ -536,8 +509,8 @@ impl From<fmt::Error> for HirDisplayError {
     }
 }
 
-pub struct HirDisplayWrapper<'a, T> {
-    db: &'a dyn HirDatabase,
+pub struct HirDisplayWrapper<'a, 'db, T> {
+    db: &'db dyn HirDatabase,
     t: &'a T,
     max_size: Option<usize>,
     limited_size: Option<usize>,
@@ -564,10 +537,17 @@ pub enum ClosureStyle {
     Hide,
 }
 
-impl<T: HirDisplay> HirDisplayWrapper<'_, T> {
+impl<'db, T: HirDisplay<'db>> HirDisplayWrapper<'_, 'db, T> {
     pub fn write_to<F: HirWrite>(&self, f: &mut F) -> Result<(), HirDisplayError> {
+        let krate = self.display_target.krate;
+        let block = match self.display_kind {
+            DisplayKind::SourceCode { target_module_id, .. } => target_module_id.containing_block(),
+            DisplayKind::Diagnostics | DisplayKind::Test => None,
+        };
+        let interner = DbInterner::new_with(self.db, Some(krate), block);
         self.t.hir_fmt(&mut HirFormatter {
             db: self.db,
+            interner,
             fmt: f,
             buf: String::with_capacity(self.max_size.unwrap_or(20)),
             curr_size: 0,
@@ -594,9 +574,9 @@ impl<T: HirDisplay> HirDisplayWrapper<'_, T> {
     }
 }
 
-impl<T> fmt::Display for HirDisplayWrapper<'_, T>
+impl<'db, T> fmt::Display for HirDisplayWrapper<'_, 'db, T>
 where
-    T: HirDisplay,
+    T: HirDisplay<'db>,
 {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self.write_to(f) {
@@ -614,196 +594,146 @@ where
 
 const TYPE_HINT_TRUNCATION: &str = "…";
 
-impl<T: HirDisplay> HirDisplay for &T {
-    fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
+impl<'db, T: HirDisplay<'db>> HirDisplay<'db> for &T {
+    fn hir_fmt(&self, f: &mut HirFormatter<'_, 'db>) -> Result<(), HirDisplayError> {
         HirDisplay::hir_fmt(*self, f)
     }
 }
 
-impl<T: HirDisplay + Internable> HirDisplay for Interned<T> {
-    fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
+impl<'db, T: HirDisplay<'db> + Internable> HirDisplay<'db> for Interned<T> {
+    fn hir_fmt(&self, f: &mut HirFormatter<'_, 'db>) -> Result<(), HirDisplayError> {
         HirDisplay::hir_fmt(self.as_ref(), f)
     }
 }
 
-impl HirDisplay for ProjectionTy {
-    fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
-        if f.should_truncate() {
-            return write!(f, "{TYPE_HINT_TRUNCATION}");
-        }
-        let trait_ref = self.trait_ref(f.db);
-        let self_ty = trait_ref.self_type_parameter(Interner);
-
-        // if we are projection on a type parameter, check if the projection target has bounds
-        // itself, if so, we render them directly as `impl Bound` instead of the less useful
-        // `<Param as Trait>::Assoc`
-        if !f.display_kind.is_source_code()
-            && let TyKind::Placeholder(idx) = self_ty.kind(Interner)
-            && !f.bounds_formatting_ctx.contains(self)
-        {
-            let db = f.db;
-            let id = from_placeholder_idx(db, *idx).0;
-            let generics = generics(db, id.parent);
-
-            let substs = generics.placeholder_subst(db);
-            let bounds = db
-                .generic_predicates(id.parent)
-                .iter()
-                .map(|pred| pred.clone().substitute(Interner, &substs))
+fn write_projection<'db>(
+    f: &mut HirFormatter<'_, 'db>,
+    alias: &AliasTy<'db>,
+) -> Result<(), HirDisplayError> {
+    if f.should_truncate() {
+        return write!(f, "{TYPE_HINT_TRUNCATION}");
+    }
+    let trait_ref = alias.trait_ref(f.interner);
+    let self_ty = trait_ref.self_ty();
+
+    // if we are projection on a type parameter, check if the projection target has bounds
+    // itself, if so, we render them directly as `impl Bound` instead of the less useful
+    // `<Param as Trait>::Assoc`
+    if !f.display_kind.is_source_code()
+        && let TyKind::Param(param) = self_ty.kind()
+        && !f.bounds_formatting_ctx.contains(alias)
+    {
+        // FIXME: We shouldn't use `param.id`, it should be removed. We should know the
+        // `GenericDefId` from the formatted type (store it inside the `HirFormatter`).
+        let bounds =
+            f.db.generic_predicates_ns(param.id.parent())
+                .instantiate_identity()
+                .into_iter()
+                .flatten()
                 .filter(|wc| {
-                    let ty = match wc.skip_binders() {
-                        WhereClause::Implemented(tr) => tr.self_type_parameter(Interner),
-                        WhereClause::TypeOutlives(t) => t.ty.clone(),
-                        // We shouldn't be here if these exist
-                        WhereClause::AliasEq(_) | WhereClause::LifetimeOutlives(_) => {
-                            return false;
-                        }
+                    let ty = match wc.kind().skip_binder() {
+                        ClauseKind::Trait(tr) => tr.self_ty(),
+                        ClauseKind::TypeOutlives(t) => t.0,
+                        _ => return false,
                     };
-                    let TyKind::Alias(AliasTy::Projection(proj)) = ty.kind(Interner) else {
+                    let TyKind::Alias(AliasTyKind::Projection, a) = ty.kind() else {
                         return false;
                     };
-                    proj == self
+                    a == *alias
                 })
                 .collect::<Vec<_>>();
-            if !bounds.is_empty() {
-                return f.format_bounds_with(self.clone(), |f| {
-                    write_bounds_like_dyn_trait_with_prefix(
-                        f,
-                        "impl",
-                        Either::Left(
-                            &TyKind::Alias(AliasTy::Projection(self.clone())).intern(Interner),
-                        ),
-                        &bounds,
-                        SizedByDefault::NotSized,
-                    )
-                });
-            }
-        }
-
-        write!(f, "<")?;
-        self_ty.hir_fmt(f)?;
-        write!(f, " as ")?;
-        trait_ref.hir_fmt(f)?;
-        write!(
-            f,
-            ">::{}",
-            f.db.type_alias_signature(from_assoc_type_id(self.associated_ty_id))
-                .name
-                .display(f.db, f.edition())
-        )?;
-        let proj_params =
-            &self.substitution.as_slice(Interner)[trait_ref.substitution.len(Interner)..];
-        hir_fmt_generics(f, proj_params, None, None)
-    }
-}
-
-impl HirDisplay for OpaqueTy {
-    fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
-        if f.should_truncate() {
-            return write!(f, "{TYPE_HINT_TRUNCATION}");
+        if !bounds.is_empty() {
+            return f.format_bounds_with(*alias, |f| {
+                write_bounds_like_dyn_trait_with_prefix(
+                    f,
+                    "impl",
+                    Either::Left(Ty::new_alias(f.interner, AliasTyKind::Projection, *alias)),
+                    &bounds,
+                    SizedByDefault::NotSized,
+                )
+            });
         }
-
-        self.substitution.at(Interner, 0).hir_fmt(f)
     }
-}
 
-impl HirDisplay for GenericArg {
-    fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
-        match self.interned() {
-            crate::GenericArgData::Ty(ty) => ty.hir_fmt(f),
-            crate::GenericArgData::Lifetime(lt) => lt.hir_fmt(f),
-            crate::GenericArgData::Const(c) => c.hir_fmt(f),
-        }
-    }
+    write!(f, "<")?;
+    self_ty.hir_fmt(f)?;
+    write!(f, " as ")?;
+    trait_ref.hir_fmt(f)?;
+    write!(
+        f,
+        ">::{}",
+        f.db.type_alias_signature(alias.def_id.expect_type_alias()).name.display(f.db, f.edition())
+    )?;
+    let proj_params = &alias.args.as_slice()[trait_ref.args.len()..];
+    hir_fmt_generics(f, proj_params, None, None)
 }
 
-impl<'db> HirDisplay for crate::next_solver::GenericArg<'db> {
-    fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
-        match self.kind() {
-            rustc_type_ir::GenericArgKind::Type(ty) => ty.hir_fmt(f),
-            rustc_type_ir::GenericArgKind::Lifetime(lt) => lt.hir_fmt(f),
-            rustc_type_ir::GenericArgKind::Const(c) => c.hir_fmt(f),
+impl<'db> HirDisplay<'db> for GenericArg<'db> {
+    fn hir_fmt(&self, f: &mut HirFormatter<'_, 'db>) -> Result<(), HirDisplayError> {
+        match self {
+            GenericArg::Ty(ty) => ty.hir_fmt(f),
+            GenericArg::Lifetime(lt) => lt.hir_fmt(f),
+            GenericArg::Const(c) => c.hir_fmt(f),
         }
     }
 }
 
-impl HirDisplay for Const {
-    fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
-        let c = self.to_nextsolver(DbInterner::new_with(f.db, None, None));
-        c.hir_fmt(f)
-    }
-}
-
-impl<'db> HirDisplay for crate::next_solver::Const<'db> {
-    fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
+impl<'db> HirDisplay<'db> for Const<'db> {
+    fn hir_fmt(&self, f: &mut HirFormatter<'_, 'db>) -> Result<(), HirDisplayError> {
         match self.kind() {
-            rustc_type_ir::ConstKind::Placeholder(_) => write!(f, "<placeholder>"),
-            rustc_type_ir::ConstKind::Bound(db, bound_const) => {
+            ConstKind::Placeholder(_) => write!(f, "<placeholder>"),
+            ConstKind::Bound(db, bound_const) => {
                 write!(f, "?{}.{}", db.as_u32(), bound_const.var.as_u32())
             }
-            rustc_type_ir::ConstKind::Infer(..) => write!(f, "#c#"),
-            rustc_type_ir::ConstKind::Param(param) => {
+            ConstKind::Infer(..) => write!(f, "#c#"),
+            ConstKind::Param(param) => {
                 let generics = generics(f.db, param.id.parent());
                 let param_data = &generics[param.id.local_id()];
                 write!(f, "{}", param_data.name().unwrap().display(f.db, f.edition()))?;
                 Ok(())
             }
-            rustc_type_ir::ConstKind::Value(const_bytes) => render_const_scalar_ns(
+            ConstKind::Value(const_bytes) => render_const_scalar(
                 f,
                 &const_bytes.value.inner().memory,
                 &const_bytes.value.inner().memory_map,
                 const_bytes.ty,
             ),
-            rustc_type_ir::ConstKind::Unevaluated(unev) => {
+            ConstKind::Unevaluated(unev) => {
                 let c = match unev.def {
                     SolverDefId::ConstId(id) => GeneralConstId::ConstId(id),
                     SolverDefId::StaticId(id) => GeneralConstId::StaticId(id),
                     _ => unreachable!(),
                 };
                 write!(f, "{}", c.name(f.db))?;
-                hir_fmt_generics_ns(f, unev.args.as_slice(), c.generic_def(f.db), None)?;
+                hir_fmt_generics(f, unev.args.as_slice(), c.generic_def(f.db), None)?;
                 Ok(())
             }
-            rustc_type_ir::ConstKind::Error(..) => f.write_char('_'),
-            rustc_type_ir::ConstKind::Expr(..) => write!(f, "<const-expr>"),
+            ConstKind::Error(..) => f.write_char('_'),
+            ConstKind::Expr(..) => write!(f, "<const-expr>"),
         }
     }
 }
 
-fn render_const_scalar(
-    f: &mut HirFormatter<'_>,
+fn render_const_scalar<'db>(
+    f: &mut HirFormatter<'_, 'db>,
     b: &[u8],
-    memory_map: &MemoryMap<'_>,
-    ty: &Ty,
+    memory_map: &MemoryMap<'db>,
+    ty: Ty<'db>,
 ) -> Result<(), HirDisplayError> {
     let trait_env = TraitEnvironment::empty(f.krate());
-    let interner = DbInterner::new_with(f.db, Some(trait_env.krate), trait_env.block);
-    let ty = normalize(f.db, trait_env.clone(), ty.clone());
-    let ty = ty.to_nextsolver(interner);
-    render_const_scalar_inner(f, b, memory_map, ty, trait_env)
-}
-
-fn render_const_scalar_ns(
-    f: &mut HirFormatter<'_>,
-    b: &[u8],
-    memory_map: &MemoryMap<'_>,
-    ty: crate::next_solver::Ty<'_>,
-) -> Result<(), HirDisplayError> {
-    let trait_env = TraitEnvironment::empty(f.krate());
-    let interner = DbInterner::new_with(f.db, Some(trait_env.krate), trait_env.block);
-    let infcx = interner.infer_ctxt().build(rustc_type_ir::TypingMode::PostAnalysis);
+    let infcx = f.interner.infer_ctxt().build(TypingMode::PostAnalysis);
     let ty = infcx.at(&ObligationCause::new(), trait_env.env).deeply_normalize(ty).unwrap_or(ty);
     render_const_scalar_inner(f, b, memory_map, ty, trait_env)
 }
 
 fn render_const_scalar_inner<'db>(
-    f: &mut HirFormatter<'_>,
+    f: &mut HirFormatter<'_, 'db>,
     b: &[u8],
-    memory_map: &MemoryMap<'_>,
-    ty: crate::next_solver::Ty<'db>,
+    memory_map: &MemoryMap<'db>,
+    ty: Ty<'db>,
     trait_env: Arc<TraitEnvironment<'db>>,
 ) -> Result<(), HirDisplayError> {
-    use rustc_type_ir::TyKind;
+    use TyKind;
     match ty.kind() {
         TyKind::Bool => write!(f, "{}", b[0] != 0),
         TyKind::Char => {
@@ -822,7 +752,7 @@ fn render_const_scalar_inner<'db>(
             write!(f, "{it}")
         }
         TyKind::Float(fl) => match fl {
-            rustc_type_ir::FloatTy::F16 => {
+            FloatTy::F16 => {
                 // FIXME(#17451): Replace with builtins once they are stabilised.
                 let it = f16::from_bits(u16::from_le_bytes(b.try_into().unwrap()).into());
                 let s = it.to_string();
@@ -833,15 +763,15 @@ fn render_const_scalar_inner<'db>(
                     write!(f, "{s}")
                 }
             }
-            rustc_type_ir::FloatTy::F32 => {
+            FloatTy::F32 => {
                 let it = f32::from_le_bytes(b.try_into().unwrap());
                 write!(f, "{it:?}")
             }
-            rustc_type_ir::FloatTy::F64 => {
+            FloatTy::F64 => {
                 let it = f64::from_le_bytes(b.try_into().unwrap());
                 write!(f, "{it:?}")
             }
-            rustc_type_ir::FloatTy::F128 => {
+            FloatTy::F128 => {
                 // FIXME(#17451): Replace with builtins once they are stabilised.
                 let it = f128::from_bits(u128::from_le_bytes(b.try_into().unwrap()));
                 let s = it.to_string();
@@ -890,7 +820,7 @@ fn render_const_scalar_inner<'db>(
                         f.write_str(", ")?;
                     }
                     let offset = size_one * i;
-                    render_const_scalar_ns(f, &bytes[offset..offset + size_one], memory_map, ty)?;
+                    render_const_scalar(f, &bytes[offset..offset + size_one], memory_map, ty)?;
                 }
                 f.write_str("]")
             }
@@ -908,7 +838,7 @@ fn render_const_scalar_inner<'db>(
                     return f.write_str("<ref-data-not-available>");
                 };
                 f.write_str("&")?;
-                render_const_scalar_ns(f, bytes, memory_map, t)
+                render_const_scalar(f, bytes, memory_map, t)
             }
             TyKind::Adt(adt, _) if b.len() == 2 * size_of::<usize>() => match adt.def_id().0 {
                 hir_def::AdtId::StructId(s) => {
@@ -938,7 +868,7 @@ fn render_const_scalar_inner<'db>(
                     return f.write_str("<ref-data-not-available>");
                 };
                 f.write_str("&")?;
-                render_const_scalar_ns(f, bytes, memory_map, t)
+                render_const_scalar(f, bytes, memory_map, t)
             }
         },
         TyKind::Tuple(tys) => {
@@ -959,7 +889,7 @@ fn render_const_scalar_inner<'db>(
                     continue;
                 };
                 let size = layout.size.bytes_usize();
-                render_const_scalar_ns(f, &b[offset..offset + size], memory_map, ty)?;
+                render_const_scalar(f, &b[offset..offset + size], memory_map, ty)?;
             }
             f.write_str(")")
         }
@@ -972,7 +902,7 @@ fn render_const_scalar_inner<'db>(
                 hir_def::AdtId::StructId(s) => {
                     let data = f.db.struct_signature(s);
                     write!(f, "{}", data.name.display(f.db, f.edition()))?;
-                    let field_types = f.db.field_types(s.into());
+                    let field_types = f.db.field_types_ns(s.into());
                     render_variant_after_name(
                         s.fields(f.db),
                         f,
@@ -1004,7 +934,7 @@ fn render_const_scalar_inner<'db>(
                             .1
                             .display(f.db, f.edition())
                     )?;
-                    let field_types = f.db.field_types(var_id.into());
+                    let field_types = f.db.field_types_ns(var_id.into());
                     render_variant_after_name(
                         var_id.fields(f.db),
                         f,
@@ -1041,7 +971,7 @@ fn render_const_scalar_inner<'db>(
                     f.write_str(", ")?;
                 }
                 let offset = size_one * i;
-                render_const_scalar_ns(f, &b[offset..offset + size_one], memory_map, ty)?;
+                render_const_scalar(f, &b[offset..offset + size_one], memory_map, ty)?;
             }
             f.write_str("]")
         }
@@ -1067,28 +997,24 @@ fn render_const_scalar_inner<'db>(
 
 fn render_variant_after_name<'db>(
     data: &VariantFields,
-    f: &mut HirFormatter<'_>,
-    field_types: &ArenaMap<LocalFieldId, Binders<Ty>>,
+    f: &mut HirFormatter<'_, 'db>,
+    field_types: &ArenaMap<LocalFieldId, EarlyBinder<'db, Ty<'db>>>,
     trait_env: Arc<TraitEnvironment<'db>>,
     layout: &Layout,
-    args: GenericArgs<'_>,
+    args: GenericArgs<'db>,
     b: &[u8],
-    memory_map: &MemoryMap<'_>,
+    memory_map: &MemoryMap<'db>,
 ) -> Result<(), HirDisplayError> {
-    let interner = DbInterner::new_with(f.db, Some(trait_env.krate), trait_env.block);
     match data.shape {
         FieldsShape::Record | FieldsShape::Tuple => {
-            let render_field = |f: &mut HirFormatter<'_>, id: LocalFieldId| {
+            let render_field = |f: &mut HirFormatter<'_, 'db>, id: LocalFieldId| {
                 let offset = layout.fields.offset(u32::from(id.into_raw()) as usize).bytes_usize();
-                let ty = field_types[id]
-                    .clone()
-                    .substitute(Interner, &convert_args_for_result(interner, args.as_slice()));
-                let Ok(layout) = f.db.layout_of_ty(ty.to_nextsolver(interner), trait_env.clone())
-                else {
+                let ty = field_types[id].instantiate(f.interner, args);
+                let Ok(layout) = f.db.layout_of_ty(ty, trait_env.clone()) else {
                     return f.write_str("<layout-error>");
                 };
                 let size = layout.size.bytes_usize();
-                render_const_scalar(f, &b[offset..offset + size], memory_map, &ty)
+                render_const_scalar(f, &b[offset..offset + size], memory_map, ty)
             };
             let mut it = data.fields().iter();
             if matches!(data.shape, FieldsShape::Record) {
@@ -1120,33 +1046,17 @@ fn render_variant_after_name<'db>(
     }
 }
 
-impl HirDisplay for BoundVar {
-    fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
-        write!(f, "?{}.{}", self.debruijn.depth(), self.index)
-    }
-}
-
-impl HirDisplay for Ty {
+impl<'db> HirDisplay<'db> for Ty<'db> {
     fn hir_fmt(
         &self,
-        f @ &mut HirFormatter { db, .. }: &mut HirFormatter<'_>,
+        f @ &mut HirFormatter { db, .. }: &mut HirFormatter<'_, 'db>,
     ) -> Result<(), HirDisplayError> {
-        let ty = self.to_nextsolver(DbInterner::new_with(db, None, None));
-        ty.hir_fmt(f)
-    }
-}
-
-impl<'db> HirDisplay for crate::next_solver::Ty<'db> {
-    fn hir_fmt(
-        &self,
-        f @ &mut HirFormatter { db, .. }: &mut HirFormatter<'_>,
-    ) -> Result<(), HirDisplayError> {
-        let interner = DbInterner::new_with(db, None, None);
+        let interner = f.interner;
         if f.should_truncate() {
             return write!(f, "{TYPE_HINT_TRUNCATION}");
         }
 
-        use rustc_type_ir::TyKind;
+        use TyKind;
         match self.kind() {
             TyKind::Never => write!(f, "!")?,
             TyKind::Str => write!(f, "str")?,
@@ -1164,14 +1074,14 @@ impl<'db> HirDisplay for crate::next_solver::Ty<'db> {
                 write!(f, "[")?;
                 t.hir_fmt(f)?;
                 write!(f, "; ")?;
-                convert_const_for_result(interner, c).hir_fmt(f)?;
+                c.hir_fmt(f)?;
                 write!(f, "]")?;
             }
             kind @ (TyKind::RawPtr(t, m) | TyKind::Ref(_, t, m)) => {
                 if let TyKind::Ref(l, _, _) = kind {
                     f.write_char('&')?;
                     if f.render_region(l) {
-                        convert_region_for_result(interner, l).hir_fmt(f)?;
+                        l.hir_fmt(f)?;
                         f.write_char(' ')?;
                     }
                     match m {
@@ -1190,32 +1100,18 @@ impl<'db> HirDisplay for crate::next_solver::Ty<'db> {
                 }
 
                 // FIXME: all this just to decide whether to use parentheses...
-                let contains_impl_fn = |bounds: &[QuantifiedWhereClause]| {
-                    bounds.iter().any(|bound| {
-                        if let WhereClause::Implemented(trait_ref) = bound.skip_binders() {
-                            let trait_ = trait_ref.hir_trait_id();
-                            fn_traits(db, trait_).any(|it| it == trait_)
-                        } else {
-                            false
-                        }
-                    })
-                };
-                let contains_impl_fn_ns = |bounds: &[BoundExistentialPredicate<'_>]| {
-                    bounds.iter().any(|bound| match bound.skip_binder() {
-                        rustc_type_ir::ExistentialPredicate::Trait(trait_ref) => {
-                            let trait_ = trait_ref.def_id.0;
-                            fn_traits(db, trait_).any(|it| it == trait_)
-                        }
-                        _ => false,
-                    })
-                };
                 let (preds_to_print, has_impl_fn_pred) = match t.kind() {
                     TyKind::Dynamic(bounds, region) => {
+                        let contains_impl_fn =
+                            bounds.iter().any(|bound| match bound.skip_binder() {
+                                ExistentialPredicate::Trait(trait_ref) => {
+                                    let trait_ = trait_ref.def_id.0;
+                                    fn_traits(db, trait_).any(|it| it == trait_)
+                                }
+                                _ => false,
+                            });
                         let render_lifetime = f.render_region(region);
-                        (
-                            bounds.len() + render_lifetime as usize,
-                            contains_impl_fn_ns(bounds.as_slice()),
-                        )
+                        (bounds.len() + render_lifetime as usize, contains_impl_fn)
                     }
                     TyKind::Alias(AliasTyKind::Opaque, ty) => {
                         let opaque_ty_id = match ty.def_id {
@@ -1225,28 +1121,25 @@ impl<'db> HirDisplay for crate::next_solver::Ty<'db> {
                         let impl_trait_id = db.lookup_intern_impl_trait_id(opaque_ty_id);
                         if let ImplTraitId::ReturnTypeImplTrait(func, idx) = impl_trait_id {
                             let datas = db
-                                .return_type_impl_traits(func)
+                                .return_type_impl_traits_ns(func)
                                 .expect("impl trait id without data");
-                            let data =
-                                (*datas).as_ref().map(|rpit| rpit.impl_traits[idx].bounds.clone());
-                            let bounds = data.substitute(
-                                Interner,
-                                &convert_args_for_result(interner, ty.args.as_slice()),
-                            );
-                            let mut len = bounds.skip_binders().len();
+                            let data = (*datas).as_ref().map_bound(|rpit| {
+                                &rpit.impl_traits[idx.to_nextsolver(interner)].predicates
+                            });
+                            let bounds =
+                                || data.iter_instantiated_copied(f.interner, ty.args.as_slice());
+                            let mut len = bounds().count();
 
                             // Don't count Sized but count when it absent
                             // (i.e. when explicit ?Sized bound is set).
                             let default_sized = SizedByDefault::Sized { anchor: func.krate(db) };
-                            let sized_bounds = bounds
-                                .skip_binders()
-                                .iter()
+                            let sized_bounds = bounds()
                                 .filter(|b| {
                                     matches!(
-                                        b.skip_binders(),
-                                        WhereClause::Implemented(trait_ref)
+                                        b.kind().skip_binder(),
+                                        ClauseKind::Trait(trait_ref)
                                             if default_sized.is_sized_trait(
-                                                trait_ref.hir_trait_id(),
+                                                trait_ref.def_id().0,
                                                 db,
                                             ),
                                     )
@@ -1259,7 +1152,15 @@ impl<'db> HirDisplay for crate::next_solver::Ty<'db> {
                                 }
                             }
 
-                            (len, contains_impl_fn(bounds.skip_binders()))
+                            let contains_impl_fn = bounds().any(|bound| {
+                                if let ClauseKind::Trait(trait_ref) = bound.kind().skip_binder() {
+                                    let trait_ = trait_ref.def_id().0;
+                                    fn_traits(db, trait_).any(|it| it == trait_)
+                                } else {
+                                    false
+                                }
+                            });
+                            (len, contains_impl_fn)
                         } else {
                             (0, false)
                         }
@@ -1291,31 +1192,28 @@ impl<'db> HirDisplay for crate::next_solver::Ty<'db> {
                 }
             }
             TyKind::FnPtr(sig, header) => {
-                let sig = CallableSig::from_fn_sig_and_header(interner, sig, header);
+                let sig = sig.with(header);
                 sig.hir_fmt(f)?;
             }
             TyKind::FnDef(def, args) => {
                 let def = def.0;
-                let sig = db
-                    .callable_item_signature(def)
-                    .instantiate(interner, args)
-                    .skip_binder()
-                    .to_chalk(interner);
+                let sig = db.callable_item_signature(def).instantiate(interner, args);
 
                 if f.display_kind.is_source_code() {
                     // `FnDef` is anonymous and there's no surface syntax for it. Show it as a
                     // function pointer type.
                     return sig.hir_fmt(f);
                 }
-                if let Safety::Unsafe = sig.safety {
+                if let Safety::Unsafe = sig.safety() {
                     write!(f, "unsafe ")?;
                 }
-                if !matches!(sig.abi, FnAbi::Rust | FnAbi::RustCall) {
+                if !matches!(sig.abi(), FnAbi::Rust | FnAbi::RustCall) {
                     f.write_str("extern \"")?;
-                    f.write_str(sig.abi.as_str())?;
+                    f.write_str(sig.abi().as_str())?;
                     f.write_str("\" ")?;
                 }
 
+                let sig = sig.skip_binder();
                 write!(f, "fn ")?;
                 f.start_location_link(def.into());
                 match def {
@@ -1338,13 +1236,12 @@ impl<'db> HirDisplay for crate::next_solver::Ty<'db> {
                 };
                 f.end_location_link();
 
-                let parameters = convert_args_for_result(interner, args.as_slice());
-                if parameters.len(Interner) > 0 {
+                if args.len() > 0 {
                     let generic_def_id = GenericDefId::from_callable(db, def);
                     let generics = generics(db, generic_def_id);
                     let (parent_len, self_param, type_, const_, impl_, lifetime) =
                         generics.provenance_split();
-                    let parameters = parameters.as_slice(Interner);
+                    let parameters = args.as_slice();
                     debug_assert_eq!(
                         parameters.len(),
                         parent_len + self_param as usize + type_ + const_ + impl_ + lifetime
@@ -1389,9 +1286,9 @@ impl<'db> HirDisplay for crate::next_solver::Ty<'db> {
                     }
                 }
                 write!(f, "(")?;
-                f.write_joined(sig.params(), ", ")?;
+                f.write_joined(sig.inputs(), ", ")?;
                 write!(f, ")")?;
-                let ret = sig.ret();
+                let ret = sig.output();
                 if !ret.is_unit() {
                     write!(f, " -> ")?;
                     ret.hir_fmt(f)?;
@@ -1434,27 +1331,9 @@ impl<'db> HirDisplay for crate::next_solver::Ty<'db> {
                 }
                 f.end_location_link();
 
-                hir_fmt_generics(
-                    f,
-                    convert_args_for_result(interner, parameters.as_slice()).as_slice(Interner),
-                    Some(def.def_id().0.into()),
-                    None,
-                )?;
-            }
-            TyKind::Alias(AliasTyKind::Projection, alias_ty) => {
-                let type_alias = match alias_ty.def_id {
-                    SolverDefId::TypeAliasId(id) => id,
-                    _ => unreachable!(),
-                };
-                let parameters = convert_args_for_result(interner, alias_ty.args.as_slice());
-
-                let projection_ty = ProjectionTy {
-                    associated_ty_id: to_assoc_type_id(type_alias),
-                    substitution: parameters.clone(),
-                };
-
-                projection_ty.hir_fmt(f)?;
+                hir_fmt_generics(f, parameters.as_slice(), Some(def.def_id().0.into()), None)?;
             }
+            TyKind::Alias(AliasTyKind::Projection, alias_ty) => write_projection(f, &alias_ty)?,
             TyKind::Foreign(alias) => {
                 let type_alias = db.type_alias_signature(alias.0);
                 f.start_location_link(alias.0.into());
@@ -1466,7 +1345,6 @@ impl<'db> HirDisplay for crate::next_solver::Ty<'db> {
                     SolverDefId::InternedOpaqueTyId(id) => id,
                     _ => unreachable!(),
                 };
-                let parameters = convert_args_for_result(interner, alias_ty.args.as_slice());
                 if !f.display_kind.allows_opaque() {
                     return Err(HirDisplayError::DisplaySourceCodeError(
                         DisplaySourceCodeError::OpaqueType,
@@ -1475,32 +1353,41 @@ impl<'db> HirDisplay for crate::next_solver::Ty<'db> {
                 let impl_trait_id = db.lookup_intern_impl_trait_id(opaque_ty_id);
                 match impl_trait_id {
                     ImplTraitId::ReturnTypeImplTrait(func, idx) => {
-                        let datas =
-                            db.return_type_impl_traits(func).expect("impl trait id without data");
-                        let data =
-                            (*datas).as_ref().map(|rpit| rpit.impl_traits[idx].bounds.clone());
-                        let bounds = data.substitute(Interner, &parameters);
+                        let datas = db
+                            .return_type_impl_traits_ns(func)
+                            .expect("impl trait id without data");
+                        let data = (*datas).as_ref().map_bound(|rpit| {
+                            &rpit.impl_traits[idx.to_nextsolver(interner)].predicates
+                        });
+                        let bounds = data
+                            .iter_instantiated_copied(interner, alias_ty.args.as_slice())
+                            .collect::<Vec<_>>();
                         let krate = func.krate(db);
                         write_bounds_like_dyn_trait_with_prefix(
                             f,
                             "impl",
-                            Either::Left(&convert_ty_for_result(interner, *self)),
-                            bounds.skip_binders(),
+                            Either::Left(*self),
+                            &bounds,
                             SizedByDefault::Sized { anchor: krate },
                         )?;
                         // FIXME: it would maybe be good to distinguish this from the alias type (when debug printing), and to show the substitution
                     }
                     ImplTraitId::TypeAliasImplTrait(alias, idx) => {
-                        let datas =
-                            db.type_alias_impl_traits(alias).expect("impl trait id without data");
-                        let data = (*datas).as_ref().map(|it| it.impl_traits[idx].bounds.clone());
-                        let bounds = data.substitute(Interner, &parameters);
+                        let datas = db
+                            .type_alias_impl_traits_ns(alias)
+                            .expect("impl trait id without data");
+                        let data = (*datas).as_ref().map_bound(|rpit| {
+                            &rpit.impl_traits[idx.to_nextsolver(interner)].predicates
+                        });
+                        let bounds = data
+                            .iter_instantiated_copied(interner, alias_ty.args.as_slice())
+                            .collect::<Vec<_>>();
                         let krate = alias.krate(db);
                         write_bounds_like_dyn_trait_with_prefix(
                             f,
                             "impl",
-                            Either::Left(&convert_ty_for_result(interner, *self)),
-                            bounds.skip_binders(),
+                            Either::Left(*self),
+                            &bounds,
                             SizedByDefault::Sized { anchor: krate },
                         )?;
                     }
@@ -1528,14 +1415,13 @@ impl<'db> HirDisplay for crate::next_solver::Ty<'db> {
                             f.end_location_link();
                         }
                         write!(f, " = ")?;
-                        parameters.at(Interner, 0).hir_fmt(f)?;
+                        alias_ty.args.type_at(0).hir_fmt(f)?;
                         write!(f, ">")?;
                     }
                 }
             }
             TyKind::Closure(id, substs) => {
                 let id = id.0;
-                let substs = convert_args_for_result(interner, substs.as_slice());
                 if f.display_kind.is_source_code() {
                     if !f.display_kind.allows_opaque() {
                         return Err(HirDisplayError::DisplaySourceCodeError(
@@ -1556,12 +1442,16 @@ impl<'db> HirDisplay for crate::next_solver::Ty<'db> {
                     }
                     ClosureStyle::ClosureWithSubst => {
                         write!(f, "{{closure#{:?}}}", salsa::plumbing::AsId::as_id(&id).index())?;
-                        return hir_fmt_generics(f, substs.as_slice(Interner), None, None);
+                        return hir_fmt_generics(f, substs.as_slice(), None, None);
                     }
                     _ => (),
                 }
-                let sig = ClosureSubst(&substs).sig_ty(db).callable_sig(db);
+                let sig = substs
+                    .split_closure_args_untupled()
+                    .closure_sig_as_fn_ptr_ty
+                    .callable_sig(interner);
                 if let Some(sig) = sig {
+                    let sig = sig.skip_binder();
                     let InternedClosure(def, _) = db.lookup_intern_closure(id);
                     let infer = db.infer(def);
                     let (_, kind) = infer.closure_info(id);
@@ -1570,22 +1460,22 @@ impl<'db> HirDisplay for crate::next_solver::Ty<'db> {
                         ClosureStyle::RANotation => write!(f, "|")?,
                         _ => unreachable!(),
                     }
-                    if sig.params().is_empty() {
+                    if sig.inputs().is_empty() {
                     } else if f.should_truncate() {
                         write!(f, "{TYPE_HINT_TRUNCATION}")?;
                     } else {
-                        f.write_joined(sig.params(), ", ")?;
+                        f.write_joined(sig.inputs(), ", ")?;
                     };
                     match f.closure_style {
                         ClosureStyle::ImplFn => write!(f, ")")?,
                         ClosureStyle::RANotation => write!(f, "|")?,
                         _ => unreachable!(),
                     }
-                    if f.closure_style == ClosureStyle::RANotation || !sig.ret().is_unit() {
+                    if f.closure_style == ClosureStyle::RANotation || !sig.output().is_unit() {
                         write!(f, " -> ")?;
                         // FIXME: We display `AsyncFn` as `-> impl Future`, but this is hard to fix because
                         // we don't have a trait environment here, required to normalize `<Ret as Future>::Output`.
-                        sig.ret().hir_fmt(f)?;
+                        sig.output().hir_fmt(f)?;
                     }
                 } else {
                     write!(f, "{{closure}}")?;
@@ -1593,6 +1483,8 @@ impl<'db> HirDisplay for crate::next_solver::Ty<'db> {
             }
             TyKind::Placeholder(_) => write!(f, "{{placeholder}}")?,
             TyKind::Param(param) => {
+                // FIXME: We should not access `param.id`, it should be removed, and we should know the
+                // parent from the formatted type.
                 let generics = generics(db, param.id.parent());
                 let param_data = &generics[param.id.local_id()];
                 match param_data {
@@ -1608,35 +1500,23 @@ impl<'db> HirDisplay for crate::next_solver::Ty<'db> {
                             )?
                         }
                         TypeParamProvenance::ArgumentImplTrait => {
-                            let substs = generics.placeholder_subst(db);
                             let bounds = db
-                                .generic_predicates(param.id.parent())
-                                .iter()
-                                .map(|pred| pred.clone().substitute(Interner, &substs))
-                                .filter(|wc| match wc.skip_binders() {
-                                    WhereClause::Implemented(tr) => {
-                                        tr.self_type_parameter(Interner)
-                                            == convert_ty_for_result(interner, *self)
-                                    }
-                                    WhereClause::AliasEq(AliasEq {
-                                        alias: AliasTy::Projection(proj),
-                                        ty: _,
-                                    }) => {
-                                        proj.self_type_parameter(db)
-                                            == convert_ty_for_result(interner, *self)
-                                    }
-                                    WhereClause::AliasEq(_) => false,
-                                    WhereClause::TypeOutlives(to) => {
-                                        to.ty == convert_ty_for_result(interner, *self)
-                                    }
-                                    WhereClause::LifetimeOutlives(_) => false,
+                                .generic_predicates_ns(param.id.parent())
+                                .instantiate_identity()
+                                .into_iter()
+                                .flatten()
+                                .filter(|wc| match wc.kind().skip_binder() {
+                                    ClauseKind::Trait(tr) => tr.self_ty() == *self,
+                                    ClauseKind::Projection(proj) => proj.self_ty() == *self,
+                                    ClauseKind::TypeOutlives(to) => to.0 == *self,
+                                    _ => false,
                                 })
                                 .collect::<Vec<_>>();
                             let krate = param.id.parent().module(db).krate();
                             write_bounds_like_dyn_trait_with_prefix(
                                 f,
                                 "impl",
-                                Either::Left(&convert_ty_for_result(interner, *self)),
+                                Either::Left(*self),
                                 &bounds,
                                 SizedByDefault::Sized { anchor: krate },
                             )?;
@@ -1647,42 +1527,34 @@ impl<'db> HirDisplay for crate::next_solver::Ty<'db> {
                     }
                 }
             }
-            TyKind::Bound(debruijn_index, ty) => {
-                let idx = chalk_ir::BoundVar {
-                    debruijn: chalk_ir::DebruijnIndex::new(debruijn_index.as_u32()),
-                    index: ty.var.as_usize(),
-                };
-                idx.hir_fmt(f)?
-            }
-            TyKind::Dynamic(..) => {
-                let ty = convert_ty_for_result(interner, *self);
-                let chalk_ir::TyKind::Dyn(dyn_ty) = ty.kind(Interner) else { unreachable!() };
-                // Reorder bounds to satisfy `write_bounds_like_dyn_trait()`'s expectation.
-                // FIXME: `Iterator::partition_in_place()` or `Vec::extract_if()` may make it
-                // more efficient when either of them hits stable.
-                let mut bounds: SmallVec<[_; 4]> =
-                    dyn_ty.bounds.skip_binders().iter(Interner).cloned().collect();
-                let (auto_traits, others): (SmallVec<[_; 4]>, _) =
-                    bounds.drain(1..).partition(|b| b.skip_binders().trait_id().is_some());
-                bounds.extend(others);
-                bounds.extend(auto_traits);
-
-                if f.render_lifetime(&dyn_ty.lifetime) {
-                    // we skip the binders in `write_bounds_like_dyn_trait_with_prefix`
-                    bounds.push(Binders::empty(
-                        Interner,
-                        chalk_ir::WhereClause::TypeOutlives(chalk_ir::TypeOutlives {
-                            ty: ty.clone(),
-                            lifetime: dyn_ty.lifetime.clone(),
-                        }),
-                    ));
+            TyKind::Bound(debruijn, ty) => {
+                write!(f, "?{}.{}", debruijn.as_usize(), ty.var.as_usize())?
+            }
+            TyKind::Dynamic(bounds, region) => {
+                // We want to put auto traits after principal traits, regardless of their written order.
+                let mut bounds_to_display = SmallVec::<[_; 4]>::new();
+                let mut auto_trait_bounds = SmallVec::<[_; 4]>::new();
+                for bound in bounds.iter() {
+                    let clause = bound.with_self_ty(interner, *self);
+                    match bound.skip_binder() {
+                        ExistentialPredicate::Trait(_) | ExistentialPredicate::Projection(_) => {
+                            bounds_to_display.push(clause);
+                        }
+                        ExistentialPredicate::AutoTrait(_) => auto_trait_bounds.push(clause),
+                    }
+                }
+                bounds_to_display.append(&mut auto_trait_bounds);
+
+                if f.render_region(region) {
+                    bounds_to_display
+                        .push(rustc_type_ir::OutlivesPredicate(*self, region).upcast(interner));
                 }
 
                 write_bounds_like_dyn_trait_with_prefix(
                     f,
                     "dyn",
-                    Either::Left(&ty),
-                    &bounds,
+                    Either::Left(*self),
+                    &bounds_to_display,
                     SizedByDefault::NotSized,
                 )?;
             }
@@ -1722,11 +1594,11 @@ impl<'db> HirDisplay for crate::next_solver::Ty<'db> {
     }
 }
 
-fn hir_fmt_generics(
-    f: &mut HirFormatter<'_>,
-    parameters: &[GenericArg],
+fn hir_fmt_generics<'db>(
+    f: &mut HirFormatter<'_, 'db>,
+    parameters: &[GenericArg<'db>],
     generic_def: Option<hir_def::GenericDefId>,
-    self_: Option<&Ty>,
+    self_: Option<Ty<'db>>,
 ) -> Result<(), HirDisplayError> {
     if parameters.is_empty() {
         return Ok(());
@@ -1743,70 +1615,23 @@ fn hir_fmt_generics(
     Ok(())
 }
 
-fn hir_fmt_generics_ns<'db>(
-    f: &mut HirFormatter<'_>,
-    parameters: &[crate::next_solver::GenericArg<'db>],
+fn generic_args_sans_defaults<'ga, 'db>(
+    f: &mut HirFormatter<'_, 'db>,
     generic_def: Option<hir_def::GenericDefId>,
-    self_: Option<crate::next_solver::Ty<'db>>,
-) -> Result<(), HirDisplayError> {
-    if parameters.is_empty() {
-        return Ok(());
-    }
-
-    let parameters_to_write = generic_args_sans_defaults_ns(f, generic_def, parameters);
-
-    if !parameters_to_write.is_empty() {
-        write!(f, "<")?;
-        hir_fmt_generic_arguments_ns(f, parameters_to_write, self_)?;
-        write!(f, ">")?;
-    }
-
-    Ok(())
-}
-
-fn generic_args_sans_defaults<'ga>(
-    f: &mut HirFormatter<'_>,
-    generic_def: Option<hir_def::GenericDefId>,
-    parameters: &'ga [GenericArg],
-) -> &'ga [GenericArg] {
+    parameters: &'ga [GenericArg<'db>],
+) -> &'ga [GenericArg<'db>] {
     if f.display_kind.is_source_code() || f.omit_verbose_types() {
-        match generic_def
-            .map(|generic_def_id| f.db.generic_defaults(generic_def_id))
-            .filter(|it| !it.is_empty())
-        {
+        match generic_def.map(|generic_def_id| f.db.generic_defaults_ns(generic_def_id)) {
             None => parameters,
             Some(default_parameters) => {
-                let should_show = |arg: &GenericArg, i: usize| {
-                    let is_err = |arg: &GenericArg| match arg.data(Interner) {
-                        chalk_ir::GenericArgData::Lifetime(it) => {
-                            *it.data(Interner) == LifetimeData::Error
-                        }
-                        chalk_ir::GenericArgData::Ty(it) => *it.kind(Interner) == TyKind::Error,
-                        chalk_ir::GenericArgData::Const(it) => matches!(
-                            it.data(Interner).value,
-                            ConstValue::Concrete(ConcreteConst {
-                                interned: ConstScalar::Unknown,
-                                ..
-                            })
-                        ),
-                    };
-                    // if the arg is error like, render it to inform the user
-                    if is_err(arg) {
-                        return true;
-                    }
-                    // otherwise, if the arg is equal to the param default, hide it (unless the
-                    // default is an error which can happen for the trait Self type)
-                    match default_parameters.get(i) {
-                        None => true,
-                        Some(default_parameter) => {
-                            // !is_err(default_parameter.skip_binders())
-                            // &&
-                            arg != &default_parameter.clone().substitute(Interner, &parameters[..i])
-                        }
+                let should_show = |arg: GenericArg<'db>, i: usize| match default_parameters.get(i) {
+                    None => true,
+                    Some(default_parameter) => {
+                        arg != default_parameter.instantiate(f.interner, &parameters[..i])
                     }
                 };
                 let mut default_from = 0;
-                for (i, parameter) in parameters.iter().enumerate() {
+                for (i, &parameter) in parameters.iter().enumerate() {
                     if should_show(parameter, i) {
                         default_from = i + 1;
                     }
@@ -1820,93 +1645,33 @@ fn generic_args_sans_defaults<'ga>(
 }
 
 fn hir_fmt_generic_args<'db>(
-    f: &mut HirFormatter<'_>,
-    parameters: &[crate::next_solver::GenericArg<'db>],
+    f: &mut HirFormatter<'_, 'db>,
+    parameters: &[GenericArg<'db>],
     generic_def: Option<hir_def::GenericDefId>,
-    self_: Option<crate::next_solver::Ty<'db>>,
+    self_: Option<Ty<'db>>,
 ) -> Result<(), HirDisplayError> {
     if parameters.is_empty() {
         return Ok(());
     }
 
-    let parameters_to_write = generic_args_sans_defaults_ns(f, generic_def, parameters);
+    let parameters_to_write = generic_args_sans_defaults(f, generic_def, parameters);
 
     if !parameters_to_write.is_empty() {
         write!(f, "<")?;
-        hir_fmt_generic_arguments_ns(f, parameters_to_write, self_)?;
+        hir_fmt_generic_arguments(f, parameters_to_write, self_)?;
         write!(f, ">")?;
     }
 
     Ok(())
 }
 
-fn generic_args_sans_defaults_ns<'ga, 'db>(
-    f: &mut HirFormatter<'_>,
-    generic_def: Option<hir_def::GenericDefId>,
-    parameters: &'ga [crate::next_solver::GenericArg<'db>],
-) -> &'ga [crate::next_solver::GenericArg<'db>] {
-    let interner = DbInterner::new_with(f.db, Some(f.krate()), None);
-    if f.display_kind.is_source_code() || f.omit_verbose_types() {
-        match generic_def
-            .map(|generic_def_id| f.db.generic_defaults(generic_def_id))
-            .filter(|it| !it.is_empty())
-        {
-            None => parameters,
-            Some(default_parameters) => {
-                let should_show = |arg: &crate::next_solver::GenericArg<'db>, i: usize| {
-                    let is_err = |arg: &crate::next_solver::GenericArg<'db>| match arg.kind() {
-                        rustc_type_ir::GenericArgKind::Lifetime(it) => {
-                            matches!(it.kind(), RegionKind::ReError(..))
-                        }
-                        rustc_type_ir::GenericArgKind::Type(it) => {
-                            matches!(it.kind(), rustc_type_ir::TyKind::Error(..))
-                        }
-                        rustc_type_ir::GenericArgKind::Const(it) => {
-                            matches!(it.kind(), rustc_type_ir::ConstKind::Error(..),)
-                        }
-                    };
-                    // if the arg is error like, render it to inform the user
-                    if is_err(arg) {
-                        return true;
-                    }
-                    // otherwise, if the arg is equal to the param default, hide it (unless the
-                    // default is an error which can happen for the trait Self type)
-                    match default_parameters.get(i) {
-                        None => true,
-                        Some(default_parameter) => {
-                            // !is_err(default_parameter.skip_binders())
-                            // &&
-                            arg != &default_parameter
-                                .clone()
-                                .substitute(
-                                    Interner,
-                                    &convert_args_for_result(interner, &parameters[..i]),
-                                )
-                                .to_nextsolver(interner)
-                        }
-                    }
-                };
-                let mut default_from = 0;
-                for (i, parameter) in parameters.iter().enumerate() {
-                    if should_show(parameter, i) {
-                        default_from = i + 1;
-                    }
-                }
-                &parameters[0..default_from]
-            }
-        }
-    } else {
-        parameters
-    }
-}
-
-fn hir_fmt_generic_arguments(
-    f: &mut HirFormatter<'_>,
-    parameters: &[GenericArg],
-    self_: Option<&Ty>,
+fn hir_fmt_generic_arguments<'db>(
+    f: &mut HirFormatter<'_, 'db>,
+    parameters: &[GenericArg<'db>],
+    self_: Option<Ty<'db>>,
 ) -> Result<(), HirDisplayError> {
     let mut first = true;
-    let lifetime_offset = parameters.iter().position(|arg| arg.lifetime(Interner).is_some());
+    let lifetime_offset = parameters.iter().position(|arg| arg.region().is_some());
 
     let (ty_or_const, lifetimes) = match lifetime_offset {
         Some(offset) => parameters.split_at(offset),
@@ -1917,40 +1682,35 @@ fn hir_fmt_generic_arguments(
             write!(f, ", ")?;
         }
         match self_ {
-            self_ @ Some(_) if generic_arg.ty(Interner) == self_ => write!(f, "Self")?,
+            self_ @ Some(_) if generic_arg.ty() == self_ => write!(f, "Self")?,
             _ => generic_arg.hir_fmt(f)?,
         }
     }
     Ok(())
 }
 
-fn hir_fmt_generic_arguments_ns<'db>(
-    f: &mut HirFormatter<'_>,
-    parameters: &[crate::next_solver::GenericArg<'db>],
-    self_: Option<crate::next_solver::Ty<'db>>,
+fn hir_fmt_tys<'db>(
+    f: &mut HirFormatter<'_, 'db>,
+    tys: &[Ty<'db>],
+    self_: Option<Ty<'db>>,
 ) -> Result<(), HirDisplayError> {
     let mut first = true;
-    let lifetime_offset = parameters.iter().position(|arg| arg.region().is_some());
 
-    let (ty_or_const, lifetimes) = match lifetime_offset {
-        Some(offset) => parameters.split_at(offset),
-        None => (parameters, &[][..]),
-    };
-    for generic_arg in lifetimes.iter().chain(ty_or_const) {
+    for ty in tys {
         if !mem::take(&mut first) {
             write!(f, ", ")?;
         }
         match self_ {
-            self_ @ Some(_) if generic_arg.ty() == self_ => write!(f, "Self")?,
-            _ => generic_arg.hir_fmt(f)?,
+            Some(self_) if *ty == self_ => write!(f, "Self")?,
+            _ => ty.hir_fmt(f)?,
         }
     }
     Ok(())
 }
 
-impl HirDisplay for CallableSig {
-    fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
-        let CallableSig { params_and_return: _, is_varargs, safety, abi: _ } = *self;
+impl<'db> HirDisplay<'db> for PolyFnSig<'db> {
+    fn hir_fmt(&self, f: &mut HirFormatter<'_, 'db>) -> Result<(), HirDisplayError> {
+        let FnSig { inputs_and_output, c_variadic, safety, abi: _ } = self.skip_binder();
         if let Safety::Unsafe = safety {
             write!(f, "unsafe ")?;
         }
@@ -1961,16 +1721,16 @@ impl HirDisplay for CallableSig {
         //     f.write_str("\" ")?;
         // }
         write!(f, "fn(")?;
-        f.write_joined(self.params(), ", ")?;
-        if is_varargs {
-            if self.params().is_empty() {
+        f.write_joined(inputs_and_output.inputs(), ", ")?;
+        if c_variadic {
+            if inputs_and_output.inputs().is_empty() {
                 write!(f, "...")?;
             } else {
                 write!(f, ", ...")?;
             }
         }
         write!(f, ")")?;
-        let ret = self.ret();
+        let ret = inputs_and_output.output();
         if !ret.is_unit() {
             write!(f, " -> ")?;
             ret.hir_fmt(f)?;
@@ -1979,6 +1739,15 @@ impl HirDisplay for CallableSig {
     }
 }
 
+impl<'db> HirDisplay<'db> for Term<'db> {
+    fn hir_fmt(&self, f: &mut HirFormatter<'_, 'db>) -> Result<(), HirDisplayError> {
+        match self {
+            Term::Ty(it) => it.hir_fmt(f),
+            Term::Const(it) => it.hir_fmt(f),
+        }
+    }
+}
+
 fn fn_traits(db: &dyn DefDatabase, trait_: TraitId) -> impl Iterator<Item = TraitId> + '_ {
     let krate = trait_.lookup(db).container.krate();
     utils::fn_traits(db, krate)
@@ -2002,11 +1771,11 @@ impl SizedByDefault {
     }
 }
 
-pub fn write_bounds_like_dyn_trait_with_prefix(
-    f: &mut HirFormatter<'_>,
+pub fn write_bounds_like_dyn_trait_with_prefix<'db>(
+    f: &mut HirFormatter<'_, 'db>,
     prefix: &str,
-    this: Either<&Ty, &Lifetime>,
-    predicates: &[QuantifiedWhereClause],
+    this: Either<Ty<'db>, Region<'db>>,
+    predicates: &[Clause<'db>],
     default_sized: SizedByDefault,
 ) -> Result<(), HirDisplayError> {
     write!(f, "{prefix}")?;
@@ -2020,10 +1789,10 @@ pub fn write_bounds_like_dyn_trait_with_prefix(
     }
 }
 
-fn write_bounds_like_dyn_trait(
-    f: &mut HirFormatter<'_>,
-    this: Either<&Ty, &Lifetime>,
-    predicates: &[QuantifiedWhereClause],
+fn write_bounds_like_dyn_trait<'db>(
+    f: &mut HirFormatter<'_, 'db>,
+    this: Either<Ty<'db>, Region<'db>>,
+    predicates: &[Clause<'db>],
     default_sized: SizedByDefault,
 ) -> Result<(), HirDisplayError> {
     // Note: This code is written to produce nice results (i.e.
@@ -2036,10 +1805,10 @@ fn write_bounds_like_dyn_trait(
     let mut angle_open = false;
     let mut is_fn_trait = false;
     let mut is_sized = false;
-    for p in predicates.iter() {
-        match p.skip_binders() {
-            WhereClause::Implemented(trait_ref) => {
-                let trait_ = trait_ref.hir_trait_id();
+    for p in predicates {
+        match p.kind().skip_binder() {
+            ClauseKind::Trait(trait_ref) => {
+                let trait_ = trait_ref.def_id().0;
                 if default_sized.is_sized_trait(trait_, f.db) {
                     is_sized = true;
                     if matches!(default_sized, SizedByDefault::Sized { .. }) {
@@ -2064,31 +1833,30 @@ fn write_bounds_like_dyn_trait(
                 write!(f, "{}", f.db.trait_signature(trait_).name.display(f.db, f.edition()))?;
                 f.end_location_link();
                 if is_fn_trait {
-                    if let [self_, params @ ..] = trait_ref.substitution.as_slice(Interner)
-                        && let Some(args) =
-                            params.first().and_then(|it| it.assert_ty_ref(Interner).as_tuple())
+                    if let [_self, params @ ..] = trait_ref.trait_ref.args.as_slice()
+                        && let Some(args) = params.first().and_then(|it| it.ty()?.as_tuple())
                     {
                         write!(f, "(")?;
-                        hir_fmt_generic_arguments(f, args.as_slice(Interner), self_.ty(Interner))?;
+                        hir_fmt_tys(f, args.as_slice(), Some(trait_ref.trait_ref.self_ty()))?;
                         write!(f, ")")?;
                     }
                 } else {
                     let params = generic_args_sans_defaults(
                         f,
                         Some(trait_.into()),
-                        trait_ref.substitution.as_slice(Interner),
+                        trait_ref.trait_ref.args.as_slice(),
                     );
-                    if let [self_, params @ ..] = params
+                    if let [_self, params @ ..] = params
                         && !params.is_empty()
                     {
                         write!(f, "<")?;
-                        hir_fmt_generic_arguments(f, params, self_.ty(Interner))?;
+                        hir_fmt_generic_arguments(f, params, Some(trait_ref.trait_ref.self_ty()))?;
                         // there might be assoc type bindings, so we leave the angle brackets open
                         angle_open = true;
                     }
                 }
             }
-            WhereClause::TypeOutlives(to) if Either::Left(&to.ty) == this => {
+            ClauseKind::TypeOutlives(to) if Either::Left(to.0) == this => {
                 if !is_fn_trait && angle_open {
                     write!(f, ">")?;
                     angle_open = false;
@@ -2096,10 +1864,9 @@ fn write_bounds_like_dyn_trait(
                 if !first {
                     write!(f, " + ")?;
                 }
-                to.lifetime.hir_fmt(f)?;
+                to.1.hir_fmt(f)?;
             }
-            WhereClause::TypeOutlives(_) => {}
-            WhereClause::LifetimeOutlives(lo) if Either::Right(&lo.a) == this => {
+            ClauseKind::RegionOutlives(lo) if Either::Right(lo.0) == this => {
                 if !is_fn_trait && angle_open {
                     write!(f, ">")?;
                     angle_open = false;
@@ -2107,17 +1874,16 @@ fn write_bounds_like_dyn_trait(
                 if !first {
                     write!(f, " + ")?;
                 }
-                lo.b.hir_fmt(f)?;
+                lo.1.hir_fmt(f)?;
             }
-            WhereClause::LifetimeOutlives(_) => {}
-            WhereClause::AliasEq(alias_eq) if is_fn_trait => {
+            ClauseKind::Projection(projection) if is_fn_trait => {
                 is_fn_trait = false;
-                if !alias_eq.ty.is_unit() {
+                if !projection.term.as_type().is_some_and(|it| it.is_unit()) {
                     write!(f, " -> ")?;
-                    alias_eq.ty.hir_fmt(f)?;
+                    projection.term.hir_fmt(f)?;
                 }
             }
-            WhereClause::AliasEq(AliasEq { ty, alias }) => {
+            ClauseKind::Projection(projection) => {
                 // in types in actual Rust, these will always come
                 // after the corresponding Implemented predicate
                 if angle_open {
@@ -2126,28 +1892,22 @@ fn write_bounds_like_dyn_trait(
                     write!(f, "<")?;
                     angle_open = true;
                 }
-                if let AliasTy::Projection(proj) = alias {
-                    let assoc_ty_id = from_assoc_type_id(proj.associated_ty_id);
-                    let type_alias = f.db.type_alias_signature(assoc_ty_id);
-                    f.start_location_link(assoc_ty_id.into());
-                    write!(f, "{}", type_alias.name.display(f.db, f.edition()))?;
-                    f.end_location_link();
-
-                    let proj_arg_count = generics(f.db, assoc_ty_id.into()).len_self();
-                    let parent_len = proj.substitution.len(Interner) - proj_arg_count;
-                    if proj_arg_count > 0 {
-                        write!(f, "<")?;
-                        hir_fmt_generic_arguments(
-                            f,
-                            &proj.substitution.as_slice(Interner)[parent_len..],
-                            None,
-                        )?;
-                        write!(f, ">")?;
-                    }
-                    write!(f, " = ")?;
+                let assoc_ty_id = projection.def_id().expect_type_alias();
+                let type_alias = f.db.type_alias_signature(assoc_ty_id);
+                f.start_location_link(assoc_ty_id.into());
+                write!(f, "{}", type_alias.name.display(f.db, f.edition()))?;
+                f.end_location_link();
+
+                let own_args = projection.projection_term.own_args(f.interner);
+                if !own_args.is_empty() {
+                    write!(f, "<")?;
+                    hir_fmt_generic_arguments(f, own_args.as_slice(), None)?;
+                    write!(f, ">")?;
                 }
-                ty.hir_fmt(f)?;
+                write!(f, " = ")?;
+                projection.term.hir_fmt(f)?;
             }
+            _ => {}
         }
         first = false;
     }
@@ -2177,154 +1937,49 @@ fn write_bounds_like_dyn_trait(
     Ok(())
 }
 
-impl HirDisplay for TraitRef {
-    fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
-        let trait_ = self.hir_trait_id();
-        f.start_location_link(trait_.into());
-        write!(f, "{}", f.db.trait_signature(trait_).name.display(f.db, f.edition()))?;
-        f.end_location_link();
-        let substs = self.substitution.as_slice(Interner);
-        hir_fmt_generics(f, &substs[1..], None, substs[0].ty(Interner))
-    }
-}
-
-impl<'db> HirDisplay for crate::next_solver::TraitRef<'db> {
-    fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
+impl<'db> HirDisplay<'db> for TraitRef<'db> {
+    fn hir_fmt(&self, f: &mut HirFormatter<'_, 'db>) -> Result<(), HirDisplayError> {
         let trait_ = self.def_id.0;
         f.start_location_link(trait_.into());
         write!(f, "{}", f.db.trait_signature(trait_).name.display(f.db, f.edition()))?;
         f.end_location_link();
         let substs = self.args.as_slice();
-        hir_fmt_generic_args(f, &substs[1..], None, substs[0].ty())
-    }
-}
-
-impl HirDisplay for WhereClause {
-    fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
-        if f.should_truncate() {
-            return write!(f, "{TYPE_HINT_TRUNCATION}");
-        }
-
-        match self {
-            WhereClause::Implemented(trait_ref) => {
-                trait_ref.self_type_parameter(Interner).hir_fmt(f)?;
-                write!(f, ": ")?;
-                trait_ref.hir_fmt(f)?;
-            }
-            WhereClause::AliasEq(AliasEq { alias: AliasTy::Projection(projection_ty), ty }) => {
-                write!(f, "<")?;
-                let trait_ref = &projection_ty.trait_ref(f.db);
-                trait_ref.self_type_parameter(Interner).hir_fmt(f)?;
-                write!(f, " as ")?;
-                trait_ref.hir_fmt(f)?;
-                write!(f, ">::",)?;
-                let type_alias = from_assoc_type_id(projection_ty.associated_ty_id);
-                f.start_location_link(type_alias.into());
-                write!(
-                    f,
-                    "{}",
-                    f.db.type_alias_signature(type_alias).name.display(f.db, f.edition()),
-                )?;
-                f.end_location_link();
-                write!(f, " = ")?;
-                ty.hir_fmt(f)?;
-            }
-            WhereClause::AliasEq(_) => write!(f, "{{error}}")?,
-
-            // FIXME implement these
-            WhereClause::TypeOutlives(..) => {}
-            WhereClause::LifetimeOutlives(..) => {}
-        }
-        Ok(())
-    }
-}
-
-impl HirDisplay for LifetimeOutlives {
-    fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
-        self.a.hir_fmt(f)?;
-        write!(f, ": ")?;
-        self.b.hir_fmt(f)
-    }
-}
-
-impl HirDisplay for Lifetime {
-    fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
-        self.interned().hir_fmt(f)
+        hir_fmt_generic_args(f, &substs[1..], None, Some(self.self_ty()))
     }
 }
 
-impl HirDisplay for LifetimeData {
-    fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
-        match self {
-            LifetimeData::Placeholder(idx) => {
-                let id = lt_from_placeholder_idx(f.db, *idx).0;
-                let generics = generics(f.db, id.parent);
-                let param_data = &generics[id.local_id];
-                write!(f, "{}", param_data.name.display(f.db, f.edition()))?;
-                Ok(())
-            }
-            LifetimeData::BoundVar(idx) => idx.hir_fmt(f),
-            LifetimeData::InferenceVar(_) => write!(f, "_"),
-            LifetimeData::Static => write!(f, "'static"),
-            LifetimeData::Error => {
-                if cfg!(test) {
-                    write!(f, "'?")
-                } else {
-                    write!(f, "'_")
-                }
-            }
-            LifetimeData::Erased => write!(f, "'<erased>"),
-            LifetimeData::Phantom(void, _) => match *void {},
-        }
-    }
-}
-
-impl<'db> HirDisplay for crate::next_solver::Region<'db> {
-    fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
+impl<'db> HirDisplay<'db> for Region<'db> {
+    fn hir_fmt(&self, f: &mut HirFormatter<'_, 'db>) -> Result<(), HirDisplayError> {
         match self.kind() {
-            rustc_type_ir::RegionKind::ReEarlyParam(param) => {
+            RegionKind::ReEarlyParam(param) => {
                 let generics = generics(f.db, param.id.parent);
                 let param_data = &generics[param.id.local_id];
                 write!(f, "{}", param_data.name.display(f.db, f.edition()))?;
                 Ok(())
             }
-            rustc_type_ir::RegionKind::ReBound(db, idx) => {
+            RegionKind::ReBound(db, idx) => {
                 write!(f, "?{}.{}", db.as_u32(), idx.var.as_u32())
             }
-            rustc_type_ir::RegionKind::ReVar(_) => write!(f, "_"),
-            rustc_type_ir::RegionKind::ReStatic => write!(f, "'static"),
-            rustc_type_ir::RegionKind::ReError(..) => {
+            RegionKind::ReVar(_) => write!(f, "_"),
+            RegionKind::ReStatic => write!(f, "'static"),
+            RegionKind::ReError(..) => {
                 if cfg!(test) {
                     write!(f, "'?")
                 } else {
                     write!(f, "'_")
                 }
             }
-            rustc_type_ir::RegionKind::ReErased => write!(f, "'<erased>"),
-            rustc_type_ir::RegionKind::RePlaceholder(_) => write!(f, "<placeholder>"),
-            rustc_type_ir::RegionKind::ReLateParam(_) => write!(f, "<late-param>"),
+            RegionKind::ReErased => write!(f, "'<erased>"),
+            RegionKind::RePlaceholder(_) => write!(f, "<placeholder>"),
+            RegionKind::ReLateParam(_) => write!(f, "<late-param>"),
         }
     }
 }
 
-impl HirDisplay for DomainGoal {
-    fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
-        match self {
-            DomainGoal::Holds(wc) => {
-                write!(f, "Holds(")?;
-                wc.hir_fmt(f)?;
-                write!(f, ")")?;
-            }
-            _ => write!(f, "_")?,
-        }
-        Ok(())
-    }
-}
-
-pub fn write_visibility(
+pub fn write_visibility<'db>(
     module_id: ModuleId,
     vis: Visibility,
-    f: &mut HirFormatter<'_>,
+    f: &mut HirFormatter<'_, 'db>,
 ) -> Result<(), HirDisplayError> {
     match vis {
         Visibility::Public => write!(f, "pub "),
@@ -2346,28 +2001,30 @@ pub fn write_visibility(
     }
 }
 
-pub trait HirDisplayWithExpressionStore {
+pub trait HirDisplayWithExpressionStore<'db> {
     fn hir_fmt(
         &self,
-        f: &mut HirFormatter<'_>,
+        f: &mut HirFormatter<'_, 'db>,
         store: &ExpressionStore,
     ) -> Result<(), HirDisplayError>;
 }
 
-impl<T: ?Sized + HirDisplayWithExpressionStore> HirDisplayWithExpressionStore for &'_ T {
+impl<'db, T: ?Sized + HirDisplayWithExpressionStore<'db>> HirDisplayWithExpressionStore<'db>
+    for &'_ T
+{
     fn hir_fmt(
         &self,
-        f: &mut HirFormatter<'_>,
+        f: &mut HirFormatter<'_, 'db>,
         store: &ExpressionStore,
     ) -> Result<(), HirDisplayError> {
         T::hir_fmt(&**self, f, store)
     }
 }
 
-pub fn hir_display_with_store<'a, T: HirDisplayWithExpressionStore + 'a>(
+pub fn hir_display_with_store<'a, 'db, T: HirDisplayWithExpressionStore<'db> + 'a>(
     value: T,
     store: &'a ExpressionStore,
-) -> impl HirDisplay + 'a {
+) -> impl HirDisplay<'db> + 'a {
     ExpressionStoreAdapter(value, store)
 }
 
@@ -2379,15 +2036,15 @@ impl<'a, T> ExpressionStoreAdapter<'a, T> {
     }
 }
 
-impl<T: HirDisplayWithExpressionStore> HirDisplay for ExpressionStoreAdapter<'_, T> {
-    fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
+impl<'db, T: HirDisplayWithExpressionStore<'db>> HirDisplay<'db> for ExpressionStoreAdapter<'_, T> {
+    fn hir_fmt(&self, f: &mut HirFormatter<'_, 'db>) -> Result<(), HirDisplayError> {
         T::hir_fmt(&self.0, f, self.1)
     }
 }
-impl HirDisplayWithExpressionStore for LifetimeRefId {
+impl<'db> HirDisplayWithExpressionStore<'db> for LifetimeRefId {
     fn hir_fmt(
         &self,
-        f: &mut HirFormatter<'_>,
+        f: &mut HirFormatter<'_, 'db>,
         store: &ExpressionStore,
     ) -> Result<(), HirDisplayError> {
         match &store[*self] {
@@ -2407,10 +2064,10 @@ impl HirDisplayWithExpressionStore for LifetimeRefId {
     }
 }
 
-impl HirDisplayWithExpressionStore for TypeRefId {
+impl<'db> HirDisplayWithExpressionStore<'db> for TypeRefId {
     fn hir_fmt(
         &self,
-        f: &mut HirFormatter<'_>,
+        f: &mut HirFormatter<'_, 'db>,
         store: &ExpressionStore,
     ) -> Result<(), HirDisplayError> {
         match &store[*self] {
@@ -2536,10 +2193,10 @@ impl HirDisplayWithExpressionStore for TypeRefId {
     }
 }
 
-impl HirDisplayWithExpressionStore for ConstRef {
+impl<'db> HirDisplayWithExpressionStore<'db> for ConstRef {
     fn hir_fmt(
         &self,
-        f: &mut HirFormatter<'_>,
+        f: &mut HirFormatter<'_, 'db>,
         _store: &ExpressionStore,
     ) -> Result<(), HirDisplayError> {
         // FIXME
@@ -2549,10 +2206,10 @@ impl HirDisplayWithExpressionStore for ConstRef {
     }
 }
 
-impl HirDisplayWithExpressionStore for TypeBound {
+impl<'db> HirDisplayWithExpressionStore<'db> for TypeBound {
     fn hir_fmt(
         &self,
-        f: &mut HirFormatter<'_>,
+        f: &mut HirFormatter<'_, 'db>,
         store: &ExpressionStore,
     ) -> Result<(), HirDisplayError> {
         match self {
@@ -2593,10 +2250,10 @@ impl HirDisplayWithExpressionStore for TypeBound {
     }
 }
 
-impl HirDisplayWithExpressionStore for Path {
+impl<'db> HirDisplayWithExpressionStore<'db> for Path {
     fn hir_fmt(
         &self,
-        f: &mut HirFormatter<'_>,
+        f: &mut HirFormatter<'_, 'db>,
         store: &ExpressionStore,
     ) -> Result<(), HirDisplayError> {
         match (self.type_anchor(), self.kind()) {
@@ -2745,10 +2402,10 @@ impl HirDisplayWithExpressionStore for Path {
     }
 }
 
-impl HirDisplayWithExpressionStore for hir_def::expr_store::path::GenericArg {
+impl<'db> HirDisplayWithExpressionStore<'db> for hir_def::expr_store::path::GenericArg {
     fn hir_fmt(
         &self,
-        f: &mut HirFormatter<'_>,
+        f: &mut HirFormatter<'_, 'db>,
         store: &ExpressionStore,
     ) -> Result<(), HirDisplayError> {
         match self {
diff --git a/crates/hir-ty/src/generics.rs b/crates/hir-ty/src/generics.rs
index e179e41b1cbe..2053a099ed78 100644
--- a/crates/hir-ty/src/generics.rs
+++ b/crates/hir-ty/src/generics.rs
@@ -130,11 +130,16 @@ impl Generics {
 
     /// Returns total number of generic parameters in scope, including those from parent.
     pub(crate) fn len(&self) -> usize {
-        let parent = self.parent_generics().map_or(0, Generics::len);
+        let parent = self.len_parent();
         let child = self.params.len();
         parent + child
     }
 
+    #[inline]
+    pub(crate) fn len_parent(&self) -> usize {
+        self.parent_generics().map_or(0, Generics::len)
+    }
+
     /// Returns numbers of generic parameters excluding those from parent.
     pub(crate) fn len_self(&self) -> usize {
         self.params.len()
diff --git a/crates/hir-ty/src/infer.rs b/crates/hir-ty/src/infer.rs
index 72498681aca5..041799be9602 100644
--- a/crates/hir-ty/src/infer.rs
+++ b/crates/hir-ty/src/infer.rs
@@ -55,8 +55,7 @@ use stdx::never;
 use triomphe::Arc;
 
 use crate::{
-    ImplTraitId, IncorrectGenericsLenKind, Interner, PathLoweringDiagnostic, TargetFeatures,
-    TraitEnvironment,
+    ImplTraitId, IncorrectGenericsLenKind, PathLoweringDiagnostic, TargetFeatures,
     db::{HirDatabase, InternedClosureId, InternedOpaqueTyId},
     generics::Generics,
     infer::{
@@ -77,7 +76,7 @@ use crate::{
             DefineOpaqueTypes,
             traits::{Obligation, ObligationCause},
         },
-        mapping::{ChalkToNextSolver, NextSolverToChalk},
+        mapping::ChalkToNextSolver,
     },
     traits::FnTrait,
     utils::TargetFeatureIsSafeInTarget,
@@ -166,31 +165,6 @@ pub(crate) fn infer_cycle_result(
     })
 }
 
-/// Fully normalize all the types found within `ty` in context of `owner` body definition.
-///
-/// This is appropriate to use only after type-check: it assumes
-/// that normalization will succeed, for example.
-#[tracing::instrument(level = "debug", skip(db))]
-pub(crate) fn normalize(
-    db: &dyn HirDatabase,
-    trait_env: Arc<TraitEnvironment<'_>>,
-    ty: crate::Ty,
-) -> crate::Ty {
-    // FIXME: TypeFlags::HAS_CT_PROJECTION is not implemented in chalk, so TypeFlags::HAS_PROJECTION only
-    // works for the type case, so we check array unconditionally. Remove the array part
-    // when the bug in chalk becomes fixed.
-    if !ty.data(Interner).flags.intersects(crate::TypeFlags::HAS_PROJECTION)
-        && !matches!(ty.kind(Interner), crate::TyKind::Array(..))
-    {
-        return ty;
-    }
-    let mut table = unify::InferenceTable::new(db, trait_env);
-
-    let ty_with_vars = table.normalize_associated_types_in(ty.to_nextsolver(table.interner()));
-    table.select_obligations_where_possible();
-    table.resolve_completely(ty_with_vars).to_chalk(table.interner())
-}
-
 /// Binding modes inferred for patterns.
 /// <https://doc.rust-lang.org/reference/patterns.html#binding-modes>
 #[derive(Copy, Clone, Debug, Eq, PartialEq, Default)]
diff --git a/crates/hir-ty/src/inhabitedness.rs b/crates/hir-ty/src/inhabitedness.rs
index 826f19cf0b68..7ebc2df6f75d 100644
--- a/crates/hir-ty/src/inhabitedness.rs
+++ b/crates/hir-ty/src/inhabitedness.rs
@@ -1,60 +1,62 @@
 //! Type inhabitedness logic.
 use std::ops::ControlFlow::{self, Break, Continue};
 
-use chalk_ir::{
-    DebruijnIndex,
-    visit::{TypeSuperVisitable, TypeVisitable, TypeVisitor},
-};
 use hir_def::{AdtId, EnumVariantId, ModuleId, VariantId, visibility::Visibility};
 use rustc_hash::FxHashSet;
+use rustc_type_ir::{
+    TypeSuperVisitable, TypeVisitable, TypeVisitor,
+    inherent::{AdtDef, IntoKind},
+};
 use triomphe::Arc;
 
 use crate::{
-    AliasTy, Binders, Interner, Substitution, TraitEnvironment, Ty, TyKind,
+    TraitEnvironment,
     consteval::try_const_usize,
     db::HirDatabase,
-    next_solver::{DbInterner, mapping::ChalkToNextSolver},
+    next_solver::{
+        DbInterner, EarlyBinder, GenericArgs, Ty, TyKind,
+        infer::{InferCtxt, traits::ObligationCause},
+        obligation_ctxt::ObligationCtxt,
+    },
 };
 
 // FIXME: Turn this into a query, it can be quite slow
 /// Checks whether a type is visibly uninhabited from a particular module.
-pub(crate) fn is_ty_uninhabited_from(
-    db: &dyn HirDatabase,
-    ty: &Ty,
+pub(crate) fn is_ty_uninhabited_from<'db>(
+    infcx: &InferCtxt<'db>,
+    ty: Ty<'db>,
     target_mod: ModuleId,
-    env: Arc<TraitEnvironment<'_>>,
+    env: Arc<TraitEnvironment<'db>>,
 ) -> bool {
     let _p = tracing::info_span!("is_ty_uninhabited_from", ?ty).entered();
-    let mut uninhabited_from =
-        UninhabitedFrom { target_mod, db, max_depth: 500, recursive_ty: FxHashSet::default(), env };
-    let inhabitedness = ty.visit_with(&mut uninhabited_from, DebruijnIndex::INNERMOST);
+    let mut uninhabited_from = UninhabitedFrom::new(infcx, target_mod, env);
+    let inhabitedness = ty.visit_with(&mut uninhabited_from);
     inhabitedness == BREAK_VISIBLY_UNINHABITED
 }
 
 // FIXME: Turn this into a query, it can be quite slow
 /// Checks whether a variant is visibly uninhabited from a particular module.
-pub(crate) fn is_enum_variant_uninhabited_from(
-    db: &dyn HirDatabase,
+pub(crate) fn is_enum_variant_uninhabited_from<'db>(
+    infcx: &InferCtxt<'db>,
     variant: EnumVariantId,
-    subst: &Substitution,
+    subst: GenericArgs<'db>,
     target_mod: ModuleId,
-    env: Arc<TraitEnvironment<'_>>,
+    env: Arc<TraitEnvironment<'db>>,
 ) -> bool {
     let _p = tracing::info_span!("is_enum_variant_uninhabited_from").entered();
 
-    let mut uninhabited_from =
-        UninhabitedFrom { target_mod, db, max_depth: 500, recursive_ty: FxHashSet::default(), env };
+    let mut uninhabited_from = UninhabitedFrom::new(infcx, target_mod, env);
     let inhabitedness = uninhabited_from.visit_variant(variant.into(), subst);
     inhabitedness == BREAK_VISIBLY_UNINHABITED
 }
 
-struct UninhabitedFrom<'a> {
+struct UninhabitedFrom<'a, 'db> {
     target_mod: ModuleId,
-    recursive_ty: FxHashSet<Ty>,
+    recursive_ty: FxHashSet<Ty<'db>>,
     // guard for preventing stack overflow in non trivial non terminating types
     max_depth: usize,
-    db: &'a dyn HirDatabase,
-    env: Arc<TraitEnvironment<'a>>,
+    infcx: &'a InferCtxt<'db>,
+    env: Arc<TraitEnvironment<'db>>,
 }
 
 const CONTINUE_OPAQUELY_INHABITED: ControlFlow<VisiblyUninhabited> = Continue(());
@@ -62,63 +64,73 @@ const BREAK_VISIBLY_UNINHABITED: ControlFlow<VisiblyUninhabited> = Break(Visibly
 #[derive(PartialEq, Eq)]
 struct VisiblyUninhabited;
 
-impl TypeVisitor<Interner> for UninhabitedFrom<'_> {
-    type BreakTy = VisiblyUninhabited;
-
-    fn as_dyn(&mut self) -> &mut dyn TypeVisitor<Interner, BreakTy = VisiblyUninhabited> {
-        self
-    }
+impl<'db> TypeVisitor<DbInterner<'db>> for UninhabitedFrom<'_, 'db> {
+    type Result = ControlFlow<VisiblyUninhabited>;
 
-    fn visit_ty(
-        &mut self,
-        ty: &Ty,
-        outer_binder: DebruijnIndex,
-    ) -> ControlFlow<VisiblyUninhabited> {
-        if self.recursive_ty.contains(ty) || self.max_depth == 0 {
+    fn visit_ty(&mut self, mut ty: Ty<'db>) -> ControlFlow<VisiblyUninhabited> {
+        if self.recursive_ty.contains(&ty) || self.max_depth == 0 {
             // rustc considers recursive types always inhabited. I think it is valid to consider
             // recursive types as always uninhabited, but we should do what rustc is doing.
             return CONTINUE_OPAQUELY_INHABITED;
         }
-        self.recursive_ty.insert(ty.clone());
+        self.recursive_ty.insert(ty);
         self.max_depth -= 1;
-        let interner = DbInterner::new_with(self.db, None, None);
-        let r = match ty.kind(Interner) {
-            TyKind::Adt(adt, subst) => self.visit_adt(adt.0, subst),
-            TyKind::Never => BREAK_VISIBLY_UNINHABITED,
-            TyKind::Tuple(..) => ty.super_visit_with(self, outer_binder),
-            TyKind::Array(item_ty, len) => {
-                match try_const_usize(self.db, len.to_nextsolver(interner)) {
-                    Some(0) | None => CONTINUE_OPAQUELY_INHABITED,
-                    Some(1..) => item_ty.super_visit_with(self, outer_binder),
-                }
-            }
-            TyKind::Alias(AliasTy::Projection(projection)) => {
-                // FIXME: I think this currently isn't used for monomorphized bodies, so there is no need to handle
-                // `TyKind::AssociatedType`, but perhaps in the future it will.
-                let normalized = self.db.normalize_projection(projection.clone(), self.env.clone());
-                self.visit_ty(&normalized, outer_binder)
+
+        if matches!(ty.kind(), TyKind::Alias(..)) {
+            let mut ocx = ObligationCtxt::new(self.infcx);
+            match ocx.structurally_normalize_ty(&ObligationCause::dummy(), self.env.env, ty) {
+                Ok(it) => ty = it,
+                Err(_) => return CONTINUE_OPAQUELY_INHABITED,
             }
+        }
+
+        let r = match ty.kind() {
+            TyKind::Adt(adt, subst) => self.visit_adt(adt.def_id().0, subst),
+            TyKind::Never => BREAK_VISIBLY_UNINHABITED,
+            TyKind::Tuple(..) => ty.super_visit_with(self),
+            TyKind::Array(item_ty, len) => match try_const_usize(self.infcx.interner.db, len) {
+                Some(0) | None => CONTINUE_OPAQUELY_INHABITED,
+                Some(1..) => item_ty.super_visit_with(self),
+            },
             _ => CONTINUE_OPAQUELY_INHABITED,
         };
-        self.recursive_ty.remove(ty);
+        self.recursive_ty.remove(&ty);
         self.max_depth += 1;
         r
     }
+}
 
-    fn interner(&self) -> Interner {
-        Interner
+impl<'a, 'db> UninhabitedFrom<'a, 'db> {
+    fn new(
+        infcx: &'a InferCtxt<'db>,
+        target_mod: ModuleId,
+        env: Arc<TraitEnvironment<'db>>,
+    ) -> Self {
+        Self { target_mod, recursive_ty: FxHashSet::default(), max_depth: 500, infcx, env }
+    }
+
+    #[inline]
+    fn interner(&self) -> DbInterner<'db> {
+        self.infcx.interner
+    }
+
+    #[inline]
+    fn db(&self) -> &'db dyn HirDatabase {
+        self.interner().db
     }
-}
 
-impl UninhabitedFrom<'_> {
-    fn visit_adt(&mut self, adt: AdtId, subst: &Substitution) -> ControlFlow<VisiblyUninhabited> {
+    fn visit_adt(
+        &mut self,
+        adt: AdtId,
+        subst: GenericArgs<'db>,
+    ) -> ControlFlow<VisiblyUninhabited> {
         // An ADT is uninhabited iff all its variants uninhabited.
         match adt {
             // rustc: For now, `union`s are never considered uninhabited.
             AdtId::UnionId(_) => CONTINUE_OPAQUELY_INHABITED,
             AdtId::StructId(s) => self.visit_variant(s.into(), subst),
             AdtId::EnumId(e) => {
-                let enum_data = e.enum_variants(self.db);
+                let enum_data = e.enum_variants(self.db());
 
                 for &(variant, _, _) in enum_data.variants.iter() {
                     let variant_inhabitedness = self.visit_variant(variant.into(), subst);
@@ -135,17 +147,17 @@ impl UninhabitedFrom<'_> {
     fn visit_variant(
         &mut self,
         variant: VariantId,
-        subst: &Substitution,
+        subst: GenericArgs<'db>,
     ) -> ControlFlow<VisiblyUninhabited> {
-        let variant_data = variant.fields(self.db);
+        let variant_data = variant.fields(self.db());
         let fields = variant_data.fields();
         if fields.is_empty() {
             return CONTINUE_OPAQUELY_INHABITED;
         }
 
         let is_enum = matches!(variant, VariantId::EnumVariantId(..));
-        let field_tys = self.db.field_types(variant);
-        let field_vis = if is_enum { None } else { Some(self.db.field_visibilities(variant)) };
+        let field_tys = self.db().field_types_ns(variant);
+        let field_vis = if is_enum { None } else { Some(self.db().field_visibilities(variant)) };
 
         for (fid, _) in fields.iter() {
             self.visit_field(field_vis.as_ref().map(|it| it[fid]), &field_tys[fid], subst)?;
@@ -156,12 +168,12 @@ impl UninhabitedFrom<'_> {
     fn visit_field(
         &mut self,
         vis: Option<Visibility>,
-        ty: &Binders<Ty>,
-        subst: &Substitution,
+        ty: &EarlyBinder<'db, Ty<'db>>,
+        subst: GenericArgs<'db>,
     ) -> ControlFlow<VisiblyUninhabited> {
-        if vis.is_none_or(|it| it.is_visible_from(self.db, self.target_mod)) {
-            let ty = ty.clone().substitute(Interner, subst);
-            ty.visit_with(self, DebruijnIndex::INNERMOST)
+        if vis.is_none_or(|it| it.is_visible_from(self.db(), self.target_mod)) {
+            let ty = ty.instantiate(self.interner(), subst);
+            ty.visit_with(self)
         } else {
             CONTINUE_OPAQUELY_INHABITED
         }
diff --git a/crates/hir-ty/src/lib.rs b/crates/hir-ty/src/lib.rs
index 734483a823e4..7277617bce8a 100644
--- a/crates/hir-ty/src/lib.rs
+++ b/crates/hir-ty/src/lib.rs
@@ -81,22 +81,17 @@ use syntax::ast::{ConstArg, make};
 use traits::FnTrait;
 use triomphe::Arc;
 
-#[cfg(not(debug_assertions))]
-use crate::next_solver::ErrorGuaranteed;
 use crate::{
+    builder::{ParamKind, TyBuilder},
+    chalk_ext::*,
     db::HirDatabase,
     display::{DisplayTarget, HirDisplay},
     generics::Generics,
     infer::unify::InferenceTable,
-    next_solver::{
-        DbInterner,
-        mapping::{ChalkToNextSolver, NextSolverToChalk, convert_ty_for_result},
-    },
+    next_solver::DbInterner,
 };
 
 pub use autoderef::autoderef;
-pub use builder::{ParamKind, TyBuilder};
-pub use chalk_ext::*;
 pub use infer::{
     Adjust, Adjustment, AutoBorrow, BindingMode, InferenceDiagnostic, InferenceResult,
     InferenceTyDiagnosticSource, OverloadedDeref, PointerCast,
@@ -124,7 +119,7 @@ pub use utils::{
 };
 pub use variance::Variance;
 
-use chalk_ir::{AdtId, BoundVar, DebruijnIndex, Safety, Scalar};
+use chalk_ir::{BoundVar, DebruijnIndex, Safety, Scalar};
 
 pub(crate) type ForeignDefId = chalk_ir::ForeignDefId<Interner>;
 pub(crate) type AssocTypeId = chalk_ir::AssocTypeId<Interner>;
@@ -156,7 +151,6 @@ pub(crate) type GenericArgData = chalk_ir::GenericArgData<Interner>;
 
 pub(crate) type Ty = chalk_ir::Ty<Interner>;
 pub type TyKind = chalk_ir::TyKind<Interner>;
-pub(crate) type TypeFlags = chalk_ir::TypeFlags;
 pub(crate) type DynTy = chalk_ir::DynTy<Interner>;
 pub(crate) type FnPointer = chalk_ir::FnPointer<Interner>;
 pub(crate) use chalk_ir::FnSubst; // a re-export so we don't lose the tuple constructor
@@ -174,7 +168,6 @@ pub(crate) type ConstValue = chalk_ir::ConstValue<Interner>;
 
 pub(crate) type Const = chalk_ir::Const<Interner>;
 pub(crate) type ConstData = chalk_ir::ConstData<Interner>;
-pub(crate) type ConcreteConst = chalk_ir::ConcreteConst<Interner>;
 
 pub(crate) type TraitRef = chalk_ir::TraitRef<Interner>;
 pub(crate) type QuantifiedWhereClause = Binders<WhereClause>;
@@ -382,7 +375,7 @@ pub(crate) fn variable_kinds_from_iter(
 /// A function signature as seen by type inference: Several parameter types and
 /// one return type.
 #[derive(Clone, PartialEq, Eq, Debug)]
-pub struct CallableSig {
+pub(crate) struct CallableSig {
     params_and_return: Arc<[Ty]>,
     is_varargs: bool,
     safety: Safety,
@@ -534,112 +527,6 @@ impl FnAbi {
     }
 }
 
-/// A polymorphic function signature.
-pub type PolyFnSig = Binders<CallableSig>;
-
-impl CallableSig {
-    pub fn from_params_and_return(
-        params: impl Iterator<Item = Ty>,
-        ret: Ty,
-        is_varargs: bool,
-        safety: Safety,
-        abi: FnAbi,
-    ) -> CallableSig {
-        let mut params_and_return = Vec::with_capacity(params.size_hint().0 + 1);
-        params_and_return.extend(params);
-        params_and_return.push(ret);
-        CallableSig { params_and_return: params_and_return.into(), is_varargs, safety, abi }
-    }
-
-    pub fn from_def(db: &dyn HirDatabase, def: FnDefId, substs: &Substitution) -> CallableSig {
-        let callable_def = ToChalk::from_chalk(db, def);
-        let interner = DbInterner::new_with(db, None, None);
-        let args: crate::next_solver::GenericArgs<'_> = substs.to_nextsolver(interner);
-        let sig = db.callable_item_signature(callable_def);
-        sig.instantiate(interner, args).skip_binder().to_chalk(interner)
-    }
-    pub fn from_fn_ptr(fn_ptr: &FnPointer) -> CallableSig {
-        CallableSig {
-            // FIXME: what to do about lifetime params? -> return PolyFnSig
-            params_and_return: Arc::from_iter(
-                fn_ptr
-                    .substitution
-                    .clone()
-                    .shifted_out_to(Interner, DebruijnIndex::ONE)
-                    .expect("unexpected lifetime vars in fn ptr")
-                    .0
-                    .as_slice(Interner)
-                    .iter()
-                    .map(|arg| arg.assert_ty_ref(Interner).clone()),
-            ),
-            is_varargs: fn_ptr.sig.variadic,
-            safety: fn_ptr.sig.safety,
-            abi: fn_ptr.sig.abi,
-        }
-    }
-    pub fn from_fn_sig_and_header<'db>(
-        interner: DbInterner<'db>,
-        sig: crate::next_solver::Binder<'db, rustc_type_ir::FnSigTys<DbInterner<'db>>>,
-        header: rustc_type_ir::FnHeader<DbInterner<'db>>,
-    ) -> CallableSig {
-        CallableSig {
-            // FIXME: what to do about lifetime params? -> return PolyFnSig
-            params_and_return: Arc::from_iter(
-                sig.skip_binder()
-                    .inputs_and_output
-                    .iter()
-                    .map(|t| convert_ty_for_result(interner, t)),
-            ),
-            is_varargs: header.c_variadic,
-            safety: match header.safety {
-                next_solver::abi::Safety::Safe => chalk_ir::Safety::Safe,
-                next_solver::abi::Safety::Unsafe => chalk_ir::Safety::Unsafe,
-            },
-            abi: header.abi,
-        }
-    }
-
-    pub fn to_fn_ptr(&self) -> FnPointer {
-        FnPointer {
-            num_binders: 0,
-            sig: FnSig { abi: self.abi, safety: self.safety, variadic: self.is_varargs },
-            substitution: FnSubst(Substitution::from_iter(
-                Interner,
-                self.params_and_return.iter().cloned(),
-            )),
-        }
-    }
-
-    pub fn abi(&self) -> FnAbi {
-        self.abi
-    }
-
-    pub fn params(&self) -> &[Ty] {
-        &self.params_and_return[0..self.params_and_return.len() - 1]
-    }
-
-    pub fn ret(&self) -> &Ty {
-        &self.params_and_return[self.params_and_return.len() - 1]
-    }
-}
-
-impl TypeFoldable<Interner> for CallableSig {
-    fn try_fold_with<E>(
-        self,
-        folder: &mut dyn chalk_ir::fold::FallibleTypeFolder<Interner, Error = E>,
-        outer_binder: DebruijnIndex,
-    ) -> Result<Self, E> {
-        let vec = self.params_and_return.to_vec();
-        let folded = vec.try_fold_with(folder, outer_binder)?;
-        Ok(CallableSig {
-            params_and_return: folded.into(),
-            is_varargs: self.is_varargs,
-            safety: self.safety,
-            abi: self.abi,
-        })
-    }
-}
-
 #[derive(Copy, Clone, PartialEq, Eq, Debug, Hash)]
 pub enum ImplTraitId {
     ReturnTypeImplTrait(hir_def::FunctionId, ImplTraitIdx), // FIXME(next-solver): Should be crate::nextsolver::ImplTraitIdx.
@@ -764,7 +651,12 @@ where
             #[cfg(debug_assertions)]
             let error = || Err(());
             #[cfg(not(debug_assertions))]
-            let error = || Ok(crate::next_solver::Ty::new_error(self.interner, ErrorGuaranteed));
+            let error = || {
+                Ok(crate::next_solver::Ty::new_error(
+                    self.interner,
+                    crate::next_solver::ErrorGuaranteed,
+                ))
+            };
 
             match t.kind() {
                 crate::next_solver::TyKind::Error(_) => {
diff --git a/crates/hir-ty/src/lower_nextsolver.rs b/crates/hir-ty/src/lower_nextsolver.rs
index abca6b6bb9e5..aced46bf806b 100644
--- a/crates/hir-ty/src/lower_nextsolver.rs
+++ b/crates/hir-ty/src/lower_nextsolver.rs
@@ -17,17 +17,20 @@ use std::{
 
 use base_db::Crate;
 use either::Either;
-use hir_def::hir::generics::GenericParamDataRef;
-use hir_def::item_tree::FieldsShape;
 use hir_def::{
-    AdtId, AssocItemId, CallableDefId, ConstParamId, DefWithBodyId, EnumVariantId, FunctionId,
-    GenericDefId, GenericParamId, HasModule, ImplId, ItemContainerId, LocalFieldId, Lookup,
-    StructId, TraitId, TypeAliasId, TypeOrConstParamId, VariantId,
+    AdtId, AssocItemId, CallableDefId, ConstId, ConstParamId, DefWithBodyId, EnumVariantId,
+    FunctionId, GenericDefId, GenericParamId, HasModule, ImplId, ItemContainerId, LifetimeParamId,
+    LocalFieldId, Lookup, StaticId, StructId, TraitId, TypeAliasId, TypeOrConstParamId,
+    TypeParamId, VariantId,
     expr_store::{
         ExpressionStore,
         path::{GenericArg, Path},
     },
-    hir::generics::{TypeOrConstParamData, WherePredicate},
+    hir::generics::{
+        GenericParamDataRef, TypeOrConstParamData, TypeParamData, TypeParamProvenance,
+        WherePredicate,
+    },
+    item_tree::FieldsShape,
     lang_item::LangItem,
     resolver::{HasResolver, LifetimeNs, Resolver, TypeNs},
     signatures::{FunctionSignature, TraitFlags, TypeAliasFlags},
@@ -36,7 +39,6 @@ use hir_def::{
         TraitRef as HirTraitRef, TypeBound, TypeRef, TypeRefId,
     },
 };
-use hir_def::{ConstId, LifetimeParamId, StaticId, TypeParamId};
 use hir_expand::name::Name;
 use intern::{Symbol, sym};
 use la_arena::{Arena, ArenaMap, Idx};
@@ -48,20 +50,17 @@ use rustc_type_ir::{
     AliasTyKind, ConstKind, DebruijnIndex, ExistentialPredicate, ExistentialProjection,
     ExistentialTraitRef, FnSig, OutlivesPredicate,
     TyKind::{self},
-    TypeVisitableExt,
+    TypeFoldable, TypeFolder, TypeVisitableExt, Upcast,
     inherent::{GenericArg as _, GenericArgs as _, IntoKind as _, Region as _, SliceLike, Ty as _},
 };
-use rustc_type_ir::{TypeFoldable, TypeFolder, Upcast};
 use salsa::plumbing::AsId;
 use smallvec::{SmallVec, smallvec};
 use stdx::never;
 use triomphe::Arc;
 
-use crate::ValueTyDefId;
-use crate::next_solver::ParamConst;
 use crate::{
     FnAbi, ImplTraitId, Interner, ParamKind, TraitEnvironment, TyDefId, TyLoweringDiagnostic,
-    TyLoweringDiagnosticKind,
+    TyLoweringDiagnosticKind, ValueTyDefId,
     consteval::{intern_const_ref, path_to_const, unknown_const_as_generic},
     db::HirDatabase,
     generics::{Generics, generics, trait_self_param_idx},
@@ -69,8 +68,8 @@ use crate::{
     next_solver::{
         AdtDef, AliasTy, Binder, BoundExistentialPredicates, BoundRegionKind, BoundTyKind,
         BoundVarKind, BoundVarKinds, Clause, Clauses, Const, DbInterner, EarlyBinder,
-        EarlyParamRegion, ErrorGuaranteed, GenericArgs, ParamEnv, PolyFnSig, Predicate, Region,
-        SolverDefId, TraitPredicate, TraitRef, Ty, Tys,
+        EarlyParamRegion, ErrorGuaranteed, GenericArgs, ParamConst, ParamEnv, PolyFnSig, Predicate,
+        Region, SolverDefId, TraitPredicate, TraitRef, Ty, Tys,
         abi::Safety,
         mapping::{ChalkToNextSolver, convert_ty_for_result},
     },
@@ -187,8 +186,9 @@ pub struct TyLoweringContext<'db, 'a> {
     pub(crate) unsized_types: FxHashSet<Ty<'db>>,
     pub(crate) diagnostics: Vec<TyLoweringDiagnostic>,
     lifetime_elision: LifetimeElisionKind<'db>,
-    /// We disallow referencing generic parameters that have an index greater than or equal to this number.
-    disallow_params_after: u32,
+    /// When lowering the defaults for generic params, this contains the index of the currently lowered param.
+    /// We disallow referring to later params, or to ADT's `Self`.
+    lowering_param_default: Option<u32>,
 }
 
 impl<'db, 'a> TyLoweringContext<'db, 'a> {
@@ -213,7 +213,7 @@ impl<'db, 'a> TyLoweringContext<'db, 'a> {
             unsized_types: FxHashSet::default(),
             diagnostics: Vec::new(),
             lifetime_elision,
-            disallow_params_after: u32::MAX,
+            lowering_param_default: None,
         }
     }
 
@@ -249,8 +249,8 @@ impl<'db, 'a> TyLoweringContext<'db, 'a> {
         self
     }
 
-    pub(crate) fn disallow_params_after(&mut self, after: u32) {
-        self.disallow_params_after = after;
+    pub(crate) fn lowering_param_default(&mut self, index: u32) {
+        self.lowering_param_default = Some(index);
     }
 
     pub(crate) fn push_diagnostic(&mut self, type_ref: TypeRefId, kind: TyLoweringDiagnosticKind) {
@@ -333,8 +333,13 @@ impl<'db, 'a> TyLoweringContext<'db, 'a> {
         self.generics.get_or_init(|| generics(self.db, self.def))
     }
 
+    fn param_index_is_disallowed(&self, index: u32) -> bool {
+        self.lowering_param_default
+            .is_some_and(|disallow_params_after| index >= disallow_params_after)
+    }
+
     fn type_param(&mut self, id: TypeParamId, index: u32, name: Symbol) -> Ty<'db> {
-        if index >= self.disallow_params_after {
+        if self.param_index_is_disallowed(index) {
             // FIXME: Report an error.
             Ty::new_error(self.interner, ErrorGuaranteed)
         } else {
@@ -343,7 +348,7 @@ impl<'db, 'a> TyLoweringContext<'db, 'a> {
     }
 
     fn const_param(&mut self, id: ConstParamId, index: u32) -> Const<'db> {
-        if index >= self.disallow_params_after {
+        if self.param_index_is_disallowed(index) {
             // FIXME: Report an error.
             Const::error(self.interner)
         } else {
@@ -352,7 +357,7 @@ impl<'db, 'a> TyLoweringContext<'db, 'a> {
     }
 
     fn region_param(&mut self, id: LifetimeParamId, index: u32) -> Region<'db> {
-        if index >= self.disallow_params_after {
+        if self.param_index_is_disallowed(index) {
             // FIXME: Report an error.
             Region::error(self.interner)
         } else {
@@ -394,7 +399,7 @@ impl<'db, 'a> TyLoweringContext<'db, 'a> {
                     type_data
                         .name
                         .as_ref()
-                        .map_or_else(|| sym::MISSING_NAME.clone(), |d| d.symbol().clone()),
+                        .map_or_else(|| sym::MISSING_NAME, |d| d.symbol().clone()),
                 )
             }
             &TypeRef::RawPtr(inner, mutability) => {
@@ -1603,8 +1608,6 @@ where
         for pred in maybe_parent_generics.where_predicates() {
             tracing::debug!(?pred);
             if filter(maybe_parent_generics.def()) {
-                // We deliberately use `generics` and not `maybe_parent_generics` here. This is not a mistake!
-                // If we use the parent generics
                 predicates.extend(ctx.lower_where_predicate(
                     pred,
                     false,
@@ -1619,49 +1622,53 @@ where
 
     let sized_trait = LangItem::Sized.resolve_trait(db, resolver.krate());
     if let Some(sized_trait) = sized_trait {
-        let (mut generics, mut def_id) =
-            (crate::next_solver::generics::generics(db, def.into()), def);
-        loop {
-            if filter(def_id) {
-                let self_idx = trait_self_param_idx(db, def_id);
-                for (idx, p) in generics.own_params.iter().enumerate() {
-                    if let Some(self_idx) = self_idx
-                        && p.index() as usize == self_idx
-                    {
-                        continue;
-                    }
-                    let GenericParamId::TypeParamId(param_id) = p.id else {
-                        continue;
-                    };
-                    let idx = idx as u32 + generics.parent_count as u32;
-                    let param_ty = Ty::new_param(interner, param_id, idx, p.name.clone());
-                    if explicitly_unsized_tys.contains(&param_ty) {
-                        continue;
-                    }
-                    let trait_ref = TraitRef::new_from_args(
-                        interner,
-                        sized_trait.into(),
-                        GenericArgs::new_from_iter(interner, [param_ty.into()]),
-                    );
-                    let clause = Clause(Predicate::new(
-                        interner,
-                        Binder::dummy(rustc_type_ir::PredicateKind::Clause(
-                            rustc_type_ir::ClauseKind::Trait(TraitPredicate {
-                                trait_ref,
-                                polarity: rustc_type_ir::PredicatePolarity::Positive,
-                            }),
-                        )),
-                    ));
-                    predicates.push(clause);
-                }
+        let mut add_sized_clause = |param_idx, param_id, param_data| {
+            let (
+                GenericParamId::TypeParamId(param_id),
+                GenericParamDataRef::TypeParamData(param_data),
+            ) = (param_id, param_data)
+            else {
+                return;
+            };
+
+            if param_data.provenance == TypeParamProvenance::TraitSelf {
+                return;
             }
 
-            if let Some(g) = generics.parent {
-                generics = crate::next_solver::generics::generics(db, g.into());
-                def_id = g;
-            } else {
-                break;
+            let param_name = param_data
+                .name
+                .as_ref()
+                .map_or_else(|| sym::MISSING_NAME, |name| name.symbol().clone());
+            let param_ty = Ty::new_param(interner, param_id, param_idx, param_name);
+            if explicitly_unsized_tys.contains(&param_ty) {
+                return;
             }
+            let trait_ref = TraitRef::new_from_args(
+                interner,
+                sized_trait.into(),
+                GenericArgs::new_from_iter(interner, [param_ty.into()]),
+            );
+            let clause = Clause(Predicate::new(
+                interner,
+                Binder::dummy(rustc_type_ir::PredicateKind::Clause(
+                    rustc_type_ir::ClauseKind::Trait(TraitPredicate {
+                        trait_ref,
+                        polarity: rustc_type_ir::PredicatePolarity::Positive,
+                    }),
+                )),
+            ));
+            predicates.push(clause);
+        };
+        if generics.parent_generics().is_some_and(|parent| filter(parent.def())) {
+            generics.iter_parent().enumerate().for_each(|(param_idx, (param_id, param_data))| {
+                add_sized_clause(param_idx as u32, param_id, param_data);
+            });
+        }
+        if filter(def) {
+            let parent_params_len = generics.len_parent();
+            generics.iter_self().enumerate().for_each(|(param_idx, (param_id, param_data))| {
+                add_sized_clause((param_idx + parent_params_len) as u32, param_id, param_data);
+            });
         }
     }
 
@@ -1860,10 +1867,7 @@ pub(crate) fn generic_defaults_with_diagnostics_query(
         p: GenericParamDataRef<'_>,
         generic_params: &Generics,
     ) -> (Option<EarlyBinder<'db, crate::next_solver::GenericArg<'db>>>, bool) {
-        // Each default can only refer to previous parameters.
-        // Type variable default referring to parameter coming
-        // after it is forbidden.
-        ctx.disallow_params_after(idx as u32);
+        ctx.lowering_param_default(idx as u32);
         match p {
             GenericParamDataRef::TypeParamData(p) => {
                 let ty = p.default.map(|ty| ctx.lower_ty(ty));
diff --git a/crates/hir-ty/src/lower_nextsolver/path.rs b/crates/hir-ty/src/lower_nextsolver/path.rs
index ef2c392f0861..6bfe266b460c 100644
--- a/crates/hir-ty/src/lower_nextsolver/path.rs
+++ b/crates/hir-ty/src/lower_nextsolver/path.rs
@@ -314,7 +314,9 @@ impl<'a, 'b, 'db> PathLoweringContext<'a, 'b, 'db> {
         self.lower_ty_relative_path(ty, Some(resolution), infer_args)
     }
 
-    fn handle_type_ns_resolution(&mut self, resolution: &TypeNs) {
+    /// This returns whether to keep the resolution (`true`) of throw it (`false`).
+    #[must_use]
+    fn handle_type_ns_resolution(&mut self, resolution: &TypeNs) -> bool {
         let mut prohibit_generics_on_resolved = |reason| {
             if self.current_or_prev_segment.args_and_bindings.is_some() {
                 let segment = self.current_segment_u32();
@@ -333,7 +335,13 @@ impl<'a, 'b, 'db> PathLoweringContext<'a, 'b, 'db> {
                 prohibit_generics_on_resolved(GenericArgsProhibitedReason::TyParam)
             }
             TypeNs::AdtSelfType(_) => {
-                prohibit_generics_on_resolved(GenericArgsProhibitedReason::SelfTy)
+                prohibit_generics_on_resolved(GenericArgsProhibitedReason::SelfTy);
+
+                if self.ctx.lowering_param_default.is_some() {
+                    // Generic defaults are not allowed to refer to `Self`.
+                    // FIXME: Emit an error.
+                    return false;
+                }
             }
             TypeNs::BuiltinType(_) => {
                 prohibit_generics_on_resolved(GenericArgsProhibitedReason::PrimitiveTy)
@@ -346,6 +354,8 @@ impl<'a, 'b, 'db> PathLoweringContext<'a, 'b, 'db> {
             | TypeNs::TypeAliasId(_)
             | TypeNs::TraitId(_) => {}
         }
+
+        true
     }
 
     pub(crate) fn resolve_path_in_type_ns_fully(&mut self) -> Option<TypeNs> {
@@ -379,11 +389,6 @@ impl<'a, 'b, 'db> PathLoweringContext<'a, 'b, 'db> {
         self.current_or_prev_segment =
             segments.get(resolved_segment_idx).expect("should have resolved segment");
 
-        if matches!(self.path, Path::BarePath(..)) {
-            // Bare paths cannot have generics, so skip them as an optimization.
-            return Some((resolution, remaining_index));
-        }
-
         for (i, mod_segment) in module_segments.iter().enumerate() {
             if mod_segment.args_and_bindings.is_some() {
                 self.on_diagnostic(PathLoweringDiagnostic::GenericArgsProhibited {
@@ -403,7 +408,9 @@ impl<'a, 'b, 'db> PathLoweringContext<'a, 'b, 'db> {
             });
         }
 
-        self.handle_type_ns_resolution(&resolution);
+        if !self.handle_type_ns_resolution(&resolution) {
+            return None;
+        }
 
         Some((resolution, remaining_index))
     }
@@ -475,7 +482,7 @@ impl<'a, 'b, 'db> PathLoweringContext<'a, 'b, 'db> {
 
                 match resolution {
                     ValueNs::ImplSelf(_) => {
-                        prohibit_generics_on_resolved(GenericArgsProhibitedReason::SelfTy)
+                        prohibit_generics_on_resolved(GenericArgsProhibitedReason::SelfTy);
                     }
                     // FIXME: rustc generates E0107 (incorrect number of generic arguments) and not
                     // E0109 (generic arguments provided for a type that doesn't accept them) for
@@ -499,7 +506,9 @@ impl<'a, 'b, 'db> PathLoweringContext<'a, 'b, 'db> {
                 }
             }
             ResolveValueResult::Partial(resolution, _, _) => {
-                self.handle_type_ns_resolution(resolution);
+                if !self.handle_type_ns_resolution(resolution) {
+                    return None;
+                }
             }
         };
         Some(res)
diff --git a/crates/hir-ty/src/mir/lower.rs b/crates/hir-ty/src/mir/lower.rs
index 92f9cd42615e..1439c43e99e8 100644
--- a/crates/hir-ty/src/mir/lower.rs
+++ b/crates/hir-ty/src/mir/lower.rs
@@ -43,7 +43,6 @@ use crate::{
     next_solver::{
         Const, DbInterner, ParamConst, Region, TyKind, TypingMode, UnevaluatedConst,
         infer::{DbInternerInferExt, InferCtxt},
-        mapping::NextSolverToChalk,
     },
     traits::FnTrait,
 };
@@ -303,6 +302,7 @@ impl<'a, 'db> MirLowerCtx<'a, 'db> {
         let resolver = owner.resolver(db);
         let env = db.trait_environment_for_body(owner);
         let interner = DbInterner::new_with(db, Some(env.krate), env.block);
+        // FIXME(next-solver): Is `non_body_analysis()` correct here? Don't we want to reveal opaque types defined by this body?
         let infcx = interner.infer_ctxt().build(TypingMode::non_body_analysis());
 
         MirLowerCtx {
@@ -1766,8 +1766,8 @@ impl<'a, 'db> MirLowerCtx<'a, 'db> {
 
     fn is_uninhabited(&self, expr_id: ExprId) -> bool {
         is_ty_uninhabited_from(
-            self.db,
-            &self.infer[expr_id].to_chalk(self.interner()),
+            &self.infcx,
+            self.infer[expr_id],
             self.owner.module(self.db),
             self.env.clone(),
         )
diff --git a/crates/hir-ty/src/mir/pretty.rs b/crates/hir-ty/src/mir/pretty.rs
index e46edb815918..0c5a64935e49 100644
--- a/crates/hir-ty/src/mir/pretty.rs
+++ b/crates/hir-ty/src/mir/pretty.rs
@@ -118,10 +118,10 @@ enum LocalName<'db> {
     Binding(Name, LocalId<'db>),
 }
 
-impl<'db> HirDisplay for LocalName<'db> {
+impl<'db> HirDisplay<'db> for LocalName<'db> {
     fn hir_fmt(
         &self,
-        f: &mut crate::display::HirFormatter<'_>,
+        f: &mut crate::display::HirFormatter<'_, 'db>,
     ) -> Result<(), crate::display::HirDisplayError> {
         match self {
             LocalName::Unknown(l) => write!(f, "_{}", u32::from(l.into_raw())),
@@ -489,7 +489,7 @@ impl<'a, 'db> MirPrettyCtx<'a, 'db> {
         }
     }
 
-    fn hir_display<'b, T: HirDisplay>(&self, ty: &'b T) -> impl Display + use<'a, 'b, 'db, T>
+    fn hir_display<'b, T: HirDisplay<'db>>(&self, ty: &'b T) -> impl Display + use<'a, 'b, 'db, T>
     where
         'db: 'b,
     {
diff --git a/crates/hir-ty/src/next_solver/consts.rs b/crates/hir-ty/src/next_solver/consts.rs
index 2fc1fc4f45a5..c5a1e7d31546 100644
--- a/crates/hir-ty/src/next_solver/consts.rs
+++ b/crates/hir-ty/src/next_solver/consts.rs
@@ -82,7 +82,11 @@ impl<'db> Const<'db> {
     }
 
     pub fn is_ct_infer(&self) -> bool {
-        matches!(&self.inner().internee, ConstKind::Infer(_))
+        matches!(self.kind(), ConstKind::Infer(_))
+    }
+
+    pub fn is_error(&self) -> bool {
+        matches!(self.kind(), ConstKind::Error(_))
     }
 
     pub fn is_trivially_wf(self) -> bool {
diff --git a/crates/hir-ty/src/next_solver/def_id.rs b/crates/hir-ty/src/next_solver/def_id.rs
index 789be3b731b1..8525d4bc96e6 100644
--- a/crates/hir-ty/src/next_solver/def_id.rs
+++ b/crates/hir-ty/src/next_solver/def_id.rs
@@ -1,8 +1,8 @@
 //! Definition of `SolverDefId`
 
 use hir_def::{
-    AdtId, CallableDefId, ConstId, EnumId, EnumVariantId, FunctionId, GeneralConstId, GenericDefId,
-    ImplId, StaticId, StructId, TraitId, TypeAliasId, UnionId,
+    AdtId, CallableDefId, ConstId, DefWithBodyId, EnumId, EnumVariantId, FunctionId,
+    GeneralConstId, GenericDefId, ImplId, StaticId, StructId, TraitId, TypeAliasId, UnionId,
 };
 use rustc_type_ir::inherent;
 use stdx::impl_from;
@@ -29,6 +29,8 @@ pub enum SolverDefId {
     InternedClosureId(InternedClosureId),
     InternedCoroutineId(InternedCoroutineId),
     InternedOpaqueTyId(InternedOpaqueTyId),
+    EnumVariantId(EnumVariantId),
+    // FIXME(next-solver): Do we need the separation of `Ctor`? It duplicates some variants.
     Ctor(Ctor),
 }
 
@@ -73,6 +75,16 @@ impl std::fmt::Debug for SolverDefId {
             SolverDefId::InternedOpaqueTyId(id) => {
                 f.debug_tuple("InternedOpaqueTyId").field(&id).finish()
             }
+            SolverDefId::EnumVariantId(id) => {
+                let parent_enum = id.loc(db).parent;
+                f.debug_tuple("EnumVariantId")
+                    .field(&format_args!(
+                        "\"{}::{}\"",
+                        db.enum_signature(parent_enum).name.as_str(),
+                        parent_enum.enum_variants(db).variant_name_by_id(id).unwrap().as_str()
+                    ))
+                    .finish()
+            }
             SolverDefId::Ctor(Ctor::Struct(id)) => {
                 f.debug_tuple("Ctor").field(&db.struct_signature(id).name.as_str()).finish()
             }
@@ -101,6 +113,7 @@ impl_from!(
     InternedClosureId,
     InternedCoroutineId,
     InternedOpaqueTyId,
+    EnumVariantId,
     Ctor
     for SolverDefId
 );
@@ -129,6 +142,18 @@ impl From<GeneralConstId> for SolverDefId {
     }
 }
 
+impl From<DefWithBodyId> for SolverDefId {
+    #[inline]
+    fn from(value: DefWithBodyId) -> Self {
+        match value {
+            DefWithBodyId::FunctionId(id) => id.into(),
+            DefWithBodyId::StaticId(id) => id.into(),
+            DefWithBodyId::ConstId(id) => id.into(),
+            DefWithBodyId::VariantId(id) => id.into(),
+        }
+    }
+}
+
 impl TryFrom<SolverDefId> for GenericDefId {
     type Error = SolverDefId;
 
@@ -141,10 +166,11 @@ impl TryFrom<SolverDefId> for GenericDefId {
             SolverDefId::StaticId(static_id) => GenericDefId::StaticId(static_id),
             SolverDefId::TraitId(trait_id) => GenericDefId::TraitId(trait_id),
             SolverDefId::TypeAliasId(type_alias_id) => GenericDefId::TypeAliasId(type_alias_id),
-            SolverDefId::InternedClosureId(_) => return Err(value),
-            SolverDefId::InternedCoroutineId(_) => return Err(value),
-            SolverDefId::InternedOpaqueTyId(_) => return Err(value),
-            SolverDefId::Ctor(_) => return Err(value),
+            SolverDefId::InternedClosureId(_)
+            | SolverDefId::InternedCoroutineId(_)
+            | SolverDefId::InternedOpaqueTyId(_)
+            | SolverDefId::EnumVariantId(_)
+            | SolverDefId::Ctor(_) => return Err(value),
         })
     }
 }
diff --git a/crates/hir-ty/src/next_solver/interner.rs b/crates/hir-ty/src/next_solver/interner.rs
index 3fd8e7b39dd7..cfa8b5b8a7f7 100644
--- a/crates/hir-ty/src/next_solver/interner.rs
+++ b/crates/hir-ty/src/next_solver/interner.rs
@@ -1211,6 +1211,7 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
             | SolverDefId::AdtId(_)
             | SolverDefId::TraitId(_)
             | SolverDefId::ImplId(_)
+            | SolverDefId::EnumVariantId(..)
             | SolverDefId::Ctor(..)
             | SolverDefId::InternedOpaqueTyId(..) => panic!(),
         };
@@ -1969,8 +1970,7 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
         self,
         defining_anchor: Self::LocalDefId,
     ) -> Self::LocalDefIds {
-        // FIXME(next-solver)
-        unimplemented!()
+        Default::default()
     }
 
     type Probe = rustc_type_ir::solve::inspect::Probe<DbInterner<'db>>;
diff --git a/crates/hir-ty/src/next_solver/predicate.rs b/crates/hir-ty/src/next_solver/predicate.rs
index 9dda9d06da27..6a0a07705a8c 100644
--- a/crates/hir-ty/src/next_solver/predicate.rs
+++ b/crates/hir-ty/src/next_solver/predicate.rs
@@ -647,6 +647,26 @@ impl<'db> UpcastFrom<DbInterner<'db>, ty::OutlivesPredicate<DbInterner<'db>, Reg
         PredicateKind::Clause(ClauseKind::RegionOutlives(from)).upcast(interner)
     }
 }
+impl<'db> UpcastFrom<DbInterner<'db>, ty::OutlivesPredicate<DbInterner<'db>, Ty<'db>>>
+    for Clause<'db>
+{
+    fn upcast_from(
+        from: ty::OutlivesPredicate<DbInterner<'db>, Ty<'db>>,
+        interner: DbInterner<'db>,
+    ) -> Self {
+        Clause(from.upcast(interner))
+    }
+}
+impl<'db> UpcastFrom<DbInterner<'db>, ty::OutlivesPredicate<DbInterner<'db>, Region<'db>>>
+    for Clause<'db>
+{
+    fn upcast_from(
+        from: ty::OutlivesPredicate<DbInterner<'db>, Region<'db>>,
+        interner: DbInterner<'db>,
+    ) -> Self {
+        Clause(from.upcast(interner))
+    }
+}
 
 impl<'db> UpcastFrom<DbInterner<'db>, PolyRegionOutlivesPredicate<'db>> for Predicate<'db> {
     fn upcast_from(from: PolyRegionOutlivesPredicate<'db>, tcx: DbInterner<'db>) -> Self {
diff --git a/crates/hir-ty/src/traits.rs b/crates/hir-ty/src/traits.rs
index cd125f3af864..35c8a197f52c 100644
--- a/crates/hir-ty/src/traits.rs
+++ b/crates/hir-ty/src/traits.rs
@@ -12,22 +12,20 @@ use intern::sym;
 use rustc_next_trait_solver::solve::{HasChanged, SolverDelegateEvalExt};
 use rustc_type_ir::{
     InferCtxtLike, TypingMode,
-    inherent::{IntoKind, SliceLike, Span as _, Ty as _},
+    inherent::{IntoKind, SliceLike, Span as _},
     solve::Certainty,
 };
 use span::Edition;
-use stdx::never;
 use triomphe::Arc;
 
 use crate::{
-    AliasEq, AliasTy, Canonical, DomainGoal, Goal, InEnvironment, Interner, ProjectionTy,
-    ProjectionTyExt, TraitRefExt, Ty, TyKind, TypeFlags, WhereClause,
+    AliasEq, AliasTy, Canonical, DomainGoal, Goal, InEnvironment, Interner, ProjectionTyExt,
+    TraitRefExt, TyKind, WhereClause,
     db::HirDatabase,
-    from_assoc_type_id,
     next_solver::{
         DbInterner, GenericArg, ParamEnv, Predicate, SolverContext, Span,
         infer::{DbInternerInferExt, InferCtxt, traits::ObligationCause},
-        mapping::{ChalkToNextSolver, NextSolverToChalk, convert_canonical_args_for_result},
+        mapping::{ChalkToNextSolver, convert_canonical_args_for_result},
         obligation_ctxt::ObligationCtxt,
         util::mini_canonicalize,
     },
@@ -94,47 +92,6 @@ pub fn structurally_normalize_ty<'db>(
     ty.replace_infer_with_error(infcx.interner)
 }
 
-pub(crate) fn normalize_projection_query<'db>(
-    db: &'db dyn HirDatabase,
-    projection: ProjectionTy,
-    env: Arc<TraitEnvironment<'db>>,
-) -> Ty {
-    if projection.substitution.iter(Interner).any(|arg| {
-        arg.ty(Interner)
-            .is_some_and(|ty| ty.data(Interner).flags.intersects(TypeFlags::HAS_TY_INFER))
-    }) {
-        never!(
-            "Invoking `normalize_projection_query` with a projection type containing inference var"
-        );
-        return TyKind::Error.intern(Interner);
-    }
-
-    let interner = DbInterner::new_with(db, Some(env.krate), env.block);
-    // FIXME(next-solver): I believe this should use `PostAnalysis` (this is only used for IDE things),
-    // but this causes some bug because of our incorrect impl of `type_of_opaque_hir_typeck()` for TAIT
-    // and async blocks.
-    let infcx = interner.infer_ctxt().build(TypingMode::Analysis {
-        defining_opaque_types_and_generators: crate::next_solver::SolverDefIds::new_from_iter(
-            interner,
-            [],
-        ),
-    });
-    let alias_ty = crate::next_solver::Ty::new_alias(
-        interner,
-        rustc_type_ir::AliasTyKind::Projection,
-        crate::next_solver::AliasTy::new(
-            interner,
-            from_assoc_type_id(projection.associated_ty_id).into(),
-            <crate::Substitution as ChalkToNextSolver<crate::next_solver::GenericArgs<'_>>>::to_nextsolver(&projection.substitution, interner),
-        ),
-    );
-    let mut ctxt = crate::next_solver::obligation_ctxt::ObligationCtxt::new(&infcx);
-    let normalized = ctxt
-        .structurally_normalize_ty(&ObligationCause::dummy(), env.env, alias_ty)
-        .unwrap_or(alias_ty);
-    normalized.replace_infer_with_error(interner).to_chalk(interner)
-}
-
 fn identity_subst(
     binders: chalk_ir::CanonicalVarKinds<Interner>,
 ) -> chalk_ir::Canonical<chalk_ir::Substitution<Interner>> {
@@ -165,45 +122,6 @@ fn identity_subst(
     chalk_ir::Canonical { binders, value: identity_subst }
 }
 
-/// Solve a trait goal using next trait solver.
-pub(crate) fn trait_solve_query(
-    db: &dyn HirDatabase,
-    krate: Crate,
-    block: Option<BlockId>,
-    goal: Canonical<InEnvironment<Goal>>,
-) -> NextTraitSolveResult {
-    let _p = tracing::info_span!("trait_solve_query", detail = ?match &goal.value.goal.data(Interner) {
-        GoalData::DomainGoal(DomainGoal::Holds(WhereClause::Implemented(it))) => db
-            .trait_signature(it.hir_trait_id())
-            .name
-            .display(db, Edition::LATEST)
-            .to_string(),
-        GoalData::DomainGoal(DomainGoal::Holds(WhereClause::AliasEq(_))) => "alias_eq".to_owned(),
-        _ => "??".to_owned(),
-    })
-    .entered();
-
-    if let GoalData::DomainGoal(DomainGoal::Holds(WhereClause::AliasEq(AliasEq {
-        alias: AliasTy::Projection(projection_ty),
-        ..
-    }))) = &goal.value.goal.data(Interner)
-        && let TyKind::BoundVar(_) = projection_ty.self_type_parameter(db).kind(Interner)
-    {
-        // Hack: don't ask Chalk to normalize with an unknown self type, it'll say that's impossible
-        return NextTraitSolveResult::Uncertain(identity_subst(goal.binders.clone()));
-    }
-
-    // Chalk see `UnevaluatedConst` as a unique concrete value, but we see it as an alias for another const. So
-    // we should get rid of it when talking to chalk.
-    let goal = goal
-        .try_fold_with(&mut UnevaluatedConstEvaluatorFolder { db }, DebruijnIndex::INNERMOST)
-        .unwrap();
-
-    // We currently don't deal with universes (I think / hope they're not yet
-    // relevant for our use cases?)
-    next_trait_solve(db, krate, block, goal)
-}
-
 fn solve_nextsolver<'db>(
     db: &'db dyn HirDatabase,
     krate: Crate,
diff --git a/crates/hir-ty/src/utils.rs b/crates/hir-ty/src/utils.rs
index e989e4c006ff..15359922c80e 100644
--- a/crates/hir-ty/src/utils.rs
+++ b/crates/hir-ty/src/utils.rs
@@ -25,8 +25,7 @@ use smallvec::{SmallVec, smallvec};
 use span::Edition;
 
 use crate::{
-    ChalkTraitId, Const, ConstScalar, Interner, Substitution, TargetFeatures, TraitRef,
-    TraitRefExt, Ty,
+    ChalkTraitId, Const, ConstScalar, Interner, TargetFeatures, TraitRef, TraitRefExt,
     consteval::unknown_const,
     db::HirDatabase,
     layout::{Layout, TagEncoding},
@@ -192,19 +191,6 @@ pub(super) fn associated_type_by_name_including_super_traits(
     })
 }
 
-pub(crate) struct ClosureSubst<'a>(pub(crate) &'a Substitution);
-
-impl<'a> ClosureSubst<'a> {
-    pub(crate) fn sig_ty(&self, db: &dyn HirDatabase) -> Ty {
-        let interner = DbInterner::new_with(db, None, None);
-        let subst =
-            <Substitution as ChalkToNextSolver<crate::next_solver::GenericArgs<'_>>>::to_nextsolver(
-                self.0, interner,
-            );
-        subst.split_closure_args_untupled().closure_sig_as_fn_ptr_ty.to_chalk(interner)
-    }
-}
-
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum Unsafety {
     Safe,
diff --git a/crates/hir/src/display.rs b/crates/hir/src/display.rs
index 49bf843367d3..b31bb248e839 100644
--- a/crates/hir/src/display.rs
+++ b/crates/hir/src/display.rs
@@ -11,14 +11,15 @@ use hir_def::{
     type_ref::{TypeBound, TypeRef, TypeRefId},
 };
 use hir_ty::{
-    AliasEq, AliasTy, Interner, ProjectionTyExt, TraitRefExt, TyBuilder, TyKind, WhereClause,
     db::HirDatabase,
     display::{
         HirDisplay, HirDisplayError, HirDisplayWithExpressionStore, HirFormatter, SizedByDefault,
         hir_display_with_store, write_bounds_like_dyn_trait_with_prefix, write_visibility,
     },
+    next_solver::ClauseKind,
 };
 use itertools::Itertools;
+use rustc_type_ir::inherent::IntoKind;
 
 use crate::{
     Adt, AsAssocItem, AssocItem, AssocItemContainer, Const, ConstParam, Crate, Enum,
@@ -27,8 +28,8 @@ use crate::{
     TypeAlias, TypeNs, TypeOrConstParam, TypeParam, Union, Variant,
 };
 
-impl HirDisplay for Function {
-    fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
+impl<'db> HirDisplay<'db> for Function {
+    fn hir_fmt(&self, f: &mut HirFormatter<'_, 'db>) -> Result<(), HirDisplayError> {
         let db = f.db;
         let data = db.function_signature(self.id);
         let container = self.as_assoc_item(db).map(|it| it.container(db));
@@ -184,7 +185,10 @@ impl HirDisplay for Function {
     }
 }
 
-fn write_impl_header(impl_: &Impl, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
+fn write_impl_header<'db>(
+    impl_: &Impl,
+    f: &mut HirFormatter<'_, 'db>,
+) -> Result<(), HirDisplayError> {
     let db = f.db;
 
     f.write_str("impl")?;
@@ -202,8 +206,8 @@ fn write_impl_header(impl_: &Impl, f: &mut HirFormatter<'_>) -> Result<(), HirDi
     Ok(())
 }
 
-impl HirDisplay for SelfParam {
-    fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
+impl<'db> HirDisplay<'db> for SelfParam {
+    fn hir_fmt(&self, f: &mut HirFormatter<'_, 'db>) -> Result<(), HirDisplayError> {
         let data = f.db.function_signature(self.func);
         let param = *data.params.first().unwrap();
         match &data.store[param] {
@@ -228,8 +232,8 @@ impl HirDisplay for SelfParam {
     }
 }
 
-impl HirDisplay for Adt {
-    fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
+impl<'db> HirDisplay<'db> for Adt {
+    fn hir_fmt(&self, f: &mut HirFormatter<'_, 'db>) -> Result<(), HirDisplayError> {
         match self {
             Adt::Struct(it) => it.hir_fmt(f),
             Adt::Union(it) => it.hir_fmt(f),
@@ -238,8 +242,8 @@ impl HirDisplay for Adt {
     }
 }
 
-impl HirDisplay for Struct {
-    fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
+impl<'db> HirDisplay<'db> for Struct {
+    fn hir_fmt(&self, f: &mut HirFormatter<'_, 'db>) -> Result<(), HirDisplayError> {
         let module_id = self.module(f.db).id;
         // FIXME: Render repr if its set explicitly?
         write_visibility(module_id, self.visibility(f.db), f)?;
@@ -279,8 +283,8 @@ impl HirDisplay for Struct {
     }
 }
 
-impl HirDisplay for Enum {
-    fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
+impl<'db> HirDisplay<'db> for Enum {
+    fn hir_fmt(&self, f: &mut HirFormatter<'_, 'db>) -> Result<(), HirDisplayError> {
         write_visibility(self.module(f.db).id, self.visibility(f.db), f)?;
         f.write_str("enum ")?;
         write!(f, "{}", self.name(f.db).display(f.db, f.edition()))?;
@@ -296,8 +300,8 @@ impl HirDisplay for Enum {
     }
 }
 
-impl HirDisplay for Union {
-    fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
+impl<'db> HirDisplay<'db> for Union {
+    fn hir_fmt(&self, f: &mut HirFormatter<'_, 'db>) -> Result<(), HirDisplayError> {
         write_visibility(self.module(f.db).id, self.visibility(f.db), f)?;
         f.write_str("union ")?;
         write!(f, "{}", self.name(f.db).display(f.db, f.edition()))?;
@@ -312,12 +316,12 @@ impl HirDisplay for Union {
     }
 }
 
-fn write_fields(
+fn write_fields<'db>(
     fields: &[Field],
     has_where_clause: bool,
     limit: usize,
     in_line: bool,
-    f: &mut HirFormatter<'_>,
+    f: &mut HirFormatter<'_, 'db>,
 ) -> Result<(), HirDisplayError> {
     let count = fields.len().min(limit);
     let (indent, separator) = if in_line { ("", ' ') } else { ("    ", '\n') };
@@ -346,11 +350,11 @@ fn write_fields(
     Ok(())
 }
 
-fn write_variants(
+fn write_variants<'db>(
     variants: &[Variant],
     has_where_clause: bool,
     limit: usize,
-    f: &mut HirFormatter<'_>,
+    f: &mut HirFormatter<'_, 'db>,
 ) -> Result<(), HirDisplayError> {
     let count = variants.len().min(limit);
     f.write_char(if !has_where_clause { ' ' } else { '\n' })?;
@@ -386,23 +390,23 @@ fn write_variants(
     Ok(())
 }
 
-impl HirDisplay for Field {
-    fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
+impl<'db> HirDisplay<'db> for Field {
+    fn hir_fmt(&self, f: &mut HirFormatter<'_, 'db>) -> Result<(), HirDisplayError> {
         write_visibility(self.parent.module(f.db).id, self.visibility(f.db), f)?;
         write!(f, "{}: ", self.name(f.db).display(f.db, f.edition()))?;
         self.ty(f.db).hir_fmt(f)
     }
 }
 
-impl HirDisplay for TupleField {
-    fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
+impl<'db> HirDisplay<'db> for TupleField {
+    fn hir_fmt(&self, f: &mut HirFormatter<'_, 'db>) -> Result<(), HirDisplayError> {
         write!(f, "pub {}: ", self.name().display(f.db, f.edition()))?;
         self.ty(f.db).hir_fmt(f)
     }
 }
 
-impl HirDisplay for Variant {
-    fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
+impl<'db> HirDisplay<'db> for Variant {
+    fn hir_fmt(&self, f: &mut HirFormatter<'_, 'db>) -> Result<(), HirDisplayError> {
         write!(f, "{}", self.name(f.db).display(f.db, f.edition()))?;
         let data = self.id.fields(f.db);
         match data.shape {
@@ -431,20 +435,20 @@ impl HirDisplay for Variant {
     }
 }
 
-impl HirDisplay for Type<'_> {
-    fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
+impl<'db> HirDisplay<'db> for Type<'db> {
+    fn hir_fmt(&self, f: &mut HirFormatter<'_, 'db>) -> Result<(), HirDisplayError> {
         self.ty.hir_fmt(f)
     }
 }
 
-impl HirDisplay for TypeNs<'_> {
-    fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
+impl<'db> HirDisplay<'db> for TypeNs<'db> {
+    fn hir_fmt(&self, f: &mut HirFormatter<'_, 'db>) -> Result<(), HirDisplayError> {
         self.ty.hir_fmt(f)
     }
 }
 
-impl HirDisplay for ExternCrateDecl {
-    fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
+impl<'db> HirDisplay<'db> for ExternCrateDecl {
+    fn hir_fmt(&self, f: &mut HirFormatter<'_, 'db>) -> Result<(), HirDisplayError> {
         write_visibility(self.module(f.db).id, self.visibility(f.db), f)?;
         f.write_str("extern crate ")?;
         write!(f, "{}", self.name(f.db).display(f.db, f.edition()))?;
@@ -455,8 +459,8 @@ impl HirDisplay for ExternCrateDecl {
     }
 }
 
-impl HirDisplay for GenericParam {
-    fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
+impl<'db> HirDisplay<'db> for GenericParam {
+    fn hir_fmt(&self, f: &mut HirFormatter<'_, 'db>) -> Result<(), HirDisplayError> {
         match self {
             GenericParam::TypeParam(it) => it.hir_fmt(f),
             GenericParam::ConstParam(it) => it.hir_fmt(f),
@@ -465,8 +469,8 @@ impl HirDisplay for GenericParam {
     }
 }
 
-impl HirDisplay for TypeOrConstParam {
-    fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
+impl<'db> HirDisplay<'db> for TypeOrConstParam {
+    fn hir_fmt(&self, f: &mut HirFormatter<'_, 'db>) -> Result<(), HirDisplayError> {
         match self.split(f.db) {
             either::Either::Left(it) => it.hir_fmt(f),
             either::Either::Right(it) => it.hir_fmt(f),
@@ -474,27 +478,22 @@ impl HirDisplay for TypeOrConstParam {
     }
 }
 
-impl HirDisplay for TypeParam {
-    fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
+impl<'db> HirDisplay<'db> for TypeParam {
+    fn hir_fmt(&self, f: &mut HirFormatter<'_, 'db>) -> Result<(), HirDisplayError> {
         let params = f.db.generic_params(self.id.parent());
         let param_data = &params[self.id.local_id()];
-        let substs = TyBuilder::placeholder_subst(f.db, self.id.parent());
         let krate = self.id.parent().krate(f.db).id;
-        let ty = TyKind::Placeholder(hir_ty::to_placeholder_idx_no_index(f.db, self.id.into()))
-            .intern(Interner);
-        let predicates = f.db.generic_predicates(self.id.parent());
+        let ty = self.ty(f.db).ty;
+        let predicates = f.db.generic_predicates_ns(self.id.parent());
         let predicates = predicates
-            .iter()
-            .cloned()
-            .map(|pred| pred.substitute(Interner, &substs))
-            .filter(|wc| match wc.skip_binders() {
-                WhereClause::Implemented(tr) => tr.self_type_parameter(Interner) == ty,
-                WhereClause::AliasEq(AliasEq { alias: AliasTy::Projection(proj), ty: _ }) => {
-                    proj.self_type_parameter(f.db) == ty
-                }
-                WhereClause::AliasEq(_) => false,
-                WhereClause::TypeOutlives(to) => to.ty == ty,
-                WhereClause::LifetimeOutlives(_) => false,
+            .instantiate_identity()
+            .into_iter()
+            .flatten()
+            .filter(|wc| match wc.kind().skip_binder() {
+                ClauseKind::Trait(tr) => tr.self_ty() == ty,
+                ClauseKind::Projection(proj) => proj.self_ty() == ty,
+                ClauseKind::TypeOutlives(to) => to.0 == ty,
+                _ => false,
             })
             .collect::<Vec<_>>();
 
@@ -507,7 +506,7 @@ impl HirDisplay for TypeParam {
                     return write_bounds_like_dyn_trait_with_prefix(
                         f,
                         "impl",
-                        Either::Left(&ty),
+                        Either::Left(ty),
                         &predicates,
                         SizedByDefault::Sized { anchor: krate },
                     );
@@ -523,23 +522,18 @@ impl HirDisplay for TypeParam {
         }
 
         let sized_trait = LangItem::Sized.resolve_trait(f.db, krate);
-        let has_only_sized_bound = predicates.iter().all(move |pred| match pred.skip_binders() {
-            WhereClause::Implemented(it) => Some(it.hir_trait_id()) == sized_trait,
-            _ => false,
-        });
+        let has_only_sized_bound =
+            predicates.iter().all(move |pred| match pred.kind().skip_binder() {
+                ClauseKind::Trait(it) => Some(it.def_id().0) == sized_trait,
+                _ => false,
+            });
         let has_only_not_sized_bound = predicates.is_empty();
         if !has_only_sized_bound || has_only_not_sized_bound {
             let default_sized = SizedByDefault::Sized { anchor: krate };
             write_bounds_like_dyn_trait_with_prefix(
                 f,
                 ":",
-                Either::Left(
-                    &hir_ty::TyKind::Placeholder(hir_ty::to_placeholder_idx_no_index(
-                        f.db,
-                        self.id.into(),
-                    ))
-                    .intern(Interner),
-                ),
+                Either::Left(ty),
                 &predicates,
                 default_sized,
             )?;
@@ -548,22 +542,22 @@ impl HirDisplay for TypeParam {
     }
 }
 
-impl HirDisplay for LifetimeParam {
-    fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
+impl<'db> HirDisplay<'db> for LifetimeParam {
+    fn hir_fmt(&self, f: &mut HirFormatter<'_, 'db>) -> Result<(), HirDisplayError> {
         write!(f, "{}", self.name(f.db).display(f.db, f.edition()))
     }
 }
 
-impl HirDisplay for ConstParam {
-    fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
+impl<'db> HirDisplay<'db> for ConstParam {
+    fn hir_fmt(&self, f: &mut HirFormatter<'_, 'db>) -> Result<(), HirDisplayError> {
         write!(f, "const {}: ", self.name(f.db).display(f.db, f.edition()))?;
         self.ty(f.db).hir_fmt(f)
     }
 }
 
-fn write_generic_params(
+fn write_generic_params<'db>(
     def: GenericDefId,
-    f: &mut HirFormatter<'_>,
+    f: &mut HirFormatter<'_, 'db>,
 ) -> Result<(), HirDisplayError> {
     let (params, store) = f.db.generic_params_and_store(def);
     if params.iter_lt().next().is_none()
@@ -578,7 +572,7 @@ fn write_generic_params(
     f.write_char('<')?;
 
     let mut first = true;
-    let mut delim = |f: &mut HirFormatter<'_>| {
+    let mut delim = |f: &mut HirFormatter<'_, 'db>| {
         if first {
             first = false;
             Ok(())
@@ -622,9 +616,9 @@ fn write_generic_params(
     Ok(())
 }
 
-fn write_where_clause(
+fn write_where_clause<'db>(
     def: GenericDefId,
-    f: &mut HirFormatter<'_>,
+    f: &mut HirFormatter<'_, 'db>,
 ) -> Result<bool, HirDisplayError> {
     let (params, store) = f.db.generic_params_and_store(def);
     if !has_disaplayable_predicates(f.db, &params, &store) {
@@ -653,10 +647,10 @@ fn has_disaplayable_predicates(
     })
 }
 
-fn write_where_predicates(
+fn write_where_predicates<'db>(
     params: &GenericParams,
     store: &ExpressionStore,
-    f: &mut HirFormatter<'_>,
+    f: &mut HirFormatter<'_, 'db>,
 ) -> Result<(), HirDisplayError> {
     use WherePredicate::*;
 
@@ -717,8 +711,8 @@ fn write_where_predicates(
     Ok(())
 }
 
-impl HirDisplay for Const {
-    fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
+impl<'db> HirDisplay<'db> for Const {
+    fn hir_fmt(&self, f: &mut HirFormatter<'_, 'db>) -> Result<(), HirDisplayError> {
         let db = f.db;
         let container = self.as_assoc_item(db).map(|it| it.container(db));
         let mut module = self.module(db);
@@ -738,8 +732,8 @@ impl HirDisplay for Const {
     }
 }
 
-impl HirDisplay for Static {
-    fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
+impl<'db> HirDisplay<'db> for Static {
+    fn hir_fmt(&self, f: &mut HirFormatter<'_, 'db>) -> Result<(), HirDisplayError> {
         write_visibility(self.module(f.db).id, self.visibility(f.db), f)?;
         let data = f.db.static_signature(self.id);
         f.write_str("static ")?;
@@ -752,14 +746,14 @@ impl HirDisplay for Static {
     }
 }
 
-impl HirDisplay for TraitRef<'_> {
-    fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
+impl<'db> HirDisplay<'db> for TraitRef<'db> {
+    fn hir_fmt(&self, f: &mut HirFormatter<'_, 'db>) -> Result<(), HirDisplayError> {
         self.trait_ref.hir_fmt(f)
     }
 }
 
-impl HirDisplay for Trait {
-    fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
+impl<'db> HirDisplay<'db> for Trait {
+    fn hir_fmt(&self, f: &mut HirFormatter<'_, 'db>) -> Result<(), HirDisplayError> {
         // FIXME(trait-alias) needs special handling to print the equal sign
         write_trait_header(self, f)?;
         let def_id = GenericDefId::TraitId(self.id);
@@ -798,7 +792,10 @@ impl HirDisplay for Trait {
     }
 }
 
-fn write_trait_header(trait_: &Trait, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
+fn write_trait_header<'db>(
+    trait_: &Trait,
+    f: &mut HirFormatter<'_, 'db>,
+) -> Result<(), HirDisplayError> {
     write_visibility(trait_.module(f.db).id, trait_.visibility(f.db), f)?;
     let data = f.db.trait_signature(trait_.id);
     if data.flags.contains(TraitFlags::UNSAFE) {
@@ -812,8 +809,8 @@ fn write_trait_header(trait_: &Trait, f: &mut HirFormatter<'_>) -> Result<(), Hi
     Ok(())
 }
 
-impl HirDisplay for TypeAlias {
-    fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
+impl<'db> HirDisplay<'db> for TypeAlias {
+    fn hir_fmt(&self, f: &mut HirFormatter<'_, 'db>) -> Result<(), HirDisplayError> {
         write_visibility(self.module(f.db).id, self.visibility(f.db), f)?;
         let data = f.db.type_alias_signature(self.id);
         write!(f, "type {}", data.name.display(f.db, f.edition()))?;
@@ -835,8 +832,8 @@ impl HirDisplay for TypeAlias {
     }
 }
 
-impl HirDisplay for Module {
-    fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
+impl<'db> HirDisplay<'db> for Module {
+    fn hir_fmt(&self, f: &mut HirFormatter<'_, 'db>) -> Result<(), HirDisplayError> {
         match self.parent(f.db) {
             Some(m) => write_visibility(m.id, self.visibility(f.db), f)?,
             None => {
@@ -853,8 +850,8 @@ impl HirDisplay for Module {
     }
 }
 
-impl HirDisplay for Crate {
-    fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
+impl<'db> HirDisplay<'db> for Crate {
+    fn hir_fmt(&self, f: &mut HirFormatter<'_, 'db>) -> Result<(), HirDisplayError> {
         match self.display_name(f.db) {
             Some(name) => write!(f, "extern crate {name}"),
             None => f.write_str("extern crate {unknown}"),
@@ -862,8 +859,8 @@ impl HirDisplay for Crate {
     }
 }
 
-impl HirDisplay for Macro {
-    fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
+impl<'db> HirDisplay<'db> for Macro {
+    fn hir_fmt(&self, f: &mut HirFormatter<'_, 'db>) -> Result<(), HirDisplayError> {
         match self.id {
             hir_def::MacroId::Macro2Id(_) => f.write_str("macro"),
             hir_def::MacroId::MacroRulesId(_) => f.write_str("macro_rules!"),
diff --git a/crates/hir/src/lib.rs b/crates/hir/src/lib.rs
index 55da27781db1..fc516a6764a5 100644
--- a/crates/hir/src/lib.rs
+++ b/crates/hir/src/lib.rs
@@ -3692,7 +3692,7 @@ impl GenericDef {
         };
 
         expr_store_diagnostics(db, acc, &source_map);
-        push_ty_diagnostics(db, acc, db.generic_defaults_with_diagnostics(def).1, &source_map);
+        push_ty_diagnostics(db, acc, db.generic_defaults_ns_with_diagnostics(def).1, &source_map);
         push_ty_diagnostics(
             db,
             acc,
diff --git a/crates/ide/src/hover/tests.rs b/crates/ide/src/hover/tests.rs
index df1800616803..6c4a074d46d6 100644
--- a/crates/ide/src/hover/tests.rs
+++ b/crates/ide/src/hover/tests.rs
@@ -9392,7 +9392,7 @@ fn main(a$0: T) {}
             *a*
 
             ```rust
-            a: T
+            a: T<T>
             ```
 
             ---
diff --git a/crates/ide/src/moniker.rs b/crates/ide/src/moniker.rs
index f1aa03c8f267..4aa9eb98a1e1 100644
--- a/crates/ide/src/moniker.rs
+++ b/crates/ide/src/moniker.rs
@@ -384,7 +384,7 @@ fn def_to_non_local_moniker(
     })
 }
 
-fn display<T: HirDisplay>(db: &RootDatabase, module: hir::Module, it: T) -> String {
+fn display<'db, T: HirDisplay<'db>>(db: &'db RootDatabase, module: hir::Module, it: T) -> String {
     match it.display_source_code(db, module.into(), true) {
         Ok(result) => result,
         // Fallback on display variant that always succeeds
diff --git a/crates/ide/src/navigation_target.rs b/crates/ide/src/navigation_target.rs
index db1298385b11..93090e2a0203 100644
--- a/crates/ide/src/navigation_target.rs
+++ b/crates/ide/src/navigation_target.rs
@@ -382,7 +382,7 @@ impl ToNavFromAst for hir::Trait {
 
 impl<D> TryToNav for D
 where
-    D: HasSource + ToNavFromAst + Copy + HasDocs + HirDisplay + HasCrate,
+    D: HasSource + ToNavFromAst + Copy + HasDocs + for<'db> HirDisplay<'db> + HasCrate,
     D::Ast: ast::HasName,
 {
     fn try_to_nav(