Make sense of the mess that were (are) different kind of generics in the solver

To the extent possible.

Previously they were confused. Sometimes generic params were treated as `Param` and sometimes as `Placeholder`. A completely redundant (in the new solver) mapping of salsa::Id to ints to intern some info where we could just store it uninterned (not in Chalk though, for some weird reason).

Plus fix a cute bug in closure substitution that was caught by the assertions of Chalk but the next solver did not have such assertions. Do we need more assertions?

Author: ChayimFriedman2

crates/hir-ty/src/chalk_ext.rs

@@ -306,7 +306,7 @@ impl TyExt for Ty {
                 predicates.map(|it| it.into_value_and_skipped_binders().0)
             }
             TyKind::Placeholder(idx) => {
-                let id = from_placeholder_idx(db, *idx);
+                let id = from_placeholder_idx(db, *idx).0;
                 let generic_params = db.generic_params(id.parent);
                 let param_data = &generic_params[id.local_id];
                 match param_data {

crates/hir-ty/src/consteval.rs

@@ -107,25 +107,24 @@ pub(crate) fn path_to_const<'g>(
     match resolver.resolve_path_in_value_ns_fully(db, path, HygieneId::ROOT) {
         Some(ValueNs::GenericParam(p)) => {
             let ty = db.const_param_ty(p);
+            let args = args();
             let value = match mode {
                 ParamLoweringMode::Placeholder => {
-                    ConstValue::Placeholder(to_placeholder_idx(db, p.into()))
+                    let idx = args.type_or_const_param_idx(p.into()).unwrap();
+                    ConstValue::Placeholder(to_placeholder_idx(db, p.into(), idx as u32))
                 }
-                ParamLoweringMode::Variable => {
-                    let args = args();
-                    match args.type_or_const_param_idx(p.into()) {
-                        Some(it) => ConstValue::BoundVar(BoundVar::new(debruijn, it)),
-                        None => {
-                            never!(
-                                "Generic list doesn't contain this param: {:?}, {:?}, {:?}",
-                                args,
-                                path,
-                                p
-                            );
-                            return None;
-                        }
+                ParamLoweringMode::Variable => match args.type_or_const_param_idx(p.into()) {
+                    Some(it) => ConstValue::BoundVar(BoundVar::new(debruijn, it)),
+                    None => {
+                        never!(
+                            "Generic list doesn't contain this param: {:?}, {:?}, {:?}",
+                            args,
+                            path,
+                            p
+                        );
+                        return None;
                     }
-                }
+                },
             };
             Some(ConstData { ty, value }.intern(Interner))
         }

crates/hir-ty/src/consteval_nextsolver.rs

@@ -49,7 +49,7 @@ pub(crate) fn path_to_const<'a, 'g>(
                 .and_then(|(idx, p)| p.const_param().map(|p| (idx, p.clone())))
             {
                 Some((idx, _param)) => {
-                    Some(Const::new_param(interner, ParamConst { index: idx as u32 }))
+                    Some(Const::new_param(interner, ParamConst { index: idx as u32, id: p }))
                 }
                 None => {
                     never!(

crates/hir-ty/src/db.rs

@@ -410,13 +410,15 @@ fn hir_database_is_dyn_compatible() {
 #[salsa_macros::interned(no_lifetime, debug, revisions = usize::MAX)]
 #[derive(PartialOrd, Ord)]
 pub struct InternedTypeOrConstParamId {
-    pub loc: TypeOrConstParamId,
+    /// This stores the param and its index.
+    pub loc: (TypeOrConstParamId, u32),
 }
 
 #[salsa_macros::interned(no_lifetime, debug, revisions = usize::MAX)]
 #[derive(PartialOrd, Ord)]
 pub struct InternedLifetimeParamId {
-    pub loc: LifetimeParamId,
+    /// This stores the param and its index.
+    pub loc: (LifetimeParamId, u32),
 }
 
 #[salsa_macros::interned(no_lifetime, debug, revisions = usize::MAX)]

crates/hir-ty/src/display.rs

@@ -61,9 +61,8 @@ use crate::{
     next_solver::{
         BoundExistentialPredicate, Ctor, DbInterner, GenericArgs, SolverDefId,
         mapping::{
-            ChalkToNextSolver, bound_var_to_lifetime_idx, bound_var_to_type_or_const_param_idx,
-            convert_args_for_result, convert_const_for_result, convert_region_for_result,
-            convert_ty_for_result,
+            ChalkToNextSolver, convert_args_for_result, convert_const_for_result,
+            convert_region_for_result, convert_ty_for_result,
         },
     },
     primitive, to_assoc_type_id,
@@ -641,7 +640,7 @@ impl HirDisplay for ProjectionTy {
             && !f.bounds_formatting_ctx.contains(self)
         {
             let db = f.db;
-            let id = from_placeholder_idx(db, *idx);
+            let id = from_placeholder_idx(db, *idx).0;
             let generics = generics(db, id.parent);
 
             let substs = generics.placeholder_subst(db);
@@ -736,14 +735,14 @@ impl HirDisplay for Const {
 impl<'db> HirDisplay for crate::next_solver::Const<'db> {
     fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
         match self.kind() {
+            rustc_type_ir::ConstKind::Placeholder(_) => write!(f, "<placeholder>"),
             rustc_type_ir::ConstKind::Bound(db, bound_const) => {
                 write!(f, "?{}.{}", db.as_u32(), bound_const.as_u32())
             }
             rustc_type_ir::ConstKind::Infer(..) => write!(f, "#c#"),
-            rustc_type_ir::ConstKind::Placeholder(idx) => {
-                let id = bound_var_to_type_or_const_param_idx(f.db, idx.bound);
-                let generics = generics(f.db, id.parent);
-                let param_data = &generics[id.local_id];
+            rustc_type_ir::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(())
             }
@@ -765,7 +764,6 @@ impl<'db> HirDisplay for crate::next_solver::Const<'db> {
             }
             rustc_type_ir::ConstKind::Error(..) => f.write_char('_'),
             rustc_type_ir::ConstKind::Expr(..) => write!(f, "<const-expr>"),
-            rustc_type_ir::ConstKind::Param(_) => write!(f, "<param>"),
         }
     }
 }
@@ -1178,7 +1176,7 @@ impl<'db> HirDisplay for crate::next_solver::Ty<'db> {
                 if let TyKind::Ref(l, _, _) = kind {
                     f.write_char('&')?;
                     if f.render_region(l) {
-                        convert_region_for_result(l).hir_fmt(f)?;
+                        convert_region_for_result(interner, l).hir_fmt(f)?;
                         f.write_char(' ')?;
                     }
                     match m {
@@ -1611,14 +1609,10 @@ impl<'db> HirDisplay for crate::next_solver::Ty<'db> {
                     write!(f, "{{closure}}")?;
                 }
             }
-            TyKind::Placeholder(idx) => {
-                let placeholder_index = chalk_ir::PlaceholderIndex {
-                    idx: idx.bound.var.as_usize(),
-                    ui: chalk_ir::UniverseIndex { counter: idx.universe.as_usize() },
-                };
-                let id = from_placeholder_idx(db, placeholder_index);
-                let generics = generics(db, id.parent);
-                let param_data = &generics[id.local_id];
+            TyKind::Placeholder(_) => write!(f, "{{placeholder}}")?,
+            TyKind::Param(param) => {
+                let generics = generics(db, param.id.parent());
+                let param_data = &generics[param.id.local_id()];
                 match param_data {
                     TypeOrConstParamData::TypeParamData(p) => match p.provenance {
                         TypeParamProvenance::TypeParamList | TypeParamProvenance::TraitSelf => {
@@ -1634,7 +1628,7 @@ impl<'db> HirDisplay for crate::next_solver::Ty<'db> {
                         TypeParamProvenance::ArgumentImplTrait => {
                             let substs = generics.placeholder_subst(db);
                             let bounds = db
-                                .generic_predicates(id.parent)
+                                .generic_predicates(param.id.parent())
                                 .iter()
                                 .map(|pred| pred.clone().substitute(Interner, &substs))
                                 .filter(|wc| match wc.skip_binders() {
@@ -1656,7 +1650,7 @@ impl<'db> HirDisplay for crate::next_solver::Ty<'db> {
                                     WhereClause::LifetimeOutlives(_) => false,
                                 })
                                 .collect::<Vec<_>>();
-                            let krate = id.parent.module(db).krate();
+                            let krate = param.id.parent().module(db).krate();
                             write_bounds_like_dyn_trait_with_prefix(
                                 f,
                                 "impl",
@@ -1671,7 +1665,6 @@ impl<'db> HirDisplay for crate::next_solver::Ty<'db> {
                     }
                 }
             }
-            TyKind::Param(_) => write!(f, "{{param}}")?,
             TyKind::Bound(debruijn_index, ty) => {
                 let idx = chalk_ir::BoundVar {
                     debruijn: chalk_ir::DebruijnIndex::new(debruijn_index.as_u32()),
@@ -2294,7 +2287,7 @@ 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);
+                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()))?;
@@ -2319,10 +2312,9 @@ impl HirDisplay for LifetimeData {
 impl<'db> HirDisplay for crate::next_solver::Region<'db> {
     fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
         match self.kind() {
-            rustc_type_ir::RegionKind::RePlaceholder(idx) => {
-                let id = bound_var_to_lifetime_idx(f.db, idx.bound.var);
-                let generics = generics(f.db, id.parent);
-                let param_data = &generics[id.local_id];
+            rustc_type_ir::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(())
             }
@@ -2339,7 +2331,7 @@ impl<'db> HirDisplay for crate::next_solver::Region<'db> {
                 }
             }
             rustc_type_ir::RegionKind::ReErased => write!(f, "'<erased>"),
-            rustc_type_ir::RegionKind::ReEarlyParam(_) => write!(f, "<param>"),
+            rustc_type_ir::RegionKind::RePlaceholder(_) => write!(f, "<placeholder>"),
             rustc_type_ir::RegionKind::ReLateParam(_) => write!(f, "<late-param>"),
         }
     }

crates/hir-ty/src/dyn_compatibility.rs

@@ -2,10 +2,12 @@
 
 use std::ops::ControlFlow;
 
+use hir_def::hir::generics::LocalTypeOrConstParamId;
 use hir_def::{
     AssocItemId, ConstId, CrateRootModuleId, FunctionId, GenericDefId, HasModule, TraitId,
     TypeAliasId, lang_item::LangItem, signatures::TraitFlags,
 };
+use hir_def::{TypeOrConstParamId, TypeParamId};
 use intern::Symbol;
 use rustc_hash::FxHashSet;
 use rustc_type_ir::{
@@ -384,19 +386,15 @@ where
         }
 
         // Allow `impl AutoTrait` predicates
-        let interner = DbInterner::new_with(db, Some(trait_.krate(db)), None);
         if let ClauseKind::Trait(TraitPredicate {
             trait_ref: pred_trait_ref,
             polarity: PredicatePolarity::Positive,
         }) = pred
             && let SolverDefId::TraitId(trait_id) = pred_trait_ref.def_id
             && let trait_data = db.trait_signature(trait_id)
             && trait_data.flags.contains(TraitFlags::AUTO)
-            && pred_trait_ref.self_ty()
-                == crate::next_solver::Ty::new(
-                    interner,
-                    rustc_type_ir::TyKind::Param(crate::next_solver::ParamTy { index: 0 }),
-                )
+            && let rustc_type_ir::TyKind::Param(crate::next_solver::ParamTy { index: 0, .. }) =
+                pred_trait_ref.self_ty().kind()
         {
             continue;
         }
@@ -422,9 +420,13 @@ fn receiver_is_dispatchable<'db>(
     let sig = sig.instantiate_identity();
 
     let interner: DbInterner<'_> = DbInterner::new_with(db, Some(trait_.krate(db)), None);
+    let self_param_id = TypeParamId::from_unchecked(TypeOrConstParamId {
+        parent: trait_.into(),
+        local_id: LocalTypeOrConstParamId::from_raw(la_arena::RawIdx::from_u32(0)),
+    });
     let self_param_ty = crate::next_solver::Ty::new(
         interner,
-        rustc_type_ir::TyKind::Param(crate::next_solver::ParamTy { index: 0 }),
+        rustc_type_ir::TyKind::Param(crate::next_solver::ParamTy { index: 0, id: self_param_id }),
     );
 
     // `self: Self` can't be dispatched on, but this is already considered dyn-compatible
@@ -452,7 +454,9 @@ fn receiver_is_dispatchable<'db>(
     };
 
     // Type `U`
-    let unsized_self_ty = crate::next_solver::Ty::new_param(interner, u32::MAX, Symbol::empty());
+    // FIXME: That seems problematic to fake a generic param like that?
+    let unsized_self_ty =
+        crate::next_solver::Ty::new_param(interner, self_param_id, u32::MAX, Symbol::empty());
     // `Receiver[Self => U]`
     let unsized_receiver_ty = receiver_for_self_ty(interner, func, receiver_ty, unsized_self_ty);
 

crates/hir-ty/src/generics.rs

@@ -256,15 +256,15 @@ impl Generics {
     pub fn placeholder_subst(&self, db: &dyn HirDatabase) -> Substitution {
         Substitution::from_iter(
             Interner,
-            self.iter_id().map(|id| match id {
+            self.iter_id().enumerate().map(|(index, id)| match id {
                 GenericParamId::TypeParamId(id) => {
-                    to_placeholder_idx(db, id.into()).to_ty(Interner).cast(Interner)
+                    to_placeholder_idx(db, id.into(), index as u32).to_ty(Interner).cast(Interner)
                 }
-                GenericParamId::ConstParamId(id) => to_placeholder_idx(db, id.into())
+                GenericParamId::ConstParamId(id) => to_placeholder_idx(db, id.into(), index as u32)
                     .to_const(Interner, db.const_param_ty(id))
                     .cast(Interner),
                 GenericParamId::LifetimeParamId(id) => {
-                    lt_to_placeholder_idx(db, id).to_lifetime(Interner).cast(Interner)
+                    lt_to_placeholder_idx(db, id, index as u32).to_lifetime(Interner).cast(Interner)
                 }
             }),
         )

crates/hir-ty/src/infer/closure.rs

@@ -866,7 +866,7 @@ impl CapturedItemWithoutTy {
                     idx: chalk_ir::PlaceholderIndex,
                     outer_binder: DebruijnIndex,
                 ) -> Result<chalk_ir::Const<Interner>, Self::Error> {
-                    let x = from_placeholder_idx(self.db, idx);
+                    let x = from_placeholder_idx(self.db, idx).0;
                     let Some(idx) = self.generics.type_or_const_param_idx(x) else {
                         return Err(());
                     };
@@ -878,7 +878,7 @@ impl CapturedItemWithoutTy {
                     idx: chalk_ir::PlaceholderIndex,
                     outer_binder: DebruijnIndex,
                 ) -> std::result::Result<Ty, Self::Error> {
-                    let x = from_placeholder_idx(self.db, idx);
+                    let x = from_placeholder_idx(self.db, idx).0;
                     let Some(idx) = self.generics.type_or_const_param_idx(x) else {
                         return Err(());
                     };

crates/hir-ty/src/layout.rs

@@ -19,14 +19,15 @@ use rustc_type_ir::{
 };
 use triomphe::Arc;
 
+use crate::utils::ClosureSubst;
 use crate::{
-    TraitEnvironment,
+    Interner, TraitEnvironment,
     consteval_nextsolver::try_const_usize,
     db::HirDatabase,
     next_solver::{
         DbInterner, GenericArgs, ParamEnv, SolverDefId, Ty, TyKind, TypingMode,
         infer::{DbInternerInferExt, traits::ObligationCause},
-        mapping::{ChalkToNextSolver, convert_binder_to_early_binder},
+        mapping::{ChalkToNextSolver, convert_args_for_result},
         project::solve_normalize::deeply_normalize,
     },
 };
@@ -333,9 +334,15 @@ pub fn layout_of_ty_query<'db>(
             let fields = captures
                 .iter()
                 .map(|it| {
-                    let ty =
-                        convert_binder_to_early_binder(interner, it.ty.to_nextsolver(interner))
-                            .instantiate(interner, args);
+                    let ty = it
+                        .ty
+                        .clone()
+                        .substitute(
+                            Interner,
+                            ClosureSubst(&convert_args_for_result(interner, args.inner()))
+                                .parent_subst(),
+                        )
+                        .to_nextsolver(interner);
                     db.layout_of_ty(ty, trait_env.clone())
                 })
                 .collect::<Result<Vec<_>, _>>()?;

crates/hir-ty/src/lib.rs

@@ -124,7 +124,7 @@ pub use lower_nextsolver::associated_type_shorthand_candidates;
 pub use mapping::{
     ToChalk, from_assoc_type_id, from_chalk_trait_id, from_foreign_def_id, from_placeholder_idx,
     lt_from_placeholder_idx, lt_to_placeholder_idx, to_assoc_type_id, to_chalk_trait_id,
-    to_foreign_def_id, to_placeholder_idx,
+    to_foreign_def_id, to_placeholder_idx, to_placeholder_idx_no_index,
 };
 pub use method_resolution::check_orphan_rules;
 pub use target_feature::TargetFeatures;
@@ -1007,7 +1007,7 @@ struct PlaceholderCollector<'db> {
 
 impl PlaceholderCollector<'_> {
     fn collect(&mut self, idx: PlaceholderIndex) {
-        let id = from_placeholder_idx(self.db, idx);
+        let id = from_placeholder_idx(self.db, idx).0;
         self.placeholders.insert(id);
     }
 }