Auto merge of rust-lang#117876 - lcnr:region-kind-rename, r=BoxyUwU

`ReLateBound` -> `ReBound`

first step of rust-lang/types-team#95

already fairly large xx

there's some future work here I intentionally did not contribute as part of this PR, from my notes:
- `DescriptionCtx` to `DescriptionCtxt`
- what is `CheckRegions::Bound`?
- `collect_late_bound_regions` et al
- `erase_late_bound_regions` -> `instantiate_bound_regions_with_erased`?
- `EraseEarlyRegions` should be removed, feels duplicate

r? `@BoxyUwU`

compiler/rustc_borrowck/src/diagnostics/mod.rs

@@ -10,7 +10,7 @@ use rustc_hir as hir;
 use rustc_hir::def::{CtorKind, Namespace};
 use rustc_hir::CoroutineKind;
 use rustc_index::IndexSlice;
-use rustc_infer::infer::LateBoundRegionConversionTime;
+use rustc_infer::infer::BoundRegionConversionTime;
 use rustc_middle::mir::tcx::PlaceTy;
 use rustc_middle::mir::{
  AggregateKind, CallSource, ConstOperand, FakeReadCause, Local, LocalInfo, LocalKind, Location,
@@ -462,7 +462,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
  // lifetimes without names with the value `'0`.
  if let ty::Ref(region, ..) = ty.kind() {
  match **region {
- ty::ReLateBound(_, ty::BoundRegion { kind: br, .. })
+ ty::ReBound(_, ty::BoundRegion { kind: br, .. })
  | ty::RePlaceholder(ty::PlaceholderRegion {
  bound: ty::BoundRegion { kind: br, .. },
  ..
@@ -482,7 +482,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
 
  let region = if let ty::Ref(region, ..) = ty.kind() {
  match **region {
- ty::ReLateBound(_, ty::BoundRegion { kind: br, .. })
+ ty::ReBound(_, ty::BoundRegion { kind: br, .. })
  | ty::RePlaceholder(ty::PlaceholderRegion {
  bound: ty::BoundRegion { kind: br, .. },
  ..
@@ -1113,7 +1113,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
  && let ty::Ref(_, _, hir::Mutability::Mut) = args.type_at(0).kind()
  && let self_ty = self.infcx.instantiate_binder_with_fresh_vars(
  fn_call_span,
- LateBoundRegionConversionTime::FnCall,
+ BoundRegionConversionTime::FnCall,
  tcx.fn_sig(method_did).instantiate(tcx, method_args).input(0),
  )
  && self.infcx.can_eq(self.param_env, ty, self_ty)

compiler/rustc_borrowck/src/diagnostics/region_name.rs

@@ -357,7 +357,7 @@ impl<'tcx> MirBorrowckCtxt<'_, 'tcx> {
  ty::BoundRegionKind::BrAnon => None,
  },
 
- ty::ReLateBound(..)
+ ty::ReBound(..)
  | ty::ReVar(..)
  | ty::RePlaceholder(..)
  | ty::ReErased

compiler/rustc_borrowck/src/renumber.rs

@@ -28,6 +28,9 @@ pub fn renumber_mir<'tcx>(
  renumberer.visit_body(body);
 }
 
+// FIXME(@lcnr): A lot of these variants overlap and it seems like
+// this type is only used to decide which region should be used
+// as representative. This should be cleaned up.
 #[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
 pub(crate) enum RegionCtxt {
  Location(Location),

compiler/rustc_borrowck/src/type_check/input_output.rs

@@ -7,7 +7,7 @@
 //! `RETURN_PLACE` the MIR arguments) are always fully normalized (and
 //! contain revealed `impl Trait` values).
 
-use rustc_infer::infer::LateBoundRegionConversionTime;
+use rustc_infer::infer::BoundRegionConversionTime;
 use rustc_middle::mir::*;
 use rustc_middle::ty::{self, Ty};
 use rustc_span::Span;
@@ -35,7 +35,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
  .instantiate_canonical_with_fresh_inference_vars(body.span, &user_provided_poly_sig);
  let user_provided_sig = self.infcx.instantiate_binder_with_fresh_vars(
  body.span,
- LateBoundRegionConversionTime::FnCall,
+ BoundRegionConversionTime::FnCall,
  user_provided_sig,
  );
 

compiler/rustc_borrowck/src/type_check/mod.rs

@@ -21,7 +21,7 @@ use rustc_infer::infer::outlives::env::RegionBoundPairs;
 use rustc_infer::infer::region_constraints::RegionConstraintData;
 use rustc_infer::infer::type_variable::{TypeVariableOrigin, TypeVariableOriginKind};
 use rustc_infer::infer::{
- InferCtxt, LateBoundRegion, LateBoundRegionConversionTime, NllRegionVariableOrigin,
+ BoundRegion, BoundRegionConversionTime, InferCtxt, NllRegionVariableOrigin,
 };
 use rustc_middle::mir::tcx::PlaceTy;
 use rustc_middle::mir::visit::{NonMutatingUseContext, PlaceContext, Visitor};
@@ -1401,10 +1401,10 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
  };
 
  self.infcx.next_region_var(
- LateBoundRegion(
+ BoundRegion(
  term.source_info.span,
  br.kind,
- LateBoundRegionConversionTime::FnCall,
+ BoundRegionConversionTime::FnCall,
  ),
  region_ctxt_fn,
  )

compiler/rustc_borrowck/src/type_check/relate_tys.rs

@@ -107,12 +107,12 @@ impl<'tcx> TypeRelatingDelegate<'tcx> for NllTypeRelatingDelegate<'_, '_, 'tcx>
  fn next_existential_region_var(
  &mut self,
  from_forall: bool,
- _name: Option<Symbol>,
+ name: Option<Symbol>,
  ) -> ty::Region<'tcx> {
  let origin = NllRegionVariableOrigin::Existential { from_forall };
 
  let reg_var =
- self.type_checker.infcx.next_nll_region_var(origin, || RegionCtxt::Existential(_name));
+ self.type_checker.infcx.next_nll_region_var(origin, || RegionCtxt::Existential(name));
 
  reg_var
  }

compiler/rustc_borrowck/src/universal_regions.rs

@@ -665,7 +665,7 @@ impl<'cx, 'tcx> UniversalRegionsBuilder<'cx, 'tcx> {
  var: ty::BoundVar::from_usize(bound_vars.len() - 1),
  kind: ty::BrEnv,
  };
- let env_region = ty::Region::new_late_bound(tcx, ty::INNERMOST, br);
+ let env_region = ty::Region::new_bound(tcx, ty::INNERMOST, br);
  let closure_ty = tcx.closure_env_ty(def_id, args, env_region).unwrap();
 
  // The "inputs" of the closure in the

compiler/rustc_hir_analysis/src/astconv/bounds.rs

@@ -350,7 +350,7 @@ impl<'tcx> dyn AstConv<'tcx> + '_ {
  let args =
  candidate.skip_binder().args.extend_to(tcx, assoc_item.def_id, |param, _| {
  let subst = match param.kind {
- ty::GenericParamDefKind::Lifetime => ty::Region::new_late_bound(
+ ty::GenericParamDefKind::Lifetime => ty::Region::new_bound(
  tcx,
  ty::INNERMOST,
  ty::BoundRegion {

compiler/rustc_hir_analysis/src/astconv/mod.rs

@@ -250,7 +250,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
  var: ty::BoundVar::from_u32(index),
  kind: ty::BrNamed(def_id, name),
  };
- ty::Region::new_late_bound(tcx, debruijn, br)
+ ty::Region::new_bound(tcx, debruijn, br)
  }
 
  Some(rbv::ResolvedArg::EarlyBound(def_id)) => {
@@ -1622,7 +1622,9 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
  }
 
  fn fold_region(&mut self, r: ty::Region<'tcx>) -> ty::Region<'tcx> {
- if r.is_late_bound() { self.tcx.lifetimes.re_erased } else { r }
+ // FIXME(@lcnr): This is broken, erasing bound regions
+ // impacts selection as it results in different types.
+ if r.is_bound() { self.tcx.lifetimes.re_erased } else { r }
  }
 
  fn fold_ty(&mut self, ty: Ty<'tcx>) -> Ty<'tcx> {

compiler/rustc_hir_analysis/src/check/compare_impl_item.rs

@@ -2345,7 +2345,7 @@ fn param_env_with_gat_bounds<'tcx>(
  let kind = ty::BoundRegionKind::BrNamed(param.def_id, param.name);
  let bound_var = ty::BoundVariableKind::Region(kind);
  bound_vars.push(bound_var);
- ty::Region::new_late_bound(
+ ty::Region::new_bound(
  tcx,
  ty::INNERMOST,
  ty::BoundRegion {

compiler/rustc_hir_analysis/src/check/intrinsic.rs

@@ -143,12 +143,12 @@ pub fn check_intrinsic_type(tcx: TyCtxt<'_>, it: &hir::ForeignItem<'_>) {
  ]);
  let mk_va_list_ty = |mutbl| {
  tcx.lang_items().va_list().map(|did| {
- let region = ty::Region::new_late_bound(
+ let region = ty::Region::new_bound(
  tcx,
  ty::INNERMOST,
  ty::BoundRegion { var: ty::BoundVar::from_u32(0), kind: ty::BrAnon },
  );
- let env_region = ty::Region::new_late_bound(
+ let env_region = ty::Region::new_bound(
  tcx,
  ty::INNERMOST,
  ty::BoundRegion { var: ty::BoundVar::from_u32(1), kind: ty::BrEnv },
@@ -411,7 +411,7 @@ pub fn check_intrinsic_type(tcx: TyCtxt<'_>, it: &hir::ForeignItem<'_>) {
  1,
  vec![Ty::new_imm_ref(
  tcx,
- ty::Region::new_late_bound(tcx, ty::INNERMOST, br),
+ ty::Region::new_bound(tcx, ty::INNERMOST, br),
  param(0),
  )],
  Ty::new_projection(tcx, discriminant_def_id, tcx.mk_args(&[param(0).into()])),
@@ -465,11 +465,8 @@ pub fn check_intrinsic_type(tcx: TyCtxt<'_>, it: &hir::ForeignItem<'_>) {
 
  sym::raw_eq => {
  let br = ty::BoundRegion { var: ty::BoundVar::from_u32(0), kind: ty::BrAnon };
- let param_ty = Ty::new_imm_ref(
- tcx,
- ty::Region::new_late_bound(tcx, ty::INNERMOST, br),
- param(0),
- );
+ let param_ty =
+ Ty::new_imm_ref(tcx, ty::Region::new_bound(tcx, ty::INNERMOST, br), param(0));
  (1, vec![param_ty; 2], tcx.types.bool)
  }
 

compiler/rustc_hir_analysis/src/check/wfcheck.rs

@@ -763,7 +763,7 @@ impl<'tcx> TypeVisitor<TyCtxt<'tcx>> for GATSubstCollector<'tcx> {
  ty::Alias(ty::Projection, p) if p.def_id == self.gat => {
  for (idx, subst) in p.args.iter().enumerate() {
  match subst.unpack() {
- GenericArgKind::Lifetime(lt) if !lt.is_late_bound() => {
+ GenericArgKind::Lifetime(lt) if !lt.is_bound() => {
  self.regions.insert((lt, idx));
  }
  GenericArgKind::Type(t) => {

compiler/rustc_hir_analysis/src/hir_wf_check.rs

@@ -196,6 +196,7 @@ impl<'tcx> TypeFolder<TyCtxt<'tcx>> for EraseAllBoundRegions<'tcx> {
  self.tcx
  }
  fn fold_region(&mut self, r: Region<'tcx>) -> Region<'tcx> {
- if r.is_late_bound() { self.tcx.lifetimes.re_erased } else { r }
+ // FIXME(@lcnr): only erase escaping bound regions!
+ if r.is_bound() { self.tcx.lifetimes.re_erased } else { r }
  }
 }

compiler/rustc_hir_analysis/src/outlives/utils.rs

@@ -167,8 +167,8 @@ fn is_free_region(region: Region<'_>) -> bool {
  // }
  //
  // The type above might generate a `T: 'b` bound, but we can
- // ignore it. We can't put it on the struct header anyway.
- ty::ReLateBound(..) => false,
+ // ignore it. We can't name this lifetime pn the struct header anyway.
+ ty::ReBound(..) => false,
 
  ty::ReError(_) => false,
 

compiler/rustc_hir_analysis/src/variance/constraints.rs

@@ -419,9 +419,11 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> {
 
  ty::ReStatic => {}
 
- ty::ReLateBound(..) => {
- // Late-bound regions do not get substituted the same
- // way early-bound regions do, so we skip them here.
+ ty::ReBound(..) => {
+ // Either a higher-ranked region inside of a type or a
+ // late-bound function parameter.
+ //
+ // We do not compute constraints for either of these.
  }
 
  ty::ReError(_) => {}

compiler/rustc_hir_typeck/src/check.rs

@@ -214,15 +214,15 @@ fn check_panic_info_fn(tcx: TyCtxt<'_>, fn_id: LocalDefId, fn_sig: ty::FnSig<'_>
  // build type `for<'a, 'b> fn(&'a PanicInfo<'b>) -> !`
  let panic_info_ty = tcx.type_of(panic_info_did).instantiate(
  tcx,
- &[ty::GenericArg::from(ty::Region::new_late_bound(
+ &[ty::GenericArg::from(ty::Region::new_bound(
  tcx,
  ty::INNERMOST,
  ty::BoundRegion { var: ty::BoundVar::from_u32(1), kind: ty::BrAnon },
  ))],
  );
  let panic_info_ref_ty = Ty::new_imm_ref(
  tcx,
- ty::Region::new_late_bound(
+ ty::Region::new_bound(
  tcx,
  ty::INNERMOST,
  ty::BoundRegion { var: ty::BoundVar::from_u32(0), kind: ty::BrAnon },

compiler/rustc_hir_typeck/src/closure.rs

@@ -7,7 +7,7 @@ use rustc_hir as hir;
 use rustc_hir::lang_items::LangItem;
 use rustc_hir_analysis::astconv::AstConv;
 use rustc_infer::infer::type_variable::{TypeVariableOrigin, TypeVariableOriginKind};
-use rustc_infer::infer::{DefineOpaqueTypes, LateBoundRegionConversionTime};
+use rustc_infer::infer::{BoundRegionConversionTime, DefineOpaqueTypes};
 use rustc_infer::infer::{InferOk, InferResult};
 use rustc_macros::{TypeFoldable, TypeVisitable};
 use rustc_middle::ty::visit::{TypeVisitable, TypeVisitableExt};
@@ -558,7 +558,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  // Instantiate (this part of..) S to S', i.e., with fresh variables.
  self.instantiate_binder_with_fresh_vars(
  hir_ty.span,
- LateBoundRegionConversionTime::FnCall,
+ BoundRegionConversionTime::FnCall,
  // (*) binder moved to here
  supplied_sig.inputs().rebind(supplied_ty),
  )
@@ -583,7 +583,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 
  let supplied_output_ty = self.instantiate_binder_with_fresh_vars(
  decl.output.span(),
- LateBoundRegionConversionTime::FnCall,
+ BoundRegionConversionTime::FnCall,
  supplied_sig.output(),
  );
  let cause = &self.misc(decl.output.span());

compiler/rustc_hir_typeck/src/expr.rs

@@ -564,7 +564,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  let span = args.get(i).map(|a| a.span).unwrap_or(expr.span);
  let input = self.instantiate_binder_with_fresh_vars(
  span,
- infer::LateBoundRegionConversionTime::FnCall,
+ infer::BoundRegionConversionTime::FnCall,
  fn_sig.input(i),
  );
  self.require_type_is_sized_deferred(
@@ -582,7 +582,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  // with fresh vars.
  let output = self.instantiate_binder_with_fresh_vars(
  expr.span,
- infer::LateBoundRegionConversionTime::FnCall,
+ infer::BoundRegionConversionTime::FnCall,
  fn_sig.output(),
  );
  self.require_type_is_sized_deferred(output, expr.span, traits::SizedReturnType);

compiler/rustc_hir_typeck/src/fn_ctxt/mod.rs

@@ -289,7 +289,7 @@ impl<'a, 'tcx> AstConv<'tcx> for FnCtxt<'a, 'tcx> {
  ) -> Ty<'tcx> {
  let trait_ref = self.instantiate_binder_with_fresh_vars(
  span,
- infer::LateBoundRegionConversionTime::AssocTypeProjection(item_def_id),
+ infer::BoundRegionConversionTime::AssocTypeProjection(item_def_id),
  poly_trait_ref,
  );
 

compiler/rustc_hir_typeck/src/method/probe.rs

@@ -801,7 +801,7 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
  // a `&self` method will wind up with an argument type like `&dyn Trait`.
  let trait_ref = principal.with_self_ty(self.tcx, self_ty);
  self.elaborate_bounds(iter::once(trait_ref), |this, new_trait_ref, item| {
- if new_trait_ref.has_non_region_late_bound() {
+ if new_trait_ref.has_non_region_bound_vars() {
  this.tcx.sess.delay_span_bug(
  this.span,
  "tried to select method from HRTB with non-lifetime bound vars",
@@ -853,7 +853,7 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
  self.elaborate_bounds(bounds, |this, poly_trait_ref, item| {
  let trait_ref = this.instantiate_binder_with_fresh_vars(
  this.span,
- infer::LateBoundRegionConversionTime::FnCall,
+ infer::BoundRegionConversionTime::FnCall,
  poly_trait_ref,
  );
 
@@ -971,7 +971,7 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
  } else {
  let new_trait_ref = self.instantiate_binder_with_fresh_vars(
  self.span,
- infer::LateBoundRegionConversionTime::FnCall,
+ infer::BoundRegionConversionTime::FnCall,
  bound_trait_ref,
  );
 

compiler/rustc_hir_typeck/src/writeback.rs

@@ -784,7 +784,7 @@ impl<'tcx> TypeFolder<TyCtxt<'tcx>> for EraseEarlyRegions<'tcx> {
  }
  }
  fn fold_region(&mut self, r: ty::Region<'tcx>) -> ty::Region<'tcx> {
- if r.is_late_bound() { r } else { self.tcx.lifetimes.re_erased }
+ if r.is_bound() { r } else { self.tcx.lifetimes.re_erased }
  }
 }
 
@@ -822,7 +822,7 @@ impl<'cx, 'tcx> TypeFolder<TyCtxt<'tcx>> for Resolver<'cx, 'tcx> {
  }
 
  fn fold_region(&mut self, r: ty::Region<'tcx>) -> ty::Region<'tcx> {
- debug_assert!(!r.is_late_bound(), "Should not be resolving bound region.");
+ debug_assert!(!r.is_bound(), "Should not be resolving bound region.");
  self.fcx.tcx.lifetimes.re_erased
  }
 

compiler/rustc_infer/src/errors/note_and_explain.rs

@@ -73,8 +73,11 @@ impl<'a> DescriptionCtx<'a> {
  // ReFree rather than dumping Debug output on the user.
  //
  // We shouldn't really be having unification failures with ReVar
- // and ReLateBound though.
- ty::ReVar(_) | ty::ReLateBound(..) | ty::ReErased => {
+ // and ReBound though.
+ //
+ // FIXME(@lcnr): figure out why we `ReBound` have to handle `ReBound`
+ // here, this feels somewhat off.
+ ty::ReVar(_) | ty::ReBound(..) | ty::ReErased => {
  (alt_span, "revar", format!("{region:?}"))
  }
  };

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

@@ -232,7 +232,7 @@ impl CanonicalizeMode for CanonicalizeUserTypeAnnotation {
  match *r {
  ty::ReEarlyBound(_) | ty::ReFree(_) | ty::ReErased | ty::ReStatic | ty::ReError(_) => r,
  ty::ReVar(_) => canonicalizer.canonical_var_for_region_in_root_universe(r),
- ty::RePlaceholder(..) | ty::ReLateBound(..) => {
+ ty::RePlaceholder(..) | ty::ReBound(..) => {
  // We only expect region names that the user can type.
  bug!("unexpected region in query response: `{:?}`", r)
  }
@@ -343,7 +343,7 @@ impl<'cx, 'tcx> TypeFolder<TyCtxt<'tcx>> for Canonicalizer<'cx, 'tcx> {
 
  fn fold_region(&mut self, r: ty::Region<'tcx>) -> ty::Region<'tcx> {
  match *r {
- ty::ReLateBound(index, ..) => {
+ ty::ReBound(index, ..) => {
  if index >= self.binder_index {
  bug!("escaping late-bound region during canonicalization");
  } else {
@@ -776,7 +776,7 @@ impl<'cx, 'tcx> Canonicalizer<'cx, 'tcx> {
  ) -> ty::Region<'tcx> {
  let var = self.canonical_var(info, r.into());
  let br = ty::BoundRegion { var, kind: ty::BrAnon };
- ty::Region::new_late_bound(self.interner(), self.binder_index, br)
+ ty::Region::new_bound(self.interner(), self.binder_index, br)
  }
 
  /// Given a type variable `ty_var` of the given kind, first check