Initial attempt at refining liveness with "maybe initialized" analysis

Author: Nashenas88

src/librustc_mir/borrow_check.rs renamed to src/librustc_mir/borrow_check/mod.rs

@@ -18,7 +18,6 @@ use rustc::mir::{AssertMessage, BasicBlock, BorrowKind, Location, Lvalue, Local}
 use rustc::mir::{Mir, Mutability, Operand, Projection, ProjectionElem, Rvalue};
 use rustc::mir::{Statement, StatementKind, Terminator, TerminatorKind};
 use rustc::mir::transform::MirSource;
-use transform::nll;
 
 use rustc_data_structures::indexed_set::{self, IdxSetBuf};
 use rustc_data_structures::indexed_vec::{Idx};
@@ -38,6 +37,7 @@ use util::borrowck_errors::{BorrowckErrors, Origin};
 use self::MutateMode::{JustWrite, WriteAndRead};
 use self::ConsumeKind::{Consume};
 
+pub(crate) mod nll;
 
 pub fn provide(providers: &mut Providers) {
     *providers = Providers {
@@ -77,7 +77,16 @@ fn do_mir_borrowck<'a, 'gcx, 'tcx>(infcx: &InferCtxt<'a, 'gcx, 'tcx>,
 
     let id = src.item_id();
 
-    let move_data: MoveData<'tcx> = match MoveData::gather_moves(input_mir, tcx, param_env) {
+    // Make our own copy of the MIR. This copy will be modified (in place) to
+    // contain non-lexical lifetimes. It will have a lifetime tied
+    // to the inference context.
+    let mut mir: Mir<'tcx> = input_mir.clone();
+    let mir = &mut mir;
+
+    // Replace all regions with fresh inference variables.
+    let num_region_variables = nll::renumber::renumber_mir(infcx, mir);
+
+    let move_data: MoveData<'tcx> = match MoveData::gather_moves(mir, tcx, param_env) {
         Ok(move_data) => move_data,
         Err((move_data, move_errors)) => {
             for move_error in move_errors {
@@ -105,31 +114,22 @@ fn do_mir_borrowck<'a, 'gcx, 'tcx>(infcx: &InferCtxt<'a, 'gcx, 'tcx>,
         }
     };
 
-    // Make our own copy of the MIR. This copy will be modified (in place) to
-    // contain non-lexical lifetimes. It will have a lifetime tied
-    // to the inference context.
-    let mut mir: Mir<'tcx> = input_mir.clone();
-    let mir = &mut mir;
+    let mdpe = MoveDataParamEnv { move_data: move_data, param_env: param_env };
+    let dead_unwinds = IdxSetBuf::new_empty(mir.basic_blocks().len());
+    let flow_inits = FlowInProgress::new(do_dataflow(tcx, mir, id, &attributes, &dead_unwinds,
+                                 MaybeInitializedLvals::new(tcx, mir, &mdpe),
+                                 |bd, i| &bd.move_data().move_paths[i]));
+    let flow_uninits = FlowInProgress::new(do_dataflow(tcx, mir, id, &attributes, &dead_unwinds,
+                                   MaybeUninitializedLvals::new(tcx, mir, &mdpe),
+                                   |bd, i| &bd.move_data().move_paths[i]));
 
     // If we are in non-lexical mode, compute the non-lexical lifetimes.
     let opt_regioncx = if !tcx.sess.opts.debugging_opts.nll {
         None
     } else {
-        Some(nll::compute_regions(infcx, src, param_env, mir))
+        Some(nll::compute_regions(infcx, src, param_env, mir, num_region_variables, &flow_inits, &mdpe.move_data))
     };
 
-    let mdpe = MoveDataParamEnv { move_data: move_data, param_env: param_env };
-    let dead_unwinds = IdxSetBuf::new_empty(mir.basic_blocks().len());
-    let flow_borrows = do_dataflow(tcx, mir, id, &attributes, &dead_unwinds,
-                                   Borrows::new(tcx, mir, opt_regioncx.as_ref()),
-                                   |bd, i| bd.location(i));
-    let flow_inits = do_dataflow(tcx, mir, id, &attributes, &dead_unwinds,
-                                 MaybeInitializedLvals::new(tcx, mir, &mdpe),
-                                 |bd, i| &bd.move_data().move_paths[i]);
-    let flow_uninits = do_dataflow(tcx, mir, id, &attributes, &dead_unwinds,
-                                   MaybeUninitializedLvals::new(tcx, mir, &mdpe),
-                                   |bd, i| &bd.move_data().move_paths[i]);
-
     let mut mbcx = MirBorrowckCtxt {
         tcx: tcx,
         mir: mir,
@@ -138,6 +138,10 @@ fn do_mir_borrowck<'a, 'gcx, 'tcx>(infcx: &InferCtxt<'a, 'gcx, 'tcx>,
         param_env: param_env,
     };
 
+    let flow_borrows = FlowInProgress::new(do_dataflow(tcx, mir, id, &attributes, &dead_unwinds,
+                                   Borrows::new(tcx, mir, opt_regioncx.as_ref()),
+                                   |bd, i| bd.location(i)));
+
     let mut state = InProgress::new(flow_borrows,
                                     flow_inits,
                                     flow_uninits);
@@ -1401,14 +1405,14 @@ impl ContextKind {
 }
 
 impl<'b, 'gcx, 'tcx> InProgress<'b, 'gcx, 'tcx> {
-    pub(super) fn new(borrows: DataflowResults<Borrows<'b, 'gcx, 'tcx>>,
-                      inits: DataflowResults<MaybeInitializedLvals<'b, 'gcx, 'tcx>>,
-                      uninits: DataflowResults<MaybeUninitializedLvals<'b, 'gcx, 'tcx>>)
+    fn new(borrows: FlowInProgress<Borrows<'b, 'gcx, 'tcx>>,
+                      inits: FlowInProgress<MaybeInitializedLvals<'b, 'gcx, 'tcx>>,
+                      uninits: FlowInProgress<MaybeUninitializedLvals<'b, 'gcx, 'tcx>>)
                       -> Self {
         InProgress {
-            borrows: FlowInProgress::new(borrows),
-            inits: FlowInProgress::new(inits),
-            uninits: FlowInProgress::new(uninits),
+            borrows,
+            inits,
+            uninits,
         }
     }
 
@@ -1474,35 +1478,42 @@ impl<'b, 'gcx, 'tcx> InProgress<'b, 'gcx, 'tcx> {
     }
 }
 
-impl<'b, 'gcx, 'tcx> FlowInProgress<MaybeUninitializedLvals<'b, 'gcx, 'tcx>> {
-    fn has_any_child_of(&self, mpi: MovePathIndex) -> Option<MovePathIndex> {
-        let move_data = self.base_results.operator().move_data();
-
-        let mut todo = vec![mpi];
-        let mut push_siblings = false; // don't look at siblings of original `mpi`.
-        while let Some(mpi) = todo.pop() {
-            if self.curr_state.contains(&mpi) {
-                return Some(mpi);
-            }
-            let move_path = &move_data.move_paths[mpi];
-            if let Some(child) = move_path.first_child {
-                todo.push(child);
-            }
-            if push_siblings {
-                if let Some(sibling) = move_path.next_sibling {
-                    todo.push(sibling);
+macro_rules! has_any_child_of_impl {
+    ($MaybeTLvals:ident) => {
+        impl<'b, 'gcx, 'tcx> FlowInProgress<$MaybeTLvals<'b, 'gcx, 'tcx>> {
+            fn has_any_child_of(&self, mpi: MovePathIndex) -> Option<MovePathIndex> {
+                let move_data = self.base_results.operator().move_data();
+
+                let mut todo = vec![mpi];
+                let mut push_siblings = false; // don't look at siblings of original `mpi`.
+                while let Some(mpi) = todo.pop() {
+                    if self.curr_state.contains(&mpi) {
+                        return Some(mpi);
+                    }
+                    let move_path = &move_data.move_paths[mpi];
+                    if let Some(child) = move_path.first_child {
+                        todo.push(child);
+                    }
+                    if push_siblings {
+                        if let Some(sibling) = move_path.next_sibling {
+                            todo.push(sibling);
+                        }
+                    } else {
+                        // after we've processed the original `mpi`, we should
+                        // always traverse the siblings of any of its
+                        // children.
+                        push_siblings = true;
+                    }
                 }
-            } else {
-                // after we've processed the original `mpi`, we should
-                // always traverse the siblings of any of its
-                // children.
-                push_siblings = true;
+                return None;
             }
         }
-        return None;
-    }
+    };
 }
 
+has_any_child_of_impl!(MaybeInitializedLvals);
+has_any_child_of_impl!(MaybeUninitializedLvals);
+
 impl<BD> FlowInProgress<BD> where BD: BitDenotation {
     fn each_state_bit<F>(&self, f: F) where F: FnMut(BD::Idx) {
         self.curr_state.each_bit(self.base_results.operator().bits_per_block(), f)

src/librustc_mir/transform/nll/constraint_generation.rs renamed to src/librustc_mir/borrow_check/nll/constraint_generation.rs

@@ -21,6 +21,9 @@ use rustc::ty::fold::TypeFoldable;
 use rustc::util::common::ErrorReported;
 use rustc_data_structures::fx::FxHashSet;
 use syntax::codemap::DUMMY_SP;
+use borrow_check::FlowInProgress;
+use dataflow::MaybeInitializedLvals;
+use dataflow::move_paths::{MoveData, LookupResult};
 
 use super::LivenessResults;
 use super::ToRegionVid;
@@ -32,25 +35,31 @@ pub(super) fn generate_constraints<'a, 'gcx, 'tcx>(
     mir: &Mir<'tcx>,
     mir_source: MirSource,
     liveness: &LivenessResults,
+    flow_inits: &FlowInProgress<MaybeInitializedLvals<'a, 'gcx, 'tcx>>,
+    move_data: &MoveData<'tcx>,
 ) {
     ConstraintGeneration {
         infcx,
         regioncx,
         mir,
         liveness,
         mir_source,
+        flow_inits,
+        move_data,
     }.add_constraints();
 }
 
-struct ConstraintGeneration<'cx, 'gcx: 'tcx, 'tcx: 'cx> {
-    infcx: &'cx InferCtxt<'cx, 'gcx, 'tcx>,
-    regioncx: &'cx mut RegionInferenceContext<'tcx>,
-    mir: &'cx Mir<'tcx>,
-    liveness: &'cx LivenessResults,
+struct ConstraintGeneration<'a, 'cx: 'a, 'gcx: 'tcx, 'tcx: 'cx> {
+    infcx: &'a InferCtxt<'cx, 'gcx, 'tcx>,
+    regioncx: &'a mut RegionInferenceContext<'tcx>,
+    mir: &'a Mir<'tcx>,
+    liveness: &'a LivenessResults,
     mir_source: MirSource,
+    flow_inits: &'a FlowInProgress<MaybeInitializedLvals<'cx, 'gcx, 'tcx>>,
+    move_data: &'a MoveData<'tcx>,
 }
 
-impl<'cx, 'gcx, 'tcx> ConstraintGeneration<'cx, 'gcx, 'tcx> {
+impl<'a, 'cx, 'gcx, 'tcx> ConstraintGeneration<'a, 'cx, 'gcx, 'tcx> {
     fn add_constraints(&mut self) {
         self.add_liveness_constraints();
         self.add_borrow_constraints();
@@ -78,8 +87,12 @@ impl<'cx, 'gcx, 'tcx> ConstraintGeneration<'cx, 'gcx, 'tcx> {
                 .drop
                 .simulate_block(self.mir, bb, |location, live_locals| {
                     for live_local in live_locals.iter() {
-                        let live_local_ty = self.mir.local_decls[live_local].ty;
-                        self.add_drop_live_constraint(live_local_ty, location);
+                        if let LookupResult::Exact(mpi) = self.move_data.rev_lookup.find(&Lvalue::Local(live_local)) {
+                            if self.flow_inits.has_any_child_of(mpi).is_some() {
+                                let live_local_ty = self.mir.local_decls[live_local].ty;
+                                self.add_drop_live_constraint(live_local_ty, location);
+                            }
+                        }
                     }
                 });
         }
@@ -215,7 +228,7 @@ impl<'cx, 'gcx, 'tcx> ConstraintGeneration<'cx, 'gcx, 'tcx> {
     }
 }
 
-impl<'cx, 'gcx, 'tcx> Visitor<'tcx> for ConstraintGeneration<'cx, 'gcx, 'tcx> {
+impl<'a, 'cx, 'gcx, 'tcx> Visitor<'tcx> for ConstraintGeneration<'a, 'cx, 'gcx, 'tcx> {
     fn visit_rvalue(&mut self,
                     rvalue: &Rvalue<'tcx>,
                     location: Location) {

src/librustc_mir/transform/nll/mod.rs renamed to src/librustc_mir/borrow_check/nll/mod.rs

@@ -16,6 +16,9 @@ use rustc::util::nodemap::FxHashMap;
 use std::collections::BTreeSet;
 use transform::type_check;
 use util::liveness::{self, LivenessMode, LivenessResult, LocalSet};
+use borrow_check::FlowInProgress;
+use dataflow::MaybeInitializedLvals;
+use dataflow::move_paths::MoveData;
 
 use util as mir_util;
 use self::mir_util::PassWhere;
@@ -27,33 +30,20 @@ mod free_regions;
 pub(crate) mod region_infer;
 use self::region_infer::RegionInferenceContext;
 
-mod renumber;
+pub(super) mod renumber;
 
 /// Computes the (non-lexical) regions from the input MIR.
 ///
 /// This may result in errors being reported.
-pub fn compute_regions<'a, 'gcx, 'tcx>(
+pub(super) fn compute_regions<'a, 'gcx, 'tcx>(
     infcx: &InferCtxt<'a, 'gcx, 'tcx>,
     source: MirSource,
+    mir: &Mir<'tcx>,
     param_env: ty::ParamEnv<'gcx>,
-    mir: &mut Mir<'tcx>,
-) -> RegionInferenceContext<'tcx> {
-    // Compute named region information.
-    let free_regions = &free_regions::free_regions(infcx, source);
-
-    // Replace all regions with fresh inference variables.
-    renumber::renumber_mir(infcx, free_regions, mir);
-
-    // Run the MIR type-checker.
-    let body_id = source.item_id();
-    let constraint_sets = &type_check::type_check(infcx, body_id, param_env, mir);
-
-    // Create the region inference context, taking ownership of the region inference
-    // data that was contained in `infcx`.
-    let var_origins = infcx.take_region_var_origins();
-    let mut regioncx = RegionInferenceContext::new(var_origins, free_regions, mir);
-    subtype_constraint_generation::generate(&mut regioncx, free_regions, mir, constraint_sets);
-
+    num_region_variables: usize,
+    flow_inits: &FlowInProgress<MaybeInitializedLvals<'a, 'gcx, 'tcx>>,
+    move_data: &MoveData<'tcx>,
+) -> RegionInferenceContext {
     // Compute what is live where.
     let liveness = &LivenessResults {
         regular: liveness::liveness_of_locals(
@@ -74,7 +64,8 @@ pub fn compute_regions<'a, 'gcx, 'tcx>(
     };
 
     // Generate non-subtyping constraints.
-    constraint_generation::generate_constraints(infcx, &mut regioncx, &mir, source, liveness);
+    constraint_generation::generate_constraints(infcx, &mut regioncx, &mir, source, liveness,
+                                                flow_inits, move_data);
 
     // Solve the region constraints.
     regioncx.solve(infcx, &mir);

src/librustc_mir/transform/nll/region_infer.rs renamed to src/librustc_mir/borrow_check/nll/region_infer.rs

@@ -21,8 +21,8 @@ use rustc_data_structures::indexed_vec::{IndexVec};
 
 use dataflow::{BitDenotation, BlockSets, DataflowOperator};
 pub use dataflow::indexes::BorrowIndex;
-use transform::nll::region_infer::RegionInferenceContext;
-use transform::nll::ToRegionVid;
+use borrow_check::nll::region_infer::RegionInferenceContext;
+use borrow_check::nll::ToRegionVid;
 
 use syntax_pos::Span;
 

src/librustc_mir/transform/nll/renumber.rs renamed to src/librustc_mir/borrow_check/nll/renumber.rs

@@ -43,7 +43,6 @@ pub mod instcombine;
 pub mod copy_prop;
 pub mod generator;
 pub mod inline;
-pub mod nll;
 
 pub(crate) fn provide(providers: &mut Providers) {
     self::qualify_consts::provide(providers);