Auto merge of #142735 - lcnr:search_graph-5, r=<try>

lazily reevaluate nested goals

It sure is a tragedy. Opening just so I have something to show for the last few weeks. This does not yet fix the perf regression in rayon. However, it does pass fuzzing and implements the simplest version of what I want this to be long term.

r? ghost

Author: rust-bors[bot]

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

@@ -425,25 +425,27 @@ where
         //
         // The actual solver logic happens in `ecx.compute_goal`.
         let result = ensure_sufficient_stack(|| {
-            search_graph.with_new_goal(
-                cx,
-                canonical_input,
-                step_kind_from_parent,
-                &mut canonical_goal_evaluation,
-                |search_graph, canonical_goal_evaluation| {
-                    EvalCtxt::enter_canonical(
-                        cx,
-                        search_graph,
-                        canonical_input,
-                        canonical_goal_evaluation,
-                        |ecx, goal| {
-                            let result = ecx.compute_goal(goal);
-                            ecx.inspect.query_result(result);
-                            result
-                        },
-                    )
-                },
-            )
+            search_graph
+                .with_new_goal(
+                    cx,
+                    canonical_input,
+                    step_kind_from_parent,
+                    &mut canonical_goal_evaluation,
+                    |search_graph, cx, canonical_input, canonical_goal_evaluation| {
+                        EvalCtxt::enter_canonical(
+                            cx,
+                            search_graph,
+                            canonical_input,
+                            canonical_goal_evaluation,
+                            |ecx, goal| {
+                                let result = ecx.compute_goal(goal);
+                                ecx.inspect.query_result(result);
+                                result
+                            },
+                        )
+                    },
+                )
+                .1
         });
 
         canonical_goal_evaluation.query_result(result);

compiler/rustc_type_ir/src/data_structures/mod.rs

@@ -2,7 +2,7 @@ use std::hash::BuildHasherDefault;
 
 pub use ena::unify::{NoError, UnifyKey, UnifyValue};
 use rustc_hash::FxHasher;
-pub use rustc_hash::{FxHashMap as HashMap, FxHashSet as HashSet};
+pub use rustc_hash::{FxBuildHasher as BuildHasher, FxHashMap as HashMap, FxHashSet as HashSet};
 
 pub type IndexMap<K, V> = indexmap::IndexMap<K, V, BuildHasherDefault<FxHasher>>;
 pub type IndexSet<V> = indexmap::IndexSet<V, BuildHasherDefault<FxHasher>>;

compiler/rustc_type_ir/src/search_graph/global_cache.rs

@@ -2,6 +2,7 @@ use derive_where::derive_where;
 
 use super::{AvailableDepth, Cx, NestedGoals};
 use crate::data_structures::HashMap;
+use crate::search_graph::EvaluationResult;
 
 struct Success<X: Cx> {
     required_depth: usize,
@@ -43,28 +44,32 @@ impl<X: Cx> GlobalCache<X> {
         &mut self,
         cx: X,
         input: X::Input,
-
-        origin_result: X::Result,
+        evaluation_result: EvaluationResult<X>,
         dep_node: X::DepNodeIndex,
-
-        required_depth: usize,
-        encountered_overflow: bool,
-        nested_goals: NestedGoals<X>,
     ) {
-        let result = cx.mk_tracked(origin_result, dep_node);
+        let EvaluationResult {
+            node_id: _,
+            encountered_overflow,
+            required_depth,
+            heads,
+            nested_goals,
+            result,
+        } = evaluation_result;
+        debug_assert!(heads.is_empty());
+        let result = cx.mk_tracked(result, dep_node);
         let entry = self.map.entry(input).or_default();
         if encountered_overflow {
             let with_overflow = WithOverflow { nested_goals, result };
             let prev = entry.with_overflow.insert(required_depth, with_overflow);
             if let Some(prev) = &prev {
                 assert!(cx.evaluation_is_concurrent());
-                assert_eq!(cx.get_tracked(&prev.result), origin_result);
+                assert_eq!(cx.get_tracked(&prev.result), evaluation_result.result);
             }
         } else {
             let prev = entry.success.replace(Success { required_depth, nested_goals, result });
             if let Some(prev) = &prev {
                 assert!(cx.evaluation_is_concurrent());
-                assert_eq!(cx.get_tracked(&prev.result), origin_result);
+                assert_eq!(cx.get_tracked(&prev.result), evaluation_result.result);
             }
         }
     }