Restore alternative predicates for obligation forest

Extracted a test from the object crate found while running on CI (did
not exist the in the actual test suite).

Author: Marwes

compiler/rustc_data_structures/src/obligation_forest/mod.rs

@@ -252,6 +252,10 @@ struct Node<O: ForestObligation> {
     obligation: O,
     state: Cell<NodeState>,
 
+    /// A predicate (and its key) can change during processing. If it does we need to register the
+    /// old predicate so that we can remove or mark it as done if this node errors or is done.
+    alternative_predicates: Vec<O::CacheKey>,
+
     /// Obligations that depend on this obligation for their completion. They
     /// must all be in a non-pending state.
     dependents: Vec<NodeIndex>,
@@ -287,6 +291,7 @@ where
         Node {
             obligation,
             state: Cell::new(NodeState::Pending),
+            alternative_predicates: vec![],
             dependents: if let Some(parent_index) = parent { vec![parent_index] } else { vec![] },
             reverse_dependents: vec![],
             has_parent: parent.is_some(),
@@ -311,6 +316,7 @@ where
             self.state
         );
         self.state.set(NodeState::Pending);
+        self.alternative_predicates.clear();
         self.dependents.clear();
         self.reverse_dependents.clear();
         if let Some(parent_index) = parent {
@@ -660,7 +666,12 @@ impl<O: ForestObligation> ObligationForest<O> {
                 // `self.active_cache`. This means that `self.active_cache` can get
                 // out of sync with `nodes`. It's not very common, but it does
                 // happen, and code in `compress` has to allow for it.
+                let before = node.obligation.as_cache_key();
                 let result = processor.process_obligation(&mut node.obligation);
+                let after = node.obligation.as_cache_key();
+                if before != after {
+                    node.alternative_predicates.push(before);
+                }
 
                 self.unblock_nodes(processor);
                 let node = &mut self.nodes[index];
@@ -934,6 +945,12 @@ impl<O: ForestObligation> ObligationForest<O> {
                         .active_cache
                         .entry(node.obligation.as_cache_key())
                         .or_insert(CacheState::Done) = CacheState::Done;
+                    // If the node's predicate changed at some point we mark all its alternate
+                    // predicates as done as well
+                    for alt in node.alternative_predicates.drain(..) {
+                        *self.active_cache.entry(alt).or_insert(CacheState::Done) =
+                            CacheState::Done;
+                    }
 
                     if do_completed == DoCompleted::Yes {
                         // Extract the success stories.
@@ -949,6 +966,11 @@ impl<O: ForestObligation> ObligationForest<O> {
                     // tests must come up with a different type on every type error they
                     // check against.
                     self.active_cache.remove(&node.obligation.as_cache_key());
+                    // If the node's predicate changed at some point we remove all its alternate
+                    // predicates as well
+                    for alt in &node.alternative_predicates {
+                        self.active_cache.remove(alt);
+                    }
                     self.insert_into_error_cache(index);
                     self.dead_nodes.push(index);
                 }

compiler/rustc_middle/src/infer/unify_key.rs

@@ -160,7 +160,7 @@ pub struct ConstVarValue<'tcx> {
     pub val: ConstVariableValue<'tcx>,
 }
 
-#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, RustcEncodable, RustcDecodable)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, TyEncodable, TyDecodable)]
 pub struct ConstVidEqKey<'tcx> {
     pub vid: ty::ConstVid,
     pub phantom: PhantomData<&'tcx ()>,

compiler/rustc_middle/src/ty/sty.rs

@@ -1040,11 +1040,7 @@ impl<T> Binder<T> {
     where
         T: TypeFoldable<'tcx>,
     {
-        if self.0.has_escaping_bound_vars() {
-            None
-        } else {
-            Some(self.skip_binder())
-        }
+        if self.0.has_escaping_bound_vars() { None } else { Some(self.skip_binder()) }
     }
 
     /// Given two things that have the same binder level,
@@ -1927,11 +1923,7 @@ impl<'tcx> TyS<'tcx> {
 
     #[inline]
     pub fn is_phantom_data(&self) -> bool {
-        if let Adt(def, _) = self.kind() {
-            def.is_phantom_data()
-        } else {
-            false
-        }
+        if let Adt(def, _) = self.kind() { def.is_phantom_data() } else { false }
     }
 
     #[inline]

src/test/ui/obligation-forest-bug-69218-2.rs

@@ -0,0 +1,27 @@
+// run-pass
+#![allow(dead_code)]
+
+use std::borrow::Cow;
+
+pub type Result<T> = std::result::Result<T, &'static str>;
+
+pub struct CompressedData<'data> {
+    pub format: CompressionFormat,
+    pub data: &'data [u8],
+}
+
+pub enum CompressionFormat {
+    None,
+    Unknown,
+}
+
+impl<'data> CompressedData<'data> {
+    pub fn decompress(self) -> Result<Cow<'data, [u8]>> {
+        match self.format {
+            CompressionFormat::None => Ok(Cow::Borrowed(self.data)),
+            _ => Err("Unsupported compressed data."),
+        }
+    }
+}
+
+fn main() {}