gamer, fuzzing works

Author: lcnr

compiler/rustc_type_ir/src/search_graph/mod.rs

@@ -193,41 +193,6 @@ impl UsageKind {
     }
 }
 
-/// For each goal we track whether the paths from this goal
-/// to its cycle heads are coinductive.
-///
-/// This is a necessary condition to rebase provisional cache
-/// entries.
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum AllPathsToHeadForcedAmbiguity {
-    Yes,
-    No,
-}
-impl From<PathKind> for AllPathsToHeadForcedAmbiguity {
-    fn from(path: PathKind) -> AllPathsToHeadForcedAmbiguity {
-        match path {
-            PathKind::ForcedAmbiguity => AllPathsToHeadForcedAmbiguity::Yes,
-            _ => AllPathsToHeadForcedAmbiguity::No,
-        }
-    }
-}
-impl AllPathsToHeadForcedAmbiguity {
-    #[must_use]
-    fn merge(self, other: impl Into<Self>) -> Self {
-        match (self, other.into()) {
-            (AllPathsToHeadForcedAmbiguity::Yes, AllPathsToHeadForcedAmbiguity::Yes) => {
-                AllPathsToHeadForcedAmbiguity::Yes
-            }
-            (AllPathsToHeadForcedAmbiguity::No, _) | (_, AllPathsToHeadForcedAmbiguity::No) => {
-                AllPathsToHeadForcedAmbiguity::No
-            }
-        }
-    }
-    fn and_merge(&mut self, other: impl Into<Self>) {
-        *self = self.merge(other);
-    }
-}
-
 #[derive(Debug, Clone, Copy)]
 struct AvailableDepth(usize);
 impl AvailableDepth {
@@ -267,9 +232,9 @@ impl AvailableDepth {
 ///
 /// We also track all paths from this goal to that head. This is necessary
 /// when rebasing provisional cache results.
-#[derive(Clone, Debug, PartialEq, Eq, Default)]
+#[derive(Clone, Debug, Default)]
 struct CycleHeads {
-    heads: BTreeMap<StackDepth, AllPathsToHeadForcedAmbiguity>,
+    heads: BTreeMap<StackDepth, PathsToNested>,
 }
 
 impl CycleHeads {
@@ -289,27 +254,22 @@ impl CycleHeads {
         self.heads.first_key_value().map(|(k, _)| *k)
     }
 
-    fn remove_highest_cycle_head(&mut self) {
+    fn remove_highest_cycle_head(&mut self) -> PathsToNested {
         let last = self.heads.pop_last();
-        debug_assert_ne!(last, None);
+        last.unwrap().1
     }
 
-    fn insert(
-        &mut self,
-        head: StackDepth,
-        path_from_entry: impl Into<AllPathsToHeadForcedAmbiguity> + Copy,
-    ) {
-        self.heads.entry(head).or_insert(path_from_entry.into()).and_merge(path_from_entry);
+    fn insert(&mut self, head: StackDepth, path_from_entry: impl Into<PathsToNested> + Copy) {
+        *self.heads.entry(head).or_insert(path_from_entry.into()) |= path_from_entry.into();
     }
 
     fn merge(&mut self, heads: &CycleHeads) {
         for (&head, &path_from_entry) in heads.heads.iter() {
             self.insert(head, path_from_entry);
-            debug_assert!(matches!(self.heads[&head], AllPathsToHeadForcedAmbiguity::Yes));
         }
     }
 
-    fn iter(&self) -> impl Iterator<Item = (StackDepth, AllPathsToHeadForcedAmbiguity)> + '_ {
+    fn iter(&self) -> impl Iterator<Item = (StackDepth, PathsToNested)> + '_ {
         self.heads.iter().map(|(k, v)| (*k, *v))
     }
 
@@ -323,15 +283,7 @@ impl CycleHeads {
                 Ordering::Equal => continue,
                 Ordering::Greater => unreachable!(),
             }
-
-            let path_from_entry = match step_kind {
-                PathKind::ForcedAmbiguity => AllPathsToHeadForcedAmbiguity::Yes,
-                PathKind::Unknown | PathKind::Inductive | PathKind::Coinductive => {
-                    path_from_entry
-                }
-            };
-
-            self.insert(head, path_from_entry);
+            self.insert(head, path_from_entry.extend_with(step_kind));
         }
     }
 
@@ -348,7 +300,7 @@ bitflags::bitflags! {
     /// Tracks how nested goals have been accessed. This is necessary to disable
     /// global cache entries if computing them would otherwise result in a cycle or
     /// access a provisional cache entry.
-    #[derive(Debug, Clone, Copy)]
+    #[derive(Debug, Clone, Copy, PartialEq, Eq)]
     pub struct PathsToNested: u8 {
         /// The initial value when adding a goal to its own nested goals.
         const EMPTY                      = 1 << 0;
@@ -417,6 +369,26 @@ impl PathsToNested {
 
         self
     }
+
+    #[must_use]
+    fn extend_with_paths(mut self, path: PathsToNested) -> Self {
+        let mut new = PathsToNested::empty();
+        let (PathKind::Inductive
+        | PathKind::Unknown
+        | PathKind::Coinductive
+        | PathKind::ForcedAmbiguity);
+        for n in [
+            PathKind::Inductive,
+            PathKind::Unknown,
+            PathKind::Coinductive,
+            PathKind::ForcedAmbiguity,
+        ] {
+            if path.contains(n.into()) {
+                new |= self.extend_with(n);
+            }
+        }
+        new
+    }
 }
 
 /// The nested goals of each stack entry and the path from the
@@ -862,30 +834,30 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
                     path_from_head,
                     result,
                 } = entry;
-                if heads.highest_cycle_head() == head {
+                let ep = if heads.highest_cycle_head() == head {
                     heads.remove_highest_cycle_head()
                 } else {
                     return true;
-                }
-
-                // We only try to rebase if all paths from the cache entry
-                // to its heads are coinductive. In this case these cycle
-                // kinds won't change, no matter the goals between these
-                // heads and the provisional cache entry.
-                if heads.iter().any(|(_, p)| matches!(p, AllPathsToHeadForcedAmbiguity::No)) {
-                    return false;
-                }
+                };
 
-                // The same for nested goals of the cycle head.
-                if stack_entry.heads.iter().any(|(_, p)| matches!(p, AllPathsToHeadForcedAmbiguity::No))
-                {
-                    return false;
+                // We're rebasing an entry `e` over a head `p`. This head
+                // has a number of own heads `h` it depends on. We need to
+                // make sure that the cycle `hph` cannot change after rebasing.
+                //
+                // After rebasing the cycles `hph` will go through the path `heph` instead.
+                // We need to check hep = hp.
+                for (h, ph) in stack_entry.heads.iter() {
+                    let hp = Self::cycle_path_kind(&stack, stack_entry.step_kind_from_parent, h);
+                    let he = hp.extend(*path_from_head);
+                    let hep = ep.extend_with(he);
+                    if PathsToNested::from(hp) == hep {
+                        let eph = ep.extend_with_paths(ph);
+                        heads.insert(h, eph);
+                    } else {
+                        return false;
+                    }
                 }
 
-                // Merge the cycle heads of the provisional cache entry and the
-                // popped head. If the popped cycle head was a root, discard all
-                // provisional cache entries which depend on it.
-                heads.merge(&stack_entry.heads);
                 let Some(head) = heads.opt_highest_cycle_head() else {
                     return false;
                 };