reverse liveness and subset traversal order

During traversal, instead of checking: for each live region r at point p, whether
the issuing region can reach r, we do this in the opposite order: for
each rechable region r, is r live at point p.

This will prevent continuously checking regions that are live at point p
and that we know aren't reachable by the issuing region. If it did, we
wouldn't need to compute the scope in the first place.

Author: lqd

compiler/rustc_borrowck/src/dataflow.rs

@@ -1,6 +1,6 @@
 #![deny(rustc::untranslatable_diagnostic)]
 #![deny(rustc::diagnostic_outside_of_impl)]
-use rustc_data_structures::fx::FxIndexMap;
+use rustc_data_structures::fx::{FxHashSet, FxIndexMap};
 use rustc_index::bit_set::BitSet;
 use rustc_middle::mir::{self, BasicBlock, Body, Location, Place};
 use rustc_middle::ty::RegionVid;
@@ -235,9 +235,9 @@ struct PoloniusOutOfScopePrecomputer<'a, 'tcx> {
     body: &'a Body<'tcx>,
     regioncx: &'a RegionInferenceContext<'tcx>,
     borrows_out_of_scope_at_location: FxIndexMap<Location, Vec<BorrowIndex>>,
-    placeholders: Vec<RegionVid>,
-    reachability: BitSet<ConstraintSccIndex>,
-    reachability_stack: Vec<ConstraintSccIndex>,
+    placeholders: FxHashSet<ConstraintSccIndex>,
+    reachability: BitSet<RegionVid>,
+    reachability_stack: Vec<RegionVid>,
 }
 
 impl<'a, 'tcx> PoloniusOutOfScopePrecomputer<'a, 'tcx> {
@@ -256,6 +256,7 @@ impl<'a, 'tcx> PoloniusOutOfScopePrecomputer<'a, 'tcx> {
                 );
                 is_placeholder
             })
+            .map(|r| regioncx.constraint_sccs.scc(r))
             .collect();
 
         Self {
@@ -265,7 +266,7 @@ impl<'a, 'tcx> PoloniusOutOfScopePrecomputer<'a, 'tcx> {
             regioncx,
             borrows_out_of_scope_at_location: FxIndexMap::default(),
             placeholders,
-            reachability: BitSet::new_empty(regioncx.constraint_sccs.num_sccs()),
+            reachability: BitSet::new_empty(regioncx.regions().count()),
             reachability_stack: vec![],
         }
     }
@@ -286,42 +287,51 @@ impl<'tcx> PoloniusOutOfScopePrecomputer<'_, 'tcx> {
         // regions via member constraints. (The `OutOfScopePrecomputer` wouldn't be called on a
         // region that outlives free regions via outlives constraints.)
 
-        let liveness = &self.regioncx.liveness_constraints;
         let sccs = &self.regioncx.constraint_sccs;
+        let member_constraints = &self.regioncx.member_constraints;
 
-        let issuing_region_scc = sccs.scc(issuing_region);
-        self.reachability_stack.push(issuing_region_scc);
-        self.reachability.insert(issuing_region_scc);
+        self.reachability_stack.push(issuing_region);
+        self.reachability.insert(issuing_region);
 
-        let member_constraints = &self.regioncx.member_constraints;
+        let static_region = self.regioncx.universal_regions().fr_static;
+        while let Some(region) = self.reachability_stack.pop() {
+            let scc = sccs.scc(region);
 
-        while let Some(scc) = self.reachability_stack.pop() {
             // Handle successors of this SCC:
             //
-            // 1. Push outlives successors to the worklist stack
-
-            // should be something like:
-            // self.reachability_stack
-            //     .extend(sccs.successors(scc).filter(|succ_scc| reachability.insert(succ_scc)));
-            for &succ_scc in sccs.successors(scc) {
-                if self.reachability.insert(succ_scc) {
-                    self.reachability_stack.push(succ_scc);
-                }
-            }
-
-            // 2. Deal with member constraints
+            // 1. Via member constraints
             //
             // The issuing region can flow into the choice regions here, and they are either:
             // - placeholders or free regions themselves,
             // - or also transitively outlive a free region.
             //
             // 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() {
+            //
+            // 2. Via placeholders
+            //
+            // If the issuing region outlives placeholders, its loan escapes the function and
+            // cannot go out of scope. We can early return.
+            if member_constraints.indices(scc).next().is_some() || self.placeholders.contains(&scc)
+            {
                 self.reachability_stack.clear();
                 self.reachability.clear();
                 return;
             }
+
+            // 3. Via outlives successors, which we want to record and traverse, so we add them
+            //    to the worklist stack
+            let successors = self.regioncx.constraint_graph.outgoing_edges(
+                region,
+                &self.regioncx.constraints,
+                static_region,
+            );
+            for outlives_constraint in successors {
+                let succ = outlives_constraint.sub;
+                if self.reachability.insert(succ) {
+                    self.reachability_stack.push(succ);
+                }
+            }
         }
 
         // We visit one BB at a time. The complication is that we may start in the
@@ -352,23 +362,10 @@ impl<'tcx> PoloniusOutOfScopePrecomputer<'_, 'tcx> {
                 // live regions.
                 let mut issuing_region_can_reach_live_regions = false;
 
-                // Check reachability of all live regions:
-                // - the local regions that are live at this point,
-                // - the placeholders, which are live at all points and don't need liveness to be
-                //   computed, and are thus absent from the liveness values.
-                //
-                // As mentioned above, we don't need to check for free regions, if the issuing
-                // region outlived a free region via outlives constraints, we wouldn't need to
-                // compute its loan's scope.
-                for live_region in
-                    liveness.live_regions_at(location).chain(self.placeholders.iter().copied())
-                {
-                    let live_region_scc = sccs.scc(live_region);
-
-                    // 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 self.reachability.contains(live_region_scc) {
+                // Check whether the issuing region can reach local regions that are live at this
+                // point.
+                for reachable_region in self.reachability.iter() {
+                    if self.regioncx.liveness_constraints.contains(reachable_region, location) {
                         issuing_region_can_reach_live_regions = true;
                         break;
                     }
@@ -422,7 +419,7 @@ impl<'tcx> PoloniusOutOfScopePrecomputer<'_, 'tcx> {
         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");
+        assert!(self.reachability_stack.is_empty(), "reachability stack should be empty");
     }
 }
 

compiler/rustc_borrowck/src/region_infer/mod.rs

@@ -61,12 +61,12 @@ pub struct RegionInferenceContext<'tcx> {
     pub(crate) liveness_constraints: LivenessValues<RegionVid>,
 
     /// The outlives constraints computed by the type-check.
-    constraints: Frozen<OutlivesConstraintSet<'tcx>>,
+    pub(crate) constraints: Frozen<OutlivesConstraintSet<'tcx>>,
 
     /// The constraint-set, but in graph form, making it easy to traverse
     /// the constraints adjacent to a particular region. Used to construct
     /// the SCC (see `constraint_sccs`) and for error reporting.
-    constraint_graph: Frozen<NormalConstraintGraph>,
+    pub(crate) constraint_graph: Frozen<NormalConstraintGraph>,
 
     /// The SCC computed from `constraints` and the constraint
     /// graph. We have an edge from SCC A to SCC B if `A: B`. Used to

compiler/rustc_borrowck/src/region_infer/values.rs

@@ -176,11 +176,6 @@ impl<N: Idx> LivenessValues<N> {
     pub(crate) fn region_value_str(&self, r: N) -> String {
         region_value_str(self.get_elements(r).map(RegionElement::Location))
     }
-
-    pub(crate) fn live_regions_at(&self, location: Location) -> impl Iterator<Item = N> + '_ {
-        let point = self.elements.point_from_location(location);
-        self.points.rows().filter(move |row| self.points.contains(*row, point))
-    }
 }
 
 /// Maps from `ty::PlaceholderRegion` values that are used in the rest of