Calculate liveness for the same locals with and without -Zpolonius

This fixes some test differences and also avoids overflow in
issue-38591.rs.

Author: matthewjasper

src/librustc_mir/borrow_check/nll/type_check/liveness/local_use_map.rs

@@ -70,6 +70,10 @@ impl LocalUseMap {
             appearances: IndexVec::new(),
         };
 
+        if live_locals.is_empty() {
+            return local_use_map;
+        }
+
         let mut locals_with_use_data: IndexVec<Local, bool> =
             IndexVec::from_elem_n(false, body.local_decls.len());
         live_locals.iter().for_each(|&local| locals_with_use_data[local] = true);

src/librustc_mir/borrow_check/nll/type_check/liveness/mod.rs

@@ -36,31 +36,39 @@ pub(super) fn generate<'tcx>(
 ) {
     debug!("liveness::generate");
 
-    let live_locals: Vec<Local> = if AllFacts::enabled(typeck.tcx()) {
-        // If "dump facts from NLL analysis" was requested perform
-        // the liveness analysis for all `Local`s. This case opens
-        // the possibility of the variables being analyzed in `trace`
-        // to be *any* `Local`, not just the "live" ones, so we can't
-        // make any assumptions past this point as to the characteristics
-        // of the `live_locals`.
-        // FIXME: Review "live" terminology past this point, we should
-        // not be naming the `Local`s as live.
-        body.local_decls.indices().collect()
+    let free_regions = regions_that_outlive_free_regions(
+        typeck.infcx.num_region_vars(),
+        &typeck.borrowck_context.universal_regions,
+        &typeck.borrowck_context.constraints.outlives_constraints,
+    );
+    let live_locals = compute_live_locals(typeck.tcx(), &free_regions, body);
+    let facts_enabled = AllFacts::enabled(typeck.tcx());
+
+
+    let polonius_drop_used = if facts_enabled {
+        let mut drop_used = Vec::new();
+        polonius::populate_access_facts(
+            typeck,
+            body,
+            location_table,
+            move_data,
+            &mut drop_used,
+        );
+        Some(drop_used)
     } else {
-        let free_regions = {
-            regions_that_outlive_free_regions(
-                typeck.infcx.num_region_vars(),
-                &typeck.borrowck_context.universal_regions,
-                &typeck.borrowck_context.constraints.outlives_constraints,
-            )
-        };
-        compute_live_locals(typeck.tcx(), &free_regions, body)
+        None
     };
 
-    if !live_locals.is_empty() {
-        trace::trace(typeck, body, elements, flow_inits, move_data, live_locals);
-
-        polonius::populate_access_facts(typeck, body, location_table, move_data);
+    if !live_locals.is_empty() || facts_enabled {
+        trace::trace(
+            typeck,
+            body,
+            elements,
+            flow_inits,
+            move_data,
+            live_locals,
+            polonius_drop_used,
+        );
     }
 }
 

src/librustc_mir/borrow_check/nll/type_check/liveness/polonius.rs

@@ -16,7 +16,7 @@ struct UseFactsExtractor<'me> {
     var_defined: &'me mut VarPointRelations,
     var_used: &'me mut VarPointRelations,
     location_table: &'me LocationTable,
-    var_drop_used: &'me mut VarPointRelations,
+    var_drop_used: &'me mut Vec<(Local, Location)>,
     move_data: &'me MoveData<'me>,
     path_accessed_at: &'me mut MovePathPointRelations,
 }
@@ -39,7 +39,7 @@ impl UseFactsExtractor<'_> {
 
     fn insert_drop_use(&mut self, local: Local, location: Location) {
         debug!("LivenessFactsExtractor::insert_drop_use()");
-        self.var_drop_used.push((local, self.location_to_index(location)));
+        self.var_drop_used.push((local, location));
     }
 
     fn insert_path_access(&mut self, path: MovePathIndex, location: Location) {
@@ -100,19 +100,24 @@ pub(super) fn populate_access_facts(
     body: &Body<'tcx>,
     location_table: &LocationTable,
     move_data: &MoveData<'_>,
+    drop_used: &mut Vec<(Local, Location)>,
 ) {
     debug!("populate_var_liveness_facts()");
 
     if let Some(facts) = typeck.borrowck_context.all_facts.as_mut() {
         UseFactsExtractor {
             var_defined: &mut facts.var_defined,
             var_used: &mut facts.var_used,
-            var_drop_used: &mut facts.var_drop_used,
+            var_drop_used: drop_used,
             path_accessed_at: &mut facts.path_accessed_at,
             location_table,
             move_data,
         }
         .visit_body(body);
+
+        facts.var_drop_used.extend(drop_used.iter().map(|&(local, location)| {
+            (local, location_table.mid_index(location))
+        }));
     }
 
     for (local, local_decl) in body.local_decls.iter_enumerated() {

src/librustc_mir/borrow_check/nll/type_check/liveness/trace.rs

@@ -13,7 +13,7 @@ use rustc::traits::query::type_op::outlives::DropckOutlives;
 use rustc::traits::query::type_op::TypeOp;
 use rustc::ty::{Ty, TypeFoldable};
 use rustc_index::bit_set::HybridBitSet;
-use rustc_data_structures::fx::FxHashMap;
+use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use std::rc::Rc;
 
 /// This is the heart of the liveness computation. For each variable X
@@ -37,6 +37,7 @@ pub(super) fn trace(
     flow_inits: &mut FlowAtLocation<'tcx, MaybeInitializedPlaces<'_, 'tcx>>,
     move_data: &MoveData<'tcx>,
     live_locals: Vec<Local>,
+    polonius_drop_used: Option<Vec<(Local, Location)>>,
 ) {
     debug!("trace()");
 
@@ -52,7 +53,13 @@ pub(super) fn trace(
         drop_data: FxHashMap::default(),
     };
 
-    LivenessResults::new(cx).compute_for_all_locals(live_locals);
+    let mut results = LivenessResults::new(cx);
+
+    if let Some(drop_used) = polonius_drop_used {
+        results.add_extra_drop_facts(drop_used, live_locals.iter().copied().collect())
+    }
+
+    results.compute_for_all_locals(live_locals);
 }
 
 /// Contextual state for the type-liveness generator.
@@ -145,6 +152,32 @@ impl LivenessResults<'me, 'typeck, 'flow, 'tcx> {
         }
     }
 
+    /// 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,
+        drop_used: Vec<(Local, Location)>,
+        live_locals: FxHashSet<Local>,
+    ) {
+        let locations = HybridBitSet::new_empty(self.cx.elements.num_points());
+
+        for (local, location) in drop_used {
+            if !live_locals.contains(&local) {
+                let local_ty = self.cx.body.local_decls[local].ty;
+                if local_ty.has_free_regions() {
+                    self.cx.add_drop_live_facts_for(
+                        local,
+                        local_ty,
+                        &[location],
+                        &locations,
+                    );
+                }
+            }
+        }
+    }
+
     /// Clear the value of fields that are "per local variable".
     fn reset_local_state(&mut self) {
         self.defs.clear();