From 3cd1f7d0d30cf8a885d584258ad120f6a8355822 Mon Sep 17 00:00:00 2001 From: Amirhossein Akhlaghpour Date: Thu, 27 Aug 2026 19:14:00 +0330 Subject: [PATCH 1/5] 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 | 92 ++++++++++++++++++- 6 files changed, 186 insertions(+), 20 deletions(-) diff --git a/compiler/rustc_infer/src/infer/context.rs b/compiler/rustc_infer/src/infer/context.rs index f9b08efad88cf..1a18687a3aa04 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 ad469ac8f86d3..a74aa62904542 100644 --- a/compiler/rustc_infer/src/infer/mod.rs +++ b/compiler/rustc_infer/src/infer/mod.rs @@ -172,9 +172,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(), @@ -238,6 +238,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 @@ -685,7 +723,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(), @@ -1656,6 +1694,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 35d04597451c0..ce7e1998eec9c 100644 --- a/compiler/rustc_infer/src/infer/relate/generalize.rs +++ b/compiler/rustc_infer/src/infer/relate/generalize.rs @@ -259,17 +259,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 2b1ac29173483..6609b85102991 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 ()>, } @@ -103,6 +104,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 @@ -149,6 +151,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. @@ -175,9 +178,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 7d3c0a4a6c1f1..47aa7b1194526 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; @@ -49,6 +50,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, } @@ -99,13 +111,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>, @@ -142,10 +174,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); } } @@ -166,8 +210,34 @@ 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 all_pending_trackable = true; + let mut stalled_on_empty_opaques = false; self.obligations.pending.retain_mut(|(obligation, opt_stalled_on)| { // Common case: still stalled; keep the obligation. This path is extremely hot in @@ -175,6 +245,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; } @@ -250,12 +325,27 @@ 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 !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 774620b3e2121c307aab9449e075d71b3f5427da Mon Sep 17 00:00:00 2001 From: Amirhossein Akhlaghpour Date: Mon, 31 Aug 2026 19:18:58 +0330 Subject: [PATCH 2/5] 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 a74aa62904542..10d260ddaf56e 100644 --- a/compiler/rustc_infer/src/infer/mod.rs +++ b/compiler/rustc_infer/src/infer/mod.rs @@ -98,6 +98,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. @@ -174,7 +179,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(), @@ -215,7 +221,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] @@ -238,41 +244,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 }); } @@ -1175,7 +1198,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); @@ -1204,7 +1229,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() @@ -1698,7 +1725,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 6609b85102991..42132edda6357 100644 --- a/compiler/rustc_infer/src/infer/snapshot/undo_log.rs +++ b/compiler/rustc_infer/src/infer/snapshot/undo_log.rs @@ -104,7 +104,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 @@ -151,7 +150,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. @@ -178,32 +177,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 84b1b61ec9271f67b10217c616c562ed3602a086 Mon Sep 17 00:00:00 2001 From: Amirhossein Akhlaghpour Date: Tue, 1 Sep 2026 13:10:25 +0330 Subject: [PATCH 3/5] 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 1a18687a3aa04..70212ace6ec23 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 10d260ddaf56e..83d98bcd6db16 100644 --- a/compiler/rustc_infer/src/infer/mod.rs +++ b/compiler/rustc_infer/src/infer/mod.rs @@ -221,7 +221,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] @@ -261,6 +261,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] @@ -1198,9 +1216,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); @@ -1229,9 +1245,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() @@ -1422,7 +1436,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 ce7e1998eec9c..7699ca4ae575d 100644 --- a/compiler/rustc_infer/src/infer/relate/generalize.rs +++ b/compiler/rustc_infer/src/infer/relate/generalize.rs @@ -246,7 +246,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 @@ -254,7 +254,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)) => { @@ -529,7 +529,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. @@ -549,7 +549,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 72a202b87a441eeb813364f40c7acb933a9e0087 Mon Sep 17 00:00:00 2001 From: Amirhossein Akhlaghpour Date: Sun, 6 Sep 2026 14:41:59 +0330 Subject: [PATCH 4/5] 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 7699ca4ae575d..2bb75474a3bfb 100644 --- a/compiler/rustc_infer/src/infer/relate/generalize.rs +++ b/compiler/rustc_infer/src/infer/relate/generalize.rs @@ -658,8 +658,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) @@ -668,7 +668,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, @@ -681,7 +682,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)) } From 317506a8a66dfed86d9b61406f675e34486ed857 Mon Sep 17 00:00:00 2001 From: Amirhossein Akhlaghpour Date: Wed, 16 Sep 2026 13:40:19 +0330 Subject: [PATCH 5/5] document invariant behind next solver candidate merging Signed-off-by: Amirhossein Akhlaghpour --- compiler/rustc_next_trait_solver/src/solve/mod.rs | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/compiler/rustc_next_trait_solver/src/solve/mod.rs b/compiler/rustc_next_trait_solver/src/solve/mod.rs index 8d20bcf4c7a6d..15fe11cd7f990 100644 --- a/compiler/rustc_next_trait_solver/src/solve/mod.rs +++ b/compiler/rustc_next_trait_solver/src/solve/mod.rs @@ -301,6 +301,16 @@ where { /// Try to merge multiple possible ways to prove a goal, if that is not possible returns `None`. /// + /// Candidate merging assumes that candidate-source-specific preferences + /// have already been handled before candidate sets reach this point. for + /// example trait candidate selection handles specialization and builtin + /// versus impl preferences before merging. here we only merge candidates + /// based on their canonical responses. + /// + /// An always applicable candidate can be selected early when it does not + /// introduce any inference variables or external constraints since the + /// remaining candidates cannot change the final response. + /// /// In this case we tend to flounder and return ambiguity by calling `[EvalCtxt::flounder]`. #[instrument(level = "trace", skip(self), ret)] fn try_merge_candidates(