Trying to fix rust-analyzer's placeholder crimes

ShoyuVanilla · ShoyuVanilla · commit f2c0406d4f15 · 2025-08-31T03:48:07.000+09:00
diff --git a/crates/hir-ty/src/display.rs b/crates/hir-ty/src/display.rs
@@ -12,7 +12,7 @@ use chalk_ir::{BoundVar, Safety, TyKind};
 use either::Either;
 use hir_def::{
     GeneralConstId, GenericDefId, HasModule, ImportPathConfig, LocalFieldId, Lookup, ModuleDefId,
-    ModuleId, TraitId,
+    ModuleId, TraitId, TypeOrConstParamId,
     db::DefDatabase,
     expr_store::{ExpressionStore, path::Path},
     find_path::{self, PrefixKind},
@@ -1612,9 +1612,28 @@ impl<'db> HirDisplay for crate::next_solver::Ty<'db> {
                 }
             }
             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 placeholder_index = match idx.bound.kind {
+                    crate::next_solver::BoundTyKind::Anon => chalk_ir::PlaceholderIndex {
+                        idx: idx.bound.var.as_usize(),
+                        ui: chalk_ir::UniverseIndex { counter: idx.universe.as_usize() },
+                    },
+                    crate::next_solver::BoundTyKind::Param(solver_def_id) => {
+                        let Some(def) =
+                            crate::next_solver::mapping::solver_def_id_to_generic_def_id_opt(
+                                interner.db,
+                                solver_def_id,
+                            )
+                        else {
+                            unreachable!()
+                        };
+                        crate::mapping::to_placeholder_idx(
+                            interner.db,
+                            TypeOrConstParamId {
+                                parent: def,
+                                local_id: crate::Idx::from_raw(idx.bound.var.as_u32().into()),
+                            },
+                        )
+                    }
                 };
                 let id = from_placeholder_idx(db, placeholder_index);
                 let generics = generics(db, id.parent);
diff --git a/crates/hir-ty/src/infer/closure.rs b/crates/hir-ty/src/infer/closure.rs
@@ -568,7 +568,10 @@ impl InferenceContext<'_> {
         let supplied_sig = self.supplied_sig_of_closure(body, ret_type, arg_types, closure_kind);
 
         let snapshot = self.table.snapshot();
-        if !self.table.unify::<_, crate::next_solver::GenericArgs<'_>>(&expected_sig.substitution.0, &supplied_sig.expected_sig.substitution.0) {
+        if !self.table.unify::<_, crate::next_solver::GenericArgs<'_>>(
+            &expected_sig.substitution.0,
+            &supplied_sig.expected_sig.substitution.0,
+        ) {
             self.table.rollback_to(snapshot);
         }
 
@@ -878,7 +881,9 @@ impl CapturedItemWithoutTy {
                     idx: chalk_ir::PlaceholderIndex,
                     outer_binder: DebruijnIndex,
                 ) -> std::result::Result<Ty, Self::Error> {
+                    dbg!(&idx);
                     let x = from_placeholder_idx(self.db, idx);
+                    dbg!(&x);
                     let Some(idx) = self.generics.type_or_const_param_idx(x) else {
                         return Err(());
                     };
diff --git a/crates/hir-ty/src/infer/path.rs b/crates/hir-ty/src/infer/path.rs
@@ -10,7 +10,15 @@ use hir_expand::name::Name;
 use stdx::never;
 
 use crate::{
-    builder::ParamKind, consteval, error_lifetime, generics::generics, infer::diagnostics::InferenceTyLoweringContext as TyLoweringContext, method_resolution::{self, VisibleFromModule}, next_solver::mapping::ChalkToNextSolver, to_chalk_trait_id, InferenceDiagnostic, Interner, LifetimeElisionKind, Substitution, TraitRef, TraitRefExt, Ty, TyBuilder, TyExt, TyKind, ValueTyDefId
+    InferenceDiagnostic, Interner, LifetimeElisionKind, Substitution, TraitRef, TraitRefExt, Ty,
+    TyBuilder, TyExt, TyKind, ValueTyDefId,
+    builder::ParamKind,
+    consteval, error_lifetime,
+    generics::generics,
+    infer::diagnostics::InferenceTyLoweringContext as TyLoweringContext,
+    method_resolution::{self, VisibleFromModule},
+    next_solver::mapping::ChalkToNextSolver,
+    to_chalk_trait_id,
 };
 
 use super::{ExprOrPatId, InferenceContext, InferenceTyDiagnosticSource};
diff --git a/crates/hir-ty/src/next_solver/infer/canonical/canonicalizer.rs b/crates/hir-ty/src/next_solver/infer/canonical/canonicalizer.rs
@@ -1,14 +1,20 @@
-
 use rustc_hash::FxHashMap;
 use rustc_index::Idx;
-use rustc_type_ir::inherent::{Const as _, IntoKind as _, Region as _, SliceLike, Ty as _};
 use rustc_type_ir::InferTy::{self, FloatVar, IntVar, TyVar};
-use rustc_type_ir::{BoundVar, CanonicalQueryInput, CanonicalTyVarKind, DebruijnIndex, Flags, InferConst, RegionKind, TypeFlags, TypeFoldable, TypeFolder, TypeSuperFoldable, TypeVisitableExt, UniverseIndex};
+use rustc_type_ir::inherent::{Const as _, IntoKind as _, Region as _, SliceLike, Ty as _};
+use rustc_type_ir::{
+    BoundVar, CanonicalQueryInput, CanonicalTyVarKind, DebruijnIndex, Flags, InferConst,
+    RegionKind, TypeFlags, TypeFoldable, TypeFolder, TypeSuperFoldable, TypeVisitableExt,
+    UniverseIndex,
+};
 use smallvec::SmallVec;
 use tracing::debug;
 
 use crate::next_solver::infer::InferCtxt;
-use crate::next_solver::{Binder, BoundRegion, BoundRegionKind, BoundTy, Canonical, CanonicalVarKind, CanonicalVars, Const, ConstKind, DbInterner, GenericArg, ParamEnvAnd, Placeholder, Region, Ty, TyKind};
+use crate::next_solver::{
+    Binder, BoundRegion, BoundRegionKind, BoundTy, Canonical, CanonicalVarKind, CanonicalVars,
+    Const, ConstKind, DbInterner, GenericArg, ParamEnvAnd, Placeholder, Region, Ty, TyKind,
+};
 
 /// When we canonicalize a value to form a query, we wind up replacing
 /// various parts of it with canonical variables. This struct stores
@@ -180,12 +186,14 @@ impl CanonicalizeMode for CanonicalizeQueryResponse {
         };
 
         match r.kind() {
-            RegionKind::ReLateParam(_) | RegionKind::ReErased | RegionKind::ReStatic | RegionKind::ReEarlyParam(..) | RegionKind::ReError(..) => r,
+            RegionKind::ReLateParam(_)
+            | RegionKind::ReErased
+            | RegionKind::ReStatic
+            | RegionKind::ReEarlyParam(..)
+            | RegionKind::ReError(..) => r,
 
-            RegionKind::RePlaceholder(placeholder) => canonicalizer.canonical_var_for_region(
-                CanonicalVarKind::PlaceholderRegion(placeholder),
-                r,
-            ),
+            RegionKind::RePlaceholder(placeholder) => canonicalizer
+                .canonical_var_for_region(CanonicalVarKind::PlaceholderRegion(placeholder), r),
 
             RegionKind::ReVar(vid) => {
                 let universe = infcx
@@ -194,10 +202,7 @@ impl CanonicalizeMode for CanonicalizeQueryResponse {
                     .unwrap_region_constraints()
                     .probe_value(vid)
                     .unwrap_err();
-                canonicalizer.canonical_var_for_region(
-                    CanonicalVarKind::Region(universe),
-                    r,
-                )
+                canonicalizer.canonical_var_for_region(CanonicalVarKind::Region(universe), r)
             }
 
             _ => {
@@ -384,36 +389,29 @@ impl<'cx, 'db> TypeFolder<DbInterner<'db>> for Canonicalizer<'cx, 'db> {
                 if nt != t {
                     self.fold_ty(nt)
                 } else {
-                    self.canonicalize_ty_var(
-                        CanonicalVarKind::Ty(CanonicalTyVarKind::Int),
-                        t,
-                    )
+                    self.canonicalize_ty_var(CanonicalVarKind::Ty(CanonicalTyVarKind::Int), t)
                 }
             }
             TyKind::Infer(FloatVar(vid)) => {
                 let nt = self.infcx.unwrap().opportunistic_resolve_float_var(vid);
                 if nt != t {
                     self.fold_ty(nt)
                 } else {
-                    self.canonicalize_ty_var(
-                        CanonicalVarKind::Ty(CanonicalTyVarKind::Float),
-                        t,
-                    )
+                    self.canonicalize_ty_var(CanonicalVarKind::Ty(CanonicalTyVarKind::Float), t)
                 }
             }
 
-            TyKind::Infer(InferTy::FreshTy(_) | InferTy::FreshIntTy(_) | InferTy::FreshFloatTy(_)) => {
+            TyKind::Infer(
+                InferTy::FreshTy(_) | InferTy::FreshIntTy(_) | InferTy::FreshFloatTy(_),
+            ) => {
                 panic!("encountered a fresh type during canonicalization")
             }
 
             TyKind::Placeholder(mut placeholder) => {
                 if !self.canonicalize_mode.preserve_universes() {
                     placeholder.universe = UniverseIndex::ROOT;
                 }
-                self.canonicalize_ty_var(
-                    CanonicalVarKind::PlaceholderTy(placeholder),
-                    t,
-                )
+                self.canonicalize_ty_var(CanonicalVarKind::PlaceholderTy(placeholder), t)
             }
 
             TyKind::Bound(debruijn, _) => {
@@ -485,10 +483,7 @@ impl<'cx, 'db> TypeFolder<DbInterner<'db>> for Canonicalizer<'cx, 'db> {
                             // FIXME: perf problem described in #55921.
                             ui = UniverseIndex::ROOT;
                         }
-                        return self.canonicalize_const_var(
-                            CanonicalVarKind::Const(ui),
-                            ct,
-                        );
+                        return self.canonicalize_const_var(CanonicalVarKind::Const(ui), ct);
                     }
                 }
             }
@@ -503,10 +498,8 @@ impl<'cx, 'db> TypeFolder<DbInterner<'db>> for Canonicalizer<'cx, 'db> {
                 }
             }
             ConstKind::Placeholder(placeholder) => {
-                return self.canonicalize_const_var(
-                    CanonicalVarKind::PlaceholderConst(placeholder),
-                    ct,
-                );
+                return self
+                    .canonicalize_const_var(CanonicalVarKind::PlaceholderConst(placeholder), ct);
             }
             _ => {}
         }
@@ -596,7 +589,8 @@ impl<'cx, 'db> Canonicalizer<'cx, 'db> {
         // anymore.
         debug_assert!(!out_value.has_infer() && !out_value.has_placeholders());
 
-        let canonical_variables = CanonicalVars::new_from_iter(tcx, canonicalizer.universe_canonicalized_variables());
+        let canonical_variables =
+            CanonicalVars::new_from_iter(tcx, canonicalizer.universe_canonicalized_variables());
 
         let max_universe = canonical_variables
             .iter()
@@ -690,15 +684,11 @@ impl<'cx, 'db> Canonicalizer<'cx, 'db> {
         self.variables
             .iter()
             .map(|v| match *v {
-                CanonicalVarKind::Ty(CanonicalTyVarKind::Int | CanonicalTyVarKind::Float) => {
-                    *v
-                }
+                CanonicalVarKind::Ty(CanonicalTyVarKind::Int | CanonicalTyVarKind::Float) => *v,
                 CanonicalVarKind::Ty(CanonicalTyVarKind::General(u)) => {
                     CanonicalVarKind::Ty(CanonicalTyVarKind::General(reverse_universe_map[&u]))
                 }
-                CanonicalVarKind::Region(u) => {
-                    CanonicalVarKind::Region(reverse_universe_map[&u])
-                }
+                CanonicalVarKind::Region(u) => CanonicalVarKind::Region(reverse_universe_map[&u]),
                 CanonicalVarKind::Const(u) => CanonicalVarKind::Const(reverse_universe_map[&u]),
                 CanonicalVarKind::PlaceholderTy(placeholder) => {
                     CanonicalVarKind::PlaceholderTy(Placeholder {
@@ -735,14 +725,8 @@ impl<'cx, 'db> Canonicalizer<'cx, 'db> {
     ///
     /// (This works because unification never fails -- and hence trait
     /// selection is never affected -- due to a universe mismatch.)
-    fn canonical_var_for_region_in_root_universe(
-        &mut self,
-        r: Region<'db>,
-    ) -> Region<'db> {
-        self.canonical_var_for_region(
-            CanonicalVarKind::Region(UniverseIndex::ROOT),
-            r,
-        )
+    fn canonical_var_for_region_in_root_universe(&mut self, r: Region<'db>) -> Region<'db> {
+        self.canonical_var_for_region(CanonicalVarKind::Region(UniverseIndex::ROOT), r)
     }
 
     /// Creates a canonical variable (with the given `info`)
@@ -764,7 +748,11 @@ impl<'cx, 'db> Canonicalizer<'cx, 'db> {
     fn canonicalize_ty_var(&mut self, info: CanonicalVarKind<'db>, ty_var: Ty<'db>) -> Ty<'db> {
         debug_assert!(!self.infcx.is_some_and(|infcx| ty_var != infcx.shallow_resolve(ty_var)));
         let var = self.canonical_var(info, ty_var.into());
-        Ty::new_bound(self.tcx, self.binder_index, BoundTy { kind: crate::next_solver::BoundTyKind::Anon, var })
+        Ty::new_bound(
+            self.tcx,
+            self.binder_index,
+            BoundTy { kind: crate::next_solver::BoundTyKind::Anon, var },
+        )
     }
 
     /// Given a type variable `const_var` of the given kind, first check
diff --git a/crates/hir-ty/src/next_solver/mapping.rs b/crates/hir-ty/src/next_solver/mapping.rs
@@ -6,8 +6,8 @@ use chalk_ir::{
     WellFormed, cast::Cast, fold::Shift, interner::HasInterner,
 };
 use hir_def::{
-    CallableDefId, ConstParamId, FunctionId, GeneralConstId, LifetimeParamId, TypeAliasId,
-    TypeOrConstParamId, TypeParamId, signatures::TraitFlags,
+    CallableDefId, ConstParamId, FunctionId, GeneralConstId, GenericDefId, LifetimeParamId,
+    TypeAliasId, TypeOrConstParamId, TypeParamId, signatures::TraitFlags,
 };
 use intern::sym;
 use rustc_type_ir::{
@@ -276,10 +276,23 @@ impl<'db> ChalkToNextSolver<'db, Ty<'db>> for chalk_ir::Ty<Interner> {
                 ),
                 chalk_ir::TyKind::Error => rustc_type_ir::TyKind::Error(ErrorGuaranteed),
                 chalk_ir::TyKind::Placeholder(placeholder_index) => {
-                    rustc_type_ir::TyKind::Placeholder(PlaceholderTy::new_anon(
-                        placeholder_index.ui.to_nextsolver(interner),
-                        rustc_type_ir::BoundVar::from_usize(placeholder_index.idx),
-                    ))
+                    if placeholder_index.idx < 128 {
+                        dbg!(placeholder_index.idx);
+                        rustc_type_ir::TyKind::Placeholder(PlaceholderTy::new_anon(
+                            placeholder_index.ui.to_nextsolver(interner),
+                            rustc_type_ir::BoundVar::from_usize(placeholder_index.idx),
+                        ))
+                    } else {
+                        let id =
+                            crate::mapping::from_placeholder_idx(interner.db, *placeholder_index);
+                        rustc_type_ir::TyKind::Placeholder(PlaceholderTy::new(
+                            placeholder_index.ui.to_nextsolver(interner),
+                            BoundTy {
+                                var: BoundVar::from_u32(id.local_id.into_raw().into_u32()),
+                                kind: BoundTyKind::Param(id.parent.into()),
+                            },
+                        ))
+                    }
                 }
                 chalk_ir::TyKind::Dyn(dyn_ty) => {
                     // exists<type> { for<...> ^1.0: ... }
@@ -559,8 +572,27 @@ impl<'db> ChalkToNextSolver<'db, Ty<'db>> for chalk_ir::Ty<Interner> {
 
             rustc_type_ir::TyKind::Placeholder(placeholder) => {
                 let ui = chalk_ir::UniverseIndex { counter: placeholder.universe.as_usize() };
-                let placeholder_index =
-                    chalk_ir::PlaceholderIndex { idx: placeholder.bound.var.as_usize(), ui };
+                let placeholder_index = match placeholder.bound.kind {
+                    BoundTyKind::Anon => {
+                        chalk_ir::PlaceholderIndex { idx: placeholder.bound.var.as_usize(), ui }
+                    }
+                    BoundTyKind::Param(solver_def_id) => {
+                        let Some(def) =
+                            solver_def_id_to_generic_def_id_opt(interner.db, solver_def_id)
+                        else {
+                            unreachable!()
+                        };
+                        crate::mapping::to_placeholder_idx(
+                            interner.db,
+                            TypeOrConstParamId {
+                                parent: def,
+                                local_id: crate::Idx::from_raw(
+                                    placeholder.bound.var.as_u32().into(),
+                                ),
+                            },
+                        )
+                    }
+                };
                 TyKind::Placeholder(placeholder_index)
             }
 
@@ -1986,8 +2018,24 @@ pub(crate) fn convert_ty_for_result<'db>(interner: DbInterner<'db>, ty: Ty<'db>)
 
         rustc_type_ir::TyKind::Placeholder(placeholder) => {
             let ui = chalk_ir::UniverseIndex { counter: placeholder.universe.as_usize() };
-            let placeholder_index =
-                chalk_ir::PlaceholderIndex { idx: placeholder.bound.var.as_usize(), ui };
+            let placeholder_index = match placeholder.bound.kind {
+                BoundTyKind::Anon => {
+                    chalk_ir::PlaceholderIndex { idx: placeholder.bound.var.as_usize(), ui }
+                }
+                BoundTyKind::Param(solver_def_id) => {
+                    let Some(def) = solver_def_id_to_generic_def_id_opt(interner.db, solver_def_id)
+                    else {
+                        unreachable!()
+                    };
+                    crate::mapping::to_placeholder_idx(
+                        interner.db,
+                        TypeOrConstParamId {
+                            parent: def,
+                            local_id: crate::Idx::from_raw(placeholder.bound.var.as_u32().into()),
+                        },
+                    )
+                }
+            };
             TyKind::Placeholder(placeholder_index)
         }
 
@@ -2298,3 +2346,27 @@ impl InferenceVarExt for InferenceVar {
         InferenceVar::from(vid.as_u32())
     }
 }
+
+pub fn solver_def_id_to_generic_def_id_opt(
+    db: &dyn HirDatabase,
+    id: SolverDefId,
+) -> Option<GenericDefId> {
+    match id {
+        SolverDefId::AdtId(it) => Some(it.into()),
+        SolverDefId::ConstId(it) => Some(it.into()),
+        SolverDefId::FunctionId(it) => Some(it.into()),
+        SolverDefId::ImplId(it) => Some(it.into()),
+        SolverDefId::StaticId(it) => Some(it.into()),
+        SolverDefId::TraitId(it) => Some(it.into()),
+        SolverDefId::TypeAliasId(it) => Some(it.into()),
+        SolverDefId::Ctor(crate::next_solver::Ctor::Struct(it)) => Some(it.into()),
+        SolverDefId::Ctor(crate::next_solver::Ctor::Enum(it)) => Some(it.loc(db).parent.into()),
+        SolverDefId::InternedOpaqueTyId(it) => match it.loc(db) {
+            crate::ImplTraitId::ReturnTypeImplTrait(it, _) => Some(it.into()),
+            crate::ImplTraitId::TypeAliasImplTrait(it, _) => Some(it.into()),
+            crate::ImplTraitId::AsyncBlockTypeImplTrait(..) => None,
+        },
+        SolverDefId::InternedClosureId(_) => None,
+        SolverDefId::InternedCoroutineId(_) => None,
+    }
+}
diff --git a/crates/hir-ty/src/next_solver/solver.rs b/crates/hir-ty/src/next_solver/solver.rs
@@ -13,8 +13,7 @@ use crate::{
     TraitRefExt,
     db::HirDatabase,
     next_solver::{
-        ClauseKind, CoercePredicate, PredicateKind, SubtypePredicate,
-        mapping::ChalkToNextSolver,
+        ClauseKind, CoercePredicate, PredicateKind, SubtypePredicate, mapping::ChalkToNextSolver,
         util::sizedness_fast_path,
     },
 };
