diff --git a/compiler/rustc_infer/src/infer/canonical/query_response.rs b/compiler/rustc_infer/src/infer/canonical/query_response.rs
index 3a245a5b25759..4a94a2a48635b 100644
--- a/compiler/rustc_infer/src/infer/canonical/query_response.rs
+++ b/compiler/rustc_infer/src/infer/canonical/query_response.rs
@@ -155,13 +155,7 @@ impl<'tcx> InferCtxt<'tcx> {
         });
         debug!(?region_constraints);
 
-        let opaque_types = self
-            .inner
-            .borrow_mut()
-            .opaque_type_storage
-            .take_opaque_types()
-            .map(|(k, v)| (k, v.ty))
-            .collect();
+        let opaque_types = self.take_opaque_types().into_iter().map(|(k, v)| (k, v.ty)).collect();
 
         Ok(QueryResponse {
             var_values: inference_vars,
diff --git a/compiler/rustc_infer/src/infer/context.rs b/compiler/rustc_infer/src/infer/context.rs
index 4d90e60736995..721801fe3f2c1 100644
--- a/compiler/rustc_infer/src/infer/context.rs
+++ b/compiler/rustc_infer/src/infer/context.rs
@@ -195,7 +195,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) {
@@ -203,30 +203,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>>(
@@ -247,11 +244,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>>(
@@ -380,10 +377,10 @@ impl<'tcx> rustc_type_ir::InferCtxtLike for InferCtxt<'tcx> {
         hidden_ty: Ty<'tcx>,
         span: Span,
     ) {
-        self.inner
-            .borrow_mut()
-            .opaque_types()
-            .add_duplicate(opaque_type_key, ty::ProvisionalHiddenType { span, ty: hidden_ty })
+        self.inner.borrow_mut().add_duplicate_opaque_type(
+            opaque_type_key,
+            ty::ProvisionalHiddenType { span, ty: hidden_ty },
+        )
     }
 
     fn reset_opaque_types(&self) {
@@ -461,7 +458,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)
                         }
                     }
@@ -501,7 +498,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 267c36652656d..24cef2a6df4b7 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.
@@ -171,9 +176,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(),
@@ -222,6 +228,26 @@ impl<'tcx> InferCtxtInner<'tcx> {
         self.opaque_type_storage.with_log(&mut self.undo_log)
     }
 
+    #[inline]
+    fn register_opaque_type(
+        &mut self,
+        key: OpaqueTypeKey<'tcx>,
+        hidden_type: ProvisionalHiddenType<'tcx>,
+    ) -> Option<Ty<'tcx>> {
+        self.bump_stalled_goal_generation();
+        self.opaque_types().register(key, hidden_type)
+    }
+
+    #[inline]
+    fn add_duplicate_opaque_type(
+        &mut self,
+        key: OpaqueTypeKey<'tcx>,
+        hidden_type: ProvisionalHiddenType<'tcx>,
+    ) {
+        self.bump_stalled_goal_generation();
+        self.opaque_types().add_duplicate(key, hidden_type);
+    }
+
     #[inline]
     fn int_unification_table(&mut self) -> UnificationTable<'_, 'tcx, ty::IntVid> {
         self.int_unification_storage.with_log(&mut self.undo_log)
@@ -237,6 +263,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
@@ -684,7 +783,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(),
@@ -1121,7 +1220,13 @@ impl<'tcx> InferCtxt<'tcx> {
 
     #[instrument(level = "debug", skip(self), ret)]
     pub fn take_opaque_types(&self) -> Vec<(OpaqueTypeKey<'tcx>, ProvisionalHiddenType<'tcx>)> {
-        self.inner.borrow_mut().opaque_type_storage.take_opaque_types().collect()
+        let inner = &mut *self.inner.borrow_mut();
+
+        if !inner.opaque_type_storage.is_empty() {
+            inner.bump_stalled_goal_generation();
+        }
+
+        inner.opaque_type_storage.take_opaque_types().collect()
     }
 
     #[instrument(level = "debug", skip(self), ret)]
@@ -1379,7 +1484,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 {
@@ -1713,6 +1818,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/opaque_types/mod.rs b/compiler/rustc_infer/src/infer/opaque_types/mod.rs
index 3cca843157b8f..2c1bd1d66c666 100644
--- a/compiler/rustc_infer/src/infer/opaque_types/mod.rs
+++ b/compiler/rustc_infer/src/infer/opaque_types/mod.rs
@@ -204,7 +204,7 @@ impl<'tcx> InferCtxt<'tcx> {
         opaque_type_key: OpaqueTypeKey<'tcx>,
         hidden_ty: ProvisionalHiddenType<'tcx>,
     ) -> Option<Ty<'tcx>> {
-        self.inner.borrow_mut().opaque_types().register(opaque_type_key, hidden_ty)
+        self.inner.borrow_mut().register_opaque_type(opaque_type_key, hidden_ty)
     }
 
     /// Insert a hidden type into the opaque type storage, equating it
@@ -238,11 +238,10 @@ impl<'tcx> InferCtxt<'tcx> {
                 goals.push(Goal::new(tcx, param_env, ty::PredicateKind::Ambiguous));
             }
             ty::TypingMode::Typeck { .. } => {
-                let prev = self
-                    .inner
-                    .borrow_mut()
-                    .opaque_types()
-                    .register(opaque_type_key, ProvisionalHiddenType { ty: hidden_ty, span });
+                let prev = self.inner.borrow_mut().register_opaque_type(
+                    opaque_type_key,
+                    ProvisionalHiddenType { ty: hidden_ty, span },
+                );
                 if let Some(prev) = prev {
                     goals.extend(
                         self.at(&ObligationCause::dummy_with_span(span), param_env)
@@ -254,11 +253,10 @@ impl<'tcx> InferCtxt<'tcx> {
                 }
             }
             ty::TypingMode::PostTypeckUntilBorrowck { .. } => {
-                let prev = self
-                    .inner
-                    .borrow_mut()
-                    .opaque_types()
-                    .register(opaque_type_key, ProvisionalHiddenType { ty: hidden_ty, span });
+                let prev = self.inner.borrow_mut().register_opaque_type(
+                    opaque_type_key,
+                    ProvisionalHiddenType { ty: hidden_ty, span },
+                );
 
                 // We either equate the new hidden type with the previous entry or with the type
                 // inferred by HIR typeck.
diff --git a/compiler/rustc_infer/src/infer/relate/generalize.rs b/compiler/rustc_infer/src/infer/relate/generalize.rs
index 69ced9d3acb40..be4bf83e578fb 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 2b1ac29173483..42132edda6357 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 ()>,
 }
 
@@ -149,6 +150,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.
@@ -175,9 +177,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 c74cc92e7d006..75671446342eb 100644
--- a/compiler/rustc_infer/src/infer/type_variable.rs
+++ b/compiler/rustc_infer/src/infer/type_variable.rs
@@ -177,6 +177,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);
     }
@@ -188,6 +189,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);
     }
 
@@ -203,6 +205,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 7d3c0a4a6c1f1..ac1d9b56fd3b4 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,12 @@ 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 every pending goal stays stalled until the generation changes.
+    all_goals_known_to_be_stalled: bool,
+
     _errors: PhantomData<E>,
 }
 
@@ -99,13 +106,26 @@ 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,
+            all_goals_known_to_be_stalled: true,
             _errors: PhantomData,
         }
     }
 
+    fn goal_is_known_to_be_stalled(stalled_on: &GoalStalledOn<TyCtxt<'tcx>>) -> bool {
+        // Registering or removing an opaque bumps the generation. A goal that
+        // observed an empty storage therefore remains stalled until it changes.
+        matches!(
+            stalled_on.opaques,
+            GoalStalledOnOpaques::No | GoalStalledOnOpaques::Yes { num_opaques_in_storage: 0, .. }
+        )
+    }
+
     fn inspect_evaluated_obligation(
         infcx: &InferCtxt<'tcx>,
         obligation: &PredicateObligation<'tcx>,
@@ -142,10 +162,14 @@ where
             match certainty {
                 Certainty::Yes => {}
                 Certainty::Maybe(_) => {
+                    self.all_goals_known_to_be_stalled &=
+                        stalled_on.as_ref().is_some_and(Self::goal_is_known_to_be_stalled);
+
                     self.obligations.register(obligation, stalled_on);
                 }
             }
         } else {
+            self.all_goals_known_to_be_stalled = false;
             self.obligations.register(obligation, None);
         }
     }
@@ -166,8 +190,27 @@ 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.all_goals_known_to_be_stalled = true;
+            return errors;
+        }
+
+        if !infcx.tcx.disable_trait_solver_fast_paths()
+            && self.all_goals_known_to_be_stalled
+            && self.last_stalled_goal_generation == generation
+        {
+            return errors;
+        }
+
         loop {
+            let pass_generation = infcx.stalled_goal_generation();
+
             let mut any_changed = false;
+            let mut all_goals_known_to_be_stalled = true;
 
             self.obligations.pending.retain_mut(|(obligation, opt_stalled_on)| {
                 // Common case: still stalled; keep the obligation. This path is extremely hot in
@@ -175,6 +218,8 @@ where
                 if let Some(stalled_on) = opt_stalled_on
                     && delegate.goal_remains_stalled(stalled_on)
                 {
+                    all_goals_known_to_be_stalled &= Self::goal_is_known_to_be_stalled(stalled_on);
+
                     return true;
                 }
 
@@ -250,12 +295,16 @@ where
                         // Update `opt_stalled_on` goal, for the next retain_mut, because we are
                         // running until a fixpoint.
                         *opt_stalled_on = stalled_on;
+
+                        all_goals_known_to_be_stalled &=
+                            opt_stalled_on.as_ref().is_some_and(Self::goal_is_known_to_be_stalled);
                         true
                     }
                 }
             });
-
             if !any_changed {
+                self.all_goals_known_to_be_stalled = all_goals_known_to_be_stalled;
+                self.last_stalled_goal_generation = pass_generation;
                 break;
             }
         }
diff --git a/tests/ui/traits/next-solver/stalled-goal-opaque-invalidation.rs b/tests/ui/traits/next-solver/stalled-goal-opaque-invalidation.rs
new file mode 100644
index 0000000000000..2af9a097aa99e
--- /dev/null
+++ b/tests/ui/traits/next-solver/stalled-goal-opaque-invalidation.rs
@@ -0,0 +1,14 @@
+//@ check-pass
+//@ edition: 2021
+//@ compile-flags: -Znext-solver
+
+// A recursive non-defining use of the async fn opaque relies on the
+// registered opaque type to guide inference for the recursive result.
+async fn mirror<T>(t: T) -> T {
+    let value = Box::pin(mirror(String::new())).await;
+    let _ = value.len();
+
+    t
+}
+
+fn main() {}