wow

Author: lcnr

compiler/rustc_type_ir/src/search_graph/mod.rs

@@ -1331,34 +1331,44 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
             if first_cycle {
                 first_cycle = false;
             } else {
-                while let Some(&(stack_depth, node_id, info)) = added_goals.peek() {
-                    if let Some(existing_entry) = self.stack.get(stack_depth) {
-                        let provisional_result = provisional_results.get(&stack_depth).copied();
-                        // Issue: changing the provisional result means we must not rebase, but instead
-                        // invalidate.
-                        if existing_entry.node_id == node_id
-                            && provisional_result == existing_entry.provisional_result
-                        {
-                            debug_assert_eq!(existing_entry.input, info.input);
-                            debug_assert_eq!(
-                                existing_entry.step_kind_from_parent,
-                                info.step_kind_from_parent
-                            );
-                            let _ = added_goals.next().unwrap();
-                        } else {
-                            truncate_stack(
-                                &mut self.stack,
-                                &mut self.provisional_cache,
-                                StackDepth::from_usize(stack_depth.as_usize()),
-                            );
-                            break;
-                        }
-                    } else {
-                        if only_evaluated_leaf {
-                            break;
+                if added_goals.peek().is_none() {
+                    if self.stack.len() > current_stack_len {
+                        truncate_stack(
+                            &mut self.stack,
+                            &mut self.provisional_cache,
+                            StackDepth::from_usize(current_stack_len),
+                        );
+                    }
+                } else {
+                    while let Some(&(stack_depth, node_id, info)) = added_goals.peek() {
+                        if let Some(existing_entry) = self.stack.get(stack_depth) {
+                            let provisional_result = provisional_results.get(&stack_depth).copied();
+                            // Issue: changing the provisional result means we must not rebase, but instead
+                            // invalidate.
+                            if existing_entry.node_id == node_id
+                                && provisional_result == existing_entry.provisional_result
+                            {
+                                debug_assert_eq!(existing_entry.input, info.input);
+                                debug_assert_eq!(
+                                    existing_entry.step_kind_from_parent,
+                                    info.step_kind_from_parent
+                                );
+                                let _ = added_goals.next().unwrap();
+                            } else {
+                                truncate_stack(
+                                    &mut self.stack,
+                                    &mut self.provisional_cache,
+                                    stack_depth,
+                                );
+                                break;
+                            }
                         } else {
-                            debug!(parent = ?info.input, cycle = ?added_goals.last().unwrap(), "reevaluated parent, skip cycle");
-                            continue 'outer;
+                            if only_evaluated_leaf {
+                                break;
+                            } else {
+                                debug!(parent = ?info.input, cycle = ?added_goals.last().unwrap(), "reevaluated parent, skip cycle");
+                                continue 'outer;
+                            }
                         }
                     }
                 }