make deeply_resolve a method on InferCtxtLike

Author: jdonszelmann

compiler/rustc_infer/src/infer/outlives/obligations.rs

@@ -66,9 +66,10 @@ use rustc_middle::mir::ConstraintCategory;
 use rustc_middle::ty::outlives::{Component, push_outlives_components};
 use rustc_middle::ty::{
     self, GenericArgKind, GenericArgsRef, PolyTypeOutlivesClause, Region, RegionExt, RegionVid, Ty,
-    TyCtxt, TypeVisitableExt, deeply_resolve,
+    TyCtxt, TypeVisitableExt,
 };
 use rustc_span::Span;
+use rustc_type_ir::InferCtxtLike;
 use smallvec::smallvec;
 use tracing::{debug, instrument};
 
@@ -335,7 +336,11 @@ impl<'tcx> InferCtxt<'tcx> {
                 // `TypeOutlives` is structural, so we should try to opportunistically resolve all
                 // region vids before processing regions, so we have a better chance to match clauses
                 // in our param-env.
-                let (sup_type, sub_region) = deeply_resolve(self, (sup_type, sub_region));
+                //
+                // We *want* this folder to live in `rustc_type_ir`. Our best way to call into it is
+                // through `InferCtxtLike` and it is not defined as an inherent method on `InferCtxt`.
+                #[allow(rustc::usage_of_type_ir_traits)]
+                let (sup_type, sub_region) = self.deeply_resolve((sup_type, sub_region));
 
                 if self.tcx.sess.opts.unstable_opts.higher_ranked_assumptions
                     && outlives_env

compiler/rustc_next_trait_solver/src/canonical/mod.rs

@@ -19,7 +19,7 @@ use rustc_type_ir::relate::{
 };
 use rustc_type_ir::{
     self as ty, Canonical, CanonicalVarKind, CanonicalVarValues, InferCtxtLike, Interner, Region,
-    TypeFoldable, TypingMode, TypingModeEqWrapper, deeply_resolve,
+    TypeFoldable, TypingMode, TypingModeEqWrapper,
 };
 use thin_vec::ThinVec;
 use tracing::instrument;
@@ -567,7 +567,7 @@ where
 {
     let var_values = CanonicalVarValues { var_values: delegate.cx().mk_args(var_values) };
     let state = inspect::State { var_values, data };
-    let state = deeply_resolve(&**delegate, state);
+    let state = delegate.deeply_resolve(state);
     Canonicalizer::canonicalize_response(delegate, max_input_universe, state)
 }
 

compiler/rustc_next_trait_solver/src/normalize.rs

@@ -3,7 +3,7 @@ use std::fmt::Debug;
 use rustc_type_ir::inherent::*;
 use rustc_type_ir::{
     self as ty, AliasTerm, Binder, FallibleTypeFolder, InferCtxtLike, Interner, TypeFoldable,
-    TypeSuperFoldable, TypeVisitableExt, UniverseIndex, deeply_resolve,
+    TypeSuperFoldable, TypeVisitableExt, UniverseIndex,
 };
 use tracing::instrument;
 
@@ -139,8 +139,8 @@ where
 
         if self.cx().renormalize_rigid_aliases() && orig_is_rigid == ty::IsRigid::Yes {
             // find out missing typing env change.
-            let original = deeply_resolve(infcx, original);
-            let normalized = deeply_resolve(infcx, normalized);
+            let original = infcx.deeply_resolve(original);
+            let normalized = infcx.deeply_resolve(normalized);
             assert_eq!(original, normalized, "rigid alias is further normalized");
         }
         Ok(normalized)
@@ -189,8 +189,8 @@ where
 
         if self.cx().renormalize_rigid_aliases() && orig_is_rigid == ty::IsRigid::Yes {
             // find out missing typing env change.
-            let original = deeply_resolve(infcx, original);
-            let normalized = deeply_resolve(infcx, normalized);
+            let original = infcx.deeply_resolve(original);
+            let normalized = infcx.deeply_resolve(normalized);
             assert_eq!(original, normalized, "rigid alias is further normalized");
         }
 

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

@@ -19,7 +19,7 @@ use rustc_type_ir::solve::{
 use rustc_type_ir::{
     self as ty, CanonicalVarValues, ClauseKind, InferCtxtLike, Interner, MayBeErased,
     OpaqueTypeKey, PredicateKind, Region, TypeFoldable, TypeSuperVisitable, TypeVisitable,
-    TypeVisitableExt, TypeVisitor, TypingMode, deeply_resolve,
+    TypeVisitableExt, TypeVisitor, TypingMode,
 };
 use thin_vec::ThinVec;
 use tracing::{Level, debug, instrument, trace, warn};
@@ -658,7 +658,7 @@ where
         // so we only canonicalize the lookup table and ignore
         // duplicate entries.
         let opaque_types = self.delegate.clone_opaque_types_lookup_table();
-        let (goal, opaque_types) = deeply_resolve(&**self.delegate, (goal, opaque_types));
+        let (goal, opaque_types) = self.delegate.deeply_resolve((goal, opaque_types));
         let typing_mode = self.typing_mode();
         let step_kind = self.step_kind_for_source(source);
 
@@ -1600,7 +1600,7 @@ where
         let external_constraints =
             self.compute_external_query_constraints(certainty, normalization_nested_goals);
         let (var_values, mut external_constraints) =
-            deeply_resolve(&**self.delegate, (self.var_values, external_constraints));
+            self.delegate.deeply_resolve((self.var_values, external_constraints));
 
         // Remove any trivial or duplicated region constraints once we've resolved regions
         let mut unique = HashSet::default();
@@ -1855,7 +1855,7 @@ pub(super) fn evaluate_root_goal_for_proof_tree<D: SolverDelegate<Interner = I>,
     root_depth: usize,
 ) -> (Result<NestedNormalizationGoals<I>, NoSolution>, inspect::GoalEvaluation<I>) {
     let opaque_types = delegate.clone_opaque_types_lookup_table();
-    let (goal, opaque_types) = deeply_resolve(&**delegate, (goal, opaque_types));
+    let (goal, opaque_types) = delegate.deeply_resolve((goal, opaque_types));
     let typing_mode = delegate.typing_mode_raw().assert_not_erased();
 
     let (orig_values, canonical_goal) =

compiler/rustc_trait_selection/src/solve/inspect/analyse.rs

@@ -14,7 +14,7 @@ use std::assert_matches;
 use rustc_infer::infer::InferCtxt;
 use rustc_macros::extension;
 use rustc_middle::traits::solve::{Certainty, Goal, GoalSource, NoSolution, QueryResult};
-use rustc_middle::ty::{RequiredDepth, TyCtxt, VisitorResult, deeply_resolve, try_visit};
+use rustc_middle::ty::{InferCtxtLike, RequiredDepth, TyCtxt, VisitorResult, try_visit};
 use rustc_middle::{bug, ty};
 use rustc_next_trait_solver::canonical::instantiate_canonical_state;
 use rustc_next_trait_solver::solve::{MaybeCause, MaybeInfo, SolverDelegateEvalExt as _, inspect};
@@ -170,7 +170,10 @@ impl<'a, 'tcx> InspectCandidate<'a, 'tcx> {
                         self.final_state,
                     );
 
-                    return deeply_resolve(&**infcx, impl_args);
+                    // We *want* this folder to live in `rustc_type_ir`. Our best way to call into it is
+                    // through `InferCtxtLike` and it is not defined as an inherent method on `InferCtxt`.
+                    #[allow(rustc::usage_of_type_ir_traits)]
+                    return infcx.deeply_resolve(impl_args);
                 }
                 inspect::ProbeStep::AddGoal(..) => {}
                 inspect::ProbeStep::MakeCanonicalResponse { .. }
@@ -361,7 +364,10 @@ impl<'a, 'tcx> InspectGoal<'a, 'tcx> {
             depth,
             orig_values,
             prev_universe,
-            goal: deeply_resolve(&**infcx, uncanonicalized_goal),
+            // We *want* this folder to live in `rustc_type_ir`. Our best way to call into it is
+            // through `InferCtxtLike` and it is not defined as an inherent method on `InferCtxt`.
+            #[allow(rustc::usage_of_type_ir_traits)]
+            goal: infcx.deeply_resolve(uncanonicalized_goal),
             result,
             final_revision,
             source,

compiler/rustc_type_ir/src/infer_ctxt.rs

@@ -572,6 +572,20 @@ pub trait InferCtxtLike: Sized {
     );
 
     fn reset_opaque_types(&self);
+
+    /// Where possible, replaces type/const/region variables in `value` with their final value.
+    /// If a type/const/region variable has not (yet) been unified, it is left as is.
+    ///
+    /// This is an idempotent operation that does not affect inference state in any way,
+    /// which means it's safe to call this function at will.
+    fn deeply_resolve<T: TypeFoldable<Self::Interner>>(&self, value: T) -> T {
+        if value.has_infer() {
+            let mut folder = DeepVariableResolver::new(self);
+            value.fold_with(&mut folder)
+        } else {
+            value
+        }
+    }
 }
 
 pub fn may_use_unstable_feature<'a, I: Interner, Infcx>(
@@ -618,23 +632,6 @@ where
     }
 }
 
-/// Where possible, replaces type/const/region variables in `value` with their final value.
-/// If a type/const/region variable has not (yet) been unified, it is left as is.
-///
-/// This is an idempotent operation that does not affect inference state in any way,
-/// which means it's safe to call this function at will.
-pub fn deeply_resolve<Infcx: InferCtxtLike, T: TypeFoldable<Infcx::Interner>>(
-    infcx: &Infcx,
-    value: T,
-) -> T {
-    if value.has_infer() {
-        let mut folder = DeepVariableResolver::new(infcx);
-        value.fold_with(&mut folder)
-    } else {
-        value
-    }
-}
-
 struct DeepVariableResolver<'a, D, I = <D as InferCtxtLike>::Interner>
 where
     D: InferCtxtLike<Interner = I>,