extract function to find a kill location

this will help match the structure from PR 112236, where `first_non_contained_inclusive` serves
the same purpose as `loan_kill_location` introduced in this commit: finding the location
within a range of statements in the block, where the loan goes out of scope, if any.

Author: lqd

compiler/rustc_borrowck/src/dataflow.rs

@@ -389,40 +389,17 @@ impl<'tcx> PoloniusOutOfScopePrecomputer<'_, 'tcx> {
 
         self.visit_stack.push(StackEntry { bb: issued_location.block, lo: first_lo, hi: first_hi });
 
-        'preorder: while let Some(StackEntry { bb, lo, hi }) = self.visit_stack.pop() {
-            for i in lo..=hi {
-                let location = Location { block: bb, statement_index: i };
-
-                // The loan is out of scope at point `location` if it's not contained within any
-                // live regions.
-                let mut issuing_region_can_reach_live_regions = false;
-
-                // Check whether the issuing region can reach local regions that are live at this
-                // point.
-                //
-                // FIXME: if the issuing region `i` can reach a live region `r` at point `p`, and
-                // `r` is live at point `q`, then it's guaranteed that `i` would reach `r` at point
-                // `q`. The reachability is location-insensitive, and we could take advantage of
-                // that, by jumping to a further point than the next statement. We can jump to the
-                // furthest point within the block where `r` is live.
-                let point = self.regioncx.liveness_values().point_from_location(location);
-                if let Some(live_sccs) = self.live_sccs_per_point.row(point) {
-                    for live_scc in live_sccs.iter() {
-                        if self.reachability.contains(live_scc) {
-                            issuing_region_can_reach_live_regions = true;
-                            break;
-                        }
-                    }
-                }
-
-                // If no live region is reachable from the issuing region, then the loan is killed
-                // at this point, and goes out of scope. We also can skip visiting successor
-                // locations.
-                if !issuing_region_can_reach_live_regions {
-                    debug!("loan {:?} gets killed at {:?}", loan_idx, location);
-                    self.loans_out_of_scope_at_location.entry(location).or_default().push(loan_idx);
-                    continue 'preorder;
-                }
+        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) {
+                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
@@ -460,6 +437,36 @@ impl<'tcx> PoloniusOutOfScopePrecomputer<'_, 'tcx> {
         assert!(self.visit_stack.is_empty(), "visit stack should be empty");
         assert!(self.reachability_stack.is_empty(), "reachability stack should be empty");
     }
+
+    /// 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.
+    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 };
+
+            // Check whether the issuing region can reach local regions that are live at this
+            // point.
+            //
+            // FIXME: if the issuing region `i` can reach a live region `r` at point `p`, and
+            // `r` is live at point `q`, then it's guaranteed that `i` would reach `r` at point
+            // `q`. Reachability is location-insensitive, and we could take advantage of
+            // that, by jumping to a further point than the next statement. We can jump to the
+            // furthest point within the block where `r` is live.
+            let point = self.regioncx.liveness_values().point_from_location(location);
+            if let Some(live_sccs) = self.live_sccs_per_point.row(point) {
+                if live_sccs.iter().any(|live_scc| self.reachability.contains(live_scc)) {
+                    continue;
+                }
+            }
+
+            // No live region is reachable from the issuing region: the loan is killed at this point
+            // and goes out of scope.
+            return Some(location);
+        }
+
+        None
+    }
 }
 
 impl<'a, 'tcx> Borrows<'a, 'tcx> {