Deeply normalize TypeOutlives on next solver

JohnTitor · JohnTitor · commit 3f9571c865f9 · 2026-02-14T18:54:27.000+09:00
diff --git a/compiler/rustc_infer/src/infer/outlives/mod.rs b/compiler/rustc_infer/src/infer/outlives/mod.rs
@@ -1,13 +1,13 @@
 //! Various code related to computing outlives relations.
 
 use rustc_data_structures::undo_log::UndoLogs;
-use rustc_middle::traits::query::{NoSolution, OutlivesBound};
+use rustc_middle::traits::query::OutlivesBound;
 use rustc_middle::ty;
 use tracing::instrument;
 
 use self::env::OutlivesEnvironment;
 use super::region_constraints::{RegionConstraintData, UndoLog};
-use super::{InferCtxt, RegionResolutionError, SubregionOrigin};
+use super::{InferCtxt, RegionResolutionError};
 use crate::infer::free_regions::RegionRelations;
 use crate::infer::lexical_region_resolve;
 use crate::infer::region_constraints::ConstraintKind;
@@ -35,25 +35,12 @@ impl<'tcx> InferCtxt<'tcx> {
     /// result. After this, no more unification operations should be
     /// done -- or the compiler will panic -- but it is legal to use
     /// `resolve_vars_if_possible` as well as `fully_resolve`.
-    ///
-    /// If you are in a crate that has access to `rustc_trait_selection`,
-    /// then it's probably better to use `resolve_regions`,
-    /// which knows how to normalize registered region obligations.
     #[must_use]
-    pub fn resolve_regions_with_normalize(
+    pub fn resolve_regions_with_outlives_env(
         &self,
         outlives_env: &OutlivesEnvironment<'tcx>,
-        deeply_normalize_ty: impl Fn(
-            ty::PolyTypeOutlivesPredicate<'tcx>,
-            SubregionOrigin<'tcx>,
-        ) -> Result<ty::PolyTypeOutlivesPredicate<'tcx>, NoSolution>,
     ) -> Vec<RegionResolutionError<'tcx>> {
-        match self.process_registered_region_obligations(outlives_env, deeply_normalize_ty) {
-            Ok(()) => {}
-            Err((clause, origin)) => {
-                return vec![RegionResolutionError::CannotNormalize(clause, origin)];
-            }
-        };
+        self.process_registered_region_obligations(outlives_env);
 
         let mut storage = {
             let mut inner = self.inner.borrow_mut();
diff --git a/compiler/rustc_infer/src/infer/outlives/obligations.rs b/compiler/rustc_infer/src/infer/outlives/obligations.rs
@@ -62,11 +62,9 @@
 use rustc_data_structures::undo_log::UndoLogs;
 use rustc_middle::bug;
 use rustc_middle::mir::ConstraintCategory;
-use rustc_middle::traits::query::NoSolution;
 use rustc_middle::ty::outlives::{Component, push_outlives_components};
 use rustc_middle::ty::{
-    self, GenericArgKind, GenericArgsRef, PolyTypeOutlivesPredicate, Region, Ty, TyCtxt,
-    TypeFoldable as _, TypeVisitableExt,
+    self, GenericArgKind, GenericArgsRef, Region, Ty, TyCtxt, TypeFoldable as _, TypeVisitableExt,
 };
 use smallvec::smallvec;
 use tracing::{debug, instrument};
@@ -194,19 +192,11 @@ impl<'tcx> InferCtxt<'tcx> {
     /// flow of the inferencer. The key point is that it is
     /// invoked after all type-inference variables have been bound --
     /// right before lexical region resolution.
-    #[instrument(level = "debug", skip(self, outlives_env, deeply_normalize_ty))]
-    pub fn process_registered_region_obligations(
-        &self,
-        outlives_env: &OutlivesEnvironment<'tcx>,
-        mut deeply_normalize_ty: impl FnMut(
-            PolyTypeOutlivesPredicate<'tcx>,
-            SubregionOrigin<'tcx>,
-        )
-            -> Result<PolyTypeOutlivesPredicate<'tcx>, NoSolution>,
-    ) -> Result<(), (PolyTypeOutlivesPredicate<'tcx>, SubregionOrigin<'tcx>)> {
+    #[instrument(level = "debug", skip(self, outlives_env))]
+    pub fn process_registered_region_obligations(&self, outlives_env: &OutlivesEnvironment<'tcx>) {
         assert!(!self.in_snapshot(), "cannot process registered region obligations in a snapshot");
 
-        // Must loop since the process of normalizing may itself register region obligations.
+        // We loop to handle the case that processing one obligation ends up registering another.
         for iteration in 0.. {
             let my_region_obligations = self.take_registered_region_obligations();
             if my_region_obligations.is_empty() {
@@ -223,12 +213,12 @@ impl<'tcx> InferCtxt<'tcx> {
             }
 
             for TypeOutlivesConstraint { sup_type, sub_region, origin } in my_region_obligations {
-                let outlives = ty::Binder::dummy(ty::OutlivesPredicate(sup_type, sub_region));
-                let ty::OutlivesPredicate(sup_type, sub_region) =
-                    deeply_normalize_ty(outlives, origin.clone())
-                        .map_err(|NoSolution| (outlives, origin.clone()))?
-                        .no_bound_vars()
-                        .expect("started with no bound vars, should end with no bound vars");
+                let outlives = self.resolve_vars_if_possible(ty::Binder::dummy(
+                    ty::OutlivesPredicate(sup_type, sub_region),
+                ));
+                let ty::OutlivesPredicate(sup_type, sub_region) = outlives
+                    .no_bound_vars()
+                    .expect("started with no bound vars, should end with no bound vars");
                 // `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.
@@ -256,8 +246,6 @@ impl<'tcx> InferCtxt<'tcx> {
                 outlives.type_must_outlive(origin, sup_type, sub_region, category);
             }
         }
-
-        Ok(())
     }
 }
 
diff --git a/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs b/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs
@@ -420,6 +420,18 @@ where
         Ok(goal_evaluation)
     }
 
+    /// Evaluate `goal` without adding it to `nested_goals`.
+    ///
+    /// This is intended for goal evaluation which should not affect the
+    /// certainty of the currently evaluated goal.
+    pub(super) fn try_evaluate_goal(
+        &mut self,
+        source: GoalSource,
+        goal: Goal<I, I::Predicate>,
+    ) -> Result<GoalEvaluation<I>, NoSolution> {
+        self.evaluate_goal(source, goal, None)
+    }
+
     /// Recursively evaluates `goal`, returning the nested goals in case
     /// the nested goal is a `NormalizesTo` goal.
     ///
@@ -1076,6 +1088,10 @@ where
         self.delegate.shallow_resolve(ty)
     }
 
+    pub(super) fn shallow_resolve_const(&self, ct: I::Const) -> I::Const {
+        self.delegate.shallow_resolve_const(ct)
+    }
+
     pub(super) fn eager_resolve_region(&self, r: I::Region) -> I::Region {
         if let ty::ReVar(vid) = r.kind() {
             self.delegate.opportunistic_resolve_lt_var(vid)
diff --git a/compiler/rustc_next_trait_solver/src/solve/mod.rs b/compiler/rustc_next_trait_solver/src/solve/mod.rs
@@ -22,9 +22,13 @@ mod search_graph;
 mod trait_goals;
 
 use derive_where::derive_where;
+use rustc_type_ir::data_structures::ensure_sufficient_stack;
 use rustc_type_ir::inherent::*;
 pub use rustc_type_ir::solve::*;
-use rustc_type_ir::{self as ty, Interner, TyVid, TypingMode};
+use rustc_type_ir::{
+    self as ty, FallibleTypeFolder, Interner, TyVid, TypeFoldable, TypeSuperFoldable,
+    TypeVisitableExt, TypingMode,
+};
 use tracing::instrument;
 
 pub use self::eval_ctxt::{
@@ -91,6 +95,15 @@ where
         goal: Goal<I, ty::OutlivesPredicate<I, I::Ty>>,
     ) -> QueryResult<I> {
         let ty::OutlivesPredicate(ty, lt) = goal.predicate;
+
+        // With `-Znext-solver`, `TypeOutlives` goals normalize aliases before registering region
+        // obligations so that later processing does not have to structurally process aliases.
+        let ty = self.resolve_vars_if_possible(ty);
+        let ty = if ty.has_aliases() {
+            self.deeply_normalize_for_outlives(goal.param_env, ty)
+        } else {
+            ty
+        };
         self.register_ty_outlives(ty, lt);
         self.evaluate_added_goals_and_make_canonical_response(Certainty::Yes)
     }
@@ -306,6 +319,131 @@ where
         }
     }
 
+    /// This is the solver-internal equivalent of the `deeply_normalize` helper in
+    /// `compiler/rustc_trait_selection/src/solve/normalize.rs`.
+    fn deeply_normalize_for_outlives(&mut self, param_env: I::ParamEnv, ty: I::Ty) -> I::Ty {
+        debug_assert!(ty.has_aliases());
+
+        // We only use this for `TypeOutlives` goals,
+        // so the input should not have escaping bound vars.
+        debug_assert!(
+            !ty.has_escaping_bound_vars(),
+            "expected `TypeOutlives` ty to not have escaping bound vars: {ty:?}"
+        );
+
+        struct DeepNormalizer<'ecx, 'a, D, I>
+        where
+            D: SolverDelegate<Interner = I>,
+            I: Interner,
+        {
+            ecx: &'ecx mut EvalCtxt<'a, D, I>,
+            param_env: I::ParamEnv,
+            depth: usize,
+        }
+
+        impl<D, I> DeepNormalizer<'_, '_, D, I>
+        where
+            D: SolverDelegate<Interner = I>,
+            I: Interner,
+        {
+            fn normalize_alias_term(&mut self, alias_term: I::Term) -> Result<I::Term, NoSolution> {
+                debug_assert!(alias_term.to_alias_term().is_some());
+
+                if alias_term.has_non_region_infer() || alias_term.has_non_region_placeholders() {
+                    return match alias_term.kind() {
+                        ty::TermKind::Ty(ty) => Ok(ty.try_super_fold_with(self)?.into()),
+                        ty::TermKind::Const(ct) => Ok(ct.try_super_fold_with(self)?.into()),
+                    };
+                }
+
+                // Avoid getting stuck on self-referential normalization.
+                if self.depth >= self.ecx.cx().recursion_limit() {
+                    return match alias_term.kind() {
+                        ty::TermKind::Ty(ty) => Ok(ty.try_super_fold_with(self)?.into()),
+                        ty::TermKind::Const(ct) => Ok(ct.try_super_fold_with(self)?.into()),
+                    };
+                }
+
+                self.depth += 1;
+
+                let normalized_term = self.ecx.next_term_infer_of_kind(alias_term);
+                let goal = Goal::new(
+                    self.ecx.cx(),
+                    self.param_env,
+                    ty::PredicateKind::AliasRelate(
+                        alias_term,
+                        normalized_term,
+                        ty::AliasRelationDirection::Equate,
+                    ),
+                );
+
+                let result = match self.ecx.try_evaluate_goal(GoalSource::TypeRelating, goal) {
+                    Ok(GoalEvaluation { certainty: Certainty::Yes, .. }) => {
+                        // Resolve the fresh term and continue normalization recursively.
+                        let term = self.ecx.resolve_vars_if_possible(normalized_term);
+                        match term.kind() {
+                            ty::TermKind::Ty(ty) => ty.try_super_fold_with(self)?.into(),
+                            ty::TermKind::Const(ct) => ct.try_super_fold_with(self)?.into(),
+                        }
+                    }
+                    Ok(GoalEvaluation { certainty: Certainty::Maybe { .. }, .. })
+                    | Err(NoSolution) => {
+                        // If normalizing this alias isn't possible right now, keep it and continue
+                        // folding inside of it.
+                        match alias_term.kind() {
+                            ty::TermKind::Ty(ty) => ty.try_super_fold_with(self)?.into(),
+                            ty::TermKind::Const(ct) => ct.try_super_fold_with(self)?.into(),
+                        }
+                    }
+                };
+
+                self.depth -= 1;
+                Ok(result)
+            }
+        }
+
+        impl<D, I> FallibleTypeFolder<I> for DeepNormalizer<'_, '_, D, I>
+        where
+            D: SolverDelegate<Interner = I>,
+            I: Interner,
+        {
+            type Error = NoSolution;
+
+            fn cx(&self) -> I {
+                self.ecx.cx()
+            }
+
+            #[instrument(level = "trace", skip(self), ret)]
+            fn try_fold_ty(&mut self, ty: I::Ty) -> Result<I::Ty, Self::Error> {
+                let ty = self.ecx.shallow_resolve(ty);
+                if !ty.has_aliases() {
+                    return Ok(ty);
+                }
+
+                let ty::Alias(..) = ty.kind() else { return ty.try_super_fold_with(self) };
+                let term = ensure_sufficient_stack(|| self.normalize_alias_term(ty.into()))?;
+                Ok(term.expect_ty())
+            }
+
+            #[instrument(level = "trace", skip(self), ret)]
+            fn try_fold_const(&mut self, ct: I::Const) -> Result<I::Const, Self::Error> {
+                let ct = self.ecx.shallow_resolve_const(ct);
+                if !ct.has_aliases() {
+                    return Ok(ct);
+                }
+
+                let ty::ConstKind::Unevaluated(..) = ct.kind() else {
+                    return ct.try_super_fold_with(self);
+                };
+
+                let term = ensure_sufficient_stack(|| self.normalize_alias_term(ct.into()))?;
+                Ok(term.expect_const())
+            }
+        }
+
+        ty.try_fold_with(&mut DeepNormalizer { ecx: self, param_env, depth: 0 }).unwrap()
+    }
+
     /// Normalize a type for when it is structurally matched on.
     ///
     /// This function is necessary in nearly all cases before matching on a type.
diff --git a/compiler/rustc_trait_selection/src/regions.rs b/compiler/rustc_trait_selection/src/regions.rs
@@ -1,9 +1,7 @@
 use rustc_data_structures::fx::FxHashSet;
 use rustc_hir::def_id::LocalDefId;
 use rustc_infer::infer::outlives::env::OutlivesEnvironment;
-use rustc_infer::infer::{
-    InferCtxt, RegionResolutionError, SubregionOrigin, TypeOutlivesConstraint,
-};
+use rustc_infer::infer::{InferCtxt, RegionResolutionError};
 use rustc_macros::extension;
 use rustc_middle::traits::ObligationCause;
 use rustc_middle::ty::{self, Ty, elaborate};
@@ -58,48 +56,6 @@ fn normalize_higher_ranked_assumptions<'tcx>(
     elaborate::elaborate_outlives_assumptions(infcx.tcx, normalized_assumptions)
 }
 
-fn normalize_registered_region_obligations<'tcx>(
-    infcx: &InferCtxt<'tcx>,
-    param_env: ty::ParamEnv<'tcx>,
-) -> Result<(), (ty::PolyTypeOutlivesPredicate<'tcx>, SubregionOrigin<'tcx>)> {
-    if !infcx.next_trait_solver() {
-        return Ok(());
-    }
-
-    let obligations = infcx.take_registered_region_obligations();
-    let mut seen_outputs = FxHashSet::default();
-    let mut normalized_obligations = vec![];
-
-    for TypeOutlivesConstraint { sup_type, sub_region, origin } in obligations {
-        let outlives = infcx.resolve_vars_if_possible(ty::Binder::dummy(ty::OutlivesPredicate(
-            sup_type, sub_region,
-        )));
-        let ty::OutlivesPredicate(sup_type, sub_region) = crate::solve::deeply_normalize(
-            infcx.at(&ObligationCause::dummy_with_span(origin.span()), param_env),
-            outlives,
-        )
-        .map_err(|_: Vec<ScrubbedTraitError<'tcx>>| (outlives, origin.clone()))?
-        .no_bound_vars()
-        .expect("started with no bound vars, should end with no bound vars");
-
-        if seen_outputs.insert((sup_type, sub_region)) {
-            normalized_obligations.push(TypeOutlivesConstraint { sup_type, sub_region, origin });
-        }
-    }
-
-    for obligation in infcx.take_registered_region_obligations() {
-        if seen_outputs.insert((obligation.sup_type, obligation.sub_region)) {
-            normalized_obligations.push(obligation);
-        }
-    }
-
-    for obligation in normalized_obligations {
-        infcx.register_type_outlives_constraint_inner(obligation);
-    }
-
-    Ok(())
-}
-
 #[extension(pub trait OutlivesEnvironmentBuildExt<'tcx>)]
 impl<'tcx> OutlivesEnvironment<'tcx> {
     fn new(
@@ -159,12 +115,11 @@ impl<'tcx> OutlivesEnvironment<'tcx> {
 
 #[extension(pub trait InferCtxtRegionExt<'tcx>)]
 impl<'tcx> InferCtxt<'tcx> {
-    /// Resolve regions, using the deep normalizer to normalize any type-outlives
-    /// obligations in the process. This is in `rustc_trait_selection` because
-    /// we need to normalize.
+    /// Resolve regions.
     ///
-    /// Prefer this method over `resolve_regions_with_normalize`, unless you are
-    /// doing something specific for normalization.
+    /// With the next solver, `TypeOutlives` goals are normalized while they are
+    /// evaluated (and before being registered as region obligations), so region
+    /// resolution does not need to normalize them.
     ///
     /// This function assumes that all infer variables are already constrained.
     fn resolve_regions(
@@ -180,20 +135,4 @@ impl<'tcx> InferCtxt<'tcx> {
             assumed_wf_tys,
         ))
     }
-
-    /// Don't call this directly unless you know what you're doing.
-    fn resolve_regions_with_outlives_env(
-        &self,
-        outlives_env: &OutlivesEnvironment<'tcx>,
-    ) -> Vec<RegionResolutionError<'tcx>> {
-        if let Err((outlives, origin)) =
-            normalize_registered_region_obligations(self, outlives_env.param_env)
-        {
-            return vec![RegionResolutionError::CannotNormalize(outlives, origin)];
-        }
-
-        self.resolve_regions_with_normalize(outlives_env, |outlives, _| {
-            Ok(self.resolve_vars_if_possible(outlives))
-        })
-    }
 }
diff --git a/compiler/rustc_trait_selection/src/solve/delegate.rs b/compiler/rustc_trait_selection/src/solve/delegate.rs
diff --git a/compiler/rustc_trait_selection/src/traits/auto_trait.rs b/compiler/rustc_trait_selection/src/traits/auto_trait.rs
