Auto merge of rust-lang#154308 - ShoyuVanilla:undo-fudge-iv, r=jieyouxu

Revert rust-lang#151380 and rust-lang#153869

cc https://rust-lang.zulipchat.com/#narrow/channel/474880-t-compiler.2Fbackports/topic/.23153869.3A.20beta-nominated/with/581306395

r? ghost

Author: bors

Cargo.lock

@@ -1296,9 +1296,9 @@ dependencies = [
 
 [[package]]
 name = "ena"
-version = "0.14.4"
+version = "0.14.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eabffdaee24bd1bf95c5ef7cec31260444317e72ea56c4c91750e8b7ee58d5f1"
+checksum = "3d248bdd43ce613d87415282f69b9bb99d947d290b10962dd6c56233312c2ad5"
 dependencies = [
  "log",
 ]

compiler/rustc_data_structures/Cargo.toml

@@ -9,7 +9,7 @@ arrayvec = { version = "0.7", default-features = false }
 bitflags = "2.4.1"
 either = "1.0"
 elsa = "1.11.0"
-ena = "0.14.4"
+ena = "0.14.3"
 indexmap = "2.12.1"
 jobserver_crate = { version = "0.1.28", package = "jobserver" }
 measureme = "12.0.1"

compiler/rustc_hir_typeck/src/expr.rs

@@ -1871,7 +1871,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 if !ocx.try_evaluate_obligations().is_empty() {
                     return Err(TypeError::Mismatch);
                 }
-                Ok(adt_ty)
+                Ok(self.resolve_vars_if_possible(adt_ty))
             })
             .ok()
         });

compiler/rustc_hir_typeck/src/fallback.rs

@@ -357,6 +357,11 @@ impl<'tcx> FnCtxt<'_, 'tcx> {
         VecGraph::new(num_ty_vars, coercion_edges)
     }
 
+    /// If `ty` is an unresolved type variable, returns its root vid.
+    fn root_vid(&self, ty: Ty<'tcx>) -> Option<ty::TyVid> {
+        Some(self.root_var(self.shallow_resolve(ty).ty_vid()?))
+    }
+
     /// Given a set of diverging vids and coercions, walk the HIR to gather a
     /// set of suggestions which can be applied to preserve fallback to unit.
     fn try_to_suggest_annotations(

compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs

@@ -276,7 +276,12 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 
                     // Record all the argument types, with the args
                     // produced from the above subtyping unification.
-                    Ok(Some(formal_input_tys.to_vec()))
+                    Ok(Some(
+                        formal_input_tys
+                            .iter()
+                            .map(|&ty| self.resolve_vars_if_possible(ty))
+                            .collect(),
+                    ))
                 })
                 .ok()
             })

compiler/rustc_infer/src/infer/mod.rs

@@ -1099,45 +1099,22 @@ impl<'tcx> InferCtxt<'tcx> {
                     //
                     // Note: if these two lines are combined into one we get
                     // dynamic borrow errors on `self.inner`.
-                    let (root_vid, value) =
-                        self.inner.borrow_mut().type_variables().probe_with_root_vid(v);
-                    value.known().map_or_else(
-                        || if root_vid == v { ty } else { Ty::new_var(self.tcx, root_vid) },
-                        |t| self.shallow_resolve(t),
-                    )
+                    let known = self.inner.borrow_mut().type_variables().probe(v).known();
+                    known.map_or(ty, |t| self.shallow_resolve(t))
                 }
 
                 ty::IntVar(v) => {
-                    let (root, value) =
-                        self.inner.borrow_mut().int_unification_table().inlined_probe_key_value(v);
-                    match value {
+                    match self.inner.borrow_mut().int_unification_table().probe_value(v) {
                         ty::IntVarValue::IntType(ty) => Ty::new_int(self.tcx, ty),
                         ty::IntVarValue::UintType(ty) => Ty::new_uint(self.tcx, ty),
-                        ty::IntVarValue::Unknown => {
-                            if root == v {
-                                ty
-                            } else {
-                                Ty::new_int_var(self.tcx, root)
-                            }
-                        }
+                        ty::IntVarValue::Unknown => ty,
                     }
                 }
 
                 ty::FloatVar(v) => {
-                    let (root, value) = self
-                        .inner
-                        .borrow_mut()
-                        .float_unification_table()
-                        .inlined_probe_key_value(v);
-                    match value {
+                    match self.inner.borrow_mut().float_unification_table().probe_value(v) {
                         ty::FloatVarValue::Known(ty) => Ty::new_float(self.tcx, ty),
-                        ty::FloatVarValue::Unknown => {
-                            if root == v {
-                                ty
-                            } else {
-                                Ty::new_float_var(self.tcx, root)
-                            }
-                        }
+                        ty::FloatVarValue::Unknown => ty,
                     }
                 }
 
@@ -1151,16 +1128,13 @@ impl<'tcx> InferCtxt<'tcx> {
     pub fn shallow_resolve_const(&self, ct: ty::Const<'tcx>) -> ty::Const<'tcx> {
         match ct.kind() {
             ty::ConstKind::Infer(infer_ct) => match infer_ct {
-                InferConst::Var(vid) => {
-                    let (root, value) = self
-                        .inner
-                        .borrow_mut()
-                        .const_unification_table()
-                        .inlined_probe_key_value(vid);
-                    value.known().unwrap_or_else(|| {
-                        if root.vid == vid { ct } else { ty::Const::new_var(self.tcx, root.vid) }
-                    })
-                }
+                InferConst::Var(vid) => self
+                    .inner
+                    .borrow_mut()
+                    .const_unification_table()
+                    .probe_value(vid)
+                    .known()
+                    .unwrap_or(ct),
                 InferConst::Fresh(_) => ct,
             },
             ty::ConstKind::Param(_)
@@ -1184,13 +1158,6 @@ impl<'tcx> InferCtxt<'tcx> {
         self.inner.borrow_mut().type_variables().root_var(var)
     }
 
-    /// If `ty` is an unresolved type variable, returns its root vid.
-    pub fn root_vid(&self, ty: Ty<'tcx>) -> Option<ty::TyVid> {
-        let (root, value) =
-            self.inner.borrow_mut().type_variables().inlined_probe_with_vid(ty.ty_vid()?);
-        value.is_unknown().then_some(root)
-    }
-
     pub fn sub_unify_ty_vids_raw(&self, a: ty::TyVid, b: ty::TyVid) {
         self.inner.borrow_mut().type_variables().sub_unify(a, b);
     }
@@ -1250,36 +1217,6 @@ impl<'tcx> InferCtxt<'tcx> {
         value.fold_with(&mut r)
     }
 
-    /// Normally, we shallow-resolve unresolved type variables to their root
-    /// variables. This is mainly done for performance reasons, and in most
-    /// cases resolving to the root variable (instead of the variable itself)
-    /// does not affect type inference.
-    ///
-    /// However, there is an exceptional case: *fudging*. Fudging is intended
-    /// to guide inference rather than impose hard requirements. But our current
-    /// handling here is somewhat janky.
-    ///
-    /// In particular, inference variables that are considered equal within the
-    /// fudging scope may not remain equal outside of it. This makes it observable
-    /// which inference variable we resolve to. For backwards compatibility, we
-    /// avoid resolving to the root variable by using this function inside the
-    /// fudge instead of [`InferCtxt::resolve_vars_if_possible`].
-    ///
-    /// See #153869 for more details.
-    pub fn resolve_vars_if_possible_for_fudging<T>(&self, value: T) -> T
-    where
-        T: TypeFoldable<TyCtxt<'tcx>>,
-    {
-        if let Err(guar) = value.error_reported() {
-            self.set_tainted_by_errors(guar);
-        }
-        if !value.has_non_region_infer() {
-            return value;
-        }
-        let mut r = resolve::OpportunisticVarResolver::new_for_fudging(self);
-        value.fold_with(&mut r)
-    }
-
     pub fn resolve_numeric_literals_with_default<T>(&self, value: T) -> T
     where
         T: TypeFoldable<TyCtxt<'tcx>>,

compiler/rustc_infer/src/infer/resolve.rs

@@ -17,9 +17,6 @@ use crate::infer::TyOrConstInferVar;
 /// points for correctness.
 pub struct OpportunisticVarResolver<'a, 'tcx> {
     infcx: &'a InferCtxt<'tcx>,
-    /// If true, we don't resolve ty/const vars to their roots.
-    /// See comments on [`InferCtxt::resolve_vars_if_possible_for_fudging`]
-    for_fudging: bool,
     /// We're able to use a cache here as the folder does
     /// not have any mutable state.
     cache: DelayedMap<Ty<'tcx>, Ty<'tcx>>,
@@ -28,12 +25,7 @@ pub struct OpportunisticVarResolver<'a, 'tcx> {
 impl<'a, 'tcx> OpportunisticVarResolver<'a, 'tcx> {
     #[inline]
     pub fn new(infcx: &'a InferCtxt<'tcx>) -> Self {
-        OpportunisticVarResolver { infcx, for_fudging: false, cache: Default::default() }
-    }
-
-    #[inline]
-    pub fn new_for_fudging(infcx: &'a InferCtxt<'tcx>) -> Self {
-        OpportunisticVarResolver { infcx, for_fudging: true, cache: Default::default() }
+        OpportunisticVarResolver { infcx, cache: Default::default() }
     }
 }
 
@@ -51,7 +43,6 @@ impl<'a, 'tcx> TypeFolder<TyCtxt<'tcx>> for OpportunisticVarResolver<'a, 'tcx> {
         } else {
             let shallow = self.infcx.shallow_resolve(t);
             let res = shallow.super_fold_with(self);
-            let res = if self.for_fudging && res.is_ty_var() { t } else { res };
             assert!(self.cache.insert(t, res));
             res
         }
@@ -61,11 +52,8 @@ impl<'a, 'tcx> TypeFolder<TyCtxt<'tcx>> for OpportunisticVarResolver<'a, 'tcx> {
         if !ct.has_non_region_infer() {
             ct // micro-optimize -- if there is nothing in this const that this fold affects...
         } else {
-            let res = self.infcx.shallow_resolve_const(ct);
-            if self.for_fudging && res.is_ct_infer() {
-                return ct;
-            };
-            res.super_fold_with(self)
+            let ct = self.infcx.shallow_resolve_const(ct);
+            ct.super_fold_with(self)
         }
     }
 

compiler/rustc_infer/src/infer/snapshot/fudge.rs

@@ -101,7 +101,7 @@ impl<'tcx> InferCtxt<'tcx> {
             // going to be popped, so we will have to
             // eliminate any references to them.
             let snapshot_vars = SnapshotVarData::new(self, variable_lengths);
-            Ok((snapshot_vars, self.resolve_vars_if_possible_for_fudging(value)))
+            Ok((snapshot_vars, self.resolve_vars_if_possible(value)))
         })?;
 
         // At this point, we need to replace any of the now-popped

compiler/rustc_infer/src/infer/type_variable.rs

@@ -258,25 +258,6 @@ impl<'tcx> TypeVariableTable<'_, 'tcx> {
         self.eq_relations().inlined_probe_value(vid)
     }
 
-    /// Retrieves the type to which `vid` has been instantiated, if
-    /// any, along with the root `vid`.
-    pub(crate) fn probe_with_root_vid(
-        &mut self,
-        vid: ty::TyVid,
-    ) -> (ty::TyVid, TypeVariableValue<'tcx>) {
-        self.inlined_probe_with_vid(vid)
-    }
-
-    /// An always-inlined variant of `probe_with_root_vid`, for very hot call sites.
-    #[inline(always)]
-    pub(crate) fn inlined_probe_with_vid(
-        &mut self,
-        vid: ty::TyVid,
-    ) -> (ty::TyVid, TypeVariableValue<'tcx>) {
-        let (id, value) = self.eq_relations().inlined_probe_key_value(vid);
-        (id.vid, value)
-    }
-
     #[inline]
     fn eq_relations(&mut self) -> super::UnificationTable<'_, 'tcx, TyVidEqKey<'tcx>> {
         self.storage.eq_relations.with_log(self.undo_log)

compiler/rustc_type_ir/Cargo.toml

@@ -8,7 +8,7 @@ edition = "2024"
 arrayvec = { version = "0.7", default-features = false }
 bitflags = "2.4.1"
 derive-where = "1.6.1"
-ena = "0.14.4"
+ena = "0.14.3"
 indexmap = "2.0.0"
 rustc-hash = "2.0.0"
 rustc_abi = { path = "../rustc_abi", default-features = false }