diff --git a/compiler/rustc_infer/src/infer/context.rs b/compiler/rustc_infer/src/infer/context.rs
index e6ddbd879f9b9..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) {
@@ -206,30 +206,27 @@ 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>) {
         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>) {
         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<R: PredicateEmittingRelation<Self>>(
@@ -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<R: PredicateEmittingRelation<Self>>(
@@ -464,7 +461,7 @@ impl<'a, 'tcx> ty::TypeFolder<TyCtxt<'tcx>> 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)
                         }
                     }
@@ -504,7 +501,7 @@ impl<'a, 'tcx> ty::TypeFolder<TyCtxt<'tcx>> 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..29c47b1aaa587 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<u64>,
+
     /// Cache for projections.
     ///
     /// This cache is snapshotted along with the infcx.
@@ -168,9 +173,10 @@ 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(),
+            stalled_goal_generation: next_trait_solver.then_some(0),
 
             projection_cache: Default::default(),
             type_variable_storage: Default::default(),
@@ -234,6 +240,79 @@ impl<'tcx> InferCtxtInner<'tcx> {
         self.const_unification_storage.with_log(&mut self.undo_log)
     }
 
+    #[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<u64> {
+        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);
+        }
+    }
+
+    #[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]
+    fn equate_int_vids(&mut self, a: ty::IntVid, b: ty::IntVid) {
+        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.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.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.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.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.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 +760,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(),
@@ -1352,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 {
@@ -1651,6 +1730,14 @@ impl<'tcx> InferCtxt<'tcx> {
         self.typing_env(param_env).as_query_input(value)
     }
 
+    #[inline]
+    pub fn stalled_goal_generation(&self) -> u64 {
+        self.inner
+            .borrow()
+            .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..7e49b2cbc2716 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,22 +253,19 @@ 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)) => {
                 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:?}"),
@@ -531,7 +528,7 @@ impl<'tcx> TypeRelation<TyCtxt<'tcx>> 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.
@@ -551,7 +548,7 @@ impl<'tcx> TypeRelation<TyCtxt<'tcx>> 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);
@@ -660,8 +657,8 @@ impl<'tcx> TypeRelation<TyCtxt<'tcx>> 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)
@@ -670,7 +667,8 @@ impl<'tcx> TypeRelation<TyCtxt<'tcx>> 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,
@@ -683,7 +681,7 @@ impl<'tcx> TypeRelation<TyCtxt<'tcx>> 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))
                         }
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<TyCtxt<'tcx>> 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/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 fe697eb4c01ac..90ebc5b1cd778 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<u64>,
     _marker: PhantomData<&'tcx ()>,
 }
 
@@ -158,6 +159,7 @@ impl<'tcx> InferCtxtInner<'tcx> {
         }
 
         self.type_variable_storage.finalize_rollback();
+        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.
@@ -184,9 +186,12 @@ impl<'tcx> InferCtxtInner<'tcx> {
 }
 
 impl<'tcx> InferCtxtUndoLogs<'tcx> {
-    pub(crate) fn start_snapshot(&mut self) -> Snapshot<'tcx> {
+    pub(crate) fn start_snapshot(
+        &mut self,
+        stalled_goal_generation: Option<u64>,
+    ) -> Snapshot<'tcx> {
         self.num_open_snapshots += 1;
-        Snapshot { undo_len: self.logs.len(), _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 be0ac72d85675..c5b17c24ed491 100644
--- a/compiler/rustc_infer/src/infer/type_variable.rs
+++ b/compiler/rustc_infer/src/infer/type_variable.rs
@@ -178,6 +178,7 @@ 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.eq_relations().union(a, b);
         self.sub_unification_table().union(a, b);
     }
@@ -189,6 +190,7 @@ 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.sub_unification_table().union(a, b);
     }
 
@@ -204,6 +206,7 @@ impl<'tcx> TypeVariableTable<'_, 'tcx> {
             "instantiating type variable `{vid:?}` twice: new-value = {ty:?}, old-value={:?}",
             self.eq_relations().probe_value(vid)
         );
+
         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<E>,
 }
 
@@ -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<TyCtxt<'tcx>>,
+        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;
             }
         }