Incorporate active-borrows dataflow into MIR borrow check, yielding

two-phase `&mut`-borrow support.

This (new) support sits under `-Z two-phase-borrows` debugflag.

(Still needs tests. That's coming next.)

src/librustc/session/config.rs

@@ -1011,6 +1011,8 @@ options! {DebuggingOptions, DebuggingSetter, basic_debugging_options,
         "emit EndRegion as part of MIR; enable transforms that solely process EndRegion"),
     borrowck: Option<String> = (None, parse_opt_string, [UNTRACKED],
         "select which borrowck is used (`ast`, `mir`, or `compare`)"),
+    two_phase_borrows: bool = (false, parse_bool, [UNTRACKED],
+        "use two-phase reserved/active distinction for `&mut` borrows in MIR borrowck"),
     time_passes: bool = (false, parse_bool, [UNTRACKED],
         "measure time of each rustc pass"),
     count_llvm_insns: bool = (false, parse_bool,

src/librustc_mir/borrow_check/mod.rs

@@ -701,9 +701,17 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
             context,
             (sd, place_span.0),
             flow_state,
-            |this, _index, borrow| match (rw, borrow.kind) {
+            |this, index, borrow| match (rw, borrow.kind) {
                 (Read(_), BorrowKind::Shared) => Control::Continue,
+
                 (Read(kind), BorrowKind::Unique) | (Read(kind), BorrowKind::Mut) => {
+                    // Reading from mere reservations of mutable-borrows is OK.
+                    if this.tcx.sess.opts.debugging_opts.two_phase_borrows &&
+                        index.is_reservation()
+                    {
+                        return Control::Continue;
+                    }
+
                     match kind {
                         ReadKind::Copy => {
                             error_reported = true;
@@ -1826,9 +1834,17 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
 
         // check for loan restricting path P being used. Accounts for
         // borrows of P, P.a.b, etc.
-        for i in flow_state.borrows.elems_incoming() {
-            // FIXME for now, just skip the activation state.
-            if i.is_activation() { continue }
+        let mut elems_incoming = flow_state.borrows.elems_incoming();
+        while let Some(i) = elems_incoming.next() {
+            // Skip any reservation that has a corresponding current
+            // activation.  This way, the traversal will visit each
+            // borrow_index at most once.
+            if let Some(j) = elems_incoming.peek() {
+                if i.is_reservation() && j.is_activation() {
+                    assert_eq!(i.borrow_index(), j.borrow_index());
+                    continue;
+                }
+            }
 
             let borrowed = &data[i.borrow_index()];
 

src/librustc_mir/dataflow/at_location.rs

@@ -18,6 +18,8 @@ use rustc_data_structures::indexed_vec::Idx;
 use dataflow::{BitDenotation, BlockSets, DataflowResults};
 use dataflow::move_paths::{HasMoveData, MovePathIndex};
 
+use std::iter;
+
 /// A trait for "cartesian products" of multiple FlowAtLocation.
 ///
 /// There's probably a way to auto-impl this, but I think
@@ -94,9 +96,9 @@ where
         self.curr_state.contains(x)
     }
 
-    pub fn elems_incoming(&self) -> indexed_set::Elems<BD::Idx> {
+    pub fn elems_incoming(&self) -> iter::Peekable<indexed_set::Elems<BD::Idx>> {
         let univ = self.base_results.sets().bits_per_block();
-        self.curr_state.elems(univ)
+        self.curr_state.elems(univ).peekable()
     }
 
     pub fn with_elems_outgoing<F>(&self, f: F)