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.