extend liveness to distinguish "drop" and "non-drop" uses

Author: nikomatsakis

src/librustc_mir/transform/generator.rs

@@ -68,7 +68,7 @@ use rustc::mir::visit::{LvalueContext, Visitor, MutVisitor};
 use rustc::ty::{self, TyCtxt, AdtDef, Ty, GeneratorInterior};
 use rustc::ty::subst::{Kind, Substs};
 use util::dump_mir;
-use util::liveness;
+use util::liveness::{self, LivenessMode};
 use rustc_const_math::ConstInt;
 use rustc_data_structures::indexed_vec::Idx;
 use rustc_data_structures::indexed_set::IdxSetBuf;
@@ -348,7 +348,10 @@ fn locals_live_across_suspend_points<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
     ignored.visit_mir(mir);
 
     let mut set = liveness::LocalSet::new_empty(mir.local_decls.len());
-    let liveness = liveness::liveness_of_locals(mir);
+    let liveness = liveness::liveness_of_locals(mir, LivenessMode {
+        include_regular_use: true,
+        include_drops: true,
+    });
     liveness::dump_mir(tcx, "generator_liveness", source, mir, &liveness);
 
     let mut storage_liveness_map = HashMap::new();

src/librustc_mir/transform/nll/constraint_generation.rs

@@ -10,24 +10,30 @@
 
 use rustc::mir::Mir;
 use rustc::infer::InferCtxt;
-use util::liveness::LivenessResult;
 
+use super::LivenessResults;
 use super::ToRegionIndex;
 use super::region_infer::RegionInferenceContext;
 
-pub fn generate_constraints<'a, 'gcx, 'tcx>(infcx: &InferCtxt<'a, 'gcx, 'tcx>,
-                                            regioncx: &mut RegionInferenceContext,
-                                            mir: &Mir<'tcx>,
-                                            liveness: &LivenessResult)
-{
-    ConstraintGeneration { infcx, regioncx, mir, liveness }.add_constraints();
+pub(super) fn generate_constraints<'a, 'gcx, 'tcx>(
+    infcx: &InferCtxt<'a, 'gcx, 'tcx>,
+    regioncx: &mut RegionInferenceContext,
+    mir: &Mir<'tcx>,
+    liveness: &LivenessResults,
+) {
+    ConstraintGeneration {
+        infcx,
+        regioncx,
+        mir,
+        liveness,
+    }.add_constraints();
 }
 
 struct ConstraintGeneration<'constrain, 'gcx: 'tcx, 'tcx: 'constrain> {
     infcx: &'constrain InferCtxt<'constrain, 'gcx, 'tcx>,
     regioncx: &'constrain mut RegionInferenceContext,
     mir: &'constrain Mir<'tcx>,
-    liveness: &'constrain LivenessResult,
+    liveness: &'constrain LivenessResults,
 }
 
 impl<'constrain, 'gcx, 'tcx> ConstraintGeneration<'constrain, 'gcx, 'tcx> {
@@ -47,18 +53,23 @@ impl<'constrain, 'gcx, 'tcx> ConstraintGeneration<'constrain, 'gcx, 'tcx> {
         for bb in self.mir.basic_blocks().indices() {
             debug!("add_liveness_constraints: bb={:?}", bb);
 
-            self.liveness.simulate_block(self.mir, bb, |location, live_locals| {
-                debug!("add_liveness_constraints: location={:?} live_locals={:?}",
-                       location, live_locals);
+            self.liveness
+                .regular
+                .simulate_block(self.mir, bb, |location, live_locals| {
+                    debug!(
+                        "add_liveness_constraints: location={:?} live_locals={:?}",
+                        location,
+                        live_locals
+                    );
 
-                for live_local in live_locals.iter() {
-                    let live_local_ty = self.mir.local_decls[live_local].ty;
-                    tcx.for_each_free_region(&live_local_ty, |live_region| {
-                        let vid = live_region.to_region_index();
-                        self.regioncx.add_live_point(vid, location);
-                    })
-                }
-            });
+                    for live_local in live_locals.iter() {
+                        let live_local_ty = self.mir.local_decls[live_local].ty;
+                        tcx.for_each_free_region(&live_local_ty, |live_region| {
+                            let vid = live_region.to_region_index();
+                            self.regioncx.add_live_point(vid, location);
+                        })
+                    }
+                });
         }
     }
 }

src/librustc_mir/transform/nll/mod.rs

@@ -16,7 +16,7 @@ use rustc::util::nodemap::FxHashMap;
 use rustc_data_structures::indexed_vec::Idx;
 use std::collections::BTreeSet;
 use std::fmt;
-use util::liveness::{self, LivenessResult};
+use util::liveness::{self, LivenessResult, LivenessMode};
 
 use util as mir_util;
 use self::mir_util::PassWhere;
@@ -50,7 +50,17 @@ impl MirPass for NLL {
             let num_region_variables = renumber::renumber_mir(infcx, mir);
 
             // Compute what is live where.
-            let liveness = &liveness::liveness_of_locals(mir);
+            let liveness = &LivenessResults {
+                regular: liveness::liveness_of_locals(mir, LivenessMode {
+                    include_regular_use: true,
+                    include_drops: false,
+                }),
+
+                drop: liveness::liveness_of_locals(mir, LivenessMode {
+                    include_regular_use: false,
+                    include_drops: true,
+                })
+            };
 
             // Create the region inference context, generate the constraints,
             // and then solve them.
@@ -64,9 +74,14 @@ impl MirPass for NLL {
     }
 }
 
+struct LivenessResults {
+    regular: LivenessResult,
+    drop: LivenessResult,
+}
+
 fn dump_mir_results<'a, 'gcx, 'tcx>(
     infcx: &InferCtxt<'a, 'gcx, 'tcx>,
-    liveness: &LivenessResult,
+    liveness: &LivenessResults,
     source: MirSource,
     regioncx: &RegionInferenceContext,
     mir: &Mir<'tcx>,
@@ -75,11 +90,22 @@ fn dump_mir_results<'a, 'gcx, 'tcx>(
         return;
     }
 
-    let liveness_per_location: FxHashMap<_, _> = mir.basic_blocks()
+    let regular_liveness_per_location: FxHashMap<_, _> = mir.basic_blocks()
+        .indices()
+        .flat_map(|bb| {
+            let mut results = vec![];
+            liveness.regular.simulate_block(&mir, bb, |location, local_set| {
+                results.push((location, local_set.clone()));
+            });
+            results
+        })
+        .collect();
+
+    let drop_liveness_per_location: FxHashMap<_, _> = mir.basic_blocks()
         .indices()
         .flat_map(|bb| {
             let mut results = vec![];
-            liveness.simulate_block(&mir, bb, |location, local_set| {
+            liveness.drop.simulate_block(&mir, bb, |location, local_set| {
                 results.push((location, local_set.clone()));
             });
             results
@@ -96,16 +122,17 @@ fn dump_mir_results<'a, 'gcx, 'tcx>(
             // Before each basic block, dump out the values
             // that are live on entry to the basic block.
             PassWhere::BeforeBlock(bb) => {
-                let local_set = &liveness.ins[bb];
-                writeln!(out, "    | Variables live on entry to the block {:?}:", bb)?;
-                for local in local_set.iter() {
-                    writeln!(out, "    | - {:?}", local)?;
-                }
+                writeln!(out, "    | Variables regular-live on entry to the block {:?}: {:?}",
+                         bb, liveness.regular.ins[bb])?;
+                writeln!(out, "    | Variables drop-live on entry to the block {:?}: {:?}",
+                         bb, liveness.drop.ins[bb])?;
             }
 
             PassWhere::InCFG(location) => {
-                let local_set = &liveness_per_location[&location];
-                writeln!(out, "        | Live variables here: {:?}", local_set)?;
+                let local_set = &regular_liveness_per_location[&location];
+                writeln!(out, "        | Regular-Live variables here: {:?}", local_set)?;
+                let local_set = &drop_liveness_per_location[&location];
+                writeln!(out, "        | Drop-Live variables here: {:?}", local_set)?;
             }
 
             PassWhere::AfterCFG => {}