Review

Author: compiler-errors

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

@@ -22,8 +22,8 @@ use crate::delegate::SolverDelegate;
 use crate::solve::inspect::{self, ProofTreeBuilder};
 use crate::solve::search_graph::SearchGraph;
 use crate::solve::{
-    CanonicalGoalCacheKey, CanonicalInput, Certainty, FIXPOINT_STEP_LIMIT, Goal,
-    GoalEvaluationKind, GoalSource, HasChanged, NestedNormalizationGoals, NoSolution, QueryInput,
+    CanonicalInput, Certainty, FIXPOINT_STEP_LIMIT, Goal, GoalEvaluation, GoalEvaluationKind,
+    GoalSource, GoalStalledOn, HasChanged, NestedNormalizationGoals, NoSolution, QueryInput,
     QueryResult,
 };
 
@@ -116,7 +116,7 @@ where
 
     pub(super) search_graph: &'a mut SearchGraph<D>,
 
-    nested_goals: Vec<(GoalSource, Goal<I, I::Predicate>, Option<CanonicalGoalCacheKey<I>>)>,
+    nested_goals: Vec<(GoalSource, Goal<I, I::Predicate>, Option<GoalStalledOn<I>>)>,
 
     pub(super) origin_span: I::Span,
 
@@ -148,9 +148,9 @@ pub trait SolverDelegateEvalExt: SolverDelegate {
         goal: Goal<Self::Interner, <Self::Interner as Interner>::Predicate>,
         generate_proof_tree: GenerateProofTree,
         span: <Self::Interner as Interner>::Span,
-        cache_key: Option<CanonicalGoalCacheKey<Self::Interner>>,
+        stalled_on: Option<GoalStalledOn<Self::Interner>>,
     ) -> (
-        Result<(HasChanged, Certainty, CanonicalGoalCacheKey<Self::Interner>), NoSolution>,
+        Result<GoalEvaluation<Self::Interner>, NoSolution>,
         Option<inspect::GoalEvaluation<Self::Interner>>,
     );
 
@@ -173,15 +173,10 @@ pub trait SolverDelegateEvalExt: SolverDelegate {
         &self,
         goal: Goal<Self::Interner, <Self::Interner as Interner>::Predicate>,
         generate_proof_tree: GenerateProofTree,
-        cache_key: Option<CanonicalGoalCacheKey<Self::Interner>>,
+        stalled_on: Option<GoalStalledOn<Self::Interner>>,
     ) -> (
         Result<
-            (
-                NestedNormalizationGoals<Self::Interner>,
-                HasChanged,
-                Certainty,
-                CanonicalGoalCacheKey<Self::Interner>,
-            ),
+            (NestedNormalizationGoals<Self::Interner>, GoalEvaluation<Self::Interner>),
             NoSolution,
         >,
         Option<inspect::GoalEvaluation<Self::Interner>>,
@@ -199,13 +194,10 @@ where
         goal: Goal<I, I::Predicate>,
         generate_proof_tree: GenerateProofTree,
         span: I::Span,
-        cache_key: Option<CanonicalGoalCacheKey<I>>,
-    ) -> (
-        Result<(HasChanged, Certainty, CanonicalGoalCacheKey<I>), NoSolution>,
-        Option<inspect::GoalEvaluation<I>>,
-    ) {
+        stalled_on: Option<GoalStalledOn<I>>,
+    ) -> (Result<GoalEvaluation<I>, NoSolution>, Option<inspect::GoalEvaluation<I>>) {
         EvalCtxt::enter_root(self, self.cx().recursion_limit(), generate_proof_tree, span, |ecx| {
-            ecx.evaluate_goal(GoalEvaluationKind::Root, GoalSource::Misc, goal, cache_key)
+            ecx.evaluate_goal(GoalEvaluationKind::Root, GoalSource::Misc, goal, stalled_on)
         })
     }
 
@@ -228,12 +220,9 @@ where
         &self,
         goal: Goal<I, I::Predicate>,
         generate_proof_tree: GenerateProofTree,
-        cache_key: Option<CanonicalGoalCacheKey<I>>,
+        stalled_on: Option<GoalStalledOn<I>>,
     ) -> (
-        Result<
-            (NestedNormalizationGoals<I>, HasChanged, Certainty, CanonicalGoalCacheKey<I>),
-            NoSolution,
-        >,
+        Result<(NestedNormalizationGoals<I>, GoalEvaluation<I>), NoSolution>,
         Option<inspect::GoalEvaluation<I>>,
     ) {
         EvalCtxt::enter_root(
@@ -242,7 +231,7 @@ where
             generate_proof_tree,
             I::Span::dummy(),
             |ecx| {
-                ecx.evaluate_goal_raw(GoalEvaluationKind::Root, GoalSource::Misc, goal, cache_key)
+                ecx.evaluate_goal_raw(GoalEvaluationKind::Root, GoalSource::Misc, goal, stalled_on)
             },
         )
     }
@@ -468,12 +457,12 @@ where
         goal_evaluation_kind: GoalEvaluationKind,
         source: GoalSource,
         goal: Goal<I, I::Predicate>,
-        cache_key: Option<CanonicalGoalCacheKey<I>>,
-    ) -> Result<(HasChanged, Certainty, CanonicalGoalCacheKey<I>), NoSolution> {
-        let (normalization_nested_goals, has_changed, certainty, cache_key) =
-            self.evaluate_goal_raw(goal_evaluation_kind, source, goal, cache_key)?;
+        stalled_on: Option<GoalStalledOn<I>>,
+    ) -> Result<GoalEvaluation<I>, NoSolution> {
+        let (normalization_nested_goals, goal_evaluation) =
+            self.evaluate_goal_raw(goal_evaluation_kind, source, goal, stalled_on)?;
         assert!(normalization_nested_goals.is_empty());
-        Ok((has_changed, certainty, cache_key))
+        Ok(goal_evaluation)
     }
 
     /// Recursively evaluates `goal`, returning the nested goals in case
@@ -488,23 +477,25 @@ where
         goal_evaluation_kind: GoalEvaluationKind,
         source: GoalSource,
         goal: Goal<I, I::Predicate>,
-        cache_key: Option<CanonicalGoalCacheKey<I>>,
-    ) -> Result<
-        (NestedNormalizationGoals<I>, HasChanged, Certainty, CanonicalGoalCacheKey<I>),
-        NoSolution,
-    > {
-        if let Some(cache_key) = cache_key {
-            if !cache_key.stalled_vars.iter().any(|value| self.delegate.is_changed_arg(*value))
+        stalled_on: Option<GoalStalledOn<I>>,
+    ) -> Result<(NestedNormalizationGoals<I>, GoalEvaluation<I>), NoSolution> {
+        // If we have run this goal before, and it was stalled, check that any of the goal's
+        // args have changed. Otherwise, we don't need to re-run the goal because it'll remain
+        // stalled, since it'll canonicalize the same way and evaluation is pure.
+        if let Some(stalled_on) = stalled_on {
+            if !stalled_on.stalled_vars.iter().any(|value| self.delegate.is_changed_arg(*value))
                 && !self
                     .delegate
                     .opaque_types_storage_num_entries()
-                    .needs_reevaluation(cache_key.num_opaques)
+                    .needs_reevaluation(stalled_on.num_opaques)
             {
                 return Ok((
                     NestedNormalizationGoals::empty(),
-                    HasChanged::No,
-                    cache_key.certainty,
-                    cache_key,
+                    GoalEvaluation {
+                        certainty: Certainty::Maybe(stalled_on.stalled_cause),
+                        has_changed: HasChanged::No,
+                        stalled_on: Some(stalled_on),
+                    },
                 ));
             }
         }
@@ -544,33 +535,35 @@ where
         // Once we have decided on how to handle trait-system-refactor-initiative#75,
         // we should re-add an assert here.
 
-        // Remove the unconstrained RHS arg, which is expected to have changed.
-        let mut stalled_vars = orig_values;
-        if let Some(normalizes_to) = goal.predicate.as_normalizes_to() {
-            let normalizes_to = normalizes_to.skip_binder();
-            let rhs_arg: I::GenericArg = normalizes_to.term.into();
-            let idx = stalled_vars
-                .iter()
-                .rposition(|arg| *arg == rhs_arg)
-                .expect("expected unconstrained arg");
-            stalled_vars.swap_remove(idx);
-        }
+        let stalled_on = match certainty {
+            Certainty::Yes => None,
+            Certainty::Maybe(stalled_cause) => {
+                // Remove the unconstrained RHS arg, which is expected to have changed.
+                let mut stalled_vars = orig_values;
+                if let Some(normalizes_to) = goal.predicate.as_normalizes_to() {
+                    let normalizes_to = normalizes_to.skip_binder();
+                    let rhs_arg: I::GenericArg = normalizes_to.term.into();
+                    let idx = stalled_vars
+                        .iter()
+                        .rposition(|arg| *arg == rhs_arg)
+                        .expect("expected unconstrained arg");
+                    stalled_vars.swap_remove(idx);
+                }
 
-        Ok((
-            normalization_nested_goals,
-            has_changed,
-            certainty,
-            CanonicalGoalCacheKey {
-                num_opaques: canonical_goal
-                    .canonical
-                    .value
-                    .predefined_opaques_in_body
-                    .opaque_types
-                    .len(),
-                stalled_vars,
-                certainty,
-            },
-        ))
+                Some(GoalStalledOn {
+                    num_opaques: canonical_goal
+                        .canonical
+                        .value
+                        .predefined_opaques_in_body
+                        .opaque_types
+                        .len(),
+                    stalled_vars,
+                    stalled_cause,
+                })
+            }
+        };
+
+        Ok((normalization_nested_goals, GoalEvaluation { certainty, has_changed, stalled_on }))
     }
 
     fn compute_goal(&mut self, goal: Goal<I, I::Predicate>) -> QueryResult<I> {
@@ -670,7 +663,7 @@ where
         let cx = self.cx();
         // If this loop did not result in any progress, what's our final certainty.
         let mut unchanged_certainty = Some(Certainty::Yes);
-        for (source, goal, cache_key) in mem::take(&mut self.nested_goals) {
+        for (source, goal, stalled_on) in mem::take(&mut self.nested_goals) {
             if let Some(has_changed) = self.delegate.compute_goal_fast_path(goal, self.origin_span)
             {
                 if matches!(has_changed, HasChanged::Yes) {
@@ -698,13 +691,15 @@ where
                 let unconstrained_goal =
                     goal.with(cx, ty::NormalizesTo { alias: pred.alias, term: unconstrained_rhs });
 
-                let (NestedNormalizationGoals(nested_goals), _, certainty, cache_key) = self
-                    .evaluate_goal_raw(
-                        GoalEvaluationKind::Nested,
-                        source,
-                        unconstrained_goal,
-                        cache_key,
-                    )?;
+                let (
+                    NestedNormalizationGoals(nested_goals),
+                    GoalEvaluation { certainty, stalled_on, has_changed: _ },
+                ) = self.evaluate_goal_raw(
+                    GoalEvaluationKind::Nested,
+                    source,
+                    unconstrained_goal,
+                    stalled_on,
+                )?;
                 // Add the nested goals from normalization to our own nested goals.
                 trace!(?nested_goals);
                 self.nested_goals.extend(nested_goals.into_iter().map(|(s, g)| (s, g, None)));
@@ -743,21 +738,21 @@ where
                 match certainty {
                     Certainty::Yes => {}
                     Certainty::Maybe(_) => {
-                        self.nested_goals.push((source, with_resolved_vars, Some(cache_key)));
+                        self.nested_goals.push((source, with_resolved_vars, stalled_on));
                         unchanged_certainty = unchanged_certainty.map(|c| c.and(certainty));
                     }
                 }
             } else {
-                let (has_changed, certainty, cache_key) =
-                    self.evaluate_goal(GoalEvaluationKind::Nested, source, goal, cache_key)?;
+                let GoalEvaluation { certainty, has_changed, stalled_on } =
+                    self.evaluate_goal(GoalEvaluationKind::Nested, source, goal, stalled_on)?;
                 if has_changed == HasChanged::Yes {
                     unchanged_certainty = None;
                 }
 
                 match certainty {
                     Certainty::Yes => {}
                     Certainty::Maybe(_) => {
-                        self.nested_goals.push((source, goal, Some(cache_key)));
+                        self.nested_goals.push((source, goal, stalled_on));
                         unchanged_certainty = unchanged_certainty.map(|c| c.and(certainty));
                     }
                 }

compiler/rustc_next_trait_solver/src/solve/mod.rs

@@ -21,6 +21,7 @@ mod project_goals;
 mod search_graph;
 mod trait_goals;
 
+use derive_where::derive_where;
 use rustc_type_ir::inherent::*;
 pub use rustc_type_ir::solve::*;
 use rustc_type_ir::{self as ty, Interner, TypingMode};
@@ -369,3 +370,18 @@ fn response_no_constraints_raw<I: Interner>(
         },
     }
 }
+
+pub struct GoalEvaluation<I: Interner> {
+    pub certainty: Certainty,
+    pub has_changed: HasChanged,
+    /// Returns the args that must change for the goal to warrant re-evaluation.
+    pub stalled_on: Option<GoalStalledOn<I>>,
+}
+
+#[derive_where(Clone, Debug; I: Interner)]
+pub struct GoalStalledOn<I: Interner> {
+    pub num_opaques: usize,
+    pub stalled_vars: Vec<I::GenericArg>,
+    /// The cause that will be returned on subsequent evaluations if this goal remains stalled.
+    pub stalled_cause: MaybeCause,
+}