Defer nll-boring/polonius-relevant locals

Author: jackh726

compiler/rustc_borrowck/src/lib.rs

@@ -87,7 +87,7 @@ mod nll;
 mod path_utils;
 mod place_ext;
 mod places_conflict;
-pub(crate) mod polonius;
+mod polonius;
 mod prefixes;
 mod region_infer;
 mod renumber;

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

@@ -42,38 +42,57 @@ pub(super) fn generate<'tcx>(
         typeck.constraints.liveness_constraints.add_all_points(region);
     }
 
-    let mut free_regions = regions_that_outlive_free_regions(
+    let free_regions = regions_that_outlive_free_regions(
         typeck.infcx.num_region_vars(),
         &typeck.universal_regions,
         &typeck.constraints.outlives_constraints,
     );
 
-    // NLLs can avoid computing some liveness data here because its constraints are
-    // location-insensitive, but that doesn't work in polonius: locals whose type contains a region
-    // that outlives a free region are not necessarily live everywhere in a flow-sensitive setting,
-    // unlike NLLs.
-    // We do record these regions in the polonius context, since they're used to differentiate
-    // relevant and boring locals, which is a key distinction used later in diagnostics.
-    // This additional liveness information is ultimately used for *loan* liveness,
-    // so we don't need to compute it when there are no loans.
-    // FIXME: this NLL optimization idea, to reduce work to relevant locals only, still makes sense
-    // for polonius, and should be investigated to improve liveness performance.
-    if typeck.tcx().sess.opts.unstable_opts.polonius.is_next_enabled()
-        && typeck.borrow_set.len() > 0
-    {
-        let (_, boring_locals) =
-            compute_relevant_live_locals(typeck.tcx(), &free_regions, typeck.body);
-        typeck.polonius_context.as_mut().unwrap().boring_nll_locals =
-            boring_locals.into_iter().collect();
-        free_regions = typeck.universal_regions.universal_regions_iter().collect();
-    }
     let (relevant_live_locals, boring_locals) =
         compute_relevant_live_locals(typeck.tcx(), &free_regions, typeck.body);
 
-    let (deferred_locals, local_use_map) =
-        trace::trace(typeck, location_map, move_data, &relevant_live_locals, &boring_locals);
+    // Under Polonius Alpha, a larger set of locals are considered relevant: specifically,
+    // locals containing regions *outliving* universal regions are relevant and only
+    // locals containing solely universal regions are considered boring.
+    //
+    // However, we don't actually need liveness information for *all* these locals,
+    // only when actually computing loans. So, we can defer computing the liveness
+    // until we try to compute the loan, which is gated on `LocalizedConstraintGraph`
+    // traversal.
+    //
+    // Potentially in theory, we could defer computing liveness for *all* locals,
+    // but that's a much bigger refactor (many things rely on liveness of
+    // NLL-relevant locals). So, we only defer NLL-boring/Polonius-relevant locals
+    // for now.
+    let deferred_locals = 'deferred: {
+        // If we aren't going to be using the additional liveness information,
+        // don't even bother computing the larger relevant set.
+        // Similarly, since this liveness information is ultimately used for *loan*
+        // liveness, we don't need to compute it when there are no loans.
+        if typeck.polonius_context.is_none() || typeck.borrow_set.len() == 0 {
+            break 'deferred vec![];
+        }
+
+        let free_regions: FxHashSet<RegionVid> =
+            typeck.universal_regions.universal_regions_iter().collect();
+        let (polonius_relevant, _) =
+            compute_relevant_live_locals(typeck.tcx(), &free_regions, typeck.body);
+
+        let boring: FxHashSet<Local> = boring_locals.iter().copied().collect();
+        polonius_relevant.into_iter().filter(|local| boring.contains(local)).collect()
+    };
+
+    let (deferred_locals, local_use_map) = trace::trace(
+        typeck,
+        location_map,
+        move_data,
+        &relevant_live_locals,
+        &boring_locals,
+        &deferred_locals,
+    );
 
     if let Some(polonius_context) = &mut typeck.polonius_context {
+        polonius_context.boring_nll_locals = boring_locals.into_iter().collect();
         polonius_context.deferred_locals_for_liveness = deferred_locals;
         polonius_context.local_use_map = Some(local_use_map);
     }

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

@@ -48,10 +48,14 @@ pub(super) fn trace<'tcx>(
     move_data: &MoveData<'tcx>,
     relevant_live_locals: &[Local],
     boring_locals: &[Local],
+    deferred: &[Local],
 ) -> (DeferredLocals<'tcx>, LocalUseMap) {
     let _timer = typeck.tcx().prof.generic_activity("borrowck_liveness_trace");
 
-    let local_use_map = LocalUseMap::build(&relevant_live_locals, location_map, typeck.body);
+    // The use map must also cover the deferred locals: their liveness is computed later, from
+    // this same map, when the loan liveness traversal first reaches one of their regions.
+    let use_map_locals: Vec<Local> = relevant_live_locals.iter().chain(deferred).copied().collect();
+    let local_use_map = LocalUseMap::build(&use_map_locals, location_map, typeck.body);
     let calc = LivenessCalculation::new(
         typeck.tcx(),
         typeck.body,
@@ -61,13 +65,14 @@ pub(super) fn trace<'tcx>(
     );
     let mut results = LivenessResults::new(typeck, calc);
 
-    let deferred_locals = DeferredLocals::default();
+    let deferred: FxIndexSet<Local> = deferred.iter().copied().collect();
+    let mut deferred_locals = DeferredLocals::default();
 
-    results.add_extra_drop_facts(relevant_live_locals);
+    results.add_extra_drop_facts(relevant_live_locals, &deferred);
 
     results.compute_for_all_locals(relevant_live_locals);
 
-    results.dropck_boring_locals(boring_locals);
+    results.dropck_boring_locals(boring_locals, &deferred, &mut deferred_locals);
 
     (deferred_locals, local_use_map)
 }
@@ -174,19 +179,72 @@ impl<'a, 'typeck, 'tcx> LivenessResults<'a, 'typeck, 'tcx> {
     /// These are all the locals which do not potentially reference a region local
     /// to this body. Locals which only reference free regions are always drop-live
     /// and can therefore safely be dropped.
-    fn dropck_boring_locals(&mut self, boring_locals: &[Local]) {
+    fn dropck_boring_locals(
+        &mut self,
+        boring_locals: &[Local],
+        deferred: &FxIndexSet<Local>,
+        deferred_locals: &mut DeferredLocals<'tcx>,
+    ) {
         for &local in boring_locals {
-            let local_ty = self.calc.body.local_decls[local].ty;
-            let local_span = self.calc.body.local_decls[local].source_info.span;
-            dropck_local(&self.typeck.infcx, &mut self.calc.drop_data, local_ty, local_span);
+            self.dropck_boring_local(local, deferred, deferred_locals);
         }
     }
 
+    fn dropck_boring_local(
+        &mut self,
+        local: Local,
+        deferred: &FxIndexSet<Local>,
+        deferred_locals: &mut DeferredLocals<'tcx>,
+    ) {
+        let typeck = &mut *self.typeck;
+        let local_ty = self.calc.body.local_decls[local].ty;
+        let local_span = self.calc.body.local_decls[local].source_info.span;
+        let drop_data = dropck_local(&typeck.infcx, &mut self.calc.drop_data, local_ty, local_span);
+
+        if !deferred.contains(&local) {
+            return;
+        }
+
+        if let Some(data) = drop_data.region_constraint_data {
+            let drop_locations =
+                self.calc.local_use_map.drops(local).map(|p| self.calc.location_map.to_location(p));
+            for drop_location in drop_locations {
+                typeck.push_region_constraints(
+                    drop_location.to_locations(),
+                    ConstraintCategory::Boring,
+                    data,
+                );
+            }
+        }
+
+        for &kind in &drop_data.dropck_result.kinds {
+            polonius::legacy::emit_drop_facts(
+                typeck.tcx(),
+                local,
+                &kind,
+                typeck.universal_regions,
+                typeck.polonius_facts,
+            );
+        }
+
+        deferred_locals.defer_local(
+            typeck.infcx,
+            typeck.universal_regions,
+            local,
+            local_ty,
+            &drop_data.dropck_result.kinds,
+        );
+    }
+
     /// Add extra drop facts needed for Polonius.
     ///
     /// Add facts for all locals with free regions, since regions may outlive
     /// the function body only at certain nodes in the CFG.
-    fn add_extra_drop_facts(&mut self, relevant_live_locals: &[Local]) {
+    fn add_extra_drop_facts(
+        &mut self,
+        relevant_live_locals: &[Local],
+        deferred: &FxIndexSet<Local>,
+    ) {
         // This collect is more necessary than immediately apparent
         // because these facts go into `add_drop_live_facts_for()`,
         // which also writes to `polonius_facts`, and so this is genuinely
@@ -206,7 +264,10 @@ impl<'a, 'typeck, 'tcx> LivenessResults<'a, 'typeck, 'tcx> {
                 .iter()
                 .filter_map(|&(local, location_index)| {
                     let local_ty = self.calc.body.local_decls[local].ty;
-                    if relevant_live_locals.contains(&local) || !local_ty.has_free_regions() {
+                    if relevant_live_locals.contains(&local)
+                        || deferred.contains(&local)
+                        || !local_ty.has_free_regions()
+                    {
                         return None;
                     }