Rename lifetimes on ConstraintGeneration, move macro impl to HasMoveData impl, ensure mir is immutably borrowed after renumbering, and add find_local fn to simplify mpi lookup in constraint generation

Author: Nashenas88

src/librustc_mir/borrow_check/mod.rs

@@ -81,10 +81,13 @@ fn do_mir_borrowck<'a, 'gcx, 'tcx>(infcx: &InferCtxt<'a, 'gcx, 'tcx>,
     // 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 free_regions = {
+        let mir = &mut mir;
 
-    // Replace all regions with fresh inference variables.
-    let free_regions = nll::replace_regions_in_mir(infcx, src, mir);
+        // Replace all regions with fresh inference variables.
+        nll::replace_regions_in_mir(infcx, src, mir)
+    };
+    let mir = &mir;
 
     let move_data: MoveData<'tcx> = match MoveData::gather_moves(mir, tcx, param_env) {
         Ok(move_data) => move_data,
@@ -1486,42 +1489,35 @@ impl<'b, 'gcx, 'tcx> InProgress<'b, 'gcx, 'tcx> {
     }
 }
 
-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;
-                    }
+impl<'tcx, T> FlowInProgress<T> where T: HasMoveData<'tcx> + BitDenotation<Idx = MovePathIndex> {
+    fn has_any_child_of(&self, mpi: T::Idx) -> Option<T::Idx> {
+        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);
                 }
-                return None;
+            } else {
+                // after we've processed the original `mpi`, we should
+                // always traverse the siblings of any of its
+                // children.
+                push_siblings = true;
             }
         }
-    };
+        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/borrow_check/nll/constraint_generation.rs

@@ -23,19 +23,19 @@ 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 dataflow::move_paths::MoveData;
 
 use super::LivenessResults;
 use super::ToRegionVid;
 use super::region_infer::RegionInferenceContext;
 
-pub(super) fn generate_constraints<'a, 'gcx, 'tcx>(
-    infcx: &InferCtxt<'a, 'gcx, 'tcx>,
+pub(super) fn generate_constraints<'cx, 'gcx, 'tcx>(
+    infcx: &InferCtxt<'cx, 'gcx, 'tcx>,
     regioncx: &mut RegionInferenceContext<'tcx>,
     mir: &Mir<'tcx>,
     mir_source: MirSource,
     liveness: &LivenessResults,
-    flow_inits: &FlowInProgress<MaybeInitializedLvals<'a, 'gcx, 'tcx>>,
+    flow_inits: &FlowInProgress<MaybeInitializedLvals<'cx, 'gcx, 'tcx>>,
     move_data: &MoveData<'tcx>,
 ) {
     ConstraintGeneration {
@@ -49,17 +49,18 @@ pub(super) fn generate_constraints<'a, 'gcx, 'tcx>(
     }.add_constraints();
 }
 
-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,
+/// 'cg = the duration of the constraint generation process itself.
+struct ConstraintGeneration<'cg, 'cx: 'cg, 'gcx: 'tcx, 'tcx: 'cx> {
+    infcx: &'cg InferCtxt<'cx, 'gcx, 'tcx>,
+    regioncx: &'cg mut RegionInferenceContext<'tcx>,
+    mir: &'cg Mir<'tcx>,
+    liveness: &'cg LivenessResults,
     mir_source: MirSource,
-    flow_inits: &'a FlowInProgress<MaybeInitializedLvals<'cx, 'gcx, 'tcx>>,
-    move_data: &'a MoveData<'tcx>,
+    flow_inits: &'cg FlowInProgress<MaybeInitializedLvals<'cx, 'gcx, 'tcx>>,
+    move_data: &'cg MoveData<'tcx>,
 }
 
-impl<'a, 'cx, 'gcx, 'tcx> ConstraintGeneration<'a, 'cx, 'gcx, 'tcx> {
+impl<'cx, 'cg, 'gcx, 'tcx> ConstraintGeneration<'cx, 'cg, 'gcx, 'tcx> {
     fn add_constraints(&mut self) {
         self.add_liveness_constraints();
         self.add_borrow_constraints();
@@ -88,13 +89,10 @@ impl<'a, 'cx, 'gcx, 'tcx> ConstraintGeneration<'a, 'cx, 'gcx, 'tcx> {
                 bb,
                 |location, live_locals| {
                     for live_local in live_locals.iter() {
-                        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);
-                            }
+                        let mpi = self.move_data.rev_lookup.find_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);
                         }
                     }
                 },
@@ -232,7 +230,7 @@ impl<'a, 'cx, 'gcx, 'tcx> ConstraintGeneration<'a, 'cx, 'gcx, 'tcx> {
     }
 }
 
-impl<'a, 'cx, 'gcx, 'tcx> Visitor<'tcx> for ConstraintGeneration<'a, 'cx, 'gcx, 'tcx> {
+impl<'cg, 'cx, 'gcx, 'tcx> Visitor<'tcx> for ConstraintGeneration<'cg, 'cx, 'gcx, 'tcx> {
     fn visit_rvalue(&mut self,
                     rvalue: &Rvalue<'tcx>,
                     location: Location) {

src/librustc_mir/dataflow/move_paths/mod.rs

@@ -226,6 +226,10 @@ impl<'tcx> MovePathLookup<'tcx> {
             }
         }
     }
+
+    pub fn find_local(&self, local: Local) -> MovePathIndex {
+        self.locals[local]
+    }
 }
 
 #[derive(Debug)]