fix 158441 and unify old and new solver code for ty_or_const_infer_var_changed.

Author: jdonszelmann

compiler/rustc_infer/src/infer/context.rs

@@ -132,31 +132,8 @@ impl<'tcx> rustc_type_ir::InferCtxtLike for InferCtxt<'tcx> {
         self.inner.borrow_mut().unwrap_region_constraints().opportunistic_resolve_var(self.tcx, vid)
     }
 
-    fn is_changed_var(&self, var: TyOrConstInferVar) -> bool {
-        match var {
-            TyOrConstInferVar::Ty(vid) => !self
-                .try_resolve_ty_var_with_root_vid(vid)
-                .is_err_and(|(root_vid, _)| root_vid == vid),
-            TyOrConstInferVar::TyInt(vid) => {
-                let mut inner = self.inner.borrow_mut();
-                !matches!(
-                    inner.int_unification_table().probe_value(vid),
-                    ty::IntVarValue::Unknown
-                        if inner.int_unification_table().find(vid) == vid
-                )
-            }
-            TyOrConstInferVar::TyFloat(vid) => {
-                let mut inner = self.inner.borrow_mut();
-                !matches!(
-                    inner.float_unification_table().probe_value(vid),
-                    ty::FloatVarValue::Unknown
-                        if inner.float_unification_table().find(vid) == vid
-                )
-            }
-            TyOrConstInferVar::Const(vid) => {
-                !self.try_resolve_const_var(vid).is_err_and(|_| self.root_const_var(vid) == vid)
-            }
-        }
+    fn ty_or_const_infer_var_changed(&self, var: TyOrConstInferVar) -> bool {
+        self.ty_or_const_infer_var_changed(var)
     }
 
     fn next_region_infer(&self) -> ty::Region<'tcx> {

compiler/rustc_infer/src/infer/mod.rs

@@ -1210,7 +1210,8 @@ impl<'tcx> InferCtxt<'tcx> {
     }
 
     /// If `TyVar(vid)` resolves to a type, return that type. Else, return the
-    /// universe index of `TyVar(vid)`.
+    /// universe index of `TyVar(vid)`, along with the root vid, which can be
+    /// cheaply found at the same time.
     pub fn try_resolve_ty_var_with_root_vid(
         &self,
         vid: TyVid,
@@ -1576,14 +1577,13 @@ impl<'tcx> InferCtxt<'tcx> {
     #[inline(always)]
     pub fn ty_or_const_infer_var_changed(&self, infer_var: TyOrConstInferVar) -> bool {
         match infer_var {
-            TyOrConstInferVar::Ty(v) => {
-                use self::type_variable::TypeVariableValue;
-
-                // If `inlined_probe` returns a `Known` value, it never equals
-                // `ty::Infer(ty::TyVar(v))`.
-                match self.inner.borrow_mut().type_variables().inlined_probe(v) {
-                    TypeVariableValue::Unknown { .. } => false,
-                    TypeVariableValue::Known { .. } => true,
+            TyOrConstInferVar::Ty(vid) => {
+                // If `try_resolve_ty_var` returns `Err`, *and* the `root_vid` is unchanged,
+                // it's definitely unchanged. The check against `root_vid` matters, see
+                // https://github.com/rust-lang/rust/issues/158441
+                match self.try_resolve_ty_var_with_root_vid(vid) {
+                    Ok(_) => true,
+                    Err((root_vid, _)) => root_vid != vid,
                 }
             }
 

compiler/rustc_next_trait_solver/src/solve/eval_ctxt/fast_path.rs

@@ -51,7 +51,7 @@ where
 
     // If any of the stalled goal's generic arguments changed,
     // rerunning might make progress so we should rerun.
-    if stalled_vars.iter().any(|value| delegate.is_changed_var(*value)) {
+    if stalled_vars.iter().any(|value| delegate.ty_or_const_infer_var_changed(*value)) {
         return MayMakeProgress;
     }
 

compiler/rustc_type_ir/src/infer_ctxt.rs

@@ -391,7 +391,7 @@ pub trait InferCtxtLike: Sized {
         vid: ty::RegionVid,
     ) -> <Self::Interner as Interner>::Region;
 
-    fn is_changed_var(&self, var: TyOrConstInferVar) -> bool;
+    fn ty_or_const_infer_var_changed(&self, var: TyOrConstInferVar) -> bool;
 
     fn next_region_infer(&self) -> <Self::Interner as Interner>::Region;
     fn next_ty_infer(&self) -> <Self::Interner as Interner>::Ty;