tmp: compute live loans during liveness

Author: lqd

compiler/rustc_borrowck/src/dataflow.rs

@@ -1,7 +1,9 @@
 #![deny(rustc::untranslatable_diagnostic)]
 #![deny(rustc::diagnostic_outside_of_impl)]
-use rustc_data_structures::fx::{FxHashSet, FxIndexMap};
-use rustc_index::bit_set::{BitSet, SparseBitMatrix};
+use rustc_data_structures::fx::FxIndexMap;
+use rustc_data_structures::graph::WithSuccessors;
+use rustc_index::bit_set::BitSet;
+use rustc_infer::infer::{NllRegionVariableOrigin, RegionVariableOrigin};
 use rustc_middle::mir::{
     self, BasicBlock, Body, CallReturnPlaces, Location, Place, TerminatorEdges,
 };
@@ -13,8 +15,6 @@ use rustc_mir_dataflow::{self, fmt::DebugWithContext, GenKill};
 use rustc_mir_dataflow::{Analysis, Direction, Results};
 use std::fmt;
 
-use crate::constraints::ConstraintSccIndex;
-use crate::region_infer::values::PointIndex;
 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
@@ -255,66 +255,17 @@ struct PoloniusOutOfScopePrecomputer<'a, 'tcx> {
     visit_stack: Vec<StackEntry>,
     body: &'a Body<'tcx>,
     regioncx: &'a RegionInferenceContext<'tcx>,
-
-    sccs_live_at_all_points: FxHashSet<ConstraintSccIndex>,
-    live_sccs_per_point: SparseBitMatrix<PointIndex, ConstraintSccIndex>,
-
-    reachability: BitSet<ConstraintSccIndex>,
-    reachability_stack: Vec<ConstraintSccIndex>,
-
     loans_out_of_scope_at_location: FxIndexMap<Location, Vec<BorrowIndex>>,
 }
 
 impl<'a, 'tcx> PoloniusOutOfScopePrecomputer<'a, 'tcx> {
     fn new(body: &'a Body<'tcx>, regioncx: &'a RegionInferenceContext<'tcx>) -> Self {
-        let sccs = regioncx.constraint_sccs();
-        let num_sccs = sccs.num_sccs();
-
-        // Compute the list of SCCs that are live at all points, as it will be used for all the
-        // loan scopes we'll compute.
-        // FIXME: they're surely already available somewhere.
-        let sccs_live_at_all_points: FxHashSet<_> = regioncx
-            .regions()
-            .filter(|&r| {
-                use rustc_infer::infer::{NllRegionVariableOrigin, RegionVariableOrigin};
-                let origin = regioncx.var_infos[r].origin;
-                let live_at_all_points = matches!(
-                    origin,
-                    RegionVariableOrigin::Nll(
-                        NllRegionVariableOrigin::Placeholder(_)
-                            | NllRegionVariableOrigin::FreeRegion
-                    )
-                );
-                live_at_all_points
-            })
-            .map(|r| sccs.scc(r))
-            .collect();
-
-        // Pre-compute the set of live SCCs per point
-        let liveness = regioncx.liveness_values();
-        let mut live_sccs_per_point = SparseBitMatrix::new(num_sccs);
-
-        for region in liveness.rows() {
-            let scc = sccs.scc(region);
-            if sccs_live_at_all_points.contains(&scc) {
-                continue;
-            }
-            for location in liveness.get_elements(region) {
-                let point = liveness.point_from_location(location);
-                live_sccs_per_point.insert(point, scc);
-            }
-        }
-
         Self {
             visited: BitSet::new_empty(body.basic_blocks.len()),
             visit_stack: vec![],
             body,
             regioncx,
             loans_out_of_scope_at_location: FxIndexMap::default(),
-            sccs_live_at_all_points,
-            live_sccs_per_point,
-            reachability: BitSet::new_empty(num_sccs),
-            reachability_stack: vec![],
         }
     }
 }
@@ -329,48 +280,44 @@ impl<'tcx> PoloniusOutOfScopePrecomputer<'_, 'tcx> {
         issuing_region: RegionVid,
         issued_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
-        // regions via member constraints. (The `OutOfScopePrecomputer` wouldn't be called on a
-        // region that outlives free regions via outlives constraints.)
-
         let sccs = self.regioncx.constraint_sccs();
-
         let issuing_region_scc = sccs.scc(issuing_region);
-        self.reachability_stack.push(issuing_region_scc);
-        self.reachability.insert(issuing_region_scc);
 
-        while let Some(scc) = self.reachability_stack.pop() {
-            // Handle successors of this SCC:
-            //
+        // We first handle the cases where the loan doesn't go out of scope, depending on the issuing
+        // region's successors.
+        for scc in sccs.depth_first_search(issuing_region_scc) {
             // 1. Via member constraints
             //
-            // The issuing region can flow into the choice regions here, and they are either:
+            // The issuing region can flow into the choice regions, 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.
-            //
+            // 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 self.regioncx.scc_has_member_constraints(scc) {
+                return;
+            }
+
             // 2. Via regions that are live at all points: placeholders and free regions.
             //
             // If the issuing region outlives such a region, its loan escapes the function and
             // cannot go out of scope. We can early return.
-            if self.regioncx.scc_has_member_constraints(scc)
-                || self.sccs_live_at_all_points.contains(&scc)
-            {
-                self.reachability_stack.clear();
-                self.reachability.clear();
+            //
+            // FIXME: there must be a cleaner way to find this information. At least, when
+            // higher-ranked subtyping is abstracted away from the borrowck main path, we'll only
+            // need to check whether this is a universal region.
+            //
+            let representative = self.regioncx.scc_representatives[scc];
+            let origin = self.regioncx.var_infos[representative].origin;
+            let live_at_all_points = matches!(
+                origin,
+                RegionVariableOrigin::Nll(
+                    NllRegionVariableOrigin::Placeholder(_) | NllRegionVariableOrigin::FreeRegion
+                )
+            );
+            if live_at_all_points {
                 return;
             }
-
-            // 3. Via outlives successors, which we want to record and traverse: we add them
-            //    to the worklist stack
-            for &succ_scc in sccs.successors(scc) {
-                if self.reachability.insert(succ_scc) {
-                    self.reachability_stack.push(succ_scc);
-                }
-            }
         }
 
         // We visit one BB at a time. The complication is that we may start in the
@@ -397,26 +344,26 @@ impl<'tcx> PoloniusOutOfScopePrecomputer<'_, 'tcx> {
             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.
+                // Check whether the issuing region can reach local regions that are live at this
+                // point:
+                // - a loan is always live at its issuing location because it can reach the issuing
+                // region, which is always live at this location.
+                if location == issued_location {
+                    continue;
+                }
+
+                // - the loan is out of scope at point `location` if it's not contained within any
+                // regions live at this point.
                 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 self.regioncx.live_loans.contains(point, loan_idx) {
+                    issuing_region_can_reach_live_regions = true;
                 }
 
                 // If no live region is reachable from the issuing region, then the loan is
@@ -462,9 +409,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(), "reachability stack should be empty");
     }
 }
 
@@ -495,8 +440,8 @@ impl<'a, 'tcx> Borrows<'a, 'tcx> {
             }
 
             assert_eq!(
-                borrows_out_of_scope_at_location, polonius_prec.loans_out_of_scope_at_location,
-                "the loans out of scope must be the same as the borrows out of scope"
+                polonius_prec.loans_out_of_scope_at_location, borrows_out_of_scope_at_location,
+                "the loans out of scope are different from the borrows out of scope"
             );
 
             borrows_out_of_scope_at_location = polonius_prec.loans_out_of_scope_at_location;

compiler/rustc_borrowck/src/nll.rs

@@ -181,22 +181,26 @@ pub(crate) fn compute_regions<'cx, 'tcx>(
     let elements = &Rc::new(RegionValueElements::new(&body));
 
     // Run the MIR type-checker.
-    let MirTypeckResults { constraints, universal_region_relations, opaque_type_values } =
-        type_check::type_check(
-            infcx,
-            param_env,
-            body,
-            promoted,
-            &universal_regions,
-            location_table,
-            borrow_set,
-            &mut all_facts,
-            flow_inits,
-            move_data,
-            elements,
-            upvars,
-            polonius_input,
-        );
+    let MirTypeckResults {
+        constraints,
+        universal_region_relations,
+        opaque_type_values,
+        live_loans,
+    } = type_check::type_check(
+        infcx,
+        param_env,
+        body,
+        promoted,
+        &universal_regions,
+        location_table,
+        borrow_set,
+        &mut all_facts,
+        flow_inits,
+        move_data,
+        elements,
+        upvars,
+        polonius_input,
+    );
 
     if let Some(all_facts) = &mut all_facts {
         let _prof_timer = infcx.tcx.prof.generic_activity("polonius_fact_generation");
@@ -274,6 +278,7 @@ pub(crate) fn compute_regions<'cx, 'tcx>(
         type_tests,
         liveness_constraints,
         elements,
+        live_loans,
     );
 
     // Generate various additional constraints.

compiler/rustc_borrowck/src/region_infer/mod.rs

@@ -1,12 +1,14 @@
 use std::collections::VecDeque;
 use std::rc::Rc;
 
+use crate::BorrowIndex;
 use rustc_data_structures::binary_search_util;
 use rustc_data_structures::frozen::Frozen;
 use rustc_data_structures::fx::{FxIndexMap, FxIndexSet};
 use rustc_data_structures::graph::scc::Sccs;
 use rustc_errors::Diagnostic;
 use rustc_hir::def_id::CRATE_DEF_ID;
+use rustc_index::bit_set::SparseBitMatrix;
 use rustc_index::{IndexSlice, IndexVec};
 use rustc_infer::infer::outlives::test_type_match;
 use rustc_infer::infer::region_constraints::{GenericKind, VarInfos, VerifyBound, VerifyIfEq};
@@ -21,6 +23,7 @@ use rustc_middle::traits::ObligationCauseCode;
 use rustc_middle::ty::{self, RegionVid, Ty, TyCtxt, TypeFoldable, TypeVisitableExt};
 use rustc_span::Span;
 
+use crate::region_infer::values::PointIndex;
 use crate::{
     constraints::{
         graph::NormalConstraintGraph, ConstraintSccIndex, OutlivesConstraint, OutlivesConstraintSet,
@@ -102,7 +105,7 @@ pub struct RegionInferenceContext<'tcx> {
     /// of its SCC and be sure that -- if they have the same repr --
     /// they *must* be equal (though not having the same repr does not
     /// mean they are unequal).
-    scc_representatives: IndexVec<ConstraintSccIndex, ty::RegionVid>,
+    pub(crate) scc_representatives: IndexVec<ConstraintSccIndex, ty::RegionVid>,
 
     /// The final inferred values of the region variables; we compute
     /// one value per SCC. To get the value for any given *region*,
@@ -119,6 +122,8 @@ pub struct RegionInferenceContext<'tcx> {
     /// Information about how the universally quantified regions in
     /// scope on this function relate to one another.
     universal_region_relations: Frozen<UniversalRegionRelations<'tcx>>,
+
+    pub(crate) live_loans: SparseBitMatrix<PointIndex, BorrowIndex>,
 }
 
 /// Each time that `apply_member_constraint` is successful, it appends
@@ -330,6 +335,7 @@ impl<'tcx> RegionInferenceContext<'tcx> {
         type_tests: Vec<TypeTest<'tcx>>,
         liveness_constraints: LivenessValues<RegionVid>,
         elements: &Rc<RegionValueElements>,
+        live_loans: SparseBitMatrix<PointIndex, BorrowIndex>,
     ) -> Self {
         debug!("universal_regions: {:#?}", universal_regions);
         debug!("outlives constraints: {:#?}", outlives_constraints);
@@ -383,6 +389,7 @@ impl<'tcx> RegionInferenceContext<'tcx> {
             type_tests,
             universal_regions,
             universal_region_relations,
+            live_loans,
         };
 
         result.init_free_and_bound_regions();

compiler/rustc_borrowck/src/type_check/liveness/mod.rs

@@ -1,12 +1,15 @@
 use itertools::{Either, Itertools};
 use rustc_data_structures::fx::FxHashSet;
+use rustc_index::bit_set::SparseBitMatrix;
 use rustc_middle::mir::{Body, Local};
 use rustc_middle::ty::{RegionVid, TyCtxt};
 use rustc_mir_dataflow::impls::MaybeInitializedPlaces;
 use rustc_mir_dataflow::move_paths::MoveData;
 use rustc_mir_dataflow::ResultsCursor;
 use std::rc::Rc;
 
+use crate::dataflow::BorrowIndex;
+use crate::region_infer::values::PointIndex;
 use crate::{
     constraints::OutlivesConstraintSet,
     facts::{AllFacts, AllFactsExt},
@@ -37,7 +40,7 @@ pub(super) fn generate<'mir, 'tcx>(
     move_data: &MoveData<'tcx>,
     location_table: &LocationTable,
     use_polonius: bool,
-) {
+) -> SparseBitMatrix<PointIndex, BorrowIndex> {
     debug!("liveness::generate");
 
     let free_regions = regions_that_outlive_free_regions(
@@ -64,7 +67,7 @@ pub(super) fn generate<'mir, 'tcx>(
         relevant_live_locals,
         boring_locals,
         polonius_drop_used,
-    );
+    )
 }
 
 // The purpose of `compute_relevant_live_locals` is to define the subset of `Local`