Auto merge of #117908 - lcnr:region-kind-rename, r=BoxyUwU

finish `RegionKind` renaming second step of rust-lang/types-team#95 continues the work from #117876. While working on this and I encountered a bunch of further cleanup which I'll either open a tracking issue for or will do in a separate PR: - rewrite the `RegionKind` docs, they still talk about `ReEmpty` and are generally out of date - rename `DescriptionCtx` to `DescriptionCtxt` - what is `CheckRegions::Bound`? - `collect_late_bound_regions` et al - `erase_late_bound_regions` -> `instantiate_bound_regions_with_erased`? - `EraseEarlyRegions` visitor should be removed, feels duplicate r? `@BoxyUwU`

Author: bors

compiler/rustc_borrowck/src/diagnostics/outlives_suggestion.rs

@@ -50,8 +50,8 @@ impl OutlivesSuggestionBuilder {
  // naming the `'self` lifetime in methods, etc.
  fn region_name_is_suggestable(name: &RegionName) -> bool {
  match name.source {
- RegionNameSource::NamedEarlyBoundRegion(..)
- | RegionNameSource::NamedFreeRegion(..)
+ RegionNameSource::NamedEarlyParamRegion(..)
+ | RegionNameSource::NamedLateParamRegion(..)
  | RegionNameSource::Static => true,
 
  // Don't give suggestions for upvars, closure return types, or other unnameable

compiler/rustc_borrowck/src/diagnostics/region_errors.rs

@@ -181,8 +181,8 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
 
  /// Returns `true` if a closure is inferred to be an `FnMut` closure.
  fn is_closure_fn_mut(&self, fr: RegionVid) -> bool {
- if let Some(ty::ReFree(free_region)) = self.to_error_region(fr).as_deref()
- && let ty::BoundRegionKind::BrEnv = free_region.bound_region
+ if let Some(ty::ReLateParam(late_param)) = self.to_error_region(fr).as_deref()
+ && let ty::BoundRegionKind::BrEnv = late_param.bound_region
  && let DefiningTy::Closure(_, args) = self.regioncx.universal_regions().defining_ty
  {
  return args.as_closure().kind() == ty::ClosureKind::FnMut;
@@ -995,7 +995,7 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
  .infcx
  .tcx
  .is_suitable_region(sub)
- .and_then(|anon_reg| find_anon_type(self.infcx.tcx, sub, &anon_reg.boundregion))
+ .and_then(|anon_reg| find_anon_type(self.infcx.tcx, sub, &anon_reg.bound_region))
  else {
  return;
  };
@@ -1004,7 +1004,7 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
  .infcx
  .tcx
  .is_suitable_region(sup)
- .and_then(|anon_reg| find_anon_type(self.infcx.tcx, sup, &anon_reg.boundregion))
+ .and_then(|anon_reg| find_anon_type(self.infcx.tcx, sup, &anon_reg.bound_region))
  else {
  return;
  };

compiler/rustc_borrowck/src/diagnostics/region_name.rs

@@ -23,14 +23,14 @@ pub(crate) struct RegionName {
 }
 
 /// Denotes the source of a region that is named by a `RegionName`. For example, a free region that
-/// was named by the user would get `NamedFreeRegion` and `'static` lifetime would get `Static`.
+/// was named by the user would get `NamedLateParamRegion` and `'static` lifetime would get `Static`.
 /// This helps to print the right kinds of diagnostics.
 #[derive(Debug, Clone)]
 pub(crate) enum RegionNameSource {
  /// A bound (not free) region that was instantiated at the def site (not an HRTB).
- NamedEarlyBoundRegion(Span),
+ NamedEarlyParamRegion(Span),
  /// A free region that the user has a name (`'a`) for.
- NamedFreeRegion(Span),
+ NamedLateParamRegion(Span),
  /// The `'static` region.
  Static,
  /// The free region corresponding to the environment of a closure.
@@ -69,8 +69,8 @@ pub(crate) enum RegionNameHighlight {
 impl RegionName {
  pub(crate) fn was_named(&self) -> bool {
  match self.source {
- RegionNameSource::NamedEarlyBoundRegion(..)
- | RegionNameSource::NamedFreeRegion(..)
+ RegionNameSource::NamedEarlyParamRegion(..)
+ | RegionNameSource::NamedLateParamRegion(..)
  | RegionNameSource::Static => true,
  RegionNameSource::SynthesizedFreeEnvRegion(..)
  | RegionNameSource::AnonRegionFromArgument(..)
@@ -85,8 +85,8 @@ impl RegionName {
  pub(crate) fn span(&self) -> Option<Span> {
  match self.source {
  RegionNameSource::Static => None,
- RegionNameSource::NamedEarlyBoundRegion(span)
- | RegionNameSource::NamedFreeRegion(span)
+ RegionNameSource::NamedEarlyParamRegion(span)
+ | RegionNameSource::NamedLateParamRegion(span)
  | RegionNameSource::SynthesizedFreeEnvRegion(span, _)
  | RegionNameSource::AnonRegionFromUpvar(span, _)
  | RegionNameSource::AnonRegionFromYieldTy(span, _)
@@ -104,8 +104,8 @@ impl RegionName {
 
  pub(crate) fn highlight_region_name(&self, diag: &mut Diagnostic) {
  match &self.source {
- RegionNameSource::NamedFreeRegion(span)
- | RegionNameSource::NamedEarlyBoundRegion(span) => {
+ RegionNameSource::NamedLateParamRegion(span)
+ | RegionNameSource::NamedEarlyParamRegion(span) => {
  diag.span_label(*span, format!("lifetime `{self}` defined here"));
  }
  RegionNameSource::SynthesizedFreeEnvRegion(span, note) => {
@@ -280,28 +280,31 @@ impl<'tcx> MirBorrowckCtxt<'_, 'tcx> {
 
  debug!("give_region_a_name: error_region = {:?}", error_region);
  match *error_region {
- ty::ReEarlyBound(ebr) => ebr.has_name().then(|| {
+ ty::ReEarlyParam(ebr) => ebr.has_name().then(|| {
  let span = tcx.hir().span_if_local(ebr.def_id).unwrap_or(DUMMY_SP);
- RegionName { name: ebr.name, source: RegionNameSource::NamedEarlyBoundRegion(span) }
+ RegionName { name: ebr.name, source: RegionNameSource::NamedEarlyParamRegion(span) }
  }),
 
  ty::ReStatic => {
  Some(RegionName { name: kw::StaticLifetime, source: RegionNameSource::Static })
  }
 
- ty::ReFree(free_region) => match free_region.bound_region {
+ ty::ReLateParam(late_param) => match late_param.bound_region {
  ty::BoundRegionKind::BrNamed(region_def_id, name) => {
  // Get the span to point to, even if we don't use the name.
  let span = tcx.hir().span_if_local(region_def_id).unwrap_or(DUMMY_SP);
  debug!(
  "bound region named: {:?}, is_named: {:?}",
  name,
- free_region.bound_region.is_named()
+ late_param.bound_region.is_named()
  );
 
- if free_region.bound_region.is_named() {
+ if late_param.bound_region.is_named() {
  // A named region that is actually named.
- Some(RegionName { name, source: RegionNameSource::NamedFreeRegion(span) })
+ Some(RegionName {
+ name,
+ source: RegionNameSource::NamedLateParamRegion(span),
+ })
  } else if tcx.asyncness(self.mir_hir_id().owner).is_async() {
  // If we spuriously thought that the region is named, we should let the
  // system generate a true name for error messages. Currently this can
@@ -847,7 +850,7 @@ impl<'tcx> MirBorrowckCtxt<'_, 'tcx> {
  &self,
  fr: RegionVid,
  ) -> Option<RegionName> {
- let ty::ReEarlyBound(region) = *self.to_error_region(fr)? else {
+ let ty::ReEarlyParam(region) = *self.to_error_region(fr)? else {
  return None;
  };
  if region.has_name() {
@@ -862,7 +865,7 @@ impl<'tcx> MirBorrowckCtxt<'_, 'tcx> {
 
  let found = tcx
  .any_free_region_meets(&tcx.type_of(region_parent).instantiate_identity(), |r| {
- *r == ty::ReEarlyBound(region)
+ *r == ty::ReEarlyParam(region)
  });
 
  Some(RegionName {
@@ -881,7 +884,7 @@ impl<'tcx> MirBorrowckCtxt<'_, 'tcx> {
  &self,
  fr: RegionVid,
  ) -> Option<RegionName> {
- let ty::ReEarlyBound(region) = *self.to_error_region(fr)? else {
+ let ty::ReEarlyParam(region) = *self.to_error_region(fr)? else {
  return None;
  };
  if region.has_name() {
@@ -943,7 +946,7 @@ impl<'tcx> MirBorrowckCtxt<'_, 'tcx> {
  &self,
  clauses: &[ty::Clause<'tcx>],
  ty: Ty<'tcx>,
- region: ty::EarlyBoundRegion,
+ region: ty::EarlyParamRegion,
  ) -> bool {
  let tcx = self.infcx.tcx;
  ty.walk().any(|arg| {
@@ -956,7 +959,7 @@ impl<'tcx> MirBorrowckCtxt<'_, 'tcx> {
  ty::ClauseKind::Projection(data) if data.projection_ty.self_ty() == ty => {}
  _ => return false,
  }
- tcx.any_free_region_meets(pred, |r| *r == ty::ReEarlyBound(region))
+ tcx.any_free_region_meets(pred, |r| *r == ty::ReEarlyParam(region))
  })
  } else {
  false

compiler/rustc_borrowck/src/region_infer/opaque_types.rs

@@ -36,7 +36,7 @@ impl<'tcx> RegionInferenceContext<'tcx> {
  /// call `infer_opaque_definition_from_instantiation` to get the inferred
  /// type of `_Return<'_a>`. `infer_opaque_definition_from_instantiation`
  /// compares lifetimes directly, so we need to map the inference variables
- /// back to concrete lifetimes: `'static`, `ReEarlyBound` or `ReFree`.
+ /// back to concrete lifetimes: `'static`, `ReEarlyParam` or `ReLateParam`.
  ///
  /// First we map all the lifetimes in the concrete type to an equal
  /// universal region that occurs in the concrete type's args, in this case
@@ -386,7 +386,7 @@ fn check_opaque_type_parameter_valid(
  let arg_is_param = match arg.unpack() {
  GenericArgKind::Type(ty) => matches!(ty.kind(), ty::Param(_)),
  GenericArgKind::Lifetime(lt) if is_ty_alias => {
- matches!(*lt, ty::ReEarlyBound(_) | ty::ReFree(_))
+ matches!(*lt, ty::ReEarlyParam(_) | ty::ReLateParam(_))
  }
  // FIXME(#113916): we can't currently check for unique lifetime params,
  // see that issue for more. We will also have to ignore unused lifetime

compiler/rustc_borrowck/src/universal_regions.rs

@@ -462,7 +462,6 @@ impl<'cx, 'tcx> UniversalRegionsBuilder<'cx, 'tcx> {
 
  // "Liberate" the late-bound regions. These correspond to
  // "local" free regions.
-
  let bound_inputs_and_output = self.compute_inputs_and_output(&indices, defining_ty);
 
  let inputs_and_output = self.infcx.replace_bound_regions_with_nll_infer_vars(
@@ -784,7 +783,7 @@ impl<'cx, 'tcx> InferCtxtExt<'tcx> for BorrowckInferCtxt<'cx, 'tcx> {
  let (value, _map) = self.tcx.replace_late_bound_regions(value, |br| {
  debug!(?br);
  let liberated_region =
- ty::Region::new_free(self.tcx, all_outlive_scope.to_def_id(), br.kind);
+ ty::Region::new_late_param(self.tcx, all_outlive_scope.to_def_id(), br.kind);
  let region_vid = {
  let name = match br.kind.get_name() {
  Some(name) => name,
@@ -854,7 +853,7 @@ impl<'tcx> UniversalRegionIndices<'tcx> {
  /// Initially, the `UniversalRegionIndices` map contains only the
  /// early-bound regions in scope. Once that is all setup, we come
  /// in later and instantiate the late-bound regions, and then we
- /// insert the `ReFree` version of those into the map as
+ /// insert the `ReLateParam` version of those into the map as
  /// well. These are used for error reporting.
  fn insert_late_bound_region(&mut self, r: ty::Region<'tcx>, vid: ty::RegionVid) {
  debug!("insert_late_bound_region({:?}, {:?})", r, vid);
@@ -933,7 +932,8 @@ fn for_each_late_bound_region_in_item<'tcx>(
  let ty::BoundVariableKind::Region(bound_region) = bound_var else {
  continue;
  };
- let liberated_region = ty::Region::new_free(tcx, mir_def_id.to_def_id(), bound_region);
+ let liberated_region =
+ ty::Region::new_late_param(tcx, mir_def_id.to_def_id(), bound_region);
  f(liberated_region);
  }
 }

compiler/rustc_hir_analysis/src/astconv/mod.rs

@@ -258,12 +258,12 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
  let item_def_id = tcx.hir().ty_param_owner(def_id.expect_local());
  let generics = tcx.generics_of(item_def_id);
  let index = generics.param_def_id_to_index[&def_id];
- ty::Region::new_early_bound(tcx, ty::EarlyBoundRegion { def_id, index, name })
+ ty::Region::new_early_param(tcx, ty::EarlyParamRegion { def_id, index, name })
  }
 
  Some(rbv::ResolvedArg::Free(scope, id)) => {
  let name = lifetime_name(id.expect_local());
- ty::Region::new_free(tcx, scope, ty::BrNamed(id, name))
+ ty::Region::new_late_param(tcx, scope, ty::BrNamed(id, name))
 
  // (*) -- not late-bound, won't change
  }

compiler/rustc_hir_analysis/src/check/compare_impl_item.rs

@@ -532,8 +532,8 @@ impl<'tcx> TypeFolder<TyCtxt<'tcx>> for RemapLateBound<'_, 'tcx> {
  }
 
  fn fold_region(&mut self, r: ty::Region<'tcx>) -> ty::Region<'tcx> {
- if let ty::ReFree(fr) = *r {
- ty::Region::new_free(
+ if let ty::ReLateParam(fr) = *r {
+ ty::Region::new_late_param(
  self.tcx,
  fr.scope,
  self.mapping.get(&fr.bound_region).copied().unwrap_or(fr.bound_region),
@@ -1078,20 +1078,20 @@ impl<'tcx> ty::FallibleTypeFolder<TyCtxt<'tcx>> for RemapHiddenTyRegions<'tcx> {
  region: ty::Region<'tcx>,
  ) -> Result<ty::Region<'tcx>, Self::Error> {
  match region.kind() {
- // Remap all free regions, which correspond to late-bound regions in the function.
- ty::ReFree(_) => {}
+ // Remap late-bound regions from the function.
+ ty::ReLateParam(_) => {}
  // Remap early-bound regions as long as they don't come from the `impl` itself,
  // in which case we don't really need to renumber them.
- ty::ReEarlyBound(ebr) if self.tcx.parent(ebr.def_id) != self.impl_def_id => {}
+ ty::ReEarlyParam(ebr) if self.tcx.parent(ebr.def_id) != self.impl_def_id => {}
  _ => return Ok(region),
  }
 
  let e = if let Some(region) = self.map.get(&region) {
- if let ty::ReEarlyBound(e) = region.kind() { e } else { bug!() }
+ if let ty::ReEarlyParam(e) = region.kind() { e } else { bug!() }
  } else {
  let guar = match region.kind() {
- ty::ReEarlyBound(ty::EarlyBoundRegion { def_id, .. })
- | ty::ReFree(ty::FreeRegion {
+ ty::ReEarlyParam(ty::EarlyParamRegion { def_id, .. })
+ | ty::ReLateParam(ty::LateParamRegion {
  bound_region: ty::BoundRegionKind::BrNamed(def_id, _),
  ..
  }) => {
@@ -1119,9 +1119,9 @@ impl<'tcx> ty::FallibleTypeFolder<TyCtxt<'tcx>> for RemapHiddenTyRegions<'tcx> {
  return Err(guar);
  };
 
- Ok(ty::Region::new_early_bound(
+ Ok(ty::Region::new_early_param(
  self.tcx,
- ty::EarlyBoundRegion {
+ ty::EarlyParamRegion {
  def_id: e.def_id,
  name: e.name,
  index: (e.index as usize - self.num_trait_args + self.num_impl_args) as u32,

compiler/rustc_hir_analysis/src/check/dropck.rs

@@ -81,8 +81,7 @@ fn ensure_drop_params_and_item_params_correspond<'tcx>(
  self_type_did: DefId,
  adt_to_impl_args: GenericArgsRef<'tcx>,
 ) -> Result<(), ErrorGuaranteed> {
- let Err(arg) = tcx.uses_unique_generic_params(adt_to_impl_args, CheckRegions::OnlyEarlyBound)
- else {
+ let Err(arg) = tcx.uses_unique_generic_params(adt_to_impl_args, CheckRegions::OnlyParam) else {
  return Ok(());
  };
 

compiler/rustc_hir_analysis/src/check/wfcheck.rs

@@ -595,9 +595,9 @@ fn gather_gat_bounds<'tcx, T: TypeFoldable<TyCtxt<'tcx>>>(
  // Same for the region. In our example, 'a corresponds
  // to the 'me parameter.
  let region_param = gat_generics.param_at(*region_a_idx, tcx);
- let region_param = ty::Region::new_early_bound(
+ let region_param = ty::Region::new_early_param(
  tcx,
- ty::EarlyBoundRegion {
+ ty::EarlyParamRegion {
  def_id: region_param.def_id,
  index: region_param.index,
  name: region_param.name,
@@ -628,19 +628,19 @@ fn gather_gat_bounds<'tcx, T: TypeFoldable<TyCtxt<'tcx>>>(
  debug!("required clause: {region_a} must outlive {region_b}");
  // Translate into the generic parameters of the GAT.
  let region_a_param = gat_generics.param_at(*region_a_idx, tcx);
- let region_a_param = ty::Region::new_early_bound(
+ let region_a_param = ty::Region::new_early_param(
  tcx,
- ty::EarlyBoundRegion {
+ ty::EarlyParamRegion {
  def_id: region_a_param.def_id,
  index: region_a_param.index,
  name: region_a_param.name,
  },
  );
  // Same for the region.
  let region_b_param = gat_generics.param_at(*region_b_idx, tcx);
- let region_b_param = ty::Region::new_early_bound(
+ let region_b_param = ty::Region::new_early_param(
  tcx,
- ty::EarlyBoundRegion {
+ ty::EarlyParamRegion {
  def_id: region_b_param.def_id,
  index: region_b_param.index,
  name: region_b_param.name,

compiler/rustc_hir_analysis/src/coherence/builtin.rs

@@ -550,7 +550,7 @@ fn infringing_fields_error(
  .entry((ty.clone(), predicate.clone()))
  .or_default()
  .push(origin.span());
- if let ty::RegionKind::ReEarlyBound(ebr) = *b
+ if let ty::RegionKind::ReEarlyParam(ebr) = *b
  && ebr.has_name()
  {
  bounds.push((b.to_string(), a.to_string(), None));