From 4906be1dc832ac4e1f99091460acbc63b41d6b19 Mon Sep 17 00:00:00 2001 From: Amirhossein Akhlaghpour Date: Thu, 27 Aug 2026 19:14:00 +0330 Subject: [PATCH 1/4] avoid redundant next-solver fulfillment scans --- compiler/rustc_infer/src/infer/context.rs | 17 ++-- compiler/rustc_infer/src/infer/mod.rs | 53 ++++++++++- .../src/infer/relate/generalize.rs | 7 +- .../src/infer/snapshot/undo_log.rs | 28 +++++- .../rustc_infer/src/infer/type_variable.rs | 9 ++ .../src/solve/fulfill.rs | 93 ++++++++++++++++++- 6 files changed, 187 insertions(+), 20 deletions(-) diff --git a/compiler/rustc_infer/src/infer/context.rs b/compiler/rustc_infer/src/infer/context.rs index e6ddbd879f9b9..df499d7188642 100644 --- a/compiler/rustc_infer/src/infer/context.rs +++ b/compiler/rustc_infer/src/infer/context.rs @@ -206,15 +206,15 @@ impl<'tcx> rustc_type_ir::InferCtxtLike for InferCtxt<'tcx> { } fn equate_int_vids_raw(&self, a: ty::IntVid, b: ty::IntVid) { - self.inner.borrow_mut().int_unification_table().union(a, b); + self.inner.borrow_mut().equate_int_vids(a, b); } fn equate_float_vids_raw(&self, a: ty::FloatVid, b: ty::FloatVid) { - self.inner.borrow_mut().float_unification_table().union(a, b); + self.inner.borrow_mut().equate_float_vids(a, b); } fn equate_const_vids_raw(&self, a: ty::ConstVid, b: ty::ConstVid) { - self.inner.borrow_mut().const_unification_table().union(a, b); + self.inner.borrow_mut().equate_const_vids(a, b); } fn instantiate_ty_var_raw(&self, vid: ty::TyVid, ty: Ty<'tcx>) { @@ -226,10 +226,7 @@ impl<'tcx> rustc_type_ir::InferCtxtLike for InferCtxt<'tcx> { fn instantiate_const_var_raw(&self, vid: ty::ConstVid, ct: ty::Const<'tcx>) { let ct = lower_universe(self, self.try_resolve_const_var(vid).unwrap_err(), ct); - self.inner - .borrow_mut() - .const_unification_table() - .union_value(vid, ConstVariableValue::Known { value: ct }); + self.inner.borrow_mut().instantiate_const_var(vid, ct); } fn instantiate_ty_var>( @@ -250,11 +247,11 @@ impl<'tcx> rustc_type_ir::InferCtxtLike for InferCtxt<'tcx> { } fn instantiate_int_var_raw(&self, vid: ty::IntVid, value: ty::IntVarValue) { - self.inner.borrow_mut().int_unification_table().union_value(vid, value); + self.inner.borrow_mut().instantiate_int_var(vid, value); } fn instantiate_float_var_raw(&self, vid: ty::FloatVid, value: ty::FloatVarValue) { - self.inner.borrow_mut().float_unification_table().union_value(vid, value); + self.inner.borrow_mut().instantiate_float_var(vid, value); } fn instantiate_const_var>( @@ -504,7 +501,7 @@ impl<'a, 'tcx> ty::TypeFolder> for LowerUniverseFolder<'a, 'tcx> { }) .vid; - self.infcx.inner.borrow_mut().const_unification_table().union(vid, new_var_id); + self.infcx.inner.borrow_mut().equate_const_vids(vid, new_var_id); ty::Const::new_var(self.cx(), new_var_id) } diff --git a/compiler/rustc_infer/src/infer/mod.rs b/compiler/rustc_infer/src/infer/mod.rs index a49a4355b66b1..b255894e7b9be 100644 --- a/compiler/rustc_infer/src/infer/mod.rs +++ b/compiler/rustc_infer/src/infer/mod.rs @@ -168,9 +168,9 @@ pub struct InferCtxtInner<'tcx> { } impl<'tcx> InferCtxtInner<'tcx> { - fn new() -> InferCtxtInner<'tcx> { + fn new(next_trait_solver: bool) -> InferCtxtInner<'tcx> { InferCtxtInner { - undo_log: InferCtxtUndoLogs::default(), + undo_log: InferCtxtUndoLogs::new(next_trait_solver), projection_cache: Default::default(), type_variable_storage: Default::default(), @@ -234,6 +234,44 @@ impl<'tcx> InferCtxtInner<'tcx> { self.const_unification_storage.with_log(&mut self.undo_log) } + // Keep mutations to non-type inference variables synchronized with the + // generation used by the stalled-goal fulfillment fast path. + #[inline] + fn equate_int_vids(&mut self, a: ty::IntVid, b: ty::IntVid) { + self.undo_log.bump_stalled_goal_generation(); + self.int_unification_table().union(a, b); + } + + #[inline] + fn equate_float_vids(&mut self, a: ty::FloatVid, b: ty::FloatVid) { + self.undo_log.bump_stalled_goal_generation(); + self.float_unification_table().union(a, b); + } + + #[inline] + fn equate_const_vids(&mut self, a: ty::ConstVid, b: ty::ConstVid) { + self.undo_log.bump_stalled_goal_generation(); + self.const_unification_table().union(a, b); + } + + #[inline] + fn instantiate_int_var(&mut self, vid: ty::IntVid, value: ty::IntVarValue) { + self.undo_log.bump_stalled_goal_generation(); + self.int_unification_table().union_value(vid, value); + } + + #[inline] + fn instantiate_float_var(&mut self, vid: ty::FloatVid, value: ty::FloatVarValue) { + self.undo_log.bump_stalled_goal_generation(); + self.float_unification_table().union_value(vid, value); + } + + #[inline] + fn instantiate_const_var(&mut self, vid: ty::ConstVid, value: ty::Const<'tcx>) { + self.undo_log.bump_stalled_goal_generation(); + self.const_unification_table().union_value(vid, ConstVariableValue::Known { value }); + } + #[inline] pub fn unwrap_region_constraints(&mut self) -> RegionConstraintCollector<'_, 'tcx> { self.region_constraint_storage @@ -681,7 +719,7 @@ impl<'tcx> InferCtxtBuilder<'tcx> { considering_regions, in_hir_typeck, skip_leak_check, - inner: RefCell::new(InferCtxtInner::new()), + inner: RefCell::new(InferCtxtInner::new(next_trait_solver)), lexical_region_resolutions: RefCell::new(None), selection_cache: Default::default(), evaluation_cache: Default::default(), @@ -1651,6 +1689,15 @@ impl<'tcx> InferCtxt<'tcx> { self.typing_env(param_env).as_query_input(value) } + #[inline] + pub fn stalled_goal_generation(&self) -> u64 { + self.inner + .borrow() + .undo_log + .stalled_goal_generation() + .expect("stalled-goal generation requires the next trait solver") + } + /// The returned function is used in a fast path. If it returns `true` the variable is /// unchanged, `false` indicates that the status is unknown. #[inline] diff --git a/compiler/rustc_infer/src/infer/relate/generalize.rs b/compiler/rustc_infer/src/infer/relate/generalize.rs index afdabb38c3b20..b92199797e17f 100644 --- a/compiler/rustc_infer/src/infer/relate/generalize.rs +++ b/compiler/rustc_infer/src/infer/relate/generalize.rs @@ -258,17 +258,14 @@ impl<'tcx> InferCtxt<'tcx> { } (TermVid::Const(l), ty::TermKind::Const(r)) => { if let Some(r) = r.ct_vid() { - self.inner.borrow_mut().const_unification_table().union(l, r) + self.inner.borrow_mut().equate_const_vids(l, r) } else { debug_assert!( self.try_resolve_const_var(l) .unwrap_err() .can_name(ty::max_universe(self, r)) ); - self.inner - .borrow_mut() - .const_unification_table() - .union_value(l, ConstVariableValue::Known { value: r }) + self.inner.borrow_mut().instantiate_const_var(l, r) } } _ => bug!("mismatched term kinds in generalize: {l:?}, {r:?}"), diff --git a/compiler/rustc_infer/src/infer/snapshot/undo_log.rs b/compiler/rustc_infer/src/infer/snapshot/undo_log.rs index fe697eb4c01ac..032fa14c62a6f 100644 --- a/compiler/rustc_infer/src/infer/snapshot/undo_log.rs +++ b/compiler/rustc_infer/src/infer/snapshot/undo_log.rs @@ -12,6 +12,7 @@ use crate::traits; pub struct Snapshot<'tcx> { pub(crate) undo_len: usize, + stalled_goal_generation: Option, _marker: PhantomData<&'tcx ()>, } @@ -112,6 +113,7 @@ impl<'tcx> Rollback> for InferCtxtInner<'tcx> { pub(crate) struct InferCtxtUndoLogs<'tcx> { logs: Vec>, num_open_snapshots: usize, + stalled_goal_generation: Option, } /// The UndoLogs trait defines how we undo a particular kind of action (of type T). We can undo any @@ -158,6 +160,7 @@ impl<'tcx> InferCtxtInner<'tcx> { } self.type_variable_storage.finalize_rollback(); + self.undo_log.stalled_goal_generation = snapshot.stalled_goal_generation; if self.undo_log.num_open_snapshots == 1 { // After the root snapshot the undo log should be empty. @@ -184,9 +187,32 @@ impl<'tcx> InferCtxtInner<'tcx> { } impl<'tcx> InferCtxtUndoLogs<'tcx> { + pub(crate) fn new(track_stalled_goal_generation: bool) -> Self { + Self { + stalled_goal_generation: track_stalled_goal_generation.then_some(0), + ..Default::default() + } + } + + #[inline] + pub(crate) fn stalled_goal_generation(&self) -> Option { + self.stalled_goal_generation + } + + #[inline] + pub(crate) fn bump_stalled_goal_generation(&mut self) { + if let Some(generation) = &mut self.stalled_goal_generation { + *generation = generation.wrapping_add(1); + } + } + pub(crate) fn start_snapshot(&mut self) -> Snapshot<'tcx> { self.num_open_snapshots += 1; - Snapshot { undo_len: self.logs.len(), _marker: PhantomData } + Snapshot { + undo_len: self.logs.len(), + stalled_goal_generation: self.stalled_goal_generation, + _marker: PhantomData, + } } pub(crate) fn region_constraints_in_snapshot( diff --git a/compiler/rustc_infer/src/infer/type_variable.rs b/compiler/rustc_infer/src/infer/type_variable.rs index be0ac72d85675..2347cf47d2e26 100644 --- a/compiler/rustc_infer/src/infer/type_variable.rs +++ b/compiler/rustc_infer/src/infer/type_variable.rs @@ -178,6 +178,9 @@ impl<'tcx> TypeVariableTable<'_, 'tcx> { pub(crate) fn equate(&mut self, a: ty::TyVid, b: ty::TyVid) { debug_assert!(self.probe(a).is_unknown()); debug_assert!(self.probe(b).is_unknown()); + + self.undo_log.bump_stalled_goal_generation(); + self.eq_relations().union(a, b); self.sub_unification_table().union(a, b); } @@ -189,6 +192,9 @@ impl<'tcx> TypeVariableTable<'_, 'tcx> { pub(crate) fn sub_unify(&mut self, a: ty::TyVid, b: ty::TyVid) { debug_assert!(self.probe(a).is_unknown()); debug_assert!(self.probe(b).is_unknown()); + + self.undo_log.bump_stalled_goal_generation(); + self.sub_unification_table().union(a, b); } @@ -204,6 +210,9 @@ impl<'tcx> TypeVariableTable<'_, 'tcx> { "instantiating type variable `{vid:?}` twice: new-value = {ty:?}, old-value={:?}", self.eq_relations().probe_value(vid) ); + + self.undo_log.bump_stalled_goal_generation(); + self.eq_relations().union_value(vid, TypeVariableValue::Known { value: ty }); } diff --git a/compiler/rustc_trait_selection/src/solve/fulfill.rs b/compiler/rustc_trait_selection/src/solve/fulfill.rs index f7eb76bbe72b5..5d1b7c077a3a5 100644 --- a/compiler/rustc_trait_selection/src/solve/fulfill.rs +++ b/compiler/rustc_trait_selection/src/solve/fulfill.rs @@ -9,7 +9,8 @@ use rustc_infer::traits::{ use rustc_middle::ty::{self, TyCtxt, TypeVisitableExt, TypingMode}; use rustc_next_trait_solver::solve::fast_path::compute_goal_fast_path; use rustc_next_trait_solver::solve::{ - GoalEvaluation, GoalStalledOn, HasChanged, SolverDelegateEvalExt as _, StalledOnCoroutines, + GoalEvaluation, GoalStalledOn, GoalStalledOnOpaques, HasChanged, SolverDelegateEvalExt as _, + StalledOnCoroutines, }; use thin_vec::ThinVec; use tracing::instrument; @@ -48,6 +49,17 @@ pub struct FulfillmentCtxt<'tcx, E: 'tcx> { /// gets rolled back. Because of this we explicitly check that we only /// use the context in exactly this snapshot. usable_in_snapshot: usize, + + last_stalled_goal_generation: u64, + + /// Whether any trackable stalled obligation requires the opaque + /// type storage to remain empty. + stalled_on_empty_opaques: bool, + + /// Whether every pending obligation can use the context-wide + /// stalled-goal fast path. + all_pending_trackable: bool, + _errors: PhantomData, } @@ -133,13 +145,33 @@ impl<'tcx, E: 'tcx> FulfillmentCtxt<'tcx, E> { "new trait solver fulfillment context created when \ infcx is set up for old trait solver" ); + let generation = infcx.stalled_goal_generation(); + FulfillmentCtxt { obligations: Default::default(), usable_in_snapshot: infcx.num_open_snapshots(), + last_stalled_goal_generation: generation, + stalled_on_empty_opaques: false, + all_pending_trackable: true, _errors: PhantomData, } } + fn record_trackable_stalled_on( + stalled_on: &GoalStalledOn>, + stalled_on_empty_opaques: &mut bool, + ) -> bool { + match stalled_on.opaques { + GoalStalledOnOpaques::No => {} + GoalStalledOnOpaques::Yes { num_opaques_in_storage: 0, .. } => { + *stalled_on_empty_opaques = true; + } + GoalStalledOnOpaques::Yes { .. } => return false, + } + + true + } + fn inspect_evaluated_obligation( infcx: &InferCtxt<'tcx>, obligation: &PredicateObligation<'tcx>, @@ -176,10 +208,22 @@ where match certainty { Certainty::Yes => {} Certainty::Maybe(_) => { + if let Some(stalled_on) = &stalled_on { + if !Self::record_trackable_stalled_on( + stalled_on, + &mut self.stalled_on_empty_opaques, + ) { + self.all_pending_trackable = false; + } + } else { + self.all_pending_trackable = false; + } + self.obligations.register(obligation, stalled_on); } } } else { + self.all_pending_trackable = false; self.obligations.register(obligation, None); } } @@ -199,9 +243,35 @@ where assert_eq!(self.usable_in_snapshot, infcx.num_open_snapshots()); let mut errors = TraitErrors::NoErrors; let delegate = <&SolverDelegate<'tcx>>::from(infcx); + + let generation = infcx.stalled_goal_generation(); + + if self.obligations.pending.is_empty() { + self.last_stalled_goal_generation = generation; + self.stalled_on_empty_opaques = false; + self.all_pending_trackable = true; + return errors; + } + + if !infcx.tcx.disable_trait_solver_fast_paths() + && self.all_pending_trackable + && self.last_stalled_goal_generation == generation + { + let opaques_unchanged = !self.stalled_on_empty_opaques + || infcx.inner.borrow_mut().opaque_types().is_empty(); + + if opaques_unchanged { + return errors; + } + } + loop { + let pass_generation = infcx.stalled_goal_generation(); + let mut any_changed = false; let mut overflowed = false; + let mut all_pending_trackable = true; + let mut stalled_on_empty_opaques = false; self.obligations.pending.retain_mut(|(obligation, opt_stalled_on)| { if overflowed { @@ -213,6 +283,11 @@ where if let Some(stalled_on) = opt_stalled_on && delegate.goal_remains_stalled(stalled_on) { + if !Self::record_trackable_stalled_on(stalled_on, &mut stalled_on_empty_opaques) + { + all_pending_trackable = false; + } + return true; } @@ -283,17 +358,33 @@ where // Update `opt_stalled_on` goal, for the next retain_mut, because we are // running until a fixpoint. *opt_stalled_on = stalled_on; + + if let Some(stalled_on) = opt_stalled_on { + if !Self::record_trackable_stalled_on( + stalled_on, + &mut stalled_on_empty_opaques, + ) { + all_pending_trackable = false; + } + } else { + all_pending_trackable = false; + } + true } } }); if overflowed { + self.all_pending_trackable = false; self.obligations.on_fulfillment_overflow(infcx); // Only return true errors that we have accumulated while processing. return errors; } if !any_changed { + self.all_pending_trackable = all_pending_trackable; + self.stalled_on_empty_opaques = stalled_on_empty_opaques; + self.last_stalled_goal_generation = pass_generation; break; } } From 565a40ea798e2839c9156ff6039b969bf6f726a2 Mon Sep 17 00:00:00 2001 From: Amirhossein Akhlaghpour Date: Mon, 31 Aug 2026 19:18:58 +0330 Subject: [PATCH 2/4] move stalled-goal generation onto InferCtxtInner Signed-off-by: Amirhossein Akhlaghpour --- compiler/rustc_infer/src/infer/mod.rs | 52 ++++++++++++++----- .../rustc_infer/src/infer/snapshot/mod.rs | 2 +- .../src/infer/snapshot/undo_log.rs | 33 +++--------- .../rustc_infer/src/infer/type_variable.rs | 17 ++++-- 4 files changed, 59 insertions(+), 45 deletions(-) diff --git a/compiler/rustc_infer/src/infer/mod.rs b/compiler/rustc_infer/src/infer/mod.rs index b255894e7b9be..14c1e7aec5abb 100644 --- a/compiler/rustc_infer/src/infer/mod.rs +++ b/compiler/rustc_infer/src/infer/mod.rs @@ -97,6 +97,11 @@ pub(crate) type UnificationTable<'a, 'tcx, T> = ut::UnificationTable< pub struct InferCtxtInner<'tcx> { undo_log: InferCtxtUndoLogs<'tcx>, + /// Bumped whenever an inference change may let a stalled fulfillment goal + /// make progress. Snapshots save and restore the value, but individual bumps + /// are not undo-log entries. + stalled_goal_generation: Option, + /// Cache for projections. /// /// This cache is snapshotted along with the infcx. @@ -170,7 +175,8 @@ pub struct InferCtxtInner<'tcx> { impl<'tcx> InferCtxtInner<'tcx> { fn new(next_trait_solver: bool) -> InferCtxtInner<'tcx> { InferCtxtInner { - undo_log: InferCtxtUndoLogs::new(next_trait_solver), + undo_log: InferCtxtUndoLogs::default(), + stalled_goal_generation: next_trait_solver.then_some(0), projection_cache: Default::default(), type_variable_storage: Default::default(), @@ -211,7 +217,7 @@ impl<'tcx> InferCtxtInner<'tcx> { #[inline] fn type_variables(&mut self) -> type_variable::TypeVariableTable<'_, 'tcx> { - self.type_variable_storage.with_log(&mut self.undo_log) + self.type_variable_storage.with_log(&mut self.undo_log, &mut self.stalled_goal_generation) } #[inline] @@ -234,41 +240,58 @@ impl<'tcx> InferCtxtInner<'tcx> { self.const_unification_storage.with_log(&mut self.undo_log) } - // Keep mutations to non-type inference variables synchronized with the - // generation used by the stalled-goal fulfillment fast path. + #[inline] + pub(crate) fn start_snapshot(&mut self) -> snapshot::undo_log::Snapshot<'tcx> { + self.undo_log.start_snapshot(self.stalled_goal_generation) + } + + #[inline] + fn stalled_goal_generation(&self) -> Option { + self.stalled_goal_generation + } + + #[inline] + fn bump_stalled_goal_generation(&mut self) { + if let Some(generation) = &mut self.stalled_goal_generation { + *generation = generation.wrapping_add(1); + } + } + + // These mutations can unblock stalled goals too, so route them through the + // same generation bump. #[inline] fn equate_int_vids(&mut self, a: ty::IntVid, b: ty::IntVid) { - self.undo_log.bump_stalled_goal_generation(); + self.bump_stalled_goal_generation(); self.int_unification_table().union(a, b); } #[inline] fn equate_float_vids(&mut self, a: ty::FloatVid, b: ty::FloatVid) { - self.undo_log.bump_stalled_goal_generation(); + self.bump_stalled_goal_generation(); self.float_unification_table().union(a, b); } #[inline] fn equate_const_vids(&mut self, a: ty::ConstVid, b: ty::ConstVid) { - self.undo_log.bump_stalled_goal_generation(); + self.bump_stalled_goal_generation(); self.const_unification_table().union(a, b); } #[inline] fn instantiate_int_var(&mut self, vid: ty::IntVid, value: ty::IntVarValue) { - self.undo_log.bump_stalled_goal_generation(); + self.bump_stalled_goal_generation(); self.int_unification_table().union_value(vid, value); } #[inline] fn instantiate_float_var(&mut self, vid: ty::FloatVid, value: ty::FloatVarValue) { - self.undo_log.bump_stalled_goal_generation(); + self.bump_stalled_goal_generation(); self.float_unification_table().union_value(vid, value); } #[inline] fn instantiate_const_var(&mut self, vid: ty::ConstVid, value: ty::Const<'tcx>) { - self.undo_log.bump_stalled_goal_generation(); + self.bump_stalled_goal_generation(); self.const_unification_table().union_value(vid, ConstVariableValue::Known { value }); } @@ -1170,7 +1193,9 @@ impl<'tcx> InferCtxt<'tcx> { let ty_sub_vid = self.sub_unification_table_root_var(ty_vid); let inner = &mut *self.inner.borrow_mut(); - let mut type_variables = inner.type_variable_storage.with_log(&mut inner.undo_log); + let mut type_variables = inner + .type_variable_storage + .with_log(&mut inner.undo_log, &mut inner.stalled_goal_generation); inner.opaque_type_storage.iter_opaque_types().any(|(_, hidden_ty)| { if let ty::Infer(ty::TyVar(hidden_vid)) = *hidden_ty.ty.kind() { let opaque_sub_vid = type_variables.sub_unification_table_root_var(hidden_vid); @@ -1199,7 +1224,9 @@ impl<'tcx> InferCtxt<'tcx> { let inner = &mut *self.inner.borrow_mut(); // This is iffy, can't call `type_variables()` as we're already // borrowing the `opaque_type_storage` here. - let mut type_variables = inner.type_variable_storage.with_log(&mut inner.undo_log); + let mut type_variables = inner + .type_variable_storage + .with_log(&mut inner.undo_log, &mut inner.stalled_goal_generation); inner .opaque_type_storage .iter_opaque_types() @@ -1693,7 +1720,6 @@ impl<'tcx> InferCtxt<'tcx> { pub fn stalled_goal_generation(&self) -> u64 { self.inner .borrow() - .undo_log .stalled_goal_generation() .expect("stalled-goal generation requires the next trait solver") } diff --git a/compiler/rustc_infer/src/infer/snapshot/mod.rs b/compiler/rustc_infer/src/infer/snapshot/mod.rs index b16c80cf20143..3c2e12fe22916 100644 --- a/compiler/rustc_infer/src/infer/snapshot/mod.rs +++ b/compiler/rustc_infer/src/infer/snapshot/mod.rs @@ -51,7 +51,7 @@ impl<'tcx> InferCtxt<'tcx> { let mut inner = self.inner.borrow_mut(); CombinedSnapshot { - undo_snapshot: inner.undo_log.start_snapshot(), + undo_snapshot: inner.start_snapshot(), region_constraints_snapshot: inner.unwrap_region_constraints().start_snapshot(), universe: self.universe(), } diff --git a/compiler/rustc_infer/src/infer/snapshot/undo_log.rs b/compiler/rustc_infer/src/infer/snapshot/undo_log.rs index 032fa14c62a6f..90ebc5b1cd778 100644 --- a/compiler/rustc_infer/src/infer/snapshot/undo_log.rs +++ b/compiler/rustc_infer/src/infer/snapshot/undo_log.rs @@ -113,7 +113,6 @@ impl<'tcx> Rollback> for InferCtxtInner<'tcx> { pub(crate) struct InferCtxtUndoLogs<'tcx> { logs: Vec>, num_open_snapshots: usize, - stalled_goal_generation: Option, } /// The UndoLogs trait defines how we undo a particular kind of action (of type T). We can undo any @@ -160,7 +159,7 @@ impl<'tcx> InferCtxtInner<'tcx> { } self.type_variable_storage.finalize_rollback(); - self.undo_log.stalled_goal_generation = snapshot.stalled_goal_generation; + self.stalled_goal_generation = snapshot.stalled_goal_generation; if self.undo_log.num_open_snapshots == 1 { // After the root snapshot the undo log should be empty. @@ -187,32 +186,12 @@ impl<'tcx> InferCtxtInner<'tcx> { } impl<'tcx> InferCtxtUndoLogs<'tcx> { - pub(crate) fn new(track_stalled_goal_generation: bool) -> Self { - Self { - stalled_goal_generation: track_stalled_goal_generation.then_some(0), - ..Default::default() - } - } - - #[inline] - pub(crate) fn stalled_goal_generation(&self) -> Option { - self.stalled_goal_generation - } - - #[inline] - pub(crate) fn bump_stalled_goal_generation(&mut self) { - if let Some(generation) = &mut self.stalled_goal_generation { - *generation = generation.wrapping_add(1); - } - } - - pub(crate) fn start_snapshot(&mut self) -> Snapshot<'tcx> { + pub(crate) fn start_snapshot( + &mut self, + stalled_goal_generation: Option, + ) -> Snapshot<'tcx> { self.num_open_snapshots += 1; - Snapshot { - undo_len: self.logs.len(), - stalled_goal_generation: self.stalled_goal_generation, - _marker: PhantomData, - } + Snapshot { undo_len: self.logs.len(), stalled_goal_generation, _marker: PhantomData } } pub(crate) fn region_constraints_in_snapshot( diff --git a/compiler/rustc_infer/src/infer/type_variable.rs b/compiler/rustc_infer/src/infer/type_variable.rs index 2347cf47d2e26..52baf431aba9f 100644 --- a/compiler/rustc_infer/src/infer/type_variable.rs +++ b/compiler/rustc_infer/src/infer/type_variable.rs @@ -89,6 +89,7 @@ pub(crate) struct TypeVariableTable<'a, 'tcx> { storage: &'a mut TypeVariableStorage<'tcx>, undo_log: &'a mut InferCtxtUndoLogs<'tcx>, + stalled_goal_generation: &'a mut Option, } #[derive(Copy, Clone, Debug)] @@ -144,8 +145,9 @@ impl<'tcx> TypeVariableStorage<'tcx> { pub(crate) fn with_log<'a>( &'a mut self, undo_log: &'a mut InferCtxtUndoLogs<'tcx>, + stalled_goal_generation: &'a mut Option, ) -> TypeVariableTable<'a, 'tcx> { - TypeVariableTable { storage: self, undo_log } + TypeVariableTable { storage: self, undo_log, stalled_goal_generation } } #[inline] @@ -164,6 +166,13 @@ impl<'tcx> TypeVariableStorage<'tcx> { } impl<'tcx> TypeVariableTable<'_, 'tcx> { + #[inline] + fn bump_stalled_goal_generation(&mut self) { + if let Some(generation) = self.stalled_goal_generation.as_mut() { + *generation = generation.wrapping_add(1); + } + } + /// Returns the origin that was given when `vid` was created. /// /// Note that this function does not return care whether @@ -179,7 +188,7 @@ impl<'tcx> TypeVariableTable<'_, 'tcx> { debug_assert!(self.probe(a).is_unknown()); debug_assert!(self.probe(b).is_unknown()); - self.undo_log.bump_stalled_goal_generation(); + self.bump_stalled_goal_generation(); self.eq_relations().union(a, b); self.sub_unification_table().union(a, b); @@ -193,7 +202,7 @@ impl<'tcx> TypeVariableTable<'_, 'tcx> { debug_assert!(self.probe(a).is_unknown()); debug_assert!(self.probe(b).is_unknown()); - self.undo_log.bump_stalled_goal_generation(); + self.bump_stalled_goal_generation(); self.sub_unification_table().union(a, b); } @@ -211,7 +220,7 @@ impl<'tcx> TypeVariableTable<'_, 'tcx> { self.eq_relations().probe_value(vid) ); - self.undo_log.bump_stalled_goal_generation(); + self.bump_stalled_goal_generation(); self.eq_relations().union_value(vid, TypeVariableValue::Known { value: ty }); } From 284efc40d7edc62a1c59d7e49b6aeac942083ec2 Mon Sep 17 00:00:00 2001 From: Amirhossein Akhlaghpour Date: Tue, 1 Sep 2026 13:10:25 +0330 Subject: [PATCH 3/4] refactor stalled goal generation tracking Signed-off-by: Amirhossein Akhlaghpour --- compiler/rustc_infer/src/infer/context.rs | 6 ++-- compiler/rustc_infer/src/infer/mod.rs | 30 ++++++++++++++----- .../src/infer/relate/generalize.rs | 8 ++--- .../src/infer/relate/type_relating.rs | 2 +- .../rustc_infer/src/infer/type_variable.rs | 17 +---------- 5 files changed, 31 insertions(+), 32 deletions(-) diff --git a/compiler/rustc_infer/src/infer/context.rs b/compiler/rustc_infer/src/infer/context.rs index df499d7188642..00a89b618bae1 100644 --- a/compiler/rustc_infer/src/infer/context.rs +++ b/compiler/rustc_infer/src/infer/context.rs @@ -198,7 +198,7 @@ impl<'tcx> rustc_type_ir::InferCtxtLike for InferCtxt<'tcx> { } fn equate_ty_vids_raw(&self, a: ty::TyVid, b: ty::TyVid) { - self.inner.borrow_mut().type_variables().equate(a, b); + self.inner.borrow_mut().equate_ty_vids(a, b); } fn sub_unify_ty_vids_raw(&self, a: ty::TyVid, b: ty::TyVid) { @@ -220,7 +220,7 @@ impl<'tcx> rustc_type_ir::InferCtxtLike for InferCtxt<'tcx> { fn instantiate_ty_var_raw(&self, vid: ty::TyVid, ty: Ty<'tcx>) { let ty = lower_universe(self, self.try_resolve_ty_var(vid).unwrap_err(), ty); - self.inner.borrow_mut().type_variables().instantiate(vid, ty); + self.inner.borrow_mut().instantiate_ty_var(vid, ty); } fn instantiate_const_var_raw(&self, vid: ty::ConstVid, ct: ty::Const<'tcx>) { @@ -461,7 +461,7 @@ impl<'a, 'tcx> ty::TypeFolder> for LowerUniverseFolder<'a, 'tcx> { let origin = inner.type_variables().var_origin(vid); let new_var_id = inner.type_variables().new_var(self.for_universe, origin); - inner.type_variables().equate(vid, new_var_id); + inner.equate_ty_vids(vid, new_var_id); Ty::new_var(self.cx(), new_var_id) } } diff --git a/compiler/rustc_infer/src/infer/mod.rs b/compiler/rustc_infer/src/infer/mod.rs index 14c1e7aec5abb..29c47b1aaa587 100644 --- a/compiler/rustc_infer/src/infer/mod.rs +++ b/compiler/rustc_infer/src/infer/mod.rs @@ -217,7 +217,7 @@ impl<'tcx> InferCtxtInner<'tcx> { #[inline] fn type_variables(&mut self) -> type_variable::TypeVariableTable<'_, 'tcx> { - self.type_variable_storage.with_log(&mut self.undo_log, &mut self.stalled_goal_generation) + self.type_variable_storage.with_log(&mut self.undo_log) } #[inline] @@ -257,6 +257,24 @@ impl<'tcx> InferCtxtInner<'tcx> { } } + #[inline] + fn equate_ty_vids(&mut self, a: ty::TyVid, b: ty::TyVid) { + self.bump_stalled_goal_generation(); + self.type_variables().equate(a, b); + } + + #[inline] + fn sub_unify_ty_vids(&mut self, a: ty::TyVid, b: ty::TyVid) { + self.bump_stalled_goal_generation(); + self.type_variables().sub_unify(a, b); + } + + #[inline] + fn instantiate_ty_var(&mut self, vid: ty::TyVid, ty: Ty<'tcx>) { + self.bump_stalled_goal_generation(); + self.type_variables().instantiate(vid, ty); + } + // These mutations can unblock stalled goals too, so route them through the // same generation bump. #[inline] @@ -1193,9 +1211,7 @@ impl<'tcx> InferCtxt<'tcx> { let ty_sub_vid = self.sub_unification_table_root_var(ty_vid); let inner = &mut *self.inner.borrow_mut(); - let mut type_variables = inner - .type_variable_storage - .with_log(&mut inner.undo_log, &mut inner.stalled_goal_generation); + let mut type_variables = inner.type_variable_storage.with_log(&mut inner.undo_log); inner.opaque_type_storage.iter_opaque_types().any(|(_, hidden_ty)| { if let ty::Infer(ty::TyVar(hidden_vid)) = *hidden_ty.ty.kind() { let opaque_sub_vid = type_variables.sub_unification_table_root_var(hidden_vid); @@ -1224,9 +1240,7 @@ impl<'tcx> InferCtxt<'tcx> { let inner = &mut *self.inner.borrow_mut(); // This is iffy, can't call `type_variables()` as we're already // borrowing the `opaque_type_storage` here. - let mut type_variables = inner - .type_variable_storage - .with_log(&mut inner.undo_log, &mut inner.stalled_goal_generation); + let mut type_variables = inner.type_variable_storage.with_log(&mut inner.undo_log); inner .opaque_type_storage .iter_opaque_types() @@ -1417,7 +1431,7 @@ impl<'tcx> InferCtxt<'tcx> { } pub fn sub_unify_ty_vids_raw(&self, a: ty::TyVid, b: ty::TyVid) { - self.inner.borrow_mut().type_variables().sub_unify(a, b); + self.inner.borrow_mut().sub_unify_ty_vids(a, b); } pub fn sub_unification_table_root_var(&self, var: ty::TyVid) -> ty::TyVid { diff --git a/compiler/rustc_infer/src/infer/relate/generalize.rs b/compiler/rustc_infer/src/infer/relate/generalize.rs index b92199797e17f..a512af1c99c61 100644 --- a/compiler/rustc_infer/src/infer/relate/generalize.rs +++ b/compiler/rustc_infer/src/infer/relate/generalize.rs @@ -245,7 +245,7 @@ impl<'tcx> InferCtxt<'tcx> { match (l, r.kind()) { (TermVid::Ty(l), ty::TermKind::Ty(r)) => { if let Some(r) = r.ty_vid() { - self.inner.borrow_mut().type_variables().equate(l, r) + self.inner.borrow_mut().equate_ty_vids(l, r) } else { // Ideally, we put this assert into `type_variables().instantiate()`. // But we can't pass the infcx into it as the infcx is already @@ -253,7 +253,7 @@ impl<'tcx> InferCtxt<'tcx> { debug_assert!( self.try_resolve_ty_var(l).unwrap_err().can_name(ty::max_universe(self, r)) ); - self.inner.borrow_mut().type_variables().instantiate(l, r) + self.inner.borrow_mut().instantiate_ty_var(l, r) } } (TermVid::Const(l), ty::TermKind::Const(r)) => { @@ -528,7 +528,7 @@ impl<'tcx> TypeRelation> for Generalizer<'_, 'tcx> { // Record that `vid` and `new_var_id` have to be subtypes // of each other. This is currently only used for diagnostics. // To see why, see the docs in the `type_variables` module. - inner.type_variables().sub_unify(vid, new_var_id); + inner.sub_unify_ty_vids(vid, new_var_id); // If we're in the new solver and create a new inference // variable inside of an alias we eagerly constrain that // inference variable to prevent unexpected ambiguity errors. @@ -548,7 +548,7 @@ impl<'tcx> TypeRelation> for Generalizer<'_, 'tcx> { && !self.infcx.typing_mode_raw().is_coherence() && self.in_alias { - inner.type_variables().equate(vid, new_var_id); + inner.equate_ty_vids(vid, new_var_id); } debug!("replacing original vid={:?} with new={:?}", vid, new_var_id); diff --git a/compiler/rustc_infer/src/infer/relate/type_relating.rs b/compiler/rustc_infer/src/infer/relate/type_relating.rs index 7c8e263db5582..d837b91bd492b 100644 --- a/compiler/rustc_infer/src/infer/relate/type_relating.rs +++ b/compiler/rustc_infer/src/infer/relate/type_relating.rs @@ -166,7 +166,7 @@ impl<'tcx> TypeRelation> for TypeRelating<'_, 'tcx> { )); } ty::Invariant => { - infcx.inner.borrow_mut().type_variables().equate(a_id, b_id); + infcx.inner.borrow_mut().equate_ty_vids(a_id, b_id); } ty::Bivariant => { unreachable!("Expected bivariance to be handled in relate_with_variance") diff --git a/compiler/rustc_infer/src/infer/type_variable.rs b/compiler/rustc_infer/src/infer/type_variable.rs index 52baf431aba9f..c5b17c24ed491 100644 --- a/compiler/rustc_infer/src/infer/type_variable.rs +++ b/compiler/rustc_infer/src/infer/type_variable.rs @@ -89,7 +89,6 @@ pub(crate) struct TypeVariableTable<'a, 'tcx> { storage: &'a mut TypeVariableStorage<'tcx>, undo_log: &'a mut InferCtxtUndoLogs<'tcx>, - stalled_goal_generation: &'a mut Option, } #[derive(Copy, Clone, Debug)] @@ -145,9 +144,8 @@ impl<'tcx> TypeVariableStorage<'tcx> { pub(crate) fn with_log<'a>( &'a mut self, undo_log: &'a mut InferCtxtUndoLogs<'tcx>, - stalled_goal_generation: &'a mut Option, ) -> TypeVariableTable<'a, 'tcx> { - TypeVariableTable { storage: self, undo_log, stalled_goal_generation } + TypeVariableTable { storage: self, undo_log } } #[inline] @@ -166,13 +164,6 @@ impl<'tcx> TypeVariableStorage<'tcx> { } impl<'tcx> TypeVariableTable<'_, 'tcx> { - #[inline] - fn bump_stalled_goal_generation(&mut self) { - if let Some(generation) = self.stalled_goal_generation.as_mut() { - *generation = generation.wrapping_add(1); - } - } - /// Returns the origin that was given when `vid` was created. /// /// Note that this function does not return care whether @@ -188,8 +179,6 @@ impl<'tcx> TypeVariableTable<'_, 'tcx> { debug_assert!(self.probe(a).is_unknown()); debug_assert!(self.probe(b).is_unknown()); - self.bump_stalled_goal_generation(); - self.eq_relations().union(a, b); self.sub_unification_table().union(a, b); } @@ -202,8 +191,6 @@ impl<'tcx> TypeVariableTable<'_, 'tcx> { debug_assert!(self.probe(a).is_unknown()); debug_assert!(self.probe(b).is_unknown()); - self.bump_stalled_goal_generation(); - self.sub_unification_table().union(a, b); } @@ -220,8 +207,6 @@ impl<'tcx> TypeVariableTable<'_, 'tcx> { self.eq_relations().probe_value(vid) ); - self.bump_stalled_goal_generation(); - self.eq_relations().union_value(vid, TypeVariableValue::Known { value: ty }); } From 7bb0fcb171ed8dcc0d0281e6c6326ad3ec0c15d9 Mon Sep 17 00:00:00 2001 From: Amirhossein Akhlaghpour Date: Sun, 6 Sep 2026 14:41:59 +0330 Subject: [PATCH 4/4] route const generalization union through generation bump Signed-off-by: Amirhossein Akhlaghpour --- compiler/rustc_infer/src/infer/relate/generalize.rs | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/compiler/rustc_infer/src/infer/relate/generalize.rs b/compiler/rustc_infer/src/infer/relate/generalize.rs index a512af1c99c61..7e49b2cbc2716 100644 --- a/compiler/rustc_infer/src/infer/relate/generalize.rs +++ b/compiler/rustc_infer/src/infer/relate/generalize.rs @@ -657,8 +657,8 @@ impl<'tcx> TypeRelation> for Generalizer<'_, 'tcx> { } let mut inner = self.infcx.inner.borrow_mut(); - let variable_table = &mut inner.const_unification_table(); - match variable_table.probe_value(vid) { + let vid_value = inner.const_unification_table().probe_value(vid); + match vid_value { ConstVariableValue::Known { value: u } => { drop(inner); self.relate(u, u) @@ -667,7 +667,8 @@ impl<'tcx> TypeRelation> for Generalizer<'_, 'tcx> { if self.for_universe.can_name(universe) { Ok(c) } else { - let new_var_id = variable_table + let new_var_id = inner + .const_unification_table() .new_key(ConstVariableValue::Unknown { origin, universe: self.for_universe, @@ -680,7 +681,7 @@ impl<'tcx> TypeRelation> for Generalizer<'_, 'tcx> { && !self.infcx.typing_mode_raw().is_coherence() && self.in_alias { - variable_table.union(vid, new_var_id); + inner.equate_const_vids(vid, new_var_id); } Ok(ty::Const::new_var(tcx, new_var_id)) }