reuse reachability allocations between computing scopes

Author: lqd

compiler/rustc_borrowck/src/dataflow.rs

@@ -13,6 +13,7 @@ use rustc_mir_dataflow::{self, fmt::DebugWithContext, GenKill};
 use rustc_mir_dataflow::{Analysis, Direction, Results};
 use std::fmt;
 
+use crate::constraints::ConstraintSccIndex;
 use crate::{places_conflict, BorrowSet, PlaceConflictBias, PlaceExt, RegionInferenceContext};
 
 /// A tuple with named fields that can hold either the results or the transient state of the
@@ -251,6 +252,8 @@ struct PoloniusOutOfScopePrecomputer<'a, 'tcx> {
     regioncx: &'a RegionInferenceContext<'tcx>,
     loans_out_of_scope_at_location: FxIndexMap<Location, Vec<BorrowIndex>>,
     placeholders: Vec<RegionVid>,
+    reachability: BitSet<ConstraintSccIndex>,
+    reachability_stack: Vec<ConstraintSccIndex>,
 }
 
 impl<'a, 'tcx> PoloniusOutOfScopePrecomputer<'a, 'tcx> {
@@ -261,7 +264,7 @@ impl<'a, 'tcx> PoloniusOutOfScopePrecomputer<'a, 'tcx> {
         let placeholders = regioncx
             .regions()
             .filter(|&r| {
-                use rustc_infer::infer::*;
+                use rustc_infer::infer::{NllRegionVariableOrigin, RegionVariableOrigin};
                 let origin = regioncx.var_infos[r].origin;
                 let is_placeholder = matches!(
                     origin,
@@ -278,6 +281,8 @@ impl<'a, 'tcx> PoloniusOutOfScopePrecomputer<'a, 'tcx> {
             regioncx,
             loans_out_of_scope_at_location: FxIndexMap::default(),
             placeholders,
+            reachability: BitSet::new_empty(regioncx.constraint_sccs.num_sccs()),
+            reachability_stack: vec![],
         }
     }
 }
@@ -300,21 +305,19 @@ impl<'tcx> PoloniusOutOfScopePrecomputer<'_, 'tcx> {
         let liveness = &self.regioncx.liveness_constraints;
         let sccs = &self.regioncx.constraint_sccs;
 
-        let mut reachability = BitSet::new_empty(sccs.num_sccs());
-
         let issuing_region_scc = sccs.scc(issuing_region);
-        let mut stack = vec![issuing_region_scc];
-        reachability.insert(issuing_region_scc);
+        self.reachability_stack.push(issuing_region_scc);
+        self.reachability.insert(issuing_region_scc);
 
         let member_constraints = &self.regioncx.member_constraints;
 
-        while let Some(scc) = stack.pop() {
+        while let Some(scc) = self.reachability_stack.pop() {
             // Handle successors of this SCC:
             //
             // 1. Push outlives successors to the worklist stack
             for &succ_scc in sccs.successors(scc) {
-                if reachability.insert(succ_scc) {
-                    stack.push(succ_scc);
+                if self.reachability.insert(succ_scc) {
+                    self.reachability_stack.push(succ_scc);
                 }
             }
 
@@ -327,6 +330,8 @@ impl<'tcx> PoloniusOutOfScopePrecomputer<'_, 'tcx> {
             // That is to say, if there are member constraints here, the loan escapes the
             // function and cannot go out of scope. We can early return.
             if member_constraints.indices(scc).next().is_some() {
+                self.reachability_stack.clear();
+                self.reachability.clear();
                 return;
             }
         }
@@ -375,7 +380,7 @@ impl<'tcx> PoloniusOutOfScopePrecomputer<'_, 'tcx> {
                     // If a single live region is reachable from the issuing region, then the loan
                     // is still live at this point. We can stop checking other live regions at this
                     // location, and go to the next location.
-                    if reachability.contains(live_region_scc) {
+                    if self.reachability.contains(live_region_scc) {
                         issuing_region_can_reach_live_regions = true;
                         break;
                     }
@@ -423,9 +428,10 @@ impl<'tcx> PoloniusOutOfScopePrecomputer<'_, 'tcx> {
             }
         }
 
-        assert!(self.visit_stack.is_empty(), "stack should be empty");
-
         self.visited.clear();
+        self.reachability.clear();
+        assert!(self.visit_stack.is_empty(), "visit stack should be empty");
+        assert!(self.reachability_stack.is_empty(), "reachablity stack should be empty");
     }
 }