groundwork refactoring of gather_moves

src/librustc/mir/repr.rs

@@ -1243,7 +1243,7 @@ impl<'a, 'b>  GraphSuccessors<'b> for Mir<'a> {
     type Iter = IntoIter<BasicBlock>;
 }
 
-#[derive(Copy, Clone, PartialEq, Eq, Debug, Hash, Ord, PartialOrd)]
+#[derive(Copy, Clone, PartialEq, Eq, Hash, Ord, PartialOrd)]
 pub struct Location {
     /// the location is within this block
     pub block: BasicBlock,
@@ -1253,3 +1253,8 @@ pub struct Location {
     pub statement_index: usize,
 }
 
+impl fmt::Debug for Location {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        write!(fmt, "{:?}[{}]", self.block, self.statement_index)
+    }
+}

src/librustc/mir/visit.rs

@@ -774,9 +774,6 @@ pub enum LvalueContext<'tcx> {
     // Being borrowed
     Borrow { region: &'tcx Region, kind: BorrowKind },
 
-    // Being sliced -- this should be same as being borrowed, probably
-    Slice { from_start: usize, from_end: usize },
-
     // Used as base for another lvalue, e.g. `x` in `x.y`
     Projection,
 

src/librustc_borrowck/borrowck/mir/dataflow/impls.rs

@@ -17,7 +17,7 @@ use super::super::MoveDataParamEnv;
 use super::super::DropFlagState;
 use super::super::drop_flag_effects_for_function_entry;
 use super::super::drop_flag_effects_for_location;
-use super::super::on_all_children_bits;
+use super::super::on_lookup_result_bits;
 
 use super::{BitDenotation, BlockSets, DataflowOperator};
 
@@ -277,10 +277,9 @@ impl<'a, 'tcx> BitDenotation for MaybeInitializedLvals<'a, 'tcx> {
                              dest_lval: &repr::Lvalue) {
         // when a call returns successfully, that means we need to set
         // the bits for that dest_lval to 1 (initialized).
-        let move_path_index = ctxt.move_data.rev_lookup.find(dest_lval);
-        on_all_children_bits(self.tcx, self.mir, &ctxt.move_data,
-                             move_path_index,
-                             |mpi| { in_out.add(&mpi); });
+        on_lookup_result_bits(self.tcx, self.mir, &ctxt.move_data,
+                              ctxt.move_data.rev_lookup.find(dest_lval),
+                              |mpi| { in_out.add(&mpi); });
     }
 }
 
@@ -338,11 +337,10 @@ impl<'a, 'tcx> BitDenotation for MaybeUninitializedLvals<'a, 'tcx> {
                              _dest_bb: repr::BasicBlock,
                              dest_lval: &repr::Lvalue) {
         // when a call returns successfully, that means we need to set
-        // the bits for that dest_lval to 1 (initialized).
-        let move_path_index = ctxt.move_data.rev_lookup.find(dest_lval);
-        on_all_children_bits(self.tcx, self.mir, &ctxt.move_data,
-                             move_path_index,
-                             |mpi| { in_out.remove(&mpi); });
+        // the bits for that dest_lval to 0 (initialized).
+        on_lookup_result_bits(self.tcx, self.mir, &ctxt.move_data,
+                              ctxt.move_data.rev_lookup.find(dest_lval),
+                              |mpi| { in_out.remove(&mpi); });
     }
 }
 
@@ -400,10 +398,9 @@ impl<'a, 'tcx> BitDenotation for DefinitelyInitializedLvals<'a, 'tcx> {
                              dest_lval: &repr::Lvalue) {
         // when a call returns successfully, that means we need to set
         // the bits for that dest_lval to 1 (initialized).
-        let move_path_index = ctxt.move_data.rev_lookup.find(dest_lval);
-        on_all_children_bits(self.tcx, self.mir, &ctxt.move_data,
-                             move_path_index,
-                             |mpi| { in_out.add(&mpi); });
+        on_lookup_result_bits(self.tcx, self.mir, &ctxt.move_data,
+                              ctxt.move_data.rev_lookup.find(dest_lval),
+                              |mpi| { in_out.add(&mpi); });
     }
 }
 
@@ -448,11 +445,10 @@ impl<'a, 'tcx> BitDenotation for MovingOutStatements<'a, 'tcx> {
                 // assigning into this `lvalue` kills all
                 // MoveOuts from it, and *also* all MoveOuts
                 // for children and associated fragment sets.
-                let move_path_index = rev_lookup.find(lvalue);
-                on_all_children_bits(tcx,
+                on_lookup_result_bits(tcx,
                                      mir,
                                      move_data,
-                                     move_path_index,
+                                     rev_lookup.find(lvalue),
                                      |mpi| for moi in &path_map[mpi] {
                                          assert!(moi.index() < bits_per_block);
                                          sets.kill_set.add(&moi);
@@ -489,18 +485,17 @@ impl<'a, 'tcx> BitDenotation for MovingOutStatements<'a, 'tcx> {
                              _dest_bb: repr::BasicBlock,
                              dest_lval: &repr::Lvalue) {
         let move_data = &ctxt.move_data;
-        let move_path_index = move_data.rev_lookup.find(dest_lval);
         let bits_per_block = self.bits_per_block(ctxt);
 
         let path_map = &move_data.path_map;
-        on_all_children_bits(self.tcx,
-                             self.mir,
-                             move_data,
-                             move_path_index,
-                             |mpi| for moi in &path_map[mpi] {
-                                 assert!(moi.index() < bits_per_block);
-                                 in_out.remove(&moi);
-                             });
+        on_lookup_result_bits(self.tcx,
+                              self.mir,
+                              move_data,
+                              move_data.rev_lookup.find(dest_lval),
+                              |mpi| for moi in &path_map[mpi] {
+                                  assert!(moi.index() < bits_per_block);
+                                  in_out.remove(&moi);
+                              });
     }
 }
 

src/librustc_borrowck/borrowck/mir/dataflow/sanity_check.rs

@@ -16,7 +16,7 @@ use rustc::ty::{self, TyCtxt};
 use rustc::mir::repr::{self, Mir};
 use rustc_data_structures::indexed_vec::Idx;
 
-use super::super::gather_moves::{MovePathIndex};
+use super::super::gather_moves::{MovePathIndex, LookupResult};
 use super::super::MoveDataParamEnv;
 use super::BitDenotation;
 use super::DataflowResults;
@@ -116,20 +116,26 @@ fn each_block<'a, 'tcx, O>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
                                      repr::BorrowKind::Shared,
                                      ref peeking_at_lval) = *rvalue {
                 // Okay, our search is over.
-                let peek_mpi = move_data.rev_lookup.find(peeking_at_lval);
-                let bit_state = sets.on_entry.contains(&peek_mpi);
-                debug!("rustc_peek({:?} = &{:?}) bit_state: {}",
-                       lvalue, peeking_at_lval, bit_state);
-                if !bit_state {
-                    tcx.sess.span_err(span, &format!("rustc_peek: bit not set"));
+                match move_data.rev_lookup.find(peeking_at_lval) {
+                    LookupResult::Exact(peek_mpi) => {
+                        let bit_state = sets.on_entry.contains(&peek_mpi);
+                        debug!("rustc_peek({:?} = &{:?}) bit_state: {}",
+                               lvalue, peeking_at_lval, bit_state);
+                        if !bit_state {
+                            tcx.sess.span_err(span, "rustc_peek: bit not set");
+                        }
+                    }
+                    LookupResult::Parent(..) => {
+                        tcx.sess.span_err(span, "rustc_peek: argument untracked");
+                    }
                 }
                 return;
             } else {
                 // Our search should have been over, but the input
                 // does not match expectations of `rustc_peek` for
                 // this sanity_check.
-                let msg = &format!("rustc_peek: argument expression \
-                                    must be immediate borrow of form `&expr`");
+                let msg = "rustc_peek: argument expression \
+                           must be immediate borrow of form `&expr`";
                 tcx.sess.span_err(span, msg);
             }
         }