refactor to match precomputer from PR 112236

Author: lqd

compiler/rustc_borrowck/src/dataflow.rs

@@ -240,19 +240,9 @@ pub fn calculate_borrows_out_of_scope_at_location<'tcx>(
     prec.borrows_out_of_scope_at_location
 }
 
-/// An entry in the CFG walk stack of the scope computation, recording visited statements within a
-/// block, in case of cycles requiring revisiting the same block but at earlier points.
-// FIXME: `precompute_borrows_out_of_scope` has stopped using this structure, and a similar
-// reorganizing of `precompute_loans_out_of_scope` could also avoid it.
-struct StackEntry {
-    bb: mir::BasicBlock,
-    lo: usize,
-    hi: usize,
-}
-
 struct PoloniusOutOfScopePrecomputer<'a, 'tcx> {
     visited: BitSet<mir::BasicBlock>,
-    visit_stack: Vec<StackEntry>,
+    visit_stack: Vec<mir::BasicBlock>,
     body: &'a Body<'tcx>,
     regioncx: &'a RegionInferenceContext<'tcx>,
 
@@ -327,7 +317,7 @@ impl<'tcx> PoloniusOutOfScopePrecomputer<'_, 'tcx> {
         &mut self,
         loan_idx: BorrowIndex,
         issuing_region: RegionVid,
-        issued_location: Location,
+        first_location: Location,
     ) {
         // Let's precompute the reachability set of the issuing region, via reachability on the
         // condensation graph. We can also early return when reaching regions that outlive free
@@ -373,61 +363,51 @@ impl<'tcx> PoloniusOutOfScopePrecomputer<'_, 'tcx> {
             }
         }
 
-        // We visit one BB at a time. The complication is that we may start in the middle of the
-        // first BB visited (the one containing `issued_location`), in which case we may have to
-        // later on process the first part of that BB if there is a path back to its start.
+        let first_block = first_location.block;
+        let first_bb_data = &self.body.basic_blocks[first_block];
 
-        // For visited BBs, we record the index of the first statement processed. (In fully
-        // processed BBs this index is 0.) Note also that we add BBs to `visited` once they are
-        // added to `stack`, before they are actually processed, because this avoids the need to
-        // look them up again on completion.
-        self.visited.insert(issued_location.block);
+        // The first block we visit is the one where the loan is issued, starting from the statement
+        // where the loan is issued: at `first_location`.
+        let first_lo = first_location.statement_index;
+        let first_hi = first_bb_data.statements.len();
+
+        if let Some(kill_location) = self.loan_kill_location(first_block, first_lo, first_hi) {
+            debug!("loan {:?} gets killed at {:?}", loan_idx, kill_location);
+            self.loans_out_of_scope_at_location.entry(kill_location).or_default().push(loan_idx);
 
-        let first_block = issued_location.block;
-        let mut first_lo = issued_location.statement_index;
-        let first_hi = self.body[issued_location.block].statements.len();
+            // The loan dies within the first block, we're done and can early return.
+            self.reachability.clear();
+            return;
+        }
 
-        self.visit_stack.push(StackEntry { bb: issued_location.block, lo: first_lo, hi: first_hi });
+        // The loan is not dead. Add successor BBs to the work list, if necessary.
+        for succ_bb in first_bb_data.terminator().successors() {
+            if self.visited.insert(succ_bb) {
+                self.visit_stack.push(succ_bb);
+            }
+        }
 
-        while let Some(StackEntry { bb, lo, hi }) = self.visit_stack.pop() {
-            // Check whether the issuing region can reach local regions that are live at this point.
-            // If not, then the loan is killed at this point and goes out of scope. We also can skip
-            // visiting successor locations.
-            if let Some(kill_location) = self.loan_kill_location(bb, lo, hi) {
+        // We may end up visiting `first_block` again. This is not an issue: we know at this point
+        // that the loan is not killed in the `first_lo..=first_hi` range, so checking the
+        // `0..first_lo` range and the `0..first_hi` range gives the same result.
+        while let Some(block) = self.visit_stack.pop() {
+            let bb_data = &self.body[block];
+            let num_stmts = bb_data.statements.len();
+            if let Some(kill_location) = self.loan_kill_location(block, 0, num_stmts) {
                 debug!("loan {:?} gets killed at {:?}", loan_idx, kill_location);
                 self.loans_out_of_scope_at_location
                     .entry(kill_location)
                     .or_default()
                     .push(loan_idx);
-                continue;
-            }
 
-            // If we process the first part of the first basic block (i.e. we encounter that block
-            // for the second time), we no longer have to visit its successors again.
-            if bb == first_block && hi != first_hi {
+                // The loan dies within this block, so we don't need to visit its successors.
                 continue;
             }
 
             // Add successor BBs to the work list, if necessary.
-            let bb_data = &self.body[bb];
-            debug_assert!(hi == bb_data.statements.len());
             for succ_bb in bb_data.terminator().successors() {
-                if !self.visited.insert(succ_bb) {
-                    if succ_bb == first_block && first_lo > 0 {
-                        // `succ_bb` has been seen before. If it wasn't fully processed, add its
-                        // first part to the stack for processing.
-                        self.visit_stack.push(StackEntry { bb: succ_bb, lo: 0, hi: first_lo - 1 });
-
-                        // And update this entry with 0, to represent the whole BB being processed.
-                        first_lo = 0;
-                    }
-                } else {
-                    // `succ_bb` hasn't been seen before. Add it to the stack for processing.
-                    self.visit_stack.push(StackEntry {
-                        bb: succ_bb,
-                        lo: 0,
-                        hi: self.body[succ_bb].statements.len(),
-                    });
+                if self.visited.insert(succ_bb) {
+                    self.visit_stack.push(succ_bb);
                 }
             }
         }
@@ -439,8 +419,8 @@ impl<'tcx> PoloniusOutOfScopePrecomputer<'_, 'tcx> {
     }
 
     /// Returns the lowest statement in `start..=end`, where the loan goes out of scope, if any.
-    /// This will be the statement where the issuing region can't reach any of the regions live at
-    /// this point.
+    /// This is the statement where the issuing region can't reach any of the regions that are live
+    /// at this point.
     fn loan_kill_location(&self, block: BasicBlock, start: usize, end: usize) -> Option<Location> {
         for statement_index in start..=end {
             let location = Location { block, statement_index };