Trying to fix rust-analyzer's placeholder crimes

Author: ShoyuVanilla

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);

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(());
                     };

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,
+    }
+}