now... how do i make this readable

Author: lcnr

compiler/rustc_trait_selection/src/lib.rs

@@ -19,6 +19,7 @@
 #![feature(control_flow_enum)]
 #![feature(extract_if)]
 #![feature(let_chains)]
+#![feature(option_take_if)]
 #![feature(if_let_guard)]
 #![feature(never_type)]
 #![feature(type_alias_impl_trait)]

compiler/rustc_trait_selection/src/solve/search_graph.rs

@@ -11,7 +11,6 @@ use rustc_middle::traits::solve::{CanonicalInput, Certainty, EvaluationCache, Qu
 use rustc_middle::ty;
 use rustc_middle::ty::TyCtxt;
 use rustc_session::Limit;
-use std::collections::hash_map::Entry;
 use std::mem;
 
 rustc_index::newtype_index! {
@@ -30,7 +29,7 @@ struct StackEntry<'tcx> {
     ///
     /// If so, it must not be moved to the global cache. See
     /// [SearchGraph::cycle_participants] for more details.
-    non_root_cycle_participant: bool,
+    non_root_cycle_participant: Option<StackDepth>,
 
     encountered_overflow: bool,
     has_been_used: bool,
@@ -39,14 +38,34 @@ struct StackEntry<'tcx> {
     provisional_result: Option<QueryResult<'tcx>>,
 }
 
+struct DetachedEntry<'tcx> {
+    highest_cycle_head: StackDepth,
+    result: QueryResult<'tcx>,
+}
+
+#[derive(Default)]
+struct ProvisionalCacheEntry<'tcx> {
+    stack_depth: Option<StackDepth>,
+    true_to_highest: Option<DetachedEntry<'tcx>>,
+    false_to_highest: Option<DetachedEntry<'tcx>>,
+}
+
+impl<'tcx> ProvisionalCacheEntry<'tcx> {
+    fn is_empty(&self) -> bool {
+        self.stack_depth.is_none()
+            && self.true_to_highest.is_none()
+            && self.false_to_highest.is_none()
+    }
+}
+
 pub(super) struct SearchGraph<'tcx> {
     mode: SolverMode,
     local_overflow_limit: usize,
     /// The stack of goals currently being computed.
     ///
     /// An element is *deeper* in the stack if its index is *lower*.
     stack: IndexVec<StackDepth, StackEntry<'tcx>>,
-    stack_entries: FxHashMap<CanonicalInput<'tcx>, StackDepth>,
+    provisional_cache: FxHashMap<CanonicalInput<'tcx>, ProvisionalCacheEntry<'tcx>>,
     /// We put only the root goal of a coinductive cycle into the global cache.
     ///
     /// If we were to use that result when later trying to prove another cycle
@@ -63,7 +82,7 @@ impl<'tcx> SearchGraph<'tcx> {
             mode,
             local_overflow_limit: tcx.recursion_limit().0.checked_ilog2().unwrap_or(0) as usize,
             stack: Default::default(),
-            stack_entries: Default::default(),
+            provisional_cache: Default::default(),
             cycle_participants: Default::default(),
         }
     }
@@ -93,7 +112,7 @@ impl<'tcx> SearchGraph<'tcx> {
     /// would cause us to not track overflow and recursion depth correctly.
     fn pop_stack(&mut self) -> StackEntry<'tcx> {
         let elem = self.stack.pop().unwrap();
-        assert!(self.stack_entries.remove(&elem.input).is_some());
+        self.provisional_cache.get_mut(&elem.input).unwrap().stack_depth = None;
         if let Some(last) = self.stack.raw.last_mut() {
             last.reached_depth = last.reached_depth.max(elem.reached_depth);
             last.encountered_overflow |= elem.encountered_overflow;
@@ -114,7 +133,7 @@ impl<'tcx> SearchGraph<'tcx> {
 
     pub(super) fn is_empty(&self) -> bool {
         if self.stack.is_empty() {
-            debug_assert!(self.stack_entries.is_empty());
+            debug_assert!(self.provisional_cache.is_empty());
             debug_assert!(self.cycle_participants.is_empty());
             true
         } else {
@@ -210,23 +229,41 @@ impl<'tcx> SearchGraph<'tcx> {
             return result;
         }
 
-        // Check whether we're in a cycle.
-        match self.stack_entries.entry(input) {
-            // No entry, we push this goal on the stack and try to prove it.
-            Entry::Vacant(v) => {
-                let depth = self.stack.next_index();
-                let entry = StackEntry {
-                    input,
-                    available_depth,
-                    reached_depth: depth,
-                    non_root_cycle_participant: false,
-                    encountered_overflow: false,
-                    has_been_used: false,
-                    provisional_result: None,
-                };
-                assert_eq!(self.stack.push(entry), depth);
-                v.insert(depth);
+        // Check whether the goal is in the provisional cache.
+        let cache_entry = self.provisional_cache.entry(input).or_default();
+        if let Some(true_cycle) = &mut cache_entry.true_to_highest
+            && self.stack.raw[true_cycle.highest_cycle_head.index()..]
+                .iter()
+                .any(|entry| !entry.input.value.goal.predicate.is_coinductive(tcx))
+        {
+            // We have a nested goal which is already in the provisional cache, use
+            // its result.
+            let participants =
+                self.stack.raw.iter_mut().skip(true_cycle.highest_cycle_head.index() + 1);
+            for entry in participants {
+                entry.non_root_cycle_participant =
+                    entry.non_root_cycle_participant.max(Some(true_cycle.highest_cycle_head));
+                self.cycle_participants.insert(entry.input);
             }
+            inspect.goal_evaluation_kind(inspect::WipCanonicalGoalEvaluationKind::CycleInStack);
+            return true_cycle.result;
+        } else if let Some(false_cycle) = &mut cache_entry.false_to_highest
+            && !self.stack.raw[false_cycle.highest_cycle_head.index()..]
+                .iter()
+                .any(|entry| !entry.input.value.goal.predicate.is_coinductive(tcx))
+        {
+            // We have a nested goal which is already in the provisional cache, use
+            // its result.
+            let participants =
+                self.stack.raw.iter_mut().skip(false_cycle.highest_cycle_head.index() + 1);
+            for entry in participants {
+                entry.non_root_cycle_participant =
+                    entry.non_root_cycle_participant.max(Some(false_cycle.highest_cycle_head));
+                self.cycle_participants.insert(entry.input);
+            }
+            inspect.goal_evaluation_kind(inspect::WipCanonicalGoalEvaluationKind::CycleInStack);
+            return false_cycle.result;
+        } else if let Some(stack_depth) = cache_entry.stack_depth {
             // We have a nested goal which relies on a goal `root` deeper in the stack.
             //
             // We first store that we may have to reprove `root` in case the provisional
@@ -236,40 +273,51 @@ impl<'tcx> SearchGraph<'tcx> {
             //
             // Finally we can return either the provisional response for that goal if we have a
             // coinductive cycle or an ambiguous result if the cycle is inductive.
-            Entry::Occupied(entry) => {
-                inspect.goal_evaluation_kind(inspect::WipCanonicalGoalEvaluationKind::CycleInStack);
-
-                let stack_depth = *entry.get();
-                debug!("encountered cycle with depth {stack_depth:?}");
-                // We start by tagging all non-root cycle participants.
-                let participants = self.stack.raw.iter_mut().skip(stack_depth.as_usize() + 1);
-                for entry in participants {
-                    entry.non_root_cycle_participant = true;
-                    self.cycle_participants.insert(entry.input);
-                }
+            inspect.goal_evaluation_kind(inspect::WipCanonicalGoalEvaluationKind::CycleInStack);
+            debug!("encountered cycle with depth {stack_depth:?}");
+            // We start by tagging all non-root cycle participants.
+            let participants = self.stack.raw.iter_mut().skip(stack_depth.as_usize() + 1);
+            for entry in participants {
+                entry.non_root_cycle_participant =
+                    entry.non_root_cycle_participant.max(Some(stack_depth));
+                self.cycle_participants.insert(entry.input);
+            }
 
-                // If we're in a cycle, we have to retry proving the cycle head
-                // until we reach a fixpoint. It is not enough to simply retry the
-                // `root` goal of this cycle.
-                //
-                // See tests/ui/traits/next-solver/cycles/fixpoint-rerun-all-cycle-heads.rs
-                // for an example.
-                self.stack[stack_depth].has_been_used = true;
-                return if let Some(result) = self.stack[stack_depth].provisional_result {
-                    result
+            // If we're in a cycle, we have to retry proving the cycle head
+            // until we reach a fixpoint. It is not enough to simply retry the
+            // `root` goal of this cycle.
+            //
+            // See tests/ui/traits/next-solver/cycles/fixpoint-rerun-all-cycle-heads.rs
+            // for an example.
+            self.stack[stack_depth].has_been_used = true;
+            return if let Some(result) = self.stack[stack_depth].provisional_result {
+                result
+            } else {
+                // If we don't have a provisional result yet we're in the first iteration,
+                // so we start with no constraints.
+                let is_inductive = self.stack.raw[stack_depth.index()..]
+                    .iter()
+                    .any(|entry| !entry.input.value.goal.predicate.is_coinductive(tcx));
+                if is_inductive {
+                    Self::response_no_constraints(tcx, input, Certainty::OVERFLOW)
                 } else {
-                    // If we don't have a provisional result yet we're in the first iteration,
-                    // so we start with no constraints.
-                    let is_inductive = self.stack.raw[stack_depth.index()..]
-                        .iter()
-                        .any(|entry| !entry.input.value.goal.predicate.is_coinductive(tcx));
-                    if is_inductive {
-                        Self::response_no_constraints(tcx, input, Certainty::OVERFLOW)
-                    } else {
-                        Self::response_no_constraints(tcx, input, Certainty::Yes)
-                    }
-                };
-            }
+                    Self::response_no_constraints(tcx, input, Certainty::Yes)
+                }
+            };
+        } else {
+            // No entry, we push this goal on the stack and try to prove it.
+            let depth = self.stack.next_index();
+            let entry = StackEntry {
+                input,
+                available_depth,
+                reached_depth: depth,
+                non_root_cycle_participant: None,
+                encountered_overflow: false,
+                has_been_used: false,
+                provisional_result: None,
+            };
+            assert_eq!(self.stack.push(entry), depth);
+            cache_entry.stack_depth = Some(depth);
         }
 
         // This is for global caching, so we properly track query dependencies.
@@ -290,6 +338,20 @@ impl<'tcx> SearchGraph<'tcx> {
                     // final result.
                     let stack_entry = self.pop_stack();
                     debug_assert_eq!(stack_entry.input, input);
+
+                    if stack_entry.has_been_used {
+                        #[allow(rustc::potential_query_instability)]
+                        self.provisional_cache.retain(|_, entry| {
+                            entry
+                                .true_to_highest
+                                .take_if(|p| p.highest_cycle_head == self.stack.next_index());
+                            entry
+                                .false_to_highest
+                                .take_if(|p| p.highest_cycle_head == self.stack.next_index());
+                            !entry.is_empty()
+                        });
+                    }
+
                     if stack_entry.has_been_used
                         && stack_entry.provisional_result.map_or(true, |r| r != result)
                     {
@@ -299,7 +361,14 @@ impl<'tcx> SearchGraph<'tcx> {
                             provisional_result: Some(result),
                             ..stack_entry
                         });
-                        assert_eq!(self.stack_entries.insert(input, depth), None);
+                        assert_eq!(
+                            self.provisional_cache
+                                .entry(input)
+                                .or_default()
+                                .stack_depth
+                                .replace(depth),
+                            None
+                        );
                     } else {
                         return (stack_entry, result);
                     }
@@ -319,7 +388,18 @@ impl<'tcx> SearchGraph<'tcx> {
         //
         // It is not possible for any nested goal to depend on something deeper on the
         // stack, as this would have also updated the depth of the current goal.
-        if !final_entry.non_root_cycle_participant {
+        if let Some(highest_cycle_head) = final_entry.non_root_cycle_participant {
+            let is_true = self.stack.raw[highest_cycle_head.index()..]
+                .iter()
+                .any(|entry| !entry.input.value.goal.predicate.is_coinductive(tcx));
+
+            let entry = self.provisional_cache.entry(input).or_default();
+            if is_true {
+                entry.true_to_highest = Some(DetachedEntry { highest_cycle_head, result })
+            } else {
+                entry.false_to_highest = Some(DetachedEntry { highest_cycle_head, result })
+            }
+        } else {
             // When encountering a cycle, both inductive and coinductive, we only
             // move the root into the global cache. We also store all other cycle
             // participants involved.
@@ -328,6 +408,7 @@ impl<'tcx> SearchGraph<'tcx> {
             // participant is on the stack. This is necessary to prevent unstable
             // results. See the comment of `SearchGraph::cycle_participants` for
             // more details.
+            self.provisional_cache.remove(&input);
             let reached_depth = final_entry.reached_depth.as_usize() - self.stack.len();
             let cycle_participants = mem::take(&mut self.cycle_participants);
             self.global_cache(tcx).insert(