Rename

compiler-errors · compiler-errors · commit 0f044bad4b19 · 2025-05-26T08:36:17.000Z
diff --git a/compiler/rustc_hir_analysis/src/check/wfcheck.rs b/compiler/rustc_hir_analysis/src/check/wfcheck.rs
@@ -742,7 +742,7 @@ fn ty_known_to_outlive<'tcx>(
     region: ty::Region<'tcx>,
 ) -> bool {
     test_region_obligations(tcx, id, param_env, wf_tys, |infcx| {
-        infcx.type_outlives_predicate(infer::RegionObligation {
+        infcx.register_type_outlives_constraint_inner(infer::TypeOutlivesConstraint {
             sub_region: region,
             sup_type: ty,
             origin: infer::RelateParamBound(DUMMY_SP, ty, None),
diff --git a/compiler/rustc_infer/src/infer/canonical/query_response.rs b/compiler/rustc_infer/src/infer/canonical/query_response.rs
@@ -171,7 +171,7 @@ impl<'tcx> InferCtxt<'tcx> {
 
         for (predicate, _category) in &query_response.value.region_constraints.outlives {
             let predicate = instantiate_value(self.tcx, &result_args, *predicate);
-            self.outlives_predicate_with_cause(predicate, cause);
+            self.register_outlives_constraint(predicate, cause);
         }
 
         let user_result: R =
diff --git a/compiler/rustc_infer/src/infer/context.rs b/compiler/rustc_infer/src/infer/context.rs
@@ -214,7 +214,7 @@ impl<'tcx> rustc_type_ir::InferCtxtLike for InferCtxt<'tcx> {
     }
 
     fn register_ty_outlives(&self, ty: Ty<'tcx>, r: ty::Region<'tcx>, span: Span) {
-        self.type_outlives_predicate_with_cause(ty, r, &ObligationCause::dummy_with_span(span));
+        self.register_type_outlives_constraint(ty, r, &ObligationCause::dummy_with_span(span));
     }
 
     type OpaqueTypeStorageEntries = OpaqueTypeStorageEntries;
diff --git a/compiler/rustc_infer/src/infer/mod.rs b/compiler/rustc_infer/src/infer/mod.rs
@@ -150,7 +150,7 @@ pub struct InferCtxtInner<'tcx> {
     /// for each body-id in this map, which will process the
     /// obligations within. This is expected to be done 'late enough'
     /// that all type inference variables have been bound and so forth.
-    region_obligations: Vec<RegionObligation<'tcx>>,
+    region_obligations: Vec<TypeOutlivesConstraint<'tcx>>,
 
     /// Caches for opaque type inference.
     opaque_type_storage: OpaqueTypeStorage<'tcx>,
@@ -173,7 +173,7 @@ impl<'tcx> InferCtxtInner<'tcx> {
     }
 
     #[inline]
-    pub fn region_obligations(&self) -> &[RegionObligation<'tcx>] {
+    pub fn region_obligations(&self) -> &[TypeOutlivesConstraint<'tcx>] {
         &self.region_obligations
     }
 
@@ -488,7 +488,7 @@ impl fmt::Display for FixupError {
 
 /// See the `region_obligations` field for more information.
 #[derive(Clone, Debug)]
-pub struct RegionObligation<'tcx> {
+pub struct TypeOutlivesConstraint<'tcx> {
     pub sub_region: ty::Region<'tcx>,
     pub sup_type: Ty<'tcx>,
     pub origin: SubregionOrigin<'tcx>,
diff --git a/compiler/rustc_infer/src/infer/outlives/obligations.rs b/compiler/rustc_infer/src/infer/outlives/obligations.rs
@@ -76,27 +76,29 @@ use crate::infer::outlives::env::RegionBoundPairs;
 use crate::infer::outlives::verify::VerifyBoundCx;
 use crate::infer::resolve::OpportunisticRegionResolver;
 use crate::infer::snapshot::undo_log::UndoLog;
-use crate::infer::{self, GenericKind, InferCtxt, RegionObligation, SubregionOrigin, VerifyBound};
+use crate::infer::{
+    self, GenericKind, InferCtxt, SubregionOrigin, TypeOutlivesConstraint, VerifyBound,
+};
 use crate::traits::{ObligationCause, ObligationCauseCode};
 
 impl<'tcx> InferCtxt<'tcx> {
-    pub fn outlives_predicate_with_cause(
+    pub fn register_outlives_constraint(
         &self,
         ty::OutlivesPredicate(arg, r2): ty::OutlivesPredicate<'tcx, ty::GenericArg<'tcx>>,
         cause: &ObligationCause<'tcx>,
     ) {
         match arg.unpack() {
             ty::GenericArgKind::Lifetime(r1) => {
-                self.region_outlives_predicate(ty::OutlivesPredicate(r1, r2), cause);
+                self.register_region_outlives_constraint(ty::OutlivesPredicate(r1, r2), cause);
             }
             ty::GenericArgKind::Type(ty1) => {
-                self.type_outlives_predicate_with_cause(ty1, r2, cause);
+                self.register_type_outlives_constraint(ty1, r2, cause);
             }
             ty::GenericArgKind::Const(_) => unreachable!(),
         }
     }
 
-    pub fn region_outlives_predicate(
+    pub fn register_region_outlives_constraint(
         &self,
         ty::OutlivesPredicate(r_a, r_b): ty::RegionOutlivesPredicate<'tcx>,
         cause: &ObligationCause<'tcx>,
@@ -114,13 +116,16 @@ impl<'tcx> InferCtxt<'tcx> {
     /// available (see `region_obligations` field for more
     /// information).
     #[instrument(level = "debug", skip(self))]
-    pub fn type_outlives_predicate(&self, obligation: RegionObligation<'tcx>) {
+    pub fn register_type_outlives_constraint_inner(
+        &self,
+        obligation: TypeOutlivesConstraint<'tcx>,
+    ) {
         let mut inner = self.inner.borrow_mut();
-        inner.undo_log.push(UndoLog::PushRegionObligation);
+        inner.undo_log.push(UndoLog::PushTypeOutlivesConstraint);
         inner.region_obligations.push(obligation);
     }
 
-    pub fn type_outlives_predicate_with_cause(
+    pub fn register_type_outlives_constraint(
         &self,
         sup_type: Ty<'tcx>,
         sub_region: Region<'tcx>,
@@ -152,11 +157,15 @@ impl<'tcx> InferCtxt<'tcx> {
             )
         });
 
-        self.type_outlives_predicate(RegionObligation { sup_type, sub_region, origin });
+        self.register_type_outlives_constraint_inner(TypeOutlivesConstraint {
+            sup_type,
+            sub_region,
+            origin,
+        });
     }
 
     /// Trait queries just want to pass back type obligations "as is"
-    pub fn take_registered_region_obligations(&self) -> Vec<RegionObligation<'tcx>> {
+    pub fn take_registered_region_obligations(&self) -> Vec<TypeOutlivesConstraint<'tcx>> {
         std::mem::take(&mut self.inner.borrow_mut().region_obligations)
     }
 
@@ -194,7 +203,7 @@ impl<'tcx> InferCtxt<'tcx> {
                 );
             }
 
-            for RegionObligation { sup_type, sub_region, origin } in my_region_obligations {
+            for TypeOutlivesConstraint { sup_type, sub_region, origin } in my_region_obligations {
                 let outlives = ty::Binder::dummy(ty::OutlivesPredicate(sup_type, sub_region));
                 let ty::OutlivesPredicate(sup_type, sub_region) =
                     deeply_normalize_ty(outlives, origin.clone())
diff --git a/compiler/rustc_infer/src/infer/snapshot/undo_log.rs b/compiler/rustc_infer/src/infer/snapshot/undo_log.rs
@@ -26,7 +26,7 @@ pub(crate) enum UndoLog<'tcx> {
     RegionConstraintCollector(region_constraints::UndoLog<'tcx>),
     RegionUnificationTable(sv::UndoLog<ut::Delegate<RegionVidKey<'tcx>>>),
     ProjectionCache(traits::UndoLog<'tcx>),
-    PushRegionObligation,
+    PushTypeOutlivesConstraint,
 }
 
 macro_rules! impl_from {
@@ -72,7 +72,7 @@ impl<'tcx> Rollback<UndoLog<'tcx>> for InferCtxtInner<'tcx> {
                 self.region_constraint_storage.as_mut().unwrap().unification_table.reverse(undo)
             }
             UndoLog::ProjectionCache(undo) => self.projection_cache.reverse(undo),
-            UndoLog::PushRegionObligation => {
+            UndoLog::PushTypeOutlivesConstraint => {
                 self.region_obligations.pop();
             }
         }
diff --git a/compiler/rustc_trait_selection/src/solve/delegate.rs b/compiler/rustc_trait_selection/src/solve/delegate.rs
@@ -76,7 +76,7 @@ impl<'tcx> rustc_next_trait_solver::delegate::SolverDelegate for SolverDelegate<
                 Some(HasChanged::No)
             }
             ty::PredicateKind::Clause(ty::ClauseKind::TypeOutlives(outlives)) => {
-                self.0.type_outlives_predicate_with_cause(
+                self.0.register_type_outlives_constraint(
                     outlives.0,
                     outlives.1,
                     &ObligationCause::dummy_with_span(span),
diff --git a/compiler/rustc_trait_selection/src/traits/auto_trait.rs b/compiler/rustc_trait_selection/src/traits/auto_trait.rs
@@ -727,7 +727,7 @@ impl<'tcx> AutoTraitFinder<'tcx> {
                 ty::PredicateKind::Clause(ty::ClauseKind::RegionOutlives(binder)) => {
                     let binder = bound_predicate.rebind(binder);
                     selcx.infcx.enter_forall(binder, |pred| {
-                        selcx.infcx.region_outlives_predicate(pred, &dummy_cause);
+                        selcx.infcx.register_region_outlives_constraint(pred, &dummy_cause);
                     });
                 }
                 ty::PredicateKind::Clause(ty::ClauseKind::TypeOutlives(binder)) => {
@@ -737,14 +737,14 @@ impl<'tcx> AutoTraitFinder<'tcx> {
                         binder.map_bound_ref(|pred| pred.0).no_bound_vars(),
                     ) {
                         (None, Some(t_a)) => {
-                            selcx.infcx.type_outlives_predicate_with_cause(
+                            selcx.infcx.register_type_outlives_constraint(
                                 t_a,
                                 selcx.infcx.tcx.lifetimes.re_static,
                                 &dummy_cause,
                             );
                         }
                         (Some(ty::OutlivesPredicate(t_a, r_b)), _) => {
-                            selcx.infcx.type_outlives_predicate_with_cause(
+                            selcx.infcx.register_type_outlives_constraint(
                                 t_a,
                                 r_b,
                                 &dummy_cause,
diff --git a/compiler/rustc_trait_selection/src/traits/fulfill.rs b/compiler/rustc_trait_selection/src/traits/fulfill.rs
@@ -428,7 +428,7 @@ impl<'a, 'tcx> ObligationProcessor for FulfillProcessor<'a, 'tcx> {
 
                 ty::PredicateKind::Clause(ty::ClauseKind::RegionOutlives(data)) => {
                     if infcx.considering_regions {
-                        infcx.region_outlives_predicate(data, &obligation.cause);
+                        infcx.register_region_outlives_constraint(data, &obligation.cause);
                     }
 
                     ProcessResult::Changed(Default::default())
@@ -439,7 +439,7 @@ impl<'a, 'tcx> ObligationProcessor for FulfillProcessor<'a, 'tcx> {
                     r_b,
                 ))) => {
                     if infcx.considering_regions {
-                        infcx.type_outlives_predicate_with_cause(t_a, r_b, &obligation.cause);
+                        infcx.register_type_outlives_constraint(t_a, r_b, &obligation.cause);
                     }
                     ProcessResult::Changed(Default::default())
                 }
diff --git a/compiler/rustc_trait_selection/src/traits/outlives_bounds.rs b/compiler/rustc_trait_selection/src/traits/outlives_bounds.rs
@@ -81,7 +81,7 @@ fn implied_outlives_bounds<'a, 'tcx>(
         let QueryRegionConstraints { outlives } = constraints;
         let cause = ObligationCause::misc(span, body_id);
         for &(predicate, _) in &outlives {
-            infcx.outlives_predicate_with_cause(predicate, &cause);
+            infcx.register_outlives_constraint(predicate, &cause);
         }
     };
 
diff --git a/compiler/rustc_trait_selection/src/traits/query/type_op/implied_outlives_bounds.rs b/compiler/rustc_trait_selection/src/traits/query/type_op/implied_outlives_bounds.rs
@@ -1,6 +1,6 @@
 use std::ops::ControlFlow;
 
-use rustc_infer::infer::RegionObligation;
+use rustc_infer::infer::TypeOutlivesConstraint;
 use rustc_infer::infer::canonical::CanonicalQueryInput;
 use rustc_infer::traits::query::OutlivesBound;
 use rustc_infer::traits::query::type_op::ImpliedOutlivesBounds;
@@ -141,7 +141,7 @@ pub fn compute_implied_outlives_bounds_inner<'tcx>(
         && !ocx.infcx.tcx.sess.opts.unstable_opts.no_implied_bounds_compat
         && ty.visit_with(&mut ContainsBevyParamSet { tcx: ocx.infcx.tcx }).is_break()
     {
-        for RegionObligation { sup_type, sub_region, .. } in
+        for TypeOutlivesConstraint { sup_type, sub_region, .. } in
             ocx.infcx.take_registered_region_obligations()
         {
             let mut components = smallvec![];

Original file line number	Diff line number	Diff line change
`@@ -171,7 +171,7 @@ impl<'tcx> InferCtxt<'tcx> {`
`171`	`171`
`172`	`172`	`for (predicate, _category) in &query_response.value.region_constraints.outlives {`
`173`	`173`	`let predicate = instantiate_value(self.tcx, &result_args, *predicate);`
`174`		`- self.outlives_predicate_with_cause(predicate, cause);`
	`174`	`+ self.register_outlives_constraint(predicate, cause);`
`175`	`175`	`}`
`176`	`176`
`177`	`177`	`let user_result: R =`
Original file line number	Diff line number	Diff line change
`@@ -214,7 +214,7 @@ impl<'tcx> rustc_type_ir::InferCtxtLike for InferCtxt<'tcx> {`
`214`	`214`	`}`
`215`	`215`
`216`	`216`	`fn register_ty_outlives(&self, ty: Ty<'tcx>, r: ty::Region<'tcx>, span: Span) {`
`217`		`- self.type_outlives_predicate_with_cause(ty, r, &ObligationCause::dummy_with_span(span));`
	`217`	`+ self.register_type_outlives_constraint(ty, r, &ObligationCause::dummy_with_span(span));`
`218`	`218`	`}`
`219`	`219`
`220`	`220`	`type OpaqueTypeStorageEntries = OpaqueTypeStorageEntries;`
Original file line number	Diff line number	Diff line change
`@@ -26,7 +26,7 @@ pub(crate) enum UndoLog<'tcx> {`
`26`	`26`	`RegionConstraintCollector(region_constraints::UndoLog<'tcx>),`
`27`	`27`	`RegionUnificationTable(sv::UndoLog<ut::Delegate<RegionVidKey<'tcx>>>),`
`28`	`28`	`ProjectionCache(traits::UndoLog<'tcx>),`
`29`		`- PushRegionObligation,`
	`29`	`+ PushTypeOutlivesConstraint,`
`30`	`30`	`}`
`31`	`31`
`32`	`32`	`macro_rules! impl_from {`
`@@ -72,7 +72,7 @@ impl<'tcx> Rollback<UndoLog<'tcx>> for InferCtxtInner<'tcx> {`
`72`	`72`	`self.region_constraint_storage.as_mut().unwrap().unification_table.reverse(undo)`
`73`	`73`	`}`
`74`	`74`	`UndoLog::ProjectionCache(undo) => self.projection_cache.reverse(undo),`
`75`		`- UndoLog::PushRegionObligation => {`
	`75`	`+ UndoLog::PushTypeOutlivesConstraint => {`
`76`	`76`	`self.region_obligations.pop();`
`77`	`77`	`}`
`78`	`78`	`}`
Original file line number	Diff line number	Diff line change
`@@ -76,7 +76,7 @@ impl<'tcx> rustc_next_trait_solver::delegate::SolverDelegate for SolverDelegate<`
`76`	`76`	`Some(HasChanged::No)`
`77`	`77`	`}`
`78`	`78`	`ty::PredicateKind::Clause(ty::ClauseKind::TypeOutlives(outlives)) => {`
`79`		`- self.0.type_outlives_predicate_with_cause(`
	`79`	`+ self.0.register_type_outlives_constraint(`
`80`	`80`	`outlives.0,`
`81`	`81`	`outlives.1,`
`82`	`82`	`&ObligationCause::dummy_with_span(span),`
Original file line number	Diff line number	Diff line change
`@@ -428,7 +428,7 @@ impl<'a, 'tcx> ObligationProcessor for FulfillProcessor<'a, 'tcx> {`
`428`	`428`
`429`	`429`	`ty::PredicateKind::Clause(ty::ClauseKind::RegionOutlives(data)) => {`
`430`	`430`	`if infcx.considering_regions {`
`431`		`- infcx.region_outlives_predicate(data, &obligation.cause);`
	`431`	`+ infcx.register_region_outlives_constraint(data, &obligation.cause);`
`432`	`432`	`}`
`433`	`433`
`434`	`434`	`ProcessResult::Changed(Default::default())`
`@@ -439,7 +439,7 @@ impl<'a, 'tcx> ObligationProcessor for FulfillProcessor<'a, 'tcx> {`
`439`	`439`	`r_b,`
`440`	`440`	`))) => {`
`441`	`441`	`if infcx.considering_regions {`
`442`		`- infcx.type_outlives_predicate_with_cause(t_a, r_b, &obligation.cause);`
	`442`	`+ infcx.register_type_outlives_constraint(t_a, r_b, &obligation.cause);`
`443`	`443`	`}`
`444`	`444`	`ProcessResult::Changed(Default::default())`
`445`	`445`	`}`
Original file line number	Diff line number	Diff line change
`@@ -81,7 +81,7 @@ fn implied_outlives_bounds<'a, 'tcx>(`
`81`	`81`	`let QueryRegionConstraints { outlives } = constraints;`
`82`	`82`	`let cause = ObligationCause::misc(span, body_id);`
`83`	`83`	`for &(predicate, _) in &outlives {`
`84`		`- infcx.outlives_predicate_with_cause(predicate, &cause);`
	`84`	`+ infcx.register_outlives_constraint(predicate, &cause);`
`85`	`85`	`}`
`86`	`86`	`};`
`87`	`87`