From 8b67c5e462387a6e6a1ab0e1ec85eb3d2ac7054e Mon Sep 17 00:00:00 2001
From: "Samuel E. Moelius III" <sam@moeli.us>
Date: Thu, 3 Mar 2022 04:13:20 -0500
Subject: [PATCH] `iterate_to_fixpoint` -> `iterate_reachable_to_fixpoint`

* Renames `iterate_to_fixpoint` to `iterate_reachable_to_fixpoint`.
* Adds to `framework::Enginge` a new method with the old name
  (`iterate_to_fixpoint`). The new method computes the fixpoint over
  all basic blocks, instead of just the reachable ones.
* Changes one occurrence of `iterate_to_fixpoint` to
  `iterate_reachable_to_fixpoint` where the analysis seemed to care
  about only reachable basic blocks.
---
 .../src/framework/engine.rs                   | 52 ++++++++++++++-----
 compiler/rustc_mir_transform/src/generator.rs |  2 +-
 2 files changed, 39 insertions(+), 15 deletions(-)

diff --git a/compiler/rustc_mir_dataflow/src/framework/engine.rs b/compiler/rustc_mir_dataflow/src/framework/engine.rs
index 88ed0128a1fd3..4455f8a2512d6 100644
--- a/compiler/rustc_mir_dataflow/src/framework/engine.rs
+++ b/compiler/rustc_mir_dataflow/src/framework/engine.rs
@@ -181,37 +181,61 @@ where
         self
     }
 
-    /// Computes the fixpoint for this dataflow problem and returns it.
+    /// Computes the fixpoint for this dataflow problem over all basic blocks and returns the
+    /// fixpoint.
     pub fn iterate_to_fixpoint(self) -> Results<'tcx, A>
     where
         A::Domain: DebugWithContext<A>,
     {
-        let Engine {
-            analysis,
-            body,
-            dead_unwinds,
-            mut entry_sets,
-            tcx,
-            apply_trans_for_block,
-            pass_name,
-            ..
-        } = self;
+        let mut dirty_queue: WorkQueue<BasicBlock> =
+            WorkQueue::with_none(self.body.basic_blocks().len());
+
+        self.body.basic_blocks().indices().for_each(|bb| {
+            dirty_queue.insert(bb);
+        });
 
+        self.iterate_to_fixpoint_inner(dirty_queue)
+    }
+
+    /// Computes the fixpoint for this dataflow problem over the reachable basic blocks and returns
+    /// the fixpoint.
+    pub fn iterate_reachable_to_fixpoint(self) -> Results<'tcx, A>
+    where
+        A::Domain: DebugWithContext<A>,
+    {
         let mut dirty_queue: WorkQueue<BasicBlock> =
-            WorkQueue::with_none(body.basic_blocks().len());
+            WorkQueue::with_none(self.body.basic_blocks().len());
 
         if A::Direction::is_forward() {
-            for (bb, _) in traversal::reverse_postorder(body) {
+            for (bb, _) in traversal::reverse_postorder(self.body) {
                 dirty_queue.insert(bb);
             }
         } else {
             // Reverse post-order on the reverse CFG may generate a better iteration order for
             // backward dataflow analyses, but probably not enough to matter.
-            for (bb, _) in traversal::postorder(body) {
+            for (bb, _) in traversal::postorder(self.body) {
                 dirty_queue.insert(bb);
             }
         }
 
+        self.iterate_to_fixpoint_inner(dirty_queue)
+    }
+
+    fn iterate_to_fixpoint_inner(self, mut dirty_queue: WorkQueue<BasicBlock>) -> Results<'tcx, A>
+    where
+        A::Domain: DebugWithContext<A>,
+    {
+        let Engine {
+            analysis,
+            body,
+            dead_unwinds,
+            mut entry_sets,
+            tcx,
+            apply_trans_for_block,
+            pass_name,
+            ..
+        } = self;
+
         // `state` is not actually used between iterations;
         // this is just an optimization to avoid reallocating
         // every iteration.
diff --git a/compiler/rustc_mir_transform/src/generator.rs b/compiler/rustc_mir_transform/src/generator.rs
index d9a66cace52e5..99522d049d532 100644
--- a/compiler/rustc_mir_transform/src/generator.rs
+++ b/compiler/rustc_mir_transform/src/generator.rs
@@ -473,7 +473,7 @@ fn locals_live_across_suspend_points<'tcx>(
     // for.
     let requires_storage_results = MaybeRequiresStorage::new(body, &borrowed_locals_results)
         .into_engine(tcx, body_ref)
-        .iterate_to_fixpoint();
+        .iterate_reachable_to_fixpoint();
     let mut requires_storage_cursor =
         rustc_mir_dataflow::ResultsCursor::new(body_ref, &requires_storage_results);