Auto merge of #141432 - lcnr:canonicalize-regions, r=<try>

refactor `CanonicalVarKind`

it's unnecessary. I don't believe we'll ever need to store additional info shared by all `CanonicalVarKind`s.

r? `@compiler-errors`

Author: bors

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

@@ -17,8 +17,7 @@ use tracing::debug;
 
 use crate::infer::InferCtxt;
 use crate::infer::canonical::{
-    Canonical, CanonicalQueryInput, CanonicalTyVarKind, CanonicalVarInfo, CanonicalVarKind,
-    OriginalQueryValues,
+    Canonical, CanonicalQueryInput, CanonicalTyVarKind, CanonicalVarKind, OriginalQueryValues,
 };
 
 impl<'tcx> InferCtxt<'tcx> {
@@ -175,7 +174,7 @@ impl CanonicalizeMode for CanonicalizeQueryResponse {
             ty::ReLateParam(_) | ty::ReErased | ty::ReStatic | ty::ReEarlyParam(..) => r,
 
             ty::RePlaceholder(placeholder) => canonicalizer.canonical_var_for_region(
-                CanonicalVarInfo { kind: CanonicalVarKind::PlaceholderRegion(placeholder) },
+                CanonicalVarKind::PlaceholderRegion(placeholder.universe),
                 r,
             ),
 
@@ -186,10 +185,7 @@ impl CanonicalizeMode for CanonicalizeQueryResponse {
                     .unwrap_region_constraints()
                     .probe_value(vid)
                     .unwrap_err();
-                canonicalizer.canonical_var_for_region(
-                    CanonicalVarInfo { kind: CanonicalVarKind::Region(universe) },
-                    r,
-                )
+                canonicalizer.canonical_var_for_region(CanonicalVarKind::Region(universe), r)
             }
 
             _ => {
@@ -294,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<[CanonicalVarInfo<'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.
@@ -368,9 +364,7 @@ impl<'cx, 'tcx> TypeFolder<TyCtxt<'tcx>> for Canonicalizer<'cx, 'tcx> {
                             ui = ty::UniverseIndex::ROOT;
                         }
                         self.canonicalize_ty_var(
-                            CanonicalVarInfo {
-                                kind: CanonicalVarKind::Ty(CanonicalTyVarKind::General(ui)),
-                            },
+                            CanonicalVarKind::Ty(CanonicalTyVarKind::General(ui)),
                             t,
                         )
                     }
@@ -382,36 +376,29 @@ impl<'cx, 'tcx> TypeFolder<TyCtxt<'tcx>> for Canonicalizer<'cx, 'tcx> {
                 if nt != t {
                     return self.fold_ty(nt);
                 } else {
-                    self.canonicalize_ty_var(
-                        CanonicalVarInfo { kind: CanonicalVarKind::Ty(CanonicalTyVarKind::Int) },
-                        t,
-                    )
+                    self.canonicalize_ty_var(CanonicalVarKind::Ty(CanonicalTyVarKind::Int), t)
                 }
             }
             ty::Infer(ty::FloatVar(vid)) => {
                 let nt = self.infcx.unwrap().opportunistic_resolve_float_var(vid);
                 if nt != t {
                     return self.fold_ty(nt);
                 } else {
-                    self.canonicalize_ty_var(
-                        CanonicalVarInfo { kind: CanonicalVarKind::Ty(CanonicalTyVarKind::Float) },
-                        t,
-                    )
+                    self.canonicalize_ty_var(CanonicalVarKind::Ty(CanonicalTyVarKind::Float), t)
                 }
             }
 
             ty::Infer(ty::FreshTy(_) | ty::FreshIntTy(_) | ty::FreshFloatTy(_)) => {
                 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(
-                    CanonicalVarInfo { kind: 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, _) => {
@@ -483,10 +470,7 @@ impl<'cx, 'tcx> TypeFolder<TyCtxt<'tcx>> for Canonicalizer<'cx, 'tcx> {
                             // FIXME: perf problem described in #55921.
                             ui = ty::UniverseIndex::ROOT;
                         }
-                        return self.canonicalize_const_var(
-                            CanonicalVarInfo { kind: CanonicalVarKind::Const(ui) },
-                            ct,
-                        );
+                        return self.canonicalize_const_var(CanonicalVarKind::Const(ui), ct);
                     }
                 }
             }
@@ -501,10 +485,13 @@ impl<'cx, 'tcx> TypeFolder<TyCtxt<'tcx>> for Canonicalizer<'cx, 'tcx> {
                 }
             }
             ty::ConstKind::Placeholder(placeholder) => {
-                return self.canonicalize_const_var(
-                    CanonicalVarInfo { kind: CanonicalVarKind::PlaceholderConst(placeholder) },
-                    ct,
-                );
+                let universe = if self.canonicalize_mode.preserve_universes() {
+                    placeholder.universe
+                } else {
+                    ty::UniverseIndex::ROOT
+                };
+                return self
+                    .canonicalize_const_var(CanonicalVarKind::PlaceholderConst(universe), ct);
             }
             _ => {}
         }
@@ -595,7 +582,7 @@ impl<'cx, 'tcx> Canonicalizer<'cx, 'tcx> {
         debug_assert!(!out_value.has_infer() && !out_value.has_placeholders());
 
         let canonical_variables =
-            tcx.mk_canonical_var_infos(&canonicalizer.universe_canonicalized_variables());
+            tcx.mk_canonical_var_kinds(&canonicalizer.universe_canonicalized_variables());
 
         let max_universe = canonical_variables
             .iter()
@@ -610,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: CanonicalVarInfo<'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;
@@ -673,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<[CanonicalVarInfo<'tcx>; 8]> {
+    fn universe_canonicalized_variables(self) -> SmallVec<[CanonicalVarKind; 8]> {
         if self.query_state.universe_map.len() == 1 {
             return self.variables;
         }
@@ -688,37 +675,24 @@ impl<'cx, 'tcx> Canonicalizer<'cx, 'tcx> {
 
         self.variables
             .iter()
-            .map(|v| CanonicalVarInfo {
-                kind: match v.kind {
-                    CanonicalVarKind::Ty(CanonicalTyVarKind::Int | CanonicalTyVarKind::Float) => {
-                        return *v;
-                    }
-                    CanonicalVarKind::Ty(CanonicalTyVarKind::General(u)) => {
-                        CanonicalVarKind::Ty(CanonicalTyVarKind::General(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(ty::Placeholder {
-                            universe: reverse_universe_map[&placeholder.universe],
-                            ..placeholder
-                        })
-                    }
-                    CanonicalVarKind::PlaceholderRegion(placeholder) => {
-                        CanonicalVarKind::PlaceholderRegion(ty::Placeholder {
-                            universe: reverse_universe_map[&placeholder.universe],
-                            ..placeholder
-                        })
-                    }
-                    CanonicalVarKind::PlaceholderConst(placeholder) => {
-                        CanonicalVarKind::PlaceholderConst(ty::Placeholder {
-                            universe: reverse_universe_map[&placeholder.universe],
-                            ..placeholder
-                        })
-                    }
-                },
+            .map(|&kind| match kind {
+                CanonicalVarKind::Ty(CanonicalTyVarKind::Int | CanonicalTyVarKind::Float) => {
+                    return kind;
+                }
+                CanonicalVarKind::Ty(CanonicalTyVarKind::General(u)) => {
+                    CanonicalVarKind::Ty(CanonicalTyVarKind::General(reverse_universe_map[&u]))
+                }
+                CanonicalVarKind::Region(u) => CanonicalVarKind::Region(reverse_universe_map[&u]),
+                CanonicalVarKind::Const(u) => CanonicalVarKind::Const(reverse_universe_map[&u]),
+                CanonicalVarKind::PlaceholderTy(ui) => {
+                    CanonicalVarKind::PlaceholderTy(reverse_universe_map[&ui])
+                }
+                CanonicalVarKind::PlaceholderRegion(ui) => {
+                    CanonicalVarKind::PlaceholderRegion(reverse_universe_map[&ui])
+                }
+                CanonicalVarKind::PlaceholderConst(ui) => {
+                    CanonicalVarKind::PlaceholderConst(reverse_universe_map[&ui])
+                }
             })
             .collect()
     }
@@ -740,17 +714,14 @@ impl<'cx, 'tcx> Canonicalizer<'cx, 'tcx> {
         &mut self,
         r: ty::Region<'tcx>,
     ) -> ty::Region<'tcx> {
-        self.canonical_var_for_region(
-            CanonicalVarInfo { kind: CanonicalVarKind::Region(ty::UniverseIndex::ROOT) },
-            r,
-        )
+        self.canonical_var_for_region(CanonicalVarKind::Region(ty::UniverseIndex::ROOT), r)
     }
 
     /// Creates a canonical variable (with the given `info`)
     /// representing the region `r`; return a region referencing it.
     fn canonical_var_for_region(
         &mut self,
-        info: CanonicalVarInfo<'tcx>,
+        info: CanonicalVarKind,
         r: ty::Region<'tcx>,
     ) -> ty::Region<'tcx> {
         let var = self.canonical_var(info, r.into());
@@ -762,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: CanonicalVarInfo<'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
@@ -774,7 +745,7 @@ impl<'cx, 'tcx> Canonicalizer<'cx, 'tcx> {
     /// `const_var`.
     fn canonicalize_const_var(
         &mut self,
-        info: CanonicalVarInfo<'tcx>,
+        info: CanonicalVarKind,
         const_var: ty::Const<'tcx>,
     ) -> ty::Const<'tcx> {
         debug_assert!(

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

@@ -81,33 +81,30 @@ impl<'tcx> InferCtxt<'tcx> {
     fn instantiate_canonical_vars(
         &self,
         span: Span,
-        variables: &List<CanonicalVarInfo<'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(|info| self.instantiate_canonical_var(span, info, &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,
-        cv_info: CanonicalVarInfo<'tcx>,
+        kind: CanonicalVarKind,
         universe_map: impl Fn(ty::UniverseIndex) -> ty::UniverseIndex,
     ) -> GenericArg<'tcx> {
-        match cv_info.kind {
+        match kind {
             CanonicalVarKind::Ty(ty_kind) => {
                 let ty = match ty_kind {
                     CanonicalTyVarKind::General(ui) => {
@@ -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()
             }
         }
     }