w

Author: lcnr

compiler/rustc_type_ir/src/search_graph/mod.rs

@@ -170,28 +170,38 @@ impl PathKind {
 /// This is used to avoid rerunning a cycle if there's
 /// just a single usage kind and the final result matches
 /// its provisional result.
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum UsageKind {
-    Single(PathKind),
-    Mixed,
+#[derive(Default, Debug, Clone, Copy, PartialEq, Eq)]
+struct Usages {
+    inductive: u32,
+    unknown: u32,
+    coinductive: u32,
+    forced_ambiguity: u32,
 }
-impl From<PathKind> for UsageKind {
-    fn from(path: PathKind) -> UsageKind {
-        UsageKind::Single(path)
+
+impl Usages {
+    fn add_usage(&mut self, path: PathKind) {
+        match path {
+            PathKind::Inductive => self.inductive += 1,
+            PathKind::Unknown => self.unknown += 1,
+            PathKind::Coinductive => self.coinductive += 1,
+            PathKind::ForcedAmbiguity => self.forced_ambiguity += 1,
+        }
     }
-}
-impl UsageKind {
-    #[must_use]
-    fn merge(self, other: impl Into<Self>) -> Self {
-        match (self, other.into()) {
-            (UsageKind::Mixed, _) | (_, UsageKind::Mixed) => UsageKind::Mixed,
-            (UsageKind::Single(lhs), UsageKind::Single(rhs)) => {
-                if lhs == rhs {
-                    UsageKind::Single(lhs)
-                } else {
-                    UsageKind::Mixed
-                }
-            }
+
+    fn add_usages(&mut self, usages: Usages) {
+        let Usages { inductive, unknown, coinductive, forced_ambiguity } = usages;
+        self.inductive += inductive;
+        self.unknown += unknown;
+        self.coinductive += coinductive;
+        self.forced_ambiguity += forced_ambiguity;
+    }
+
+    fn compressed(self) -> Usages {
+        Usages {
+            inductive: if self.inductive == 0 { 0 } else { 1 },
+            unknown: if self.unknown == 0 { 0 } else { 1 },
+            coinductive: if self.coinductive == 0 { 0 } else { 1 },
+            forced_ambiguity: if self.forced_ambiguity == 0 { 0 } else { 1 },
         }
     }
 }
@@ -234,7 +244,7 @@ impl AvailableDepth {
 #[derive(Clone, Copy, Debug)]
 struct CycleHead {
     paths_to_head: PathsToNested,
-    usage_kind: UsageKind,
+    usages: Usages,
 }
 
 /// All cycle heads a given goal depends on, ordered by their stack depth.
@@ -272,16 +282,16 @@ impl CycleHeads {
         &mut self,
         head_index: StackDepth,
         path_from_entry: impl Into<PathsToNested> + Copy,
-        usage_kind: UsageKind,
+        usages: Usages,
     ) {
         match self.heads.entry(head_index) {
             btree_map::Entry::Vacant(entry) => {
-                entry.insert(CycleHead { paths_to_head: path_from_entry.into(), usage_kind });
+                entry.insert(CycleHead { paths_to_head: path_from_entry.into(), usages });
             }
             btree_map::Entry::Occupied(entry) => {
                 let head = entry.into_mut();
                 head.paths_to_head |= path_from_entry.into();
-                head.usage_kind = head.usage_kind.merge(usage_kind);
+                head.usages.add_usages(usages);
             }
         }
     }
@@ -550,13 +560,10 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
                     Ordering::Less => parent.heads.insert(
                         head_index,
                         head.paths_to_head.extend_with(step_kind_from_parent),
-                        head.usage_kind,
+                        head.usages.compressed(),
                     ),
                     Ordering::Equal => {
-                        let usage_kind = parent
-                            .has_been_used
-                            .map_or(head.usage_kind, |prev| prev.merge(head.usage_kind));
-                        parent.has_been_used = Some(usage_kind);
+                        parent.usages.get_or_insert_default().add_usages(head.usages.compressed());
                     }
                     Ordering::Greater => unreachable!(),
                 }
@@ -681,7 +688,7 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
             required_depth: 0,
             heads: Default::default(),
             encountered_overflow: false,
-            has_been_used: None,
+            usages: None,
             nested_goals: Default::default(),
         });
 
@@ -849,7 +856,7 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
                     // the heads of `e` to make sure that rebasing `e` again also considers
                     // them.
                     let eph = ep.extend_with_paths(ph);
-                    heads.insert(head_index, eph, head.usage_kind);
+                    heads.insert(head_index, eph, head.usages.compressed());
                 }
 
                 let Some(head) = heads.opt_highest_cycle_head() else {
@@ -1054,10 +1061,9 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
         // in case we're in the first fixpoint iteration for this goal.
         let path_kind = Self::cycle_path_kind(&self.stack, step_kind_from_parent, head_index);
         debug!(?path_kind, "encountered cycle with depth {head_index:?}");
-        let head = CycleHead {
-            paths_to_head: step_kind_from_parent.into(),
-            usage_kind: UsageKind::Single(path_kind),
-        };
+        let mut usages = Usages::default();
+        usages.add_usage(path_kind);
+        let head = CycleHead { paths_to_head: step_kind_from_parent.into(), usages };
         Self::update_parent_goal(
             &mut self.stack,
             step_kind_from_parent,
@@ -1081,15 +1087,28 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
         &mut self,
         cx: X,
         stack_entry: &StackEntry<X>,
-        usage_kind: UsageKind,
+        usages: Usages,
         result: X::Result,
     ) -> bool {
-        if let Some(prev) = stack_entry.provisional_result {
-            prev == result
-        } else if let UsageKind::Single(kind) = usage_kind {
-            D::is_initial_provisional_result(cx, kind, stack_entry.input, result)
-        } else {
-            false
+        let provisional_result = stack_entry.provisional_result;
+        let check = |kind| D::is_initial_provisional_result(cx, kind, stack_entry.input, result);
+        match usages {
+            Usages { inductive: 0, unknown: 0, coinductive: 0, forced_ambiguity: 0 } => true,
+            // FIXME: use `feature(if_let_guard)` once it is stable.
+            _ if provisional_result.is_some() => provisional_result.unwrap() == result,
+            Usages { inductive: _, unknown: 0, coinductive: 0, forced_ambiguity: 0 } => {
+                check(PathKind::Inductive)
+            }
+            Usages { inductive: 0, unknown: _, coinductive: 0, forced_ambiguity: 0 } => {
+                check(PathKind::Unknown)
+            }
+            Usages { inductive: 0, unknown: 0, coinductive: _, forced_ambiguity: 0 } => {
+                check(PathKind::Coinductive)
+            }
+            Usages { inductive: 0, unknown: 0, coinductive: 0, forced_ambiguity: _ } => {
+                check(PathKind::ForcedAmbiguity)
+            }
+            _ => false,
         }
     }
 
@@ -1119,7 +1138,7 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
             // 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.
-            let Some(usage_kind) = stack_entry.has_been_used else {
+            let Some(usages) = stack_entry.usages else {
                 return EvaluationResult::finalize(stack_entry, encountered_overflow, result);
             };
 
@@ -1134,7 +1153,7 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
             // is equal to the provisional result of the previous iteration, or because
             // this was only the root of either coinductive or inductive cycles, and the
             // final result is equal to the initial response for that case.
-            if self.reached_fixpoint(cx, &stack_entry, usage_kind, result) {
+            if self.reached_fixpoint(cx, &stack_entry, usages, result) {
                 self.rebase_provisional_cache_entries(&stack_entry, |_, result| result);
                 return EvaluationResult::finalize(stack_entry, encountered_overflow, result);
             }
@@ -1191,7 +1210,7 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
                 // similar to the previous iterations when reevaluating, it's better
                 // for caching if the reevaluation also starts out with `false`.
                 encountered_overflow: false,
-                has_been_used: None,
+                usages: None,
             });
         }
     }

compiler/rustc_type_ir/src/search_graph/stack.rs

@@ -3,7 +3,7 @@ use std::ops::Index;
 use derive_where::derive_where;
 use rustc_index::IndexVec;
 
-use crate::search_graph::{AvailableDepth, Cx, CycleHeads, NestedGoals, PathKind, UsageKind};
+use crate::search_graph::{AvailableDepth, Cx, CycleHeads, NestedGoals, PathKind, Usages};
 
 rustc_index::newtype_index! {
     #[orderable]
@@ -40,9 +40,8 @@ pub(super) struct StackEntry<X: Cx> {
     /// Whether evaluating this goal encountered overflow. Lazily updated.
     pub encountered_overflow: bool,
 
-    /// Whether this goal has been used as the root of a cycle. This gets
-    /// eagerly updated when encountering a cycle.
-    pub has_been_used: Option<UsageKind>,
+    /// Whether and how this goal has been used as the root of a cycle. Lazily updated.
+    pub usages: Option<Usages>,
 
     /// The nested goals of this goal, see the doc comment of the type.
     pub nested_goals: NestedGoals<X>,