Move struct placeholder pt2

compiler/rustc_borrowck/src/diagnostics/bound_region_errors.rs

@@ -169,7 +169,7 @@ pub(crate) trait TypeOpInfo<'tcx> {
 
         let placeholder_region = ty::Region::new_placeholder(
             tcx,
-            ty::Placeholder::new(adjusted_universe.into(), placeholder.bound),
+            ty::PlaceholderRegion::new(adjusted_universe.into(), placeholder.bound),
         );
 
         let error_region =
@@ -179,7 +179,7 @@ pub(crate) trait TypeOpInfo<'tcx> {
                 adjusted_universe.map(|adjusted| {
                     ty::Region::new_placeholder(
                         tcx,
-                        ty::Placeholder::new(adjusted.into(), error_placeholder.bound),
+                        ty::PlaceholderRegion::new(adjusted.into(), error_placeholder.bound),
                     )
                 })
             } else {

compiler/rustc_borrowck/src/region_infer/graphviz.rs

@@ -52,7 +52,7 @@ fn render_region_vid<'tcx>(
                 format!(" (for<{}>)", tcx.item_name(def_id))
             }
             ty::BoundRegionKind::ClosureEnv | ty::BoundRegionKind::Anon => " (for<'_>)".to_string(),
-            ty::BoundRegionKind::NamedAnon(_) => {
+            ty::BoundRegionKind::NamedForPrinting(_) => {
                 bug!("only used for pretty printing")
             }
         },

compiler/rustc_borrowck/src/region_infer/values.rs

@@ -10,8 +10,8 @@ use rustc_middle::ty::{self, RegionVid};
 use rustc_mir_dataflow::points::{DenseLocationMap, PointIndex};
 use tracing::debug;
 
+use crate::BorrowIndex;
 use crate::polonius::LiveLoans;
-use crate::{BorrowIndex, TyCtxt};
 
 rustc_index::newtype_index! {
     /// A single integer representing a `ty::Placeholder`.
@@ -420,18 +420,18 @@ impl ToElementIndex<'_> for RegionVid {
 impl<'tcx> ToElementIndex<'tcx> for ty::PlaceholderRegion<'tcx> {
     fn add_to_row<N: Idx>(self, values: &mut RegionValues<'tcx, N>, row: N) -> bool
     where
-        Self: Into<ty::Placeholder<TyCtxt<'tcx>, ty::BoundRegion>>,
+        Self: Into<ty::PlaceholderRegion<'tcx>>,
     {
-        let placeholder: ty::Placeholder<TyCtxt<'tcx>, ty::BoundRegion> = self.into();
+        let placeholder: ty::PlaceholderRegion<'tcx> = self.into();
         let index = values.placeholder_indices.lookup_index(placeholder);
         values.placeholders.insert(row, index)
     }
 
     fn contained_in_row<N: Idx>(self, values: &RegionValues<'tcx, N>, row: N) -> bool
     where
-        Self: Into<ty::Placeholder<TyCtxt<'tcx>, ty::BoundRegion>>,
+        Self: Into<ty::PlaceholderRegion<'tcx>>,
     {
-        let placeholder: ty::Placeholder<TyCtxt<'tcx>, ty::BoundRegion> = self.into();
+        let placeholder: ty::PlaceholderRegion<'tcx> = self.into();
         let index = values.placeholder_indices.lookup_index(placeholder);
         values.placeholders.contains(row, index)
     }

compiler/rustc_borrowck/src/type_check/mod.rs

@@ -772,7 +772,7 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
                             ty::BoundRegionKind::Anon => sym::anon,
                             ty::BoundRegionKind::Named(def_id) => tcx.item_name(def_id),
                             ty::BoundRegionKind::ClosureEnv => sym::env,
-                            ty::BoundRegionKind::NamedAnon(_) => {
+                            ty::BoundRegionKind::NamedForPrinting(_) => {
                                 bug!("only used for pretty printing")
                             }
                         };

compiler/rustc_borrowck/src/type_check/relate_tys.rs

@@ -174,7 +174,7 @@ impl<'a, 'b, 'tcx> NllTypeRelating<'a, 'b, 'tcx> {
             let infcx = self.type_checker.infcx;
             let mut lazy_universe = None;
             let delegate = FnMutDelegate {
-                regions: &mut |br: ty::BoundRegion| {
+                regions: &mut |br: ty::BoundRegion<'tcx>| {
                     // The first time this closure is called, create a
                     // new universe for the placeholders we will make
                     // from here out.
@@ -191,10 +191,10 @@ impl<'a, 'b, 'tcx> NllTypeRelating<'a, 'b, 'tcx> {
 
                     placeholder_reg
                 },
-                types: &mut |_bound_ty: ty::BoundTy| {
+                types: &mut |_bound_ty: ty::BoundTy<'tcx>| {
                     unreachable!("we only replace regions in nll_relate, not types")
                 },
-                consts: &mut |_bound_const: ty::BoundConst| {
+                consts: &mut |_bound_const: ty::BoundConst<'tcx>| {
                     unreachable!("we only replace regions in nll_relate, not consts")
                 },
             };
@@ -218,7 +218,7 @@ impl<'a, 'b, 'tcx> NllTypeRelating<'a, 'b, 'tcx> {
         let infcx = self.type_checker.infcx;
         let mut reg_map = FxHashMap::default();
         let delegate = FnMutDelegate {
-            regions: &mut |br: ty::BoundRegion| {
+            regions: &mut |br: ty::BoundRegion<'tcx>| {
                 if let Some(ex_reg_var) = reg_map.get(&br) {
                     *ex_reg_var
                 } else {
@@ -230,10 +230,10 @@ impl<'a, 'b, 'tcx> NllTypeRelating<'a, 'b, 'tcx> {
                     ex_reg_var
                 }
             },
-            types: &mut |_bound_ty: ty::BoundTy| {
+            types: &mut |_bound_ty: ty::BoundTy<'tcx>| {
                 unreachable!("we only replace regions in nll_relate, not types")
             },
-            consts: &mut |_bound_const: ty::BoundConst| {
+            consts: &mut |_bound_const: ty::BoundConst<'tcx>| {
                 unreachable!("we only replace regions in nll_relate, not consts")
             },
         };
@@ -268,7 +268,7 @@ impl<'a, 'b, 'tcx> NllTypeRelating<'a, 'b, 'tcx> {
             ty::BoundRegionKind::Anon => sym::anon,
             ty::BoundRegionKind::Named(def_id) => self.type_checker.tcx().item_name(def_id),
             ty::BoundRegionKind::ClosureEnv => sym::env,
-            ty::BoundRegionKind::NamedAnon(_) => bug!("only used for pretty printing"),
+            ty::BoundRegionKind::NamedForPrinting(_) => bug!("only used for pretty printing"),
         };
 
         if cfg!(debug_assertions) {

compiler/rustc_hir_analysis/src/check/compare_impl_item.rs

@@ -592,7 +592,7 @@ pub(super) fn collect_return_position_impl_trait_in_trait_tys<'tcx>(
                 ty,
                 Ty::new_placeholder(
                     tcx,
-                    ty::Placeholder::new(
+                    ty::PlaceholderType::new(
                         universe,
                         ty::BoundTy { var: idx, kind: ty::BoundTyKind::Anon },
                     ),
@@ -2551,7 +2551,7 @@ fn param_env_with_gat_bounds<'tcx>(
             }
         };
 
-        let mut bound_vars: smallvec::SmallVec<[ty::BoundVariableKind; 8]> =
+        let mut bound_vars: smallvec::SmallVec<[ty::BoundVariableKind<'tcx>; 8]> =
             smallvec::SmallVec::with_capacity(tcx.generics_of(impl_ty.def_id).own_params.len());
         // Extend the impl's identity args with late-bound GAT vars
         let normalize_impl_ty_args = ty::GenericArgs::identity_for_item(tcx, container_id)
@@ -2587,7 +2587,7 @@ fn param_env_with_gat_bounds<'tcx>(
                     ty::Const::new_bound(
                         tcx,
                         ty::INNERMOST,
-                        ty::BoundConst { var: ty::BoundVar::from_usize(bound_vars.len() - 1) },
+                        ty::BoundConst::new(ty::BoundVar::from_usize(bound_vars.len() - 1)),
                     )
                     .into()
                 }

compiler/rustc_hir_analysis/src/collect/item_bounds.rs

@@ -241,7 +241,7 @@ struct MapAndCompressBoundVars<'tcx> {
     binder: ty::DebruijnIndex,
     /// List of bound vars that remain unsubstituted because they were not
     /// mentioned in the GAT's args.
-    still_bound_vars: Vec<ty::BoundVariableKind>,
+    still_bound_vars: Vec<ty::BoundVariableKind<'tcx>>,
     /// Subtle invariant: If the `GenericArg` is bound, then it should be
     /// stored with the debruijn index of `INNERMOST` so it can be shifted
     /// correctly during substitution.
@@ -330,7 +330,8 @@ impl<'tcx> TypeFolder<TyCtxt<'tcx>> for MapAndCompressBoundVars<'tcx> {
             } else {
                 let var = ty::BoundVar::from_usize(self.still_bound_vars.len());
                 self.still_bound_vars.push(ty::BoundVariableKind::Const);
-                let mapped = ty::Const::new_bound(self.tcx, ty::INNERMOST, ty::BoundConst { var });
+                let mapped =
+                    ty::Const::new_bound(self.tcx, ty::INNERMOST, ty::BoundConst::new(var));
                 self.mapping.insert(old_bound.var, mapped.into());
                 mapped
             };

compiler/rustc_hir_analysis/src/collect/resolve_bound_vars.rs

@@ -63,9 +63,9 @@ impl ResolvedArg {
 
 struct BoundVarContext<'a, 'tcx> {
     tcx: TyCtxt<'tcx>,
-    rbv: &'a mut ResolveBoundVars,
+    rbv: &'a mut ResolveBoundVars<'tcx>,
     disambiguator: &'a mut DisambiguatorState,
-    scope: ScopeRef<'a>,
+    scope: ScopeRef<'a, 'tcx>,
     opaque_capture_errors: RefCell<Option<OpaqueHigherRankedLifetimeCaptureErrors>>,
 }
 
@@ -76,7 +76,7 @@ struct OpaqueHigherRankedLifetimeCaptureErrors {
 }
 
 #[derive(Debug)]
-enum Scope<'a> {
+enum Scope<'a, 'tcx> {
     /// Declares lifetimes, and each can be early-bound or late-bound.
     /// The `DebruijnIndex` of late-bound lifetimes starts at `1` and
     /// it should be shifted by the number of `Binder`s in between the
@@ -94,7 +94,7 @@ enum Scope<'a> {
         /// to append to.
         hir_id: HirId,
 
-        s: ScopeRef<'a>,
+        s: ScopeRef<'a, 'tcx>,
 
         /// If this binder comes from a where clause, specify how it was created.
         /// This is used to diagnose inaccessible lifetimes in APIT:
@@ -110,28 +110,28 @@ enum Scope<'a> {
     /// e.g., `(&T, fn(&T) -> &T);` becomes `(&'_ T, for<'a> fn(&'a T) -> &'a T)`.
     Body {
         id: hir::BodyId,
-        s: ScopeRef<'a>,
+        s: ScopeRef<'a, 'tcx>,
     },
 
     /// Use a specific lifetime (if `Some`) or leave it unset (to be
     /// inferred in a function body or potentially error outside one),
     /// for the default choice of lifetime in a trait object type.
     ObjectLifetimeDefault {
         lifetime: Option<ResolvedArg>,
-        s: ScopeRef<'a>,
+        s: ScopeRef<'a, 'tcx>,
     },
 
     /// When we have nested trait refs, we concatenate late bound vars for inner
     /// trait refs from outer ones. But we also need to include any HRTB
     /// lifetimes encountered when identifying the trait that an associated type
     /// is declared on.
     Supertrait {
-        bound_vars: Vec<ty::BoundVariableKind>,
-        s: ScopeRef<'a>,
+        bound_vars: Vec<ty::BoundVariableKind<'tcx>>,
+        s: ScopeRef<'a, 'tcx>,
     },
 
     TraitRefBoundary {
-        s: ScopeRef<'a>,
+        s: ScopeRef<'a, 'tcx>,
     },
 
     /// Remap lifetimes that appear in opaque types to fresh lifetime parameters. Given:
@@ -148,7 +148,7 @@ enum Scope<'a> {
         /// Mapping from each captured lifetime `'a` to the duplicate generic parameter `'b`.
         captures: &'a RefCell<FxIndexMap<ResolvedArg, LocalDefId>>,
 
-        s: ScopeRef<'a>,
+        s: ScopeRef<'a, 'tcx>,
     },
 
     /// Disallows capturing late-bound vars from parent scopes.
@@ -157,7 +157,7 @@ enum Scope<'a> {
     /// since we don't do something more correct like replacing any captured
     /// late-bound vars with early-bound params in the const's own generics.
     LateBoundary {
-        s: ScopeRef<'a>,
+        s: ScopeRef<'a, 'tcx>,
         what: &'static str,
         deny_late_regions: bool,
     },
@@ -167,7 +167,7 @@ enum Scope<'a> {
     },
 }
 
-impl<'a> Scope<'a> {
+impl<'a, 'tcx> Scope<'a, 'tcx> {
     // A helper for debugging scopes without printing parent scopes
     fn debug_truncated(&self) -> impl fmt::Debug {
         fmt::from_fn(move |f| match self {
@@ -227,7 +227,7 @@ enum BinderScopeType {
     Concatenating,
 }
 
-type ScopeRef<'a> = &'a Scope<'a>;
+type ScopeRef<'a, 'tcx> = &'a Scope<'a, 'tcx>;
 
 /// Adds query implementations to the [Providers] vtable, see [`rustc_middle::query`]
 pub(crate) fn provide(providers: &mut Providers) {
@@ -253,7 +253,7 @@ pub(crate) fn provide(providers: &mut Providers) {
 /// You should not read the result of this query directly, but rather use
 /// `named_variable_map`, `late_bound_vars_map`, etc.
 #[instrument(level = "debug", skip(tcx))]
-fn resolve_bound_vars(tcx: TyCtxt<'_>, local_def_id: hir::OwnerId) -> ResolveBoundVars {
+fn resolve_bound_vars(tcx: TyCtxt<'_>, local_def_id: hir::OwnerId) -> ResolveBoundVars<'_> {
     let mut rbv = ResolveBoundVars::default();
     let mut visitor = BoundVarContext {
         tcx,
@@ -287,7 +287,7 @@ fn resolve_bound_vars(tcx: TyCtxt<'_>, local_def_id: hir::OwnerId) -> ResolveBou
     rbv
 }
 
-fn late_arg_as_bound_arg<'tcx>(param: &GenericParam<'tcx>) -> ty::BoundVariableKind {
+fn late_arg_as_bound_arg<'tcx>(param: &GenericParam<'tcx>) -> ty::BoundVariableKind<'tcx> {
     let def_id = param.def_id.to_def_id();
     match param.kind {
         GenericParamKind::Lifetime { .. } => {
@@ -301,7 +301,9 @@ fn late_arg_as_bound_arg<'tcx>(param: &GenericParam<'tcx>) -> ty::BoundVariableK
 /// Turn a [`ty::GenericParamDef`] into a bound arg. Generally, this should only
 /// be used when turning early-bound vars into late-bound vars when lowering
 /// return type notation.
-fn generic_param_def_as_bound_arg(param: &ty::GenericParamDef) -> ty::BoundVariableKind {
+fn generic_param_def_as_bound_arg<'tcx>(
+    param: &ty::GenericParamDef,
+) -> ty::BoundVariableKind<'tcx> {
     match param.kind {
         ty::GenericParamDefKind::Lifetime => {
             ty::BoundVariableKind::Region(ty::BoundRegionKind::Named(param.def_id))
@@ -329,7 +331,9 @@ fn opaque_captures_all_in_scope_lifetimes<'tcx>(opaque: &'tcx hir::OpaqueTy<'tcx
 
 impl<'a, 'tcx> BoundVarContext<'a, 'tcx> {
     /// Returns the binders in scope and the type of `Binder` that should be created for a poly trait ref.
-    fn poly_trait_ref_binder_info(&mut self) -> (Vec<ty::BoundVariableKind>, BinderScopeType) {
+    fn poly_trait_ref_binder_info(
+        &mut self,
+    ) -> (Vec<ty::BoundVariableKind<'tcx>>, BinderScopeType) {
         let mut scope = self.scope;
         let mut supertrait_bound_vars = vec![];
         loop {
@@ -364,7 +368,7 @@ impl<'a, 'tcx> BoundVarContext<'a, 'tcx> {
 
                 Scope::Binder { hir_id, .. } => {
                     // Nested poly trait refs have the binders concatenated
-                    let mut full_binders =
+                    let mut full_binders: Vec<ty::BoundVariableKind<'tcx>> =
                         self.rbv.late_bound_vars.get_mut_or_insert_default(hir_id.local_id).clone();
                     full_binders.extend(supertrait_bound_vars);
                     break (full_binders, BinderScopeType::Concatenating);
@@ -1094,7 +1098,7 @@ fn object_lifetime_default(tcx: TyCtxt<'_>, param_def_id: LocalDefId) -> ObjectL
 }
 
 impl<'a, 'tcx> BoundVarContext<'a, 'tcx> {
-    fn with<F>(&mut self, wrap_scope: Scope<'_>, f: F)
+    fn with<F>(&mut self, wrap_scope: Scope<'_, 'tcx>, f: F)
     where
         F: for<'b> FnOnce(&mut BoundVarContext<'b, 'tcx>),
     {
@@ -1115,7 +1119,7 @@ impl<'a, 'tcx> BoundVarContext<'a, 'tcx> {
         *self.opaque_capture_errors.borrow_mut() = this.opaque_capture_errors.into_inner();
     }
 
-    fn record_late_bound_vars(&mut self, hir_id: HirId, binder: Vec<ty::BoundVariableKind>) {
+    fn record_late_bound_vars(&mut self, hir_id: HirId, binder: Vec<ty::BoundVariableKind<'tcx>>) {
         if let Some(old) = self.rbv.late_bound_vars.insert(hir_id.local_id, binder) {
             bug!(
                 "overwrote bound vars for {hir_id:?}:\nold={old:?}\nnew={:?}",
@@ -1931,7 +1935,7 @@ impl<'a, 'tcx> BoundVarContext<'a, 'tcx> {
         def_id: DefId,
         assoc_ident: Ident,
         assoc_tag: ty::AssocTag,
-    ) -> Option<(Vec<ty::BoundVariableKind>, &'tcx ty::AssocItem)> {
+    ) -> Option<(Vec<ty::BoundVariableKind<'tcx>>, &'tcx ty::AssocItem)> {
         let trait_defines_associated_item_named = |trait_def_id: DefId| {
             tcx.associated_items(trait_def_id).find_by_ident_and_kind(
                 tcx,
@@ -1942,7 +1946,7 @@ impl<'a, 'tcx> BoundVarContext<'a, 'tcx> {
         };
 
         use smallvec::{SmallVec, smallvec};
-        let mut stack: SmallVec<[(DefId, SmallVec<[ty::BoundVariableKind; 8]>); 8]> =
+        let mut stack: SmallVec<[(DefId, SmallVec<[ty::BoundVariableKind<'tcx>; 8]>); 8]> =
             smallvec![(def_id, smallvec![])];
         let mut visited: FxHashSet<DefId> = FxHashSet::default();
         loop {

compiler/rustc_hir_analysis/src/hir_ty_lowering/bounds.rs

@@ -362,7 +362,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
         param_ty: Ty<'tcx>,
         hir_bounds: I,
         bounds: &mut Vec<(ty::Clause<'tcx>, Span)>,
-        bound_vars: &'tcx ty::List<ty::BoundVariableKind>,
+        bound_vars: &'tcx ty::List<ty::BoundVariableKind<'tcx>>,
         predicate_filter: PredicateFilter,
         overlapping_assoc_constraints: OverlappingAsssocItemConstraints,
     ) where
@@ -1000,7 +1000,9 @@ impl<'tcx> TypeVisitor<TyCtxt<'tcx>> for GenericParamAndBoundVarCollector<'_, 't
                             .delayed_bug(format!("unexpected bound region kind: {:?}", br.kind));
                         return ControlFlow::Break(guar);
                     }
-                    ty::BoundRegionKind::NamedAnon(_) => bug!("only used for pretty printing"),
+                    ty::BoundRegionKind::NamedForPrinting(_) => {
+                        bug!("only used for pretty printing")
+                    }
                 });
             }
             _ => {}

compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs

@@ -2310,7 +2310,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
             Some(rbv::ResolvedArg::LateBound(debruijn, index, _)) => ty::Const::new_bound(
                 tcx,
                 debruijn,
-                ty::BoundConst { var: ty::BoundVar::from_u32(index) },
+                ty::BoundConst::new(ty::BoundVar::from_u32(index)),
             ),
             Some(rbv::ResolvedArg::Error(guar)) => ty::Const::new_error(tcx, guar),
             arg => bug!("unexpected bound var resolution for {:?}: {arg:?}", path_hir_id),
@@ -3196,8 +3196,8 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
     #[instrument(level = "trace", skip(self, generate_err))]
     fn validate_late_bound_regions<'cx>(
         &'cx self,
-        constrained_regions: FxIndexSet<ty::BoundRegionKind>,
-        referenced_regions: FxIndexSet<ty::BoundRegionKind>,
+        constrained_regions: FxIndexSet<ty::BoundRegionKind<'tcx>>,
+        referenced_regions: FxIndexSet<ty::BoundRegionKind<'tcx>>,
         generate_err: impl Fn(&str) -> Diag<'cx>,
     ) {
         for br in referenced_regions.difference(&constrained_regions) {