cleanup1

Author: lcnr

compiler/rustc_type_ir/src/search_graph/mod.rs

@@ -703,6 +703,14 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
             evaluation_result.encountered_overflow,
             UpdateParentGoalCtxt::Ordinary(&evaluation_result.nested_goals),
         );
+        // FIXME: Cloning the cycle heads here is quite ass. We should make cycle heads
+        // CoW and use reference counting.
+        self.tree.finish_evaluation(
+            evaluation_result.node_id,
+            evaluation_result.encountered_overflow,
+            evaluation_result.heads.clone(),
+            evaluation_result.result,
+        );
         let result = evaluation_result.result;
 
         // We're now done with this goal. We only add the root of cycles to the global cache.
@@ -1130,15 +1138,6 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
         let mut stack_entry = self.stack.pop();
         let mut encountered_overflow = stack_entry.encountered_overflow;
         debug_assert_eq!(stack_entry.input, input);
-        // FIXME: Cloning the cycle heads here is quite ass. We should make cycle heads
-        // CoW and use reference counting.
-        self.tree.finish_evaluate(
-            stack_entry.node_id,
-            stack_entry.encountered_overflow,
-            stack_entry.heads.clone(),
-            result,
-        );
-
         // If the current goal is not the root of a cycle, we are done.
         //
         // There are no provisional cache entries which depend on this goal.
@@ -1290,7 +1289,7 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
                 self.tree.get_cycle(cycle);
 
             match self.tree.node_kind_raw(cycle_node_id) {
-                &tree::NodeKind::InProgress { .. } | &tree::NodeKind::Regular { .. } => {
+                &tree::NodeKind::InProgress { .. } | &tree::NodeKind::Finished { .. } => {
                     unreachable!()
                 }
                 &tree::NodeKind::CycleOnStack { entry_node_id, result: _ } => {

compiler/rustc_type_ir/src/search_graph/tree.rs

@@ -28,31 +28,10 @@ rustc_index::newtype_index! {
 
 #[derive_where(Debug; X: Cx)]
 pub(super) enum NodeKind<X: Cx> {
-    InProgress {
-        cycles_start: CycleId,
-    },
-    Regular {
-        // The result of evaluating this node. This does not change between
-        // reruns and may get accessed multiple times when rerunning parent nodes.
-        encountered_overflow: bool,
-        heads: CycleHeads,
-        result: X::Result,
-
-        // When reevaluating the current goal, we need to know all cyclic
-        // goals to check whether changing the provisional result changes the
-        // the final result. This is only accessed when reevaluating a goal
-        // and gets reset to the `tree.cycles.next_index()` at this point.
-        // Not all of the cycles encountered while evaluating this goal actually
-        // depend on this goal itself.
-        cycles_start: CycleId,
-    },
-    CycleOnStack {
-        entry_node_id: NodeId,
-        result: X::Result,
-    },
-    ProvisionalCacheHit {
-        entry_node_id: NodeId,
-    },
+    InProgress { cycles_start: CycleId },
+    Finished { encountered_overflow: bool, heads: CycleHeads, result: X::Result },
+    CycleOnStack { entry_node_id: NodeId, result: X::Result },
+    ProvisionalCacheHit { entry_node_id: NodeId },
 }
 
 #[derive_where(Debug; X: Cx)]
@@ -122,18 +101,17 @@ impl<X: Cx> SearchTree<X> {
         self.nodes[node_id].kind = NodeKind::CycleOnStack { entry_node_id, result }
     }
 
-    pub(super) fn finish_evaluate(
+    pub(super) fn finish_evaluation(
         &mut self,
         node_id: NodeId,
         encountered_overflow: bool,
         heads: CycleHeads,
         result: X::Result,
     ) {
-        let NodeKind::InProgress { cycles_start } = self.nodes[node_id].kind else {
+        let NodeKind::InProgress { cycles_start: _ } = self.nodes[node_id].kind else {
             panic!("unexpected node kind: {:?}", self.nodes[node_id]);
         };
-        self.nodes[node_id].kind =
-            NodeKind::Regular { cycles_start, encountered_overflow, heads, result }
+        self.nodes[node_id].kind = NodeKind::Finished { encountered_overflow, heads, result }
     }
 
     pub(super) fn get_cycle(&self, cycle_id: CycleId) -> &Cycle<X> {
@@ -147,17 +125,15 @@ impl<X: Cx> SearchTree<X> {
     pub(super) fn result_matches(&self, prev: NodeId, new: NodeId) -> bool {
         match (&self.nodes[prev].kind, &self.nodes[new].kind) {
             (
-                NodeKind::Regular {
-                    result: prev_result,
+                NodeKind::Finished {
                     encountered_overflow: prev_overflow,
                     heads: prev_heads,
-                    cycles_start: _,
+                    result: prev_result,
                 },
-                NodeKind::Regular {
+                NodeKind::Finished {
                     encountered_overflow: new_overflow,
                     heads: new_heads,
                     result: new_result,
-                    cycles_start: _,
                 },
             ) => {
                 prev_result == new_result
@@ -173,7 +149,7 @@ impl<X: Cx> SearchTree<X> {
     }
 
     pub(super) fn rerun_get_and_reset_cycles(&mut self, node_id: NodeId) -> Range<CycleId> {
-        if let NodeKind::Regular { cycles_start, .. } = &mut self.nodes[node_id].kind {
+        if let NodeKind::InProgress { cycles_start, .. } = &mut self.nodes[node_id].kind {
             let prev = *cycles_start;
             *cycles_start = self.cycles.next_index();
             prev..self.cycles.next_index()
@@ -183,7 +159,7 @@ impl<X: Cx> SearchTree<X> {
     }
 
     pub(super) fn get_heads(&self, node_id: NodeId) -> &CycleHeads {
-        if let NodeKind::Regular { heads, .. } = &self.nodes[node_id].kind {
+        if let NodeKind::Finished { heads, .. } = &self.nodes[node_id].kind {
             heads
         } else {
             panic!("unexpected node kind: {:?}", self.nodes[node_id]);