canonicalize everything in nested goals

lcnr · lcnr · commit c12e623addf7 · 2023-08-14T14:10:31.000+02:00
diff --git a/compiler/rustc_middle/src/traits/solve.rs b/compiler/rustc_middle/src/traits/solve.rs
@@ -229,9 +229,3 @@ impl<'tcx> TypeVisitable<TyCtxt<'tcx>> for PredefinedOpaques<'tcx> {
         self.opaque_types.visit_with(visitor)
     }
 }
-
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, HashStable)]
-pub enum IsNormalizesToHack {
-    Yes,
-    No,
-}
diff --git a/compiler/rustc_middle/src/traits/solve/inspect.rs b/compiler/rustc_middle/src/traits/solve/inspect.rs
@@ -1,54 +1,73 @@
-use super::{
-    CanonicalInput, Certainty, Goal, IsNormalizesToHack, NoSolution, QueryInput, QueryResult,
-};
+use super::{CanonicalInput, Certainty, Goal, NoSolution, QueryResult};
+use crate::infer::canonical::{Canonical, CanonicalVarValues};
 use crate::ty;
 use format::ProofTreeFormatter;
 use std::fmt::{Debug, Write};
 
 mod format;
 
+#[derive(Debug, Clone, Eq, PartialEq, Hash, HashStable, TypeFoldable, TypeVisitable)]
+pub struct State<'tcx, T> {
+    pub var_values: CanonicalVarValues<'tcx>,
+    pub data: T,
+}
+pub type CanonicalState<'tcx, T> = Canonical<'tcx, State<'tcx, T>>;
+
 #[derive(Eq, PartialEq, Debug, Hash, HashStable)]
 pub enum CacheHit {
     Provisional,
     Global,
 }
 
+#[derive(Debug, PartialEq, Eq, Hash, HashStable)]
+pub enum IsNormalizesToHack {
+    Yes,
+    No,
+}
+
 #[derive(Eq, PartialEq, Hash, HashStable)]
-pub struct GoalEvaluation<'tcx> {
-    pub uncanonicalized_goal: Goal<'tcx, ty::Predicate<'tcx>>,
-    pub is_normalizes_to_hack: IsNormalizesToHack,
+pub struct RootGoalEvaluation<'tcx> {
+    pub goal: Goal<'tcx, ty::Predicate<'tcx>>,
+    pub orig_values: Vec<ty::GenericArg<'tcx>>,
     pub evaluation: CanonicalGoalEvaluation<'tcx>,
     pub returned_goals: Vec<Goal<'tcx, ty::Predicate<'tcx>>>,
 }
 
+#[derive(Eq, PartialEq, Hash, HashStable)]
+pub struct NestedGoalEvaluation<'tcx> {
+    pub goal: CanonicalState<'tcx, Goal<'tcx, ty::Predicate<'tcx>>>,
+    pub orig_values: CanonicalState<'tcx, Vec<ty::GenericArg<'tcx>>>,
+    pub is_normalizes_to_hack: IsNormalizesToHack,
+    pub evaluation: CanonicalGoalEvaluation<'tcx>,
+    pub returned_goals: Vec<CanonicalState<'tcx, Goal<'tcx, ty::Predicate<'tcx>>>>,
+}
+
 #[derive(Eq, PartialEq, Hash, HashStable)]
 pub struct CanonicalGoalEvaluation<'tcx> {
     pub goal: CanonicalInput<'tcx>,
-    pub kind: GoalEvaluationKind<'tcx>,
+    pub data: GoalEvaluationData<'tcx>,
     pub result: QueryResult<'tcx>,
 }
 
 #[derive(Eq, PartialEq, Hash, HashStable)]
-pub enum GoalEvaluationKind<'tcx> {
+pub enum GoalEvaluationData<'tcx> {
     CacheHit(CacheHit),
     Uncached { revisions: Vec<GoalEvaluationStep<'tcx>> },
 }
-impl Debug for GoalEvaluation<'_> {
+impl Debug for RootGoalEvaluation<'_> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        ProofTreeFormatter::new(f).format_goal_evaluation(self)
+        ProofTreeFormatter::new(f).format_root_goal_evaluation(self)
     }
 }
 
 #[derive(Eq, PartialEq, Hash, HashStable)]
 pub struct AddedGoalsEvaluation<'tcx> {
-    pub evaluations: Vec<Vec<GoalEvaluation<'tcx>>>,
+    pub evaluations: Vec<Vec<NestedGoalEvaluation<'tcx>>>,
     pub result: Result<Certainty, NoSolution>,
 }
 
 #[derive(Eq, PartialEq, Hash, HashStable)]
 pub struct GoalEvaluationStep<'tcx> {
-    pub instantiated_goal: QueryInput<'tcx, ty::Predicate<'tcx>>,
-
     pub added_goals_evaluations: Vec<AddedGoalsEvaluation<'tcx>>,
     pub candidates: Vec<GoalCandidate<'tcx>>,
 
diff --git a/compiler/rustc_middle/src/traits/solve/inspect/format.rs b/compiler/rustc_middle/src/traits/solve/inspect/format.rs
@@ -39,12 +39,36 @@ impl<'a, 'b> ProofTreeFormatter<'a, 'b> {
         func(&mut ProofTreeFormatter { f: &mut Indentor { f: self.f, on_newline: true } })
     }
 
-    pub(super) fn format_goal_evaluation(&mut self, eval: &GoalEvaluation<'_>) -> std::fmt::Result {
+    pub(super) fn format_root_goal_evaluation(
+        &mut self,
+        eval: &RootGoalEvaluation<'_>,
+    ) -> std::fmt::Result {
+        writeln!(self.f, "ROOT GOAL: {:?}", eval.goal)?;
+        self.nested(|this| this.format_canonical_goal_evaluation(&eval.evaluation))?;
+        if eval.returned_goals.len() > 0 {
+            writeln!(self.f, "NESTED GOALS ADDED TO CALLER: [")?;
+            self.nested(|this| {
+                for goal in eval.returned_goals.iter() {
+                    writeln!(this.f, "ADDED GOAL: {goal:?},")?;
+                }
+                Ok(())
+            })?;
+
+            writeln!(self.f, "]")
+        } else {
+            Ok(())
+        }
+    }
+
+    pub(super) fn format_nested_goal_evaluation(
+        &mut self,
+        eval: &NestedGoalEvaluation<'_>,
+    ) -> std::fmt::Result {
         let goal_text = match eval.is_normalizes_to_hack {
             IsNormalizesToHack::Yes => "NORMALIZES-TO HACK GOAL",
-            IsNormalizesToHack::No => "GOAL",
+            IsNormalizesToHack::No => "NESTED GOAL",
         };
-        writeln!(self.f, "{}: {:?}", goal_text, eval.uncanonicalized_goal)?;
+        writeln!(self.f, "{}: {:?}", goal_text, eval.goal)?;
         self.nested(|this| this.format_canonical_goal_evaluation(&eval.evaluation))?;
         if eval.returned_goals.len() > 0 {
             writeln!(self.f, "NESTED GOALS ADDED TO CALLER: [")?;
@@ -67,17 +91,17 @@ impl<'a, 'b> ProofTreeFormatter<'a, 'b> {
     ) -> std::fmt::Result {
         writeln!(self.f, "GOAL: {:?}", eval.goal)?;
 
-        match &eval.kind {
-            GoalEvaluationKind::CacheHit(CacheHit::Global) => {
+        match &eval.data {
+            GoalEvaluationData::CacheHit(CacheHit::Global) => {
                 writeln!(self.f, "GLOBAL CACHE HIT: {:?}", eval.result)
             }
-            GoalEvaluationKind::CacheHit(CacheHit::Provisional) => {
+            GoalEvaluationData::CacheHit(CacheHit::Provisional) => {
                 writeln!(self.f, "PROVISIONAL CACHE HIT: {:?}", eval.result)
             }
-            GoalEvaluationKind::Uncached { revisions } => {
+            GoalEvaluationData::Uncached { revisions } => {
                 for (n, step) in revisions.iter().enumerate() {
                     writeln!(self.f, "REVISION {n}: {:?}", step.result)?;
-                    self.nested(|this| this.format_evaluation_step(step))?;
+                    self.format_evaluation_step(step)?;
                 }
                 writeln!(self.f, "RESULT: {:?}", eval.result)
             }
@@ -88,8 +112,6 @@ impl<'a, 'b> ProofTreeFormatter<'a, 'b> {
         &mut self,
         evaluation_step: &GoalEvaluationStep<'_>,
     ) -> std::fmt::Result {
-        writeln!(self.f, "INSTANTIATED: {:?}", evaluation_step.instantiated_goal)?;
-
         for candidate in &evaluation_step.candidates {
             self.nested(|this| this.format_candidate(candidate))?;
         }
@@ -137,7 +159,7 @@ impl<'a, 'b> ProofTreeFormatter<'a, 'b> {
             writeln!(self.f, "ITERATION {n}")?;
             self.nested(|this| {
                 for goal_evaluation in iterations {
-                    this.format_goal_evaluation(goal_evaluation)?;
+                    this.format_nested_goal_evaluation(goal_evaluation)?;
                 }
                 Ok(())
             })?;
diff --git a/compiler/rustc_trait_selection/src/solve/eval_ctxt.rs b/compiler/rustc_trait_selection/src/solve/eval_ctxt.rs
@@ -12,8 +12,8 @@ use rustc_middle::infer::canonical::CanonicalVarInfos;
 use rustc_middle::infer::unify_key::{ConstVariableOrigin, ConstVariableOriginKind};
 use rustc_middle::traits::solve::inspect;
 use rustc_middle::traits::solve::{
-    CanonicalInput, CanonicalResponse, Certainty, IsNormalizesToHack, PredefinedOpaques,
-    PredefinedOpaquesData, QueryResult,
+    CanonicalInput, CanonicalResponse, Certainty, PredefinedOpaques, PredefinedOpaquesData,
+    QueryResult,
 };
 use rustc_middle::traits::{specialization_graph, DefiningAnchor};
 use rustc_middle::ty::{
@@ -28,8 +28,8 @@ use std::ops::ControlFlow;
 use crate::traits::vtable::{count_own_vtable_entries, prepare_vtable_segments, VtblSegment};
 
 use super::inspect::ProofTreeBuilder;
-use super::search_graph;
 use super::SolverMode;
+use super::{search_graph, GoalEvaluationKind};
 use super::{search_graph::SearchGraph, Goal};
 pub use select::InferCtxtSelectExt;
 
@@ -85,7 +85,7 @@ pub struct EvalCtxt<'a, 'tcx> {
     // evaluation code.
     tainted: Result<(), NoSolution>,
 
-    inspect: ProofTreeBuilder<'tcx>,
+    pub(super) inspect: ProofTreeBuilder<'tcx>,
 }
 
 #[derive(Debug, Clone)]
@@ -149,7 +149,7 @@ pub trait InferCtxtEvalExt<'tcx> {
         generate_proof_tree: GenerateProofTree,
     ) -> (
         Result<(bool, Certainty, Vec<Goal<'tcx, ty::Predicate<'tcx>>>), NoSolution>,
-        Option<inspect::GoalEvaluation<'tcx>>,
+        Option<inspect::RootGoalEvaluation<'tcx>>,
     );
 }
 
@@ -161,10 +161,10 @@ impl<'tcx> InferCtxtEvalExt<'tcx> for InferCtxt<'tcx> {
         generate_proof_tree: GenerateProofTree,
     ) -> (
         Result<(bool, Certainty, Vec<Goal<'tcx, ty::Predicate<'tcx>>>), NoSolution>,
-        Option<inspect::GoalEvaluation<'tcx>>,
+        Option<inspect::RootGoalEvaluation<'tcx>>,
     ) {
         EvalCtxt::enter_root(self, generate_proof_tree, |ecx| {
-            ecx.evaluate_goal(IsNormalizesToHack::No, goal)
+            ecx.evaluate_goal(GoalEvaluationKind::Root, goal)
         })
     }
 }
@@ -185,7 +185,7 @@ impl<'a, 'tcx> EvalCtxt<'a, 'tcx> {
         infcx: &InferCtxt<'tcx>,
         generate_proof_tree: GenerateProofTree,
         f: impl FnOnce(&mut EvalCtxt<'_, 'tcx>) -> R,
-    ) -> (R, Option<inspect::GoalEvaluation<'tcx>>) {
+    ) -> (R, Option<inspect::RootGoalEvaluation<'tcx>>) {
         let mode = if infcx.intercrate { SolverMode::Coherence } else { SolverMode::Normal };
         let mut search_graph = search_graph::SearchGraph::new(infcx.tcx, mode);
 
@@ -260,7 +260,7 @@ impl<'a, 'tcx> EvalCtxt<'a, 'tcx> {
             search_graph,
             nested_goals: NestedGoals::new(),
             tainted: Ok(()),
-            inspect: canonical_goal_evaluation.new_goal_evaluation_step(input),
+            inspect: canonical_goal_evaluation.new_goal_evaluation_step(),
         };
 
         for &(key, ty) in &input.predefined_opaques_in_body.opaque_types {
@@ -340,11 +340,13 @@ impl<'a, 'tcx> EvalCtxt<'a, 'tcx> {
     /// been constrained and the certainty of the result.
     fn evaluate_goal(
         &mut self,
-        is_normalizes_to_hack: IsNormalizesToHack,
+        goal_evaluation_kind: GoalEvaluationKind,
         goal: Goal<'tcx, ty::Predicate<'tcx>>,
     ) -> Result<(bool, Certainty, Vec<Goal<'tcx, ty::Predicate<'tcx>>>), NoSolution> {
         let (orig_values, canonical_goal) = self.canonicalize_goal(goal);
-        let mut goal_evaluation = self.inspect.new_goal_evaluation(goal, is_normalizes_to_hack);
+
+        let mut goal_evaluation =
+            ProofTreeBuilder::new_goal_evaluation(self, goal, &orig_values, goal_evaluation_kind);
         let encountered_overflow = self.search_graph.encountered_overflow();
         let canonical_response = EvalCtxt::evaluate_canonical_goal(
             self.tcx(),
@@ -354,7 +356,7 @@ impl<'a, 'tcx> EvalCtxt<'a, 'tcx> {
         );
         let canonical_response = match canonical_response {
             Err(e) => {
-                self.inspect.goal_evaluation(goal_evaluation);
+                ProofTreeBuilder::goal_evaluation(self, goal_evaluation, &[]);
                 return Err(e);
             }
             Ok(response) => response,
@@ -368,13 +370,12 @@ impl<'a, 'tcx> EvalCtxt<'a, 'tcx> {
             canonical_response,
         ) {
             Err(e) => {
-                self.inspect.goal_evaluation(goal_evaluation);
+                ProofTreeBuilder::goal_evaluation(self, goal_evaluation, &[]);
                 return Err(e);
             }
             Ok(response) => response,
         };
-        goal_evaluation.returned_goals(&nested_goals);
-        self.inspect.goal_evaluation(goal_evaluation);
+        ProofTreeBuilder::goal_evaluation(self, goal_evaluation, &nested_goals);
 
         if !has_changed && !nested_goals.is_empty() {
             bug!("an unchanged goal shouldn't have any side-effects on instantiation");
@@ -389,7 +390,7 @@ impl<'a, 'tcx> EvalCtxt<'a, 'tcx> {
         // solver cycle.
         if cfg!(debug_assertions)
             && has_changed
-            && is_normalizes_to_hack == IsNormalizesToHack::No
+            && goal_evaluation_kind != GoalEvaluationKind::NormalizesToHack
             && !self.search_graph.in_cycle()
         {
             // The nested evaluation has to happen with the original state
@@ -562,7 +563,7 @@ impl<'a, 'tcx> EvalCtxt<'a, 'tcx> {
             );
 
             let (_, certainty, instantiate_goals) =
-                self.evaluate_goal(IsNormalizesToHack::Yes, unconstrained_goal)?;
+                self.evaluate_goal(GoalEvaluationKind::NormalizesToHack, unconstrained_goal)?;
             self.add_goals(instantiate_goals);
 
             // Finally, equate the goal's RHS with the unconstrained var.
@@ -597,7 +598,7 @@ impl<'a, 'tcx> EvalCtxt<'a, 'tcx> {
 
         for goal in goals.goals.drain(..) {
             let (has_changed, certainty, instantiate_goals) =
-                self.evaluate_goal(IsNormalizesToHack::No, goal)?;
+                self.evaluate_goal(GoalEvaluationKind::Nested, goal)?;
             self.add_goals(instantiate_goals);
             if has_changed {
                 unchanged_certainty = None;
diff --git a/compiler/rustc_trait_selection/src/solve/eval_ctxt/canonical.rs b/compiler/rustc_trait_selection/src/solve/eval_ctxt/canonical.rs
@@ -10,6 +10,7 @@
 //! [c]: https://rustc-dev-guide.rust-lang.org/solve/canonicalization.html
 use super::{CanonicalInput, Certainty, EvalCtxt, Goal};
 use crate::solve::canonicalize::{CanonicalizeMode, Canonicalizer};
+use crate::solve::inspect;
 use crate::solve::{response_no_constraints_raw, CanonicalResponse, QueryResult, Response};
 use rustc_data_structures::fx::FxHashSet;
 use rustc_index::IndexVec;
@@ -331,6 +332,22 @@ impl<'tcx> EvalCtxt<'_, 'tcx> {
     }
 }
 
+impl<'tcx> inspect::ProofTreeBuilder<'tcx> {
+    pub fn make_canonical_state<T: TypeFoldable<TyCtxt<'tcx>>>(
+        ecx: &EvalCtxt<'_, 'tcx>,
+        data: T,
+    ) -> inspect::CanonicalState<'tcx, T> {
+        let state = inspect::State { var_values: ecx.var_values, data };
+        let state = state.fold_with(&mut EagerResolver { infcx: ecx.infcx });
+        Canonicalizer::canonicalize(
+            ecx.infcx,
+            CanonicalizeMode::Response { max_input_universe: ecx.max_input_universe },
+            &mut vec![],
+            state,
+        )
+    }
+}
+
 /// Resolves ty, region, and const vars to their inferred values or their root vars.
 struct EagerResolver<'a, 'tcx> {
     infcx: &'a InferCtxt<'tcx>,
diff --git a/compiler/rustc_trait_selection/src/solve/inspect.rs b/compiler/rustc_trait_selection/src/solve/inspect.rs
diff --git a/compiler/rustc_trait_selection/src/solve/mod.rs b/compiler/rustc_trait_selection/src/solve/mod.rs

Original file line number	Diff line number	Diff line change
`@@ -229,9 +229,3 @@ impl<'tcx> TypeVisitable<TyCtxt<'tcx>> for PredefinedOpaques<'tcx> {`
`229`	`229`	`self.opaque_types.visit_with(visitor)`
`230`	`230`	`}`
`231`	`231`	`}`
`232`		`-`
`233`		`-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, HashStable)]`
`234`		`-pub enum IsNormalizesToHack {`
`235`		`- Yes,`
`236`		`- No,`
`237`		`-}`