do not canonicalize BoundVar for placeholders

Author: lcnr

compiler/rustc_infer/src/infer/canonical/canonicalizer.rs

@@ -173,8 +173,10 @@ impl CanonicalizeMode for CanonicalizeQueryResponse {
         match r.kind() {
             ty::ReLateParam(_) | ty::ReErased | ty::ReStatic | ty::ReEarlyParam(..) => r,
 
-            ty::RePlaceholder(placeholder) => canonicalizer
-                .canonical_var_for_region(CanonicalVarKind::PlaceholderRegion(placeholder), r),
+            ty::RePlaceholder(placeholder) => canonicalizer.canonical_var_for_region(
+                CanonicalVarKind::PlaceholderRegion(placeholder.universe),
+                r,
+            ),
 
             ty::ReVar(vid) => {
                 let universe = infcx
@@ -288,7 +290,7 @@ struct Canonicalizer<'cx, 'tcx> {
     /// Set to `None` to disable the resolution of inference variables.
     infcx: Option<&'cx InferCtxt<'tcx>>,
     tcx: TyCtxt<'tcx>,
-    variables: SmallVec<[CanonicalVarKind<'tcx>; 8]>,
+    variables: SmallVec<[CanonicalVarKind; 8]>,
     query_state: &'cx mut OriginalQueryValues<'tcx>,
     // Note that indices is only used once `var_values` is big enough to be
     // heap-allocated.
@@ -390,11 +392,13 @@ impl<'cx, 'tcx> TypeFolder<TyCtxt<'tcx>> for Canonicalizer<'cx, 'tcx> {
                 bug!("encountered a fresh type during canonicalization")
             }
 
-            ty::Placeholder(mut placeholder) => {
-                if !self.canonicalize_mode.preserve_universes() {
-                    placeholder.universe = ty::UniverseIndex::ROOT;
-                }
-                self.canonicalize_ty_var(CanonicalVarKind::PlaceholderTy(placeholder), t)
+            ty::Placeholder(placeholder) => {
+                let universe = if self.canonicalize_mode.preserve_universes() {
+                    placeholder.universe
+                } else {
+                    ty::UniverseIndex::ROOT
+                };
+                self.canonicalize_ty_var(CanonicalVarKind::PlaceholderTy(universe), t)
             }
 
             ty::Bound(debruijn, _) => {
@@ -481,8 +485,13 @@ impl<'cx, 'tcx> TypeFolder<TyCtxt<'tcx>> for Canonicalizer<'cx, 'tcx> {
                 }
             }
             ty::ConstKind::Placeholder(placeholder) => {
+                let universe = if self.canonicalize_mode.preserve_universes() {
+                    placeholder.universe
+                } else {
+                    ty::UniverseIndex::ROOT
+                };
                 return self
-                    .canonicalize_const_var(CanonicalVarKind::PlaceholderConst(placeholder), ct);
+                    .canonicalize_const_var(CanonicalVarKind::PlaceholderConst(universe), ct);
             }
             _ => {}
         }
@@ -588,7 +597,7 @@ impl<'cx, 'tcx> Canonicalizer<'cx, 'tcx> {
     /// or returns an existing variable if `kind` has already been
     /// seen. `kind` is expected to be an unbound variable (or
     /// potentially a free region).
-    fn canonical_var(&mut self, info: CanonicalVarKind<'tcx>, kind: GenericArg<'tcx>) -> BoundVar {
+    fn canonical_var(&mut self, info: CanonicalVarKind, kind: GenericArg<'tcx>) -> BoundVar {
         let Canonicalizer { variables, query_state, indices, .. } = self;
 
         let var_values = &mut query_state.var_values;
@@ -651,7 +660,7 @@ impl<'cx, 'tcx> Canonicalizer<'cx, 'tcx> {
     /// Replaces the universe indexes used in `var_values` with their index in
     /// `query_state.universe_map`. This minimizes the maximum universe used in
     /// the canonicalized value.
-    fn universe_canonicalized_variables(self) -> SmallVec<[CanonicalVarKind<'tcx>; 8]> {
+    fn universe_canonicalized_variables(self) -> SmallVec<[CanonicalVarKind; 8]> {
         if self.query_state.universe_map.len() == 1 {
             return self.variables;
         }
@@ -675,23 +684,14 @@ impl<'cx, 'tcx> Canonicalizer<'cx, 'tcx> {
                 }
                 CanonicalVarKind::Region(u) => CanonicalVarKind::Region(reverse_universe_map[&u]),
                 CanonicalVarKind::Const(u) => CanonicalVarKind::Const(reverse_universe_map[&u]),
-                CanonicalVarKind::PlaceholderTy(placeholder) => {
-                    CanonicalVarKind::PlaceholderTy(ty::Placeholder {
-                        universe: reverse_universe_map[&placeholder.universe],
-                        ..placeholder
-                    })
+                CanonicalVarKind::PlaceholderTy(ui) => {
+                    CanonicalVarKind::PlaceholderTy(reverse_universe_map[&ui])
                 }
-                CanonicalVarKind::PlaceholderRegion(placeholder) => {
-                    CanonicalVarKind::PlaceholderRegion(ty::Placeholder {
-                        universe: reverse_universe_map[&placeholder.universe],
-                        ..placeholder
-                    })
+                CanonicalVarKind::PlaceholderRegion(ui) => {
+                    CanonicalVarKind::PlaceholderRegion(reverse_universe_map[&ui])
                 }
-                CanonicalVarKind::PlaceholderConst(placeholder) => {
-                    CanonicalVarKind::PlaceholderConst(ty::Placeholder {
-                        universe: reverse_universe_map[&placeholder.universe],
-                        ..placeholder
-                    })
+                CanonicalVarKind::PlaceholderConst(ui) => {
+                    CanonicalVarKind::PlaceholderConst(reverse_universe_map[&ui])
                 }
             })
             .collect()
@@ -721,7 +721,7 @@ impl<'cx, 'tcx> Canonicalizer<'cx, 'tcx> {
     /// representing the region `r`; return a region referencing it.
     fn canonical_var_for_region(
         &mut self,
-        info: CanonicalVarKind<'tcx>,
+        info: CanonicalVarKind,
         r: ty::Region<'tcx>,
     ) -> ty::Region<'tcx> {
         let var = self.canonical_var(info, r.into());
@@ -733,10 +733,10 @@ impl<'cx, 'tcx> Canonicalizer<'cx, 'tcx> {
     /// if `ty_var` is bound to anything; if so, canonicalize
     /// *that*. Otherwise, create a new canonical variable for
     /// `ty_var`.
-    fn canonicalize_ty_var(&mut self, info: CanonicalVarKind<'tcx>, ty_var: Ty<'tcx>) -> Ty<'tcx> {
+    fn canonicalize_ty_var(&mut self, info: CanonicalVarKind, ty_var: Ty<'tcx>) -> Ty<'tcx> {
         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, var.into())
+        Ty::new_bound(self.tcx, self.binder_index, ty::BoundTy::new_anon(var))
     }
 
     /// Given a type variable `const_var` of the given kind, first check
@@ -745,7 +745,7 @@ impl<'cx, 'tcx> Canonicalizer<'cx, 'tcx> {
     /// `const_var`.
     fn canonicalize_const_var(
         &mut self,
-        info: CanonicalVarKind<'tcx>,
+        info: CanonicalVarKind,
         const_var: ty::Const<'tcx>,
     ) -> ty::Const<'tcx> {
         debug_assert!(

compiler/rustc_infer/src/infer/canonical/mod.rs

@@ -81,30 +81,27 @@ impl<'tcx> InferCtxt<'tcx> {
     fn instantiate_canonical_vars(
         &self,
         span: Span,
-        variables: &List<CanonicalVarKind<'tcx>>,
+        variables: &List<CanonicalVarKind>,
         universe_map: impl Fn(ty::UniverseIndex) -> ty::UniverseIndex,
     ) -> CanonicalVarValues<'tcx> {
         CanonicalVarValues {
-            var_values: self.tcx.mk_args_from_iter(
-                variables
-                    .iter()
-                    .map(|kind| self.instantiate_canonical_var(span, kind, &universe_map)),
-            ),
+            var_values: self.tcx.mk_args_from_iter(variables.iter().enumerate().map(
+                |(at_index, kind)| {
+                    self.instantiate_canonical_var(span, at_index, kind, &universe_map)
+                },
+            )),
         }
     }
 
-    /// Given the "info" about a canonical variable, creates a fresh
-    /// variable for it. If this is an existentially quantified
-    /// variable, then you'll get a new inference variable; if it is a
-    /// universally quantified variable, you get a placeholder.
+    /// Given the "info" about a canonical variable, creates a fresh variable for it.
     ///
-    /// FIXME(-Znext-solver): This is public because it's used by the
-    /// new trait solver which has a different canonicalization routine.
-    /// We should somehow deduplicate all of this.
-    pub fn instantiate_canonical_var(
+    /// This ICEs if the input is not an existential variable. Handle placeholders separately
+    /// or call [Self::instantiate_canonical_var] instead.
+    #[inline]
+    pub fn instantiate_existential_canonical_var(
         &self,
         span: Span,
-        kind: CanonicalVarKind<'tcx>,
+        kind: CanonicalVarKind,
         universe_map: impl Fn(ty::UniverseIndex) -> ty::UniverseIndex,
     ) -> GenericArg<'tcx> {
         match kind {
@@ -121,32 +118,68 @@ impl<'tcx> InferCtxt<'tcx> {
                 ty.into()
             }
 
-            CanonicalVarKind::PlaceholderTy(ty::PlaceholderType { universe, bound }) => {
-                let universe_mapped = universe_map(universe);
-                let placeholder_mapped = ty::PlaceholderType { universe: universe_mapped, bound };
-                Ty::new_placeholder(self.tcx, placeholder_mapped).into()
-            }
-
             CanonicalVarKind::Region(ui) => self
                 .next_region_var_in_universe(
                     RegionVariableOrigin::MiscVariable(span),
                     universe_map(ui),
                 )
                 .into(),
 
-            CanonicalVarKind::PlaceholderRegion(ty::PlaceholderRegion { universe, bound }) => {
+            CanonicalVarKind::Const(ui) => {
+                self.next_const_var_in_universe(span, universe_map(ui)).into()
+            }
+
+            CanonicalVarKind::PlaceholderRegion(_)
+            | CanonicalVarKind::PlaceholderTy(_)
+            | CanonicalVarKind::PlaceholderConst(_) => unreachable!(),
+        }
+    }
+
+    /// Given the "info" about a canonical variable, creates a fresh
+    /// variable for it. If this is an existentially quantified
+    /// variable, then you'll get a new inference variable; if it is a
+    /// universally quantified variable, you get a placeholder.
+    ///
+    /// FIXME(-Znext-solver): This is public because it's used by the
+    /// new trait solver which has a different canonicalization routine.
+    /// We should somehow deduplicate all of this.
+    pub fn instantiate_canonical_var(
+        &self,
+        span: Span,
+        at_index: usize,
+        kind: CanonicalVarKind,
+        universe_map: impl Fn(ty::UniverseIndex) -> ty::UniverseIndex,
+    ) -> GenericArg<'tcx> {
+        match kind {
+            CanonicalVarKind::Region(_) | CanonicalVarKind::Ty(_) | CanonicalVarKind::Const(_) => {
+                self.instantiate_existential_canonical_var(span, kind, universe_map)
+            }
+
+            CanonicalVarKind::PlaceholderTy(universe) => {
+                let var = ty::BoundVar::from_usize(at_index);
                 let universe_mapped = universe_map(universe);
-                let placeholder_mapped = ty::PlaceholderRegion { universe: universe_mapped, bound };
-                ty::Region::new_placeholder(self.tcx, placeholder_mapped).into()
+                let placeholder = ty::PlaceholderType {
+                    universe: universe_mapped,
+                    bound: ty::BoundTy::new_anon(var),
+                };
+                Ty::new_placeholder(self.tcx, placeholder).into()
             }
 
-            CanonicalVarKind::Const(ui) => {
-                self.next_const_var_in_universe(span, universe_map(ui)).into()
+            CanonicalVarKind::PlaceholderRegion(universe) => {
+                let var = ty::BoundVar::from_usize(at_index);
+                let universe_mapped = universe_map(universe);
+                let placeholder = ty::PlaceholderRegion {
+                    universe: universe_mapped,
+                    bound: ty::BoundRegion::new_anon(var),
+                };
+                ty::Region::new_placeholder(self.tcx, placeholder).into()
             }
-            CanonicalVarKind::PlaceholderConst(ty::PlaceholderConst { universe, bound }) => {
+
+            CanonicalVarKind::PlaceholderConst(universe) => {
+                let var = ty::BoundVar::from_usize(at_index);
                 let universe_mapped = universe_map(universe);
-                let placeholder_mapped = ty::PlaceholderConst { universe: universe_mapped, bound };
-                ty::Const::new_placeholder(self.tcx, placeholder_mapped).into()
+                let placeholder = ty::PlaceholderConst { universe: universe_mapped, bound: var };
+                ty::Const::new_placeholder(self.tcx, placeholder).into()
             }
         }
     }

compiler/rustc_infer/src/infer/canonical/query_response.rs

@@ -449,15 +449,17 @@ impl<'tcx> InferCtxt<'tcx> {
                     if var_kind.universe() != ty::UniverseIndex::ROOT {
                         // A variable from inside a binder of the query. While ideally these shouldn't
                         // exist at all, we have to deal with them for now.
-                        self.instantiate_canonical_var(cause.span, var_kind, |u| {
+                        self.instantiate_canonical_var(cause.span, index, var_kind, |u| {
                             universe_map[u.as_usize()]
                         })
                     } else if var_kind.is_existential() {
                         match opt_values[BoundVar::new(index)] {
                             Some(k) => k,
-                            None => self.instantiate_canonical_var(cause.span, var_kind, |u| {
-                                universe_map[u.as_usize()]
-                            }),
+                            None => {
+                                self.instantiate_canonical_var(cause.span, index, var_kind, |u| {
+                                    universe_map[u.as_usize()]
+                                })
+                            }
                         }
                     } else {
                         // For placeholders which were already part of the input, we simply map this

compiler/rustc_middle/src/infer/canonical.rs

@@ -35,9 +35,9 @@ use crate::ty::{self, GenericArg, List, Ty, TyCtxt, TypeFlags, TypeVisitableExt}
 
 pub type CanonicalQueryInput<'tcx, V> = ir::CanonicalQueryInput<TyCtxt<'tcx>, V>;
 pub type Canonical<'tcx, V> = ir::Canonical<TyCtxt<'tcx>, V>;
-pub type CanonicalVarKind<'tcx> = ir::CanonicalVarKind<TyCtxt<'tcx>>;
+pub type CanonicalVarKind = ir::CanonicalVarKind;
 pub type CanonicalVarValues<'tcx> = ir::CanonicalVarValues<TyCtxt<'tcx>>;
-pub type CanonicalVarKinds<'tcx> = &'tcx List<CanonicalVarKind<'tcx>>;
+pub type CanonicalVarKinds<'tcx> = &'tcx List<CanonicalVarKind>;
 
 /// When we canonicalize a value to form a query, we wind up replacing
 /// various parts of it with canonical variables. This struct stores

compiler/rustc_middle/src/ty/codec.rs

@@ -314,7 +314,7 @@ impl<'tcx, D: TyDecoder<'tcx>> Decodable<D> for CanonicalVarKinds<'tcx> {
     fn decode(decoder: &mut D) -> Self {
         let len = decoder.read_usize();
         decoder.interner().mk_canonical_var_infos_from_iter(
-            (0..len).map::<CanonicalVarKind<'tcx>, _>(|_| Decodable::decode(decoder)),
+            (0..len).map::<CanonicalVarKind, _>(|_| Decodable::decode(decoder)),
         )
     }
 }

compiler/rustc_middle/src/ty/context.rs

@@ -108,10 +108,7 @@ impl<'tcx> Interner for TyCtxt<'tcx> {
     }
     type LocalDefIds = &'tcx ty::List<LocalDefId>;
     type CanonicalVarKinds = CanonicalVarKinds<'tcx>;
-    fn mk_canonical_var_kinds(
-        self,
-        kinds: &[ty::CanonicalVarKind<Self>],
-    ) -> Self::CanonicalVarKinds {
+    fn mk_canonical_var_kinds(self, kinds: &[ty::CanonicalVarKind]) -> Self::CanonicalVarKinds {
         self.mk_canonical_var_kinds(kinds)
     }
 
@@ -836,7 +833,7 @@ pub struct CtxtInterners<'tcx> {
     const_lists: InternedSet<'tcx, List<ty::Const<'tcx>>>,
     args: InternedSet<'tcx, GenericArgs<'tcx>>,
     type_lists: InternedSet<'tcx, List<Ty<'tcx>>>,
-    canonical_var_kinds: InternedSet<'tcx, List<CanonicalVarKind<'tcx>>>,
+    canonical_var_kinds: InternedSet<'tcx, List<CanonicalVarKind>>,
     region: InternedSet<'tcx, RegionKind<'tcx>>,
     poly_existential_predicates: InternedSet<'tcx, List<PolyExistentialPredicate<'tcx>>>,
     predicate: InternedSet<'tcx, WithCachedTypeInfo<ty::Binder<'tcx, PredicateKind<'tcx>>>>,
@@ -2678,7 +2675,7 @@ slice_interners!(
     const_lists: pub mk_const_list(Const<'tcx>),
     args: pub mk_args(GenericArg<'tcx>),
     type_lists: pub mk_type_list(Ty<'tcx>),
-    canonical_var_kinds: pub mk_canonical_var_kinds(CanonicalVarKind<'tcx>),
+    canonical_var_kinds: pub mk_canonical_var_kinds(CanonicalVarKind),
     poly_existential_predicates: intern_poly_existential_predicates(PolyExistentialPredicate<'tcx>),
     projs: pub mk_projs(ProjectionKind),
     place_elems: pub mk_place_elems(PlaceElem<'tcx>),
@@ -3058,7 +3055,7 @@ impl<'tcx> TyCtxt<'tcx> {
     pub fn mk_canonical_var_infos_from_iter<I, T>(self, iter: I) -> T::Output
     where
         I: Iterator<Item = T>,
-        T: CollectAndApply<CanonicalVarKind<'tcx>, &'tcx List<CanonicalVarKind<'tcx>>>,
+        T: CollectAndApply<CanonicalVarKind, &'tcx List<CanonicalVarKind>>,
     {
         T::collect_and_apply(iter, |xs| self.mk_canonical_var_kinds(xs))
     }

compiler/rustc_middle/src/ty/region.rs

@@ -437,13 +437,23 @@ pub struct BoundRegion {
     pub kind: BoundRegionKind,
 }
 
+impl BoundRegion {
+    pub fn new_anon(var: BoundVar) -> BoundRegion {
+        BoundRegion { var, kind: BoundRegionKind::Anon }
+    }
+}
+
 impl<'tcx> rustc_type_ir::inherent::BoundVarLike<TyCtxt<'tcx>> for BoundRegion {
+    fn new_anon(var: BoundVar) -> BoundRegion {
+        Self::new_anon(var)
+    }
+
     fn var(self) -> BoundVar {
         self.var
     }
 
-    fn assert_eq(self, var: ty::BoundVariableKind) {
-        assert_eq!(self.kind, var.expect_region())
+    fn assert_eq(self, kind: ty::BoundVariableKind) {
+        assert_eq!(self.kind, kind.expect_region())
     }
 }
 

compiler/rustc_middle/src/ty/sty.rs

@@ -374,7 +374,17 @@ pub struct BoundTy {
     pub kind: BoundTyKind,
 }
 
+impl BoundTy {
+    pub fn new_anon(var: BoundVar) -> BoundTy {
+        BoundTy { var, kind: BoundTyKind::Anon }
+    }
+}
+
 impl<'tcx> rustc_type_ir::inherent::BoundVarLike<TyCtxt<'tcx>> for BoundTy {
+    fn new_anon(var: BoundVar) -> BoundTy {
+        Self::new_anon(var)
+    }
+
     fn var(self) -> BoundVar {
         self.var
     }
@@ -391,12 +401,6 @@ pub enum BoundTyKind {
     Param(DefId, Symbol),
 }
 
-impl From<BoundVar> for BoundTy {
-    fn from(var: BoundVar) -> Self {
-        BoundTy { var, kind: BoundTyKind::Anon }
-    }
-}
-
 /// Constructors for `Ty`
 impl<'tcx> Ty<'tcx> {
     /// Avoid using this in favour of more specific `new_*` methods, where possible.

compiler/rustc_next_trait_solver/src/canonicalizer.rs

@@ -50,7 +50,7 @@ pub struct Canonicalizer<'a, D: SolverDelegate<Interner = I>, I: Interner> {
 
     // Mutable fields.
     variables: &'a mut Vec<I::GenericArg>,
-    var_kinds: Vec<CanonicalVarKind<I>>,
+    var_kinds: Vec<CanonicalVarKind>,
     variable_lookup_table: HashMap<I::GenericArg, usize>,
     binder_index: ty::DebruijnIndex,
 
@@ -149,7 +149,7 @@ impl<'a, D: SolverDelegate<Interner = I>, I: Interner> Canonicalizer<'a, D, I> {
     fn get_or_insert_bound_var(
         &mut self,
         arg: impl Into<I::GenericArg>,
-        kind: CanonicalVarKind<I>,
+        kind: CanonicalVarKind,
     ) -> ty::BoundVar {
         // FIXME: 16 is made up and arbitrary. We should look at some
         // perf data here.
@@ -232,7 +232,7 @@ impl<'a, D: SolverDelegate<Interner = I>, I: Interner> Canonicalizer<'a, D, I> {
         let mut existential_in_new_uv = None;
         let mut next_orig_uv = Some(ty::UniverseIndex::ROOT);
         while let Some(orig_uv) = next_orig_uv.take() {
-            let mut update_uv = |var: &mut CanonicalVarKind<I>, orig_uv, is_existential| {
+            let mut update_uv = |var: &mut CanonicalVarKind, orig_uv, is_existential| {
                 let uv = var.universe();
                 match uv.cmp(&orig_uv) {
                     Ordering::Less => (), // Already updated
@@ -349,16 +349,11 @@ impl<'a, D: SolverDelegate<Interner = I>, I: Interner> Canonicalizer<'a, D, I> {
                     panic!("fresh vars not expected in canonicalization")
                 }
             },
-            ty::Placeholder(placeholder) => match self.canonicalize_mode {
-                CanonicalizeMode::Input { .. } => CanonicalVarKind::PlaceholderTy(
-                    PlaceholderLike::new(placeholder.universe(), self.variables.len().into()),
-                ),
-                CanonicalizeMode::Response { .. } => CanonicalVarKind::PlaceholderTy(placeholder),
-            },
+            ty::Placeholder(placeholder) => CanonicalVarKind::PlaceholderTy(placeholder.universe()),
             ty::Param(_) => match self.canonicalize_mode {
-                CanonicalizeMode::Input { .. } => CanonicalVarKind::PlaceholderTy(
-                    PlaceholderLike::new(ty::UniverseIndex::ROOT, self.variables.len().into()),
-                ),
+                CanonicalizeMode::Input { .. } => {
+                    CanonicalVarKind::PlaceholderTy(ty::UniverseIndex::ROOT)
+                }
                 CanonicalizeMode::Response { .. } => panic!("param ty in response: {t:?}"),
             },
             ty::Bool
@@ -454,7 +449,7 @@ impl<D: SolverDelegate<Interner = I>, I: Interner> TypeFolder<I> for Canonicaliz
                     if max_input_universe.can_name(placeholder.universe()) {
                         panic!("new placeholder in universe {max_input_universe:?}: {r:?}");
                     }
-                    CanonicalVarKind::PlaceholderRegion(placeholder)
+                    CanonicalVarKind::PlaceholderRegion(placeholder.universe())
                 }
             },
 
@@ -503,18 +498,13 @@ impl<D: SolverDelegate<Interner = I>, I: Interner> TypeFolder<I> for Canonicaliz
                 }
                 ty::InferConst::Fresh(_) => todo!(),
             },
-            ty::ConstKind::Placeholder(placeholder) => match self.canonicalize_mode {
-                CanonicalizeMode::Input { .. } => CanonicalVarKind::PlaceholderConst(
-                    PlaceholderLike::new(placeholder.universe(), self.variables.len().into()),
-                ),
-                CanonicalizeMode::Response { .. } => {
-                    CanonicalVarKind::PlaceholderConst(placeholder)
-                }
-            },
+            ty::ConstKind::Placeholder(placeholder) => {
+                CanonicalVarKind::PlaceholderConst(placeholder.universe())
+            }
             ty::ConstKind::Param(_) => match self.canonicalize_mode {
-                CanonicalizeMode::Input { .. } => CanonicalVarKind::PlaceholderConst(
-                    PlaceholderLike::new(ty::UniverseIndex::ROOT, self.variables.len().into()),
-                ),
+                CanonicalizeMode::Input { .. } => {
+                    CanonicalVarKind::PlaceholderConst(ty::UniverseIndex::ROOT)
+                }
                 CanonicalizeMode::Response { .. } => panic!("param ty in response: {c:?}"),
             },
             // FIXME: See comment above -- we could fold the region separately or something.

compiler/rustc_next_trait_solver/src/delegate.rs

@@ -59,12 +59,20 @@ pub trait SolverDelegate: Deref<Target = Self::Infcx> + Sized {
     where
         V: TypeFoldable<Self::Interner>;
 
-    fn instantiate_canonical_var_with_infer(
+    fn instantiate_existential_canonical_var(
         &self,
-        kind: ty::CanonicalVarKind<Self::Interner>,
+        kind: ty::CanonicalVarKind,
         span: <Self::Interner as Interner>::Span,
         universe_map: impl Fn(ty::UniverseIndex) -> ty::UniverseIndex,
     ) -> <Self::Interner as Interner>::GenericArg;
+    fn instantiate_canonical_var(
+        &self,
+        at_index: usize,
+        kind: ty::CanonicalVarKind,
+        span: <Self::Interner as Interner>::Span,
+        universe_map: impl Fn(ty::UniverseIndex) -> ty::UniverseIndex,
+    ) -> <Self::Interner as Interner>::GenericArg;
+
     fn add_item_bounds_for_hidden_type(
         &self,
         def_id: <Self::Interner as Interner>::DefId,

compiler/rustc_next_trait_solver/src/solve/eval_ctxt/canonical.rs

@@ -365,7 +365,7 @@ where
                     // A variable from inside a binder of the query. While ideally these shouldn't
                     // exist at all (see the FIXME at the start of this method), we have to deal with
                     // them for now.
-                    delegate.instantiate_canonical_var_with_infer(var_kind, span, |idx| {
+                    delegate.instantiate_canonical_var(index, var_kind, span, |idx| {
                         prev_universe + idx.index()
                     })
                 } else if var_kind.is_existential() {
@@ -379,13 +379,14 @@ where
                     if let Some(v) = opt_values[ty::BoundVar::from_usize(index)] {
                         v
                     } else {
-                        delegate
-                            .instantiate_canonical_var_with_infer(var_kind, span, |_| prev_universe)
+                        delegate.instantiate_existential_canonical_var(var_kind, span, |_| {
+                            prev_universe
+                        })
                     }
                 } else {
                     // For placeholders which were already part of the input, we simply map this
                     // universal bound variable back the placeholder of the input.
-                    original_values[var_kind.expect_placeholder_index()]
+                    opt_values[ty::BoundVar::from_usize(index)].unwrap()
                 }
             }),
         );

compiler/rustc_trait_selection/src/solve/delegate.rs

@@ -188,13 +188,22 @@ impl<'tcx> rustc_next_trait_solver::delegate::SolverDelegate for SolverDelegate<
         canonical.instantiate(self.tcx, &values)
     }
 
-    fn instantiate_canonical_var_with_infer(
+    fn instantiate_existential_canonical_var(
         &self,
-        kind: CanonicalVarKind<'tcx>,
+        kind: CanonicalVarKind,
         span: Span,
         universe_map: impl Fn(ty::UniverseIndex) -> ty::UniverseIndex,
     ) -> ty::GenericArg<'tcx> {
-        self.0.instantiate_canonical_var(span, kind, universe_map)
+        self.0.instantiate_existential_canonical_var(span, kind, universe_map)
+    }
+    fn instantiate_canonical_var(
+        &self,
+        at_index: usize,
+        kind: CanonicalVarKind,
+        span: Span,
+        universe_map: impl Fn(ty::UniverseIndex) -> ty::UniverseIndex,
+    ) -> ty::GenericArg<'tcx> {
+        self.0.instantiate_canonical_var(span, at_index, kind, universe_map)
     }
 
     fn add_item_bounds_for_hidden_type(

compiler/rustc_type_ir/src/canonical.rs

@@ -88,42 +88,42 @@ impl<I: Interner, V: fmt::Display> fmt::Display for Canonical<I, V> {
 /// canonical value. This is sufficient information for code to create
 /// a copy of the canonical value in some other inference context,
 /// with fresh inference variables replacing the canonical values.
-#[derive_where(Clone, Copy, Hash, PartialEq, Eq, Debug; I: Interner)]
+#[derive(Clone, Copy, Hash, PartialEq, Eq, Debug)]
 #[cfg_attr(
     feature = "nightly",
     derive(Decodable_NoContext, Encodable_NoContext, HashStable_NoContext)
 )]
-pub enum CanonicalVarKind<I: Interner> {
+pub enum CanonicalVarKind {
     /// Some kind of type inference variable.
     Ty(CanonicalTyVarKind),
 
     /// A "placeholder" that represents "any type".
-    PlaceholderTy(I::PlaceholderTy),
+    PlaceholderTy(UniverseIndex),
 
     /// Region variable `'?R`.
     Region(UniverseIndex),
 
     /// A "placeholder" that represents "any region". Created when you
     /// are solving a goal like `for<'a> T: Foo<'a>` to represent the
     /// bound region `'a`.
-    PlaceholderRegion(I::PlaceholderRegion),
+    PlaceholderRegion(UniverseIndex),
 
     /// Some kind of const inference variable.
     Const(UniverseIndex),
 
     /// A "placeholder" that represents "any const".
-    PlaceholderConst(I::PlaceholderConst),
+    PlaceholderConst(UniverseIndex),
 }
 
-impl<I: Interner> CanonicalVarKind<I> {
+impl CanonicalVarKind {
     pub fn universe(self) -> UniverseIndex {
         match self {
-            CanonicalVarKind::Ty(CanonicalTyVarKind::General(ui)) => ui,
-            CanonicalVarKind::Region(ui) => ui,
-            CanonicalVarKind::Const(ui) => ui,
-            CanonicalVarKind::PlaceholderTy(placeholder) => placeholder.universe(),
-            CanonicalVarKind::PlaceholderRegion(placeholder) => placeholder.universe(),
-            CanonicalVarKind::PlaceholderConst(placeholder) => placeholder.universe(),
+            CanonicalVarKind::Ty(CanonicalTyVarKind::General(ui))
+            | CanonicalVarKind::Region(ui)
+            | CanonicalVarKind::Const(ui)
+            | CanonicalVarKind::PlaceholderTy(ui)
+            | CanonicalVarKind::PlaceholderRegion(ui)
+            | CanonicalVarKind::PlaceholderConst(ui) => ui,
             CanonicalVarKind::Ty(CanonicalTyVarKind::Float | CanonicalTyVarKind::Int) => {
                 UniverseIndex::ROOT
             }
@@ -134,23 +134,16 @@ impl<I: Interner> CanonicalVarKind<I> {
     ///
     /// In case this is a float or int variable, this causes an ICE if
     /// the updated universe is not the root.
-    pub fn with_updated_universe(self, ui: UniverseIndex) -> CanonicalVarKind<I> {
+    pub fn with_updated_universe(self, ui: UniverseIndex) -> CanonicalVarKind {
         match self {
             CanonicalVarKind::Ty(CanonicalTyVarKind::General(_)) => {
                 CanonicalVarKind::Ty(CanonicalTyVarKind::General(ui))
             }
             CanonicalVarKind::Region(_) => CanonicalVarKind::Region(ui),
             CanonicalVarKind::Const(_) => CanonicalVarKind::Const(ui),
-
-            CanonicalVarKind::PlaceholderTy(placeholder) => {
-                CanonicalVarKind::PlaceholderTy(placeholder.with_updated_universe(ui))
-            }
-            CanonicalVarKind::PlaceholderRegion(placeholder) => {
-                CanonicalVarKind::PlaceholderRegion(placeholder.with_updated_universe(ui))
-            }
-            CanonicalVarKind::PlaceholderConst(placeholder) => {
-                CanonicalVarKind::PlaceholderConst(placeholder.with_updated_universe(ui))
-            }
+            CanonicalVarKind::PlaceholderTy(_) => CanonicalVarKind::PlaceholderTy(ui),
+            CanonicalVarKind::PlaceholderRegion(_) => CanonicalVarKind::PlaceholderRegion(ui),
+            CanonicalVarKind::PlaceholderConst(_) => CanonicalVarKind::PlaceholderConst(ui),
             CanonicalVarKind::Ty(CanonicalTyVarKind::Int | CanonicalTyVarKind::Float) => {
                 assert_eq!(ui, UniverseIndex::ROOT);
                 self
@@ -178,18 +171,6 @@ impl<I: Interner> CanonicalVarKind<I> {
             | CanonicalVarKind::PlaceholderConst(_) => false,
         }
     }
-
-    pub fn expect_placeholder_index(self) -> usize {
-        match self {
-            CanonicalVarKind::Ty(_) | CanonicalVarKind::Region(_) | CanonicalVarKind::Const(_) => {
-                panic!("expected placeholder: {self:?}")
-            }
-
-            CanonicalVarKind::PlaceholderRegion(placeholder) => placeholder.var().as_usize(),
-            CanonicalVarKind::PlaceholderTy(placeholder) => placeholder.var().as_usize(),
-            CanonicalVarKind::PlaceholderConst(placeholder) => placeholder.var().as_usize(),
-        }
-    }
 }
 
 /// Rust actually has more than one category of type variables;

compiler/rustc_type_ir/src/inherent.rs

@@ -527,9 +527,11 @@ pub trait IntoKind {
 }
 
 pub trait BoundVarLike<I: Interner> {
+    fn new_anon(var: ty::BoundVar) -> Self;
+
     fn var(self) -> ty::BoundVar;
 
-    fn assert_eq(self, var: I::BoundVarKind);
+    fn assert_eq(self, kinid: I::BoundVarKind);
 }
 
 pub trait ParamLike {

compiler/rustc_type_ir/src/interner.rs

@@ -68,12 +68,9 @@ pub trait Interner:
         + Debug
         + Hash
         + Eq
-        + SliceLike<Item = ty::CanonicalVarKind<Self>>
+        + SliceLike<Item = ty::CanonicalVarKind>
         + Default;
-    fn mk_canonical_var_kinds(
-        self,
-        kinds: &[ty::CanonicalVarKind<Self>],
-    ) -> Self::CanonicalVarKinds;
+    fn mk_canonical_var_kinds(self, kinds: &[ty::CanonicalVarKind]) -> Self::CanonicalVarKinds;
 
     type ExternalConstraints: Copy
         + Debug

compiler/rustc_type_ir/src/lib.rs

@@ -386,6 +386,10 @@ rustc_index::newtype_index! {
 }
 
 impl<I: Interner> inherent::BoundVarLike<I> for BoundVar {
+    fn new_anon(var: BoundVar) -> Self {
+        var
+    }
+
     fn var(self) -> BoundVar {
         self
     }

tests/ui/traits/const-traits/const-impl-trait.stderr

@@ -89,6 +89,15 @@ LL |     fn huh() -> impl ~const PartialEq + ~const Destruct + Copy {
 note: `PartialEq` can't be used with `~const` because it isn't annotated with `#[const_trait]`
   --> $SRC_DIR/core/src/cmp.rs:LL:COL
 
+error[E0792]: expected generic type parameter, found `_`
+  --> $DIR/const-impl-trait.rs:15:1
+   |
+LL | / const fn wrap(
+LL | |     x: impl ~const PartialEq + ~const Destruct,
+   | |        --------------------------------------- this generic parameter must be used with a generic type parameter
+LL | | ) -> impl ~const PartialEq + ~const Destruct {
+   | |____________________________________________^
+
 error: `~const` can only be applied to `#[const_trait]` traits
   --> $DIR/const-impl-trait.rs:27:22
    |
@@ -191,7 +200,7 @@ LL |     a == a
    |
    = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
 
-error: aborting due to 21 previous errors
+error: aborting due to 22 previous errors
 
-Some errors have detailed explanations: E0015, E0635.
+Some errors have detailed explanations: E0015, E0635, E0792.
 For more information about an error, try `rustc --explain E0015`.

tests/ui/traits/non_lifetime_binders/placeholders-dont-outlive-static.bad.stderr

@@ -7,19 +7,19 @@ LL | #![feature(non_lifetime_binders)]
    = note: see issue #108185 <https://github.com/rust-lang/rust/issues/108185> for more information
    = note: `#[warn(incomplete_features)]` on by default
 
-error[E0310]: the placeholder type `!1_"T"` may not live long enough
+error[E0310]: the placeholder type `!1_1` may not live long enough
   --> $DIR/placeholders-dont-outlive-static.rs:13:5
    |
 LL |     foo();
    |     ^^^^^
    |     |
-   |     the placeholder type `!1_"T"` must be valid for the static lifetime...
-   |     ...so that the type `T` will meet its required lifetime bounds
+   |     the placeholder type `!1_1` must be valid for the static lifetime...
+   |     ...so that the type `!1_1` will meet its required lifetime bounds
    |
 help: consider adding an explicit lifetime bound
    |
-LL | fn bad() where !1_"T": 'static {
-   |          +++++++++++++++++++++
+LL | fn bad() where !1_1: 'static {
+   |          +++++++++++++++++++
 
 error: aborting due to 1 previous error; 1 warning emitted
 

tests/ui/traits/non_lifetime_binders/placeholders-dont-outlive-static.good.stderr

@@ -7,19 +7,19 @@ LL | #![feature(non_lifetime_binders)]
    = note: see issue #108185 <https://github.com/rust-lang/rust/issues/108185> for more information
    = note: `#[warn(incomplete_features)]` on by default
 
-error[E0310]: the placeholder type `!1_"T"` may not live long enough
+error[E0310]: the placeholder type `!1_1` may not live long enough
   --> $DIR/placeholders-dont-outlive-static.rs:19:5
    |
 LL |     foo();
    |     ^^^^^
    |     |
-   |     the placeholder type `!1_"T"` must be valid for the static lifetime...
-   |     ...so that the type `T` will meet its required lifetime bounds
+   |     the placeholder type `!1_1` must be valid for the static lifetime...
+   |     ...so that the type `!1_1` will meet its required lifetime bounds
    |
 help: consider adding an explicit lifetime bound
    |
-LL | fn good() where for<T> T: 'static, !1_"T": 'static {
-   |                                  +++++++++++++++++
+LL | fn good() where for<T> T: 'static, !1_1: 'static {
+   |                                  +++++++++++++++
 
 error: aborting due to 1 previous error; 1 warning emitted
 

tests/ui/traits/non_lifetime_binders/placeholders-dont-outlive-static.rs

@@ -11,7 +11,7 @@ fn foo() where for<T> T: 'static {}
 #[cfg(bad)]
 fn bad() {
     foo();
-    //[bad]~^ ERROR the placeholder type `!1_"T"` may not live long enough
+    //[bad]~^ ERROR the placeholder type `!1_1` may not live long enough
 }
 
 #[cfg(good)]

tests/ui/traits/non_lifetime_binders/type-match-with-late-bound.stderr

@@ -28,19 +28,19 @@ help: consider adding an explicit lifetime bound
 LL |     for<F> F: 'a, !1_"F": 'a
    |                   ++++++++++
 
-error[E0309]: the placeholder type `!1_"F"` may not live long enough
+error[E0309]: the placeholder type `!1_2` may not live long enough
   --> $DIR/type-match-with-late-bound.rs:11:1
    |
 LL | async fn walk2<'a, T: 'a>(_: T)
-   |                -- the placeholder type `!1_"F"` must be valid for the lifetime `'a` as defined here...
+   |                -- the placeholder type `!1_2` must be valid for the lifetime `'a` as defined here...
 ...
 LL | {}
-   | ^^ ...so that the type `F` will meet its required lifetime bounds
+   | ^^ ...so that the type `!1_2` will meet its required lifetime bounds
    |
 help: consider adding an explicit lifetime bound
    |
-LL |     for<F> F: 'a, !1_"F": 'a
-   |                   ++++++++++
+LL |     for<F> F: 'a, !1_2: 'a
+   |                   ++++++++
 
 error[E0309]: the placeholder type `!2_"F"` may not live long enough
   --> $DIR/type-match-with-late-bound.rs:11:1

tests/ui/traits/trait-upcasting/higher-ranked-upcasting-ub.current.stderr

@@ -1,22 +1,19 @@
-error[E0308]: mismatched types
+error: higher-ranked lifetime error
   --> $DIR/higher-ranked-upcasting-ub.rs:22:5
    |
 LL |     x
-   |     ^ one type is more general than the other
+   |     ^
    |
-   = note: expected existential trait ref `for<'a, 'b> Supertrait<'a, 'b>`
-              found existential trait ref `for<'a> Supertrait<'a, 'a>`
+   = note: could not prove `&'c (dyn for<'a> Subtrait<'a, 'a> + 'd): CoerceUnsized<&'e (dyn for<'a, 'b> Supertrait<'a, 'b> + 'f)>`
 
-error[E0308]: mismatched types
+error: higher-ranked lifetime error
   --> $DIR/higher-ranked-upcasting-ub.rs:22:5
    |
 LL |     x
-   |     ^ one type is more general than the other
+   |     ^
    |
-   = note: expected existential trait ref `for<'a, 'b> Supertrait<'a, 'b>`
-              found existential trait ref `for<'a> Supertrait<'a, 'a>`
+   = note: could not prove `&'c (dyn for<'a> Subtrait<'a, 'a> + 'd): CoerceUnsized<&'e (dyn for<'a, 'b> Supertrait<'a, 'b> + 'f)>`
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
 
 error: aborting due to 2 previous errors
 
-For more information about this error, try `rustc --explain E0308`.

tests/ui/traits/trait-upcasting/higher-ranked-upcasting-ub.rs

@@ -19,8 +19,9 @@ impl<'a> Supertrait<'a, 'a> for () {
 }
 impl<'a> Subtrait<'a, 'a> for () {}
 fn unsound(x: &dyn for<'a> Subtrait<'a, 'a>) -> &dyn for<'a, 'b> Supertrait<'a, 'b> {
-    x //~ ERROR mismatched types
-    //[current]~^ ERROR mismatched types
+    x //[next]~ ERROR mismatched types
+    //[current]~^ ERROR higher-ranked lifetime error
+    //[current]~| ERROR higher-ranked lifetime error
 }
 
 fn transmute<'a, 'b>(x: &'a str) -> &'b str {