Auto merge of #46537 - pnkfelix:two-phase-borrows, r=arielb1

[MIR-borrowck] Two phase borrows

This adds limited support for two-phase borrows as described in
  http://smallcultfollowing.com/babysteps/blog/2017/03/01/nested-method-calls-via-two-phase-borrowing/

The support is off by default; you opt into it via the flag `-Z two-phase-borrows`

I have written "*limited* support" above because there are simple variants of the simple `v.push(v.len())` example that one would think should work but currently do not, such as the one documented in the test compile-fail/borrowck/two-phase-reservation-sharing-interference-2.rs

(To be clear, that test is not describing something that is unsound. It is just providing an explicit example of a limitation in the implementation given in this PR. I have ideas on how to fix, but I want to land the work that is in this PR first, so that I can stop repeatedly rebasing this branch.)

25 files changed, 1182 insertions, 255 deletions

diff --git a/src/librustc/mir/mod.rs b/src/librustc/mir/mod.rs
index c61e776c615..a83c3f29d25 100644
--- a/src/librustc/mir/mod.rs
+++ b/src/librustc/mir/mod.rs
@@ -1137,7 +1137,7 @@ impl<'tcx> Debug for Statement<'tcx> {
 
 /// A path to a value; something that can be evaluated without
 /// changing or disturbing program state.
-#[derive(Clone, PartialEq, RustcEncodable, RustcDecodable)]
+#[derive(Clone, PartialEq, Eq, Hash, RustcEncodable, RustcDecodable)]
 pub enum Place<'tcx> {
     /// local variable
     Local(Local),
@@ -1151,7 +1151,7 @@ pub enum Place<'tcx> {
 
 /// The def-id of a static, along with its normalized type (which is
 /// stored to avoid requiring normalization when reading MIR).
-#[derive(Clone, PartialEq, RustcEncodable, RustcDecodable)]
+#[derive(Clone, PartialEq, Eq, Hash, RustcEncodable, RustcDecodable)]
 pub struct Static<'tcx> {
     pub def_id: DefId,
     pub ty: Ty<'tcx>,
diff --git a/src/librustc/session/config.rs b/src/librustc/session/config.rs
index 1319b08ca38..009fb619846 100644
--- a/src/librustc/session/config.rs
+++ b/src/librustc/session/config.rs
@@ -1028,6 +1028,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,
diff --git a/src/librustc_data_structures/indexed_set.rs b/src/librustc_data_structures/indexed_set.rs
index 5d7139507b3..223e08de826 100644
--- a/src/librustc_data_structures/indexed_set.rs
+++ b/src/librustc_data_structures/indexed_set.rs
@@ -8,6 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+use std::borrow::{Borrow, BorrowMut, ToOwned};
 use std::fmt;
 use std::iter;
 use std::marker::PhantomData;
@@ -73,6 +74,25 @@ pub struct IdxSet<T: Idx> {
     bits: [Word],
 }
 
+impl<T: Idx> Borrow<IdxSet<T>> for IdxSetBuf<T> {
+    fn borrow(&self) -> &IdxSet<T> {
+        &*self
+    }
+}
+
+impl<T: Idx> BorrowMut<IdxSet<T>> for IdxSetBuf<T> {
+    fn borrow_mut(&mut self) -> &mut IdxSet<T> {
+        &mut *self
+    }
+}
+
+impl<T: Idx> ToOwned for IdxSet<T> {
+    type Owned = IdxSetBuf<T>;
+    fn to_owned(&self) -> Self::Owned {
+        IdxSet::to_owned(self)
+    }
+}
+
 impl<T: Idx> fmt::Debug for IdxSetBuf<T> {
     fn fmt(&self, w: &mut fmt::Formatter) -> fmt::Result {
         w.debug_list()
diff --git a/src/librustc_driver/pretty.rs b/src/librustc_driver/pretty.rs
index 8d99ed858ee..769ade5dbcc 100644
--- a/src/librustc_driver/pretty.rs
+++ b/src/librustc_driver/pretty.rs
@@ -423,7 +423,8 @@ impl<'hir> pprust_hir::PpAnn for IdentifiedAnnotation<'hir> {
             pprust_hir::NodeName(_) => Ok(()),
             pprust_hir::NodeItem(item) => {
                 s.s.space()?;
-                s.synth_comment(item.id.to_string())
+                s.synth_comment(format!("node_id: {} hir local_id: {}",
+                                        item.id, item.hir_id.local_id.0))
             }
             pprust_hir::NodeSubItem(id) => {
                 s.s.space()?;
@@ -431,16 +432,19 @@ impl<'hir> pprust_hir::PpAnn for IdentifiedAnnotation<'hir> {
             }
             pprust_hir::NodeBlock(blk) => {
                 s.s.space()?;
-                s.synth_comment(format!("block {}", blk.id))
+                s.synth_comment(format!("block node_id: {} hir local_id: {}",
+                                        blk.id, blk.hir_id.local_id.0))
             }
             pprust_hir::NodeExpr(expr) => {
                 s.s.space()?;
-                s.synth_comment(expr.id.to_string())?;
+                s.synth_comment(format!("node_id: {} hir local_id: {}",
+                                        expr.id, expr.hir_id.local_id.0))?;
                 s.pclose()
             }
             pprust_hir::NodePat(pat) => {
                 s.s.space()?;
-                s.synth_comment(format!("pat {}", pat.id))
+                s.synth_comment(format!("pat node_id: {} hir local_id: {}",
+                                        pat.id, pat.hir_id.local_id.0))
             }
         }
     }
diff --git a/src/librustc_mir/borrow_check/error_reporting.rs b/src/librustc_mir/borrow_check/error_reporting.rs
index 186598001da..31a94499fd0 100644
--- a/src/librustc_mir/borrow_check/error_reporting.rs
+++ b/src/librustc_mir/borrow_check/error_reporting.rs
@@ -11,7 +11,7 @@
 use syntax_pos::Span;
 use rustc::middle::region::ScopeTree;
 use rustc::mir::{BorrowKind, Field, Local, Location, Operand};
-use rustc::mir::{Place, ProjectionElem, Rvalue, StatementKind};
+use rustc::mir::{Place, ProjectionElem, Rvalue, Statement, StatementKind};
 use rustc::ty::{self, RegionKind};
 use rustc_data_structures::indexed_vec::Idx;
 
@@ -19,7 +19,7 @@ use std::rc::Rc;
 
 use super::{MirBorrowckCtxt, Context};
 use super::{InitializationRequiringAction, PrefixSet};
-use dataflow::{BorrowData, Borrows, FlowAtLocation, MovingOutStatements};
+use dataflow::{ActiveBorrows, BorrowData, FlowAtLocation, MovingOutStatements};
 use dataflow::move_paths::MovePathIndex;
 use util::borrowck_errors::{BorrowckErrors, Origin};
 
@@ -96,7 +96,7 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
             Some(name) => format!("`{}`", name),
             None => "value".to_owned(),
         };
-        let borrow_msg = match self.describe_place(&borrow.place) {
+        let borrow_msg = match self.describe_place(&borrow.borrowed_place) {
             Some(name) => format!("`{}`", name),
             None => "value".to_owned(),
         };
@@ -124,7 +124,7 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
             span,
             &self.describe_place(place).unwrap_or("_".to_owned()),
             self.retrieve_borrow_span(borrow),
-            &self.describe_place(&borrow.place).unwrap_or("_".to_owned()),
+            &self.describe_place(&borrow.borrowed_place).unwrap_or("_".to_owned()),
             Origin::Mir,
         );
 
@@ -143,12 +143,9 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
         use rustc::hir::ExprClosure;
         use rustc::mir::AggregateKind;
 
-        let local = if let StatementKind::Assign(Place::Local(local), _) =
-            self.mir[location.block].statements[location.statement_index].kind
-        {
-            local
-        } else {
-            return None;
+        let local = match self.mir[location.block].statements.get(location.statement_index) {
+            Some(&Statement { kind: StatementKind::Assign(Place::Local(local), _), .. }) => local,
+            _ => return None,
         };
 
         for stmt in &self.mir[location.block].statements[location.statement_index + 1..] {
@@ -324,11 +321,11 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
         _: Context,
         borrow: &BorrowData<'tcx>,
         drop_span: Span,
-        borrows: &Borrows<'cx, 'gcx, 'tcx>
+        borrows: &ActiveBorrows<'cx, 'gcx, 'tcx>
     ) {
         let end_span = borrows.opt_region_end_span(&borrow.region);
-        let scope_tree = borrows.scope_tree();
-        let root_place = self.prefixes(&borrow.place, PrefixSet::All).last().unwrap();
+        let scope_tree = borrows.0.scope_tree();
+        let root_place = self.prefixes(&borrow.borrowed_place, PrefixSet::All).last().unwrap();
 
         match root_place {
             &Place::Local(local) => {
@@ -357,7 +354,7 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
             _ => drop_span,
         };
 
-        match (borrow.region, &self.describe_place(&borrow.place)) {
+        match (borrow.region, &self.describe_place(&borrow.borrowed_place)) {
             (RegionKind::ReScope(_), Some(name)) => {
                 self.report_scoped_local_value_does_not_live_long_enough(
                     name, &scope_tree, &borrow, drop_span, borrow_span, proper_span, end_span);
diff --git a/src/librustc_mir/borrow_check/flows.rs b/src/librustc_mir/borrow_check/flows.rs
index 449062989e0..69a08c7a30d 100644
--- a/src/librustc_mir/borrow_check/flows.rs
+++ b/src/librustc_mir/borrow_check/flows.rs
@@ -17,13 +17,13 @@ use rustc::mir::{BasicBlock, Location};
 
 use dataflow::{MaybeInitializedLvals, MaybeUninitializedLvals};
 use dataflow::{EverInitializedLvals, MovingOutStatements};
-use dataflow::{Borrows, FlowAtLocation, FlowsAtLocation};
+use dataflow::{ActiveBorrows, FlowAtLocation, FlowsAtLocation};
 use dataflow::move_paths::HasMoveData;
 use std::fmt;
 
 // (forced to be `pub` due to its use as an associated type below.)
-pub struct Flows<'b, 'gcx: 'tcx, 'tcx: 'b> {
-    pub borrows: FlowAtLocation<Borrows<'b, 'gcx, 'tcx>>,
+pub(crate) struct Flows<'b, 'gcx: 'tcx, 'tcx: 'b> {
+    pub borrows: FlowAtLocation<ActiveBorrows<'b, 'gcx, 'tcx>>,
     pub inits: FlowAtLocation<MaybeInitializedLvals<'b, 'gcx, 'tcx>>,
     pub uninits: FlowAtLocation<MaybeUninitializedLvals<'b, 'gcx, 'tcx>>,
     pub move_outs: FlowAtLocation<MovingOutStatements<'b, 'gcx, 'tcx>>,
@@ -32,7 +32,7 @@ pub struct Flows<'b, 'gcx: 'tcx, 'tcx: 'b> {
 
 impl<'b, 'gcx, 'tcx> Flows<'b, 'gcx, 'tcx> {
     pub fn new(
-        borrows: FlowAtLocation<Borrows<'b, 'gcx, 'tcx>>,
+        borrows: FlowAtLocation<ActiveBorrows<'b, 'gcx, 'tcx>>,
         inits: FlowAtLocation<MaybeInitializedLvals<'b, 'gcx, 'tcx>>,
         uninits: FlowAtLocation<MaybeUninitializedLvals<'b, 'gcx, 'tcx>>,
         move_outs: FlowAtLocation<MovingOutStatements<'b, 'gcx, 'tcx>>,
@@ -87,7 +87,7 @@ impl<'b, 'gcx, 'tcx> fmt::Display for Flows<'b, 'gcx, 'tcx> {
                 s.push_str(", ");
             };
             saw_one = true;
-            let borrow_data = &self.borrows.operator().borrows()[borrow];
+            let borrow_data = &self.borrows.operator().borrows()[borrow.borrow_index()];
             s.push_str(&format!("{}", borrow_data));
         });
         s.push_str("] ");
@@ -99,7 +99,7 @@ impl<'b, 'gcx, 'tcx> fmt::Display for Flows<'b, 'gcx, 'tcx> {
                 s.push_str(", ");
             };
             saw_one = true;
-            let borrow_data = &self.borrows.operator().borrows()[borrow];
+            let borrow_data = &self.borrows.operator().borrows()[borrow.borrow_index()];
             s.push_str(&format!("{}", borrow_data));
         });
         s.push_str("] ");
diff --git a/src/librustc_mir/borrow_check/mod.rs b/src/librustc_mir/borrow_check/mod.rs
index 128052e5894..39bcd2b6ae0 100644
--- a/src/librustc_mir/borrow_check/mod.rs
+++ b/src/librustc_mir/borrow_check/mod.rs
@@ -28,13 +28,15 @@ use rustc_data_structures::indexed_vec::Idx;
 use syntax::ast;
 use syntax_pos::Span;
 
-use dataflow::do_dataflow;
+use dataflow::{do_dataflow, DebugFormatted};
 use dataflow::MoveDataParamEnv;
-use dataflow::DataflowResultsConsumer;
+use dataflow::{DataflowAnalysis, DataflowResultsConsumer};
 use dataflow::{FlowAtLocation, FlowsAtLocation};
 use dataflow::{MaybeInitializedLvals, MaybeUninitializedLvals};
 use dataflow::{EverInitializedLvals, MovingOutStatements};
-use dataflow::{BorrowData, BorrowIndex, Borrows};
+use dataflow::{Borrows, BorrowData, ReserveOrActivateIndex};
+use dataflow::{ActiveBorrows, Reservations};
+use dataflow::indexes::{BorrowIndex};
 use dataflow::move_paths::{IllegalMoveOriginKind, MoveError};
 use dataflow::move_paths::{HasMoveData, LookupResult, MoveData, MovePathIndex};
 use util::borrowck_errors::{BorrowckErrors, Origin};
@@ -48,6 +50,9 @@ use self::MutateMode::{JustWrite, WriteAndRead};
 mod error_reporting;
 mod flows;
 mod prefixes;
+
+use std::borrow::Cow;
+
 pub(crate) mod nll;
 
 pub fn provide(providers: &mut Providers) {
@@ -157,7 +162,7 @@ fn do_mir_borrowck<'a, 'gcx, 'tcx>(
         &attributes,
         &dead_unwinds,
         MaybeInitializedLvals::new(tcx, mir, &mdpe),
-        |bd, i| &bd.move_data().move_paths[i],
+        |bd, i| DebugFormatted::new(&bd.move_data().move_paths[i]),
     ));
     let flow_uninits = FlowAtLocation::new(do_dataflow(
         tcx,
@@ -166,7 +171,7 @@ fn do_mir_borrowck<'a, 'gcx, 'tcx>(
         &attributes,
         &dead_unwinds,
         MaybeUninitializedLvals::new(tcx, mir, &mdpe),
-        |bd, i| &bd.move_data().move_paths[i],
+        |bd, i| DebugFormatted::new(&bd.move_data().move_paths[i]),
     ));
     let flow_move_outs = FlowAtLocation::new(do_dataflow(
         tcx,
@@ -175,7 +180,7 @@ fn do_mir_borrowck<'a, 'gcx, 'tcx>(
         &attributes,
         &dead_unwinds,
         MovingOutStatements::new(tcx, mir, &mdpe),
-        |bd, i| &bd.move_data().moves[i],
+        |bd, i| DebugFormatted::new(&bd.move_data().moves[i]),
     ));
     let flow_ever_inits = FlowAtLocation::new(do_dataflow(
         tcx,
@@ -184,7 +189,7 @@ fn do_mir_borrowck<'a, 'gcx, 'tcx>(
         &attributes,
         &dead_unwinds,
         EverInitializedLvals::new(tcx, mir, &mdpe),
-        |bd, i| &bd.move_data().inits[i],
+        |bd, i| DebugFormatted::new(&bd.move_data().inits[i]),
     ));
 
     // If we are in non-lexical mode, compute the non-lexical lifetimes.
@@ -205,23 +210,6 @@ fn do_mir_borrowck<'a, 'gcx, 'tcx>(
     };
     let flow_inits = flow_inits; // remove mut
 
-    let flow_borrows = FlowAtLocation::new(do_dataflow(
-        tcx,
-        mir,
-        id,
-        &attributes,
-        &dead_unwinds,
-        Borrows::new(tcx, mir, opt_regioncx, def_id, body_id),
-        |bd, i| bd.location(i),
-    ));
-
-    let mut state = Flows::new(
-        flow_borrows,
-        flow_inits,
-        flow_uninits,
-        flow_move_outs,
-        flow_ever_inits,
-    );
     let mut mbcx = MirBorrowckCtxt {
         tcx: tcx,
         mir: mir,
@@ -235,8 +223,47 @@ fn do_mir_borrowck<'a, 'gcx, 'tcx>(
         },
         storage_dead_or_drop_error_reported_l: FxHashSet(),
         storage_dead_or_drop_error_reported_s: FxHashSet(),
+        reservation_error_reported: FxHashSet(),
+    };
+
+    let borrows = Borrows::new(tcx, mir, opt_regioncx, def_id, body_id);
+    let flow_reservations = do_dataflow(
+        tcx,
+        mir,
+        id,
+        &attributes,
+        &dead_unwinds,
+        Reservations::new(borrows),
+        |rs, i| {
+            // In principle we could make the dataflow ensure that
+            // only reservation bits show up, and assert so here.
+            //
+            // In practice it is easier to be looser; in particular,
+            // it is okay for the kill-sets to hold activation bits.
+            DebugFormatted::new(&(i.kind(), rs.location(i)))
+        });
+    let flow_active_borrows = {
+        let reservations_on_entry = flow_reservations.0.sets.entry_set_state();
+        let reservations = flow_reservations.0.operator;
+        let a = DataflowAnalysis::new_with_entry_sets(mir,
+                                                      &dead_unwinds,
+                                                      Cow::Borrowed(reservations_on_entry),
+                                                      ActiveBorrows::new(reservations));
+        let results = a.run(tcx,
+                            id,
+                            &attributes,
+                            |ab, i| DebugFormatted::new(&(i.kind(), ab.location(i))));
+        FlowAtLocation::new(results)
     };
 
+    let mut state = Flows::new(
+        flow_active_borrows,
+        flow_inits,
+        flow_uninits,
+        flow_move_outs,
+        flow_ever_inits,
+    );
+
     mbcx.analyze_results(&mut state); // entry point for DataflowResultsConsumer
 
     opt_closure_req
@@ -262,6 +289,14 @@ pub struct MirBorrowckCtxt<'cx, 'gcx: 'tcx, 'tcx: 'cx> {
     storage_dead_or_drop_error_reported_l: FxHashSet<Local>,
     /// Same as the above, but for statics (thread-locals)
     storage_dead_or_drop_error_reported_s: FxHashSet<DefId>,
+    /// This field keeps track of when borrow conflict errors are reported
+    /// for reservations, so that we don't report seemingly duplicate
+    /// errors for corresponding activations
+    ///
+    /// FIXME: Ideally this would be a set of BorrowIndex, not Places,
+    /// but it is currently inconvenient to track down the BorrowIndex
+    /// at the time we detect and report a reservation error.
+    reservation_error_reported: FxHashSet<Place<'tcx>>,
 }
 
 // Check that:
@@ -293,6 +328,9 @@ impl<'cx, 'gcx, 'tcx> DataflowResultsConsumer<'cx, 'tcx> for MirBorrowckCtxt<'cx
             flow_state
         );
         let span = stmt.source_info.span;
+
+        self.check_activations(location, span, flow_state);
+
         match stmt.kind {
             StatementKind::Assign(ref lhs, ref rhs) => {
                 // NOTE: NLL RFC calls for *shallow* write; using Deep
@@ -399,6 +437,9 @@ impl<'cx, 'gcx, 'tcx> DataflowResultsConsumer<'cx, 'tcx> for MirBorrowckCtxt<'cx
             flow_state
         );
         let span = term.source_info.span;
+
+        self.check_activations(location, span, flow_state);
+
         match term.kind {
             TerminatorKind::SwitchInt {
                 ref discr,
@@ -504,9 +545,8 @@ impl<'cx, 'gcx, 'tcx> DataflowResultsConsumer<'cx, 'tcx> for MirBorrowckCtxt<'cx
                 let data = domain.borrows();
                 flow_state.borrows.with_elems_outgoing(|borrows| {
                     for i in borrows {
-                        let borrow = &data[i];
+                        let borrow = &data[i.borrow_index()];
                         let context = ContextKind::StorageDead.new(loc);
-
                         self.check_for_invalidation_at_exit(context, borrow, span, flow_state);
                     }
                 });
@@ -533,7 +573,7 @@ enum Control {
 }
 
 use self::ShallowOrDeep::{Deep, Shallow};
-use self::ReadOrWrite::{Read, Write};
+use self::ReadOrWrite::{Activation, Read, Reservation, Write};
 
 #[derive(Copy, Clone, PartialEq, Eq, Debug)]
 enum ArtificialField {
@@ -568,6 +608,12 @@ enum ReadOrWrite {
     /// new values or otherwise invalidated (for example, it could be
     /// de-initialized, as in a move operation).
     Write(WriteKind),
+
+    /// For two-phase borrows, we distinguish a reservation (which is treated
+    /// like a Read) from an activation (which is treated like a write), and
+    /// each of those is furthermore distinguished from Reads/Writes above.
+    Reservation(WriteKind),
+    Activation(WriteKind, BorrowIndex),
 }
 
 /// Kind of read access to a value
@@ -656,6 +702,14 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
     ) -> AccessErrorsReported {
         let (sd, rw) = kind;
 
+        if let Activation(_, borrow_index) = rw {
+            if self.reservation_error_reported.contains(&place_span.0) {
+                debug!("skipping access_place for activation of invalid reservation \
+                        place: {:?} borrow_index: {:?}", place_span.0, borrow_index);
+                return AccessErrorsReported { mutability_error: false, conflict_error: true };
+            }
+        }
+
         let mutability_error =
             self.check_access_permissions(place_span, rw, is_local_mutation_allowed);
         let conflict_error =
@@ -677,9 +731,33 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
             context,
             (sd, place_span.0),
             flow_state,
-            |this, _index, borrow| match (rw, borrow.kind) {
-                (Read(_), BorrowKind::Shared) => Control::Continue,
-                (Read(kind), BorrowKind::Unique) | (Read(kind), BorrowKind::Mut) => {
+            |this, index, borrow| match (rw, borrow.kind) {
+                // Obviously an activation is compatible with its own
+                // reservation (or even prior activating uses of same
+                // borrow); so don't check if they interfere.
+                //
+                // NOTE: *reservations* do conflict with themselves;
+                // thus aren't injecting unsoundenss w/ this check.)
+                (Activation(_, activating), _) if activating == index.borrow_index() =>
+                {
+                    debug!("check_access_for_conflict place_span: {:?} sd: {:?} rw: {:?} \
+                            skipping {:?} b/c activation of same borrow_index: {:?}",
+                           place_span, sd, rw, (index, borrow), index.borrow_index());
+                    Control::Continue
+                }
+
+                (Read(_), BorrowKind::Shared) |
+                (Reservation(..), 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;
@@ -702,13 +780,32 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
                     }
                     Control::Break
                 }
+
+                (Reservation(kind), BorrowKind::Unique) |
+                (Reservation(kind), BorrowKind::Mut) |
+                (Activation(kind, _), _) |
                 (Write(kind), _) => {
+
+                    match rw {
+                        Reservation(_) => {
+                            debug!("recording invalid reservation of \
+                                    place: {:?}", place_span.0);
+                            this.reservation_error_reported.insert(place_span.0.clone());
+                        }
+                        Activation(_, activating) => {
+                            debug!("observing check_place for activation of \
+                                    borrow_index: {:?}", activating);
+                        }
+                        Read(..) | Write(..) => {}
+                    }
+
                     match kind {
                         WriteKind::MutableBorrow(bk) => {
                             let end_issued_loan_span = flow_state
                                 .borrows
                                 .operator()
                                 .opt_region_end_span(&borrow.region);
+
                             error_reported = true;
                             this.report_conflicting_borrow(
                                 context,
@@ -721,7 +818,8 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
                         WriteKind::StorageDeadOrDrop => {
                             error_reported = true;
                             this.report_borrowed_value_does_not_live_long_enough(
-                                context, borrow, place_span.1, flow_state.borrows.operator());
+                                context, borrow, place_span.1,
+                                flow_state.borrows.operator());
                         }
                         WriteKind::Mutate => {
                             error_reported = true;
@@ -794,9 +892,15 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
                 let access_kind = match bk {
                     BorrowKind::Shared => (Deep, Read(ReadKind::Borrow(bk))),
                     BorrowKind::Unique | BorrowKind::Mut => {
-                        (Deep, Write(WriteKind::MutableBorrow(bk)))
+                        let wk = WriteKind::MutableBorrow(bk);
+                        if self.tcx.sess.opts.debugging_opts.two_phase_borrows {
+                            (Deep, Reservation(wk))
+                        } else {
+                            (Deep, Write(wk))
+                        }
                     }
                 };
+
                 self.access_place(
                     context,
                     (place, span),
@@ -804,6 +908,7 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
                     LocalMutationIsAllowed::No,
                     flow_state,
                 );
+
                 self.check_if_path_is_moved(
                     context,
                     InitializationRequiringAction::Borrow,
@@ -917,7 +1022,7 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
                                       flow_state: &Flows<'cx, 'gcx, 'tcx>)
     {
         debug!("check_for_invalidation_at_exit({:?})", borrow);
-        let place = &borrow.place;
+        let place = &borrow.borrowed_place;
         let root_place = self.prefixes(place, PrefixSet::All).last().unwrap();
 
         // FIXME(nll-rfc#40): do more precise destructor tracking here. For now
@@ -974,6 +1079,48 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
             )
         }
     }
+
+    fn check_activations(&mut self,
+                         location: Location,
+                         span: Span,
+                         flow_state: &Flows<'cx, 'gcx, 'tcx>)
+    {
+        if !self.tcx.sess.opts.debugging_opts.two_phase_borrows {
+            return;
+        }
+
+        // Two-phase borrow support: For each activation that is newly
+        // generated at this statement, check if it interferes with
+        // another borrow.
+        let domain = flow_state.borrows.operator();
+        let data = domain.borrows();
+        flow_state.borrows.each_gen_bit(|gen| {
+            if gen.is_activation()
+            {
+                let borrow_index = gen.borrow_index();
+                let borrow = &data[borrow_index];
+                // currently the flow analysis registers
+                // activations for both mutable and immutable
+                // borrows. So make sure we are talking about a
+                // mutable borrow before we check it.
+                match borrow.kind {
+                    BorrowKind::Shared => return,
+                    BorrowKind::Unique |
+                    BorrowKind::Mut => {}
+                }
+
+                self.access_place(ContextKind::Activation.new(location),
+                                  (&borrow.borrowed_place, span),
+                                  (Deep, Activation(WriteKind::MutableBorrow(borrow.kind),
+                                                    borrow_index)),
+                                  LocalMutationIsAllowed::No,
+                                  flow_state);
+                // We do not need to call `check_if_path_is_moved`
+                // again, as we already called it when we made the
+                // initial reservation.
+            }
+        });
+    }
 }
 
 impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
@@ -1217,11 +1364,13 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
         );
         let mut error_reported = false;
         match kind {
+            Reservation(WriteKind::MutableBorrow(BorrowKind::Unique)) |
             Write(WriteKind::MutableBorrow(BorrowKind::Unique)) => {
                 if let Err(_place_err) = self.is_mutable(place, LocalMutationIsAllowed::Yes) {
                     span_bug!(span, "&unique borrow for {:?} should not fail", place);
                 }
             }
+            Reservation(WriteKind::MutableBorrow(BorrowKind::Mut)) |
             Write(WriteKind::MutableBorrow(BorrowKind::Mut)) => if let Err(place_err) =
                 self.is_mutable(place, is_local_mutation_allowed)
             {
@@ -1244,6 +1393,7 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
 
                 err.emit();
             },
+            Reservation(WriteKind::Mutate) |
             Write(WriteKind::Mutate) => {
                 if let Err(place_err) = self.is_mutable(place, is_local_mutation_allowed) {
                     error_reported = true;
@@ -1265,6 +1415,9 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
                     err.emit();
                 }
             }
+            Reservation(WriteKind::Move) |
+            Reservation(WriteKind::StorageDeadOrDrop) |
+            Reservation(WriteKind::MutableBorrow(BorrowKind::Shared)) |
             Write(WriteKind::Move) |
             Write(WriteKind::StorageDeadOrDrop) |
             Write(WriteKind::MutableBorrow(BorrowKind::Shared)) => {
@@ -1279,6 +1432,9 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
                     );
                 }
             }
+
+            Activation(..) => {} // permission checks are done at Reservation point.
+
             Read(ReadKind::Borrow(BorrowKind::Unique)) |
             Read(ReadKind::Borrow(BorrowKind::Mut)) |
             Read(ReadKind::Borrow(BorrowKind::Shared)) |
@@ -1771,6 +1927,18 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
         unreachable!("iter::repeat returned None")
     }
 
+    /// This function iterates over all of the current borrows
+    /// (represented by 1-bits in `flow_state.borrows`) that conflict
+    /// with an access to a place, invoking the `op` callback for each
+    /// one.
+    ///
+    /// "Current borrow" here means a borrow that reaches the point in
+    /// the control-flow where the access occurs.
+    ///
+    /// The borrow's phase is represented by the ReserveOrActivateIndex
+    /// passed to the callback: one can call `is_reservation()` and
+    /// `is_activation()` to determine what phase the borrow is
+    /// currently in, when such distinction matters.
     fn each_borrow_involving_path<F>(
         &mut self,
         _context: Context,
@@ -1778,7 +1946,7 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
         flow_state: &Flows<'cx, 'gcx, 'tcx>,
         mut op: F,
     ) where
-        F: FnMut(&mut Self, BorrowIndex, &BorrowData<'tcx>) -> Control,
+        F: FnMut(&mut Self, ReserveOrActivateIndex, &BorrowData<'tcx>) -> Control,
     {
         let (access, place) = access_place;
 
@@ -1789,10 +1957,11 @@ 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() {
-            let borrowed = &data[i];
+        let mut elems_incoming = flow_state.borrows.elems_incoming();
+        while let Some(i) = elems_incoming.next() {
+            let borrowed = &data[i.borrow_index()];
 
-            if self.places_conflict(&borrowed.place, place, access) {
+            if self.places_conflict(&borrowed.borrowed_place, place, access) {
                 let ctrl = op(self, i, borrowed);
                 if ctrl == Control::Break { return; }
             }
@@ -1836,6 +2005,7 @@ struct Context {
 
 #[derive(Copy, Clone, PartialEq, Eq, Debug)]
 enum ContextKind {
+    Activation,
     AssignLhs,
     AssignRhs,
     SetDiscrim,
diff --git a/src/librustc_mir/dataflow/at_location.rs b/src/librustc_mir/dataflow/at_location.rs
index 90ebb45123e..a6c3398489a 100644
--- a/src/librustc_mir/dataflow/at_location.rs
+++ b/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)
@@ -121,9 +123,8 @@ impl<BD> FlowsAtLocation for FlowAtLocation<BD>
     fn reconstruct_statement_effect(&mut self, loc: Location) {
         self.stmt_gen.reset_to_empty();
         self.stmt_kill.reset_to_empty();
-        let mut ignored = IdxSetBuf::new_empty(0);
         let mut sets = BlockSets {
-            on_entry: &mut ignored,
+            on_entry: &mut self.curr_state,
             gen_set: &mut self.stmt_gen,
             kill_set: &mut self.stmt_kill,
         };
@@ -135,9 +136,8 @@ impl<BD> FlowsAtLocation for FlowAtLocation<BD>
     fn reconstruct_terminator_effect(&mut self, loc: Location) {
         self.stmt_gen.reset_to_empty();
         self.stmt_kill.reset_to_empty();
-        let mut ignored = IdxSetBuf::new_empty(0);
         let mut sets = BlockSets {
-            on_entry: &mut ignored,
+            on_entry: &mut self.curr_state,
             gen_set: &mut self.stmt_gen,
             kill_set: &mut self.stmt_kill,
         };
diff --git a/src/librustc_mir/dataflow/graphviz.rs b/src/librustc_mir/dataflow/graphviz.rs
index 7ff4fbcf199..b79e044b24f 100644
--- a/src/librustc_mir/dataflow/graphviz.rs
+++ b/src/librustc_mir/dataflow/graphviz.rs
@@ -18,7 +18,6 @@ use rustc_data_structures::indexed_vec::Idx;
 use dot;
 use dot::IntoCow;
 
-use std::fmt::Debug;
 use std::fs::File;
 use std::io;
 use std::io::prelude::*;
@@ -29,6 +28,7 @@ use util;
 
 use super::{BitDenotation, DataflowState};
 use super::DataflowBuilder;
+use super::DebugFormatted;
 
 pub trait MirWithFlowState<'tcx> {
     type BD: BitDenotation;
@@ -60,9 +60,9 @@ pub(crate) fn print_borrowck_graph_to<'a, 'tcx, BD, P>(
     render_idx: P)
     -> io::Result<()>
     where BD: BitDenotation,
-          P: Fn(&BD, BD::Idx) -> &Debug
+          P: Fn(&BD, BD::Idx) -> DebugFormatted
 {
-    let g = Graph { mbcx: mbcx, phantom: PhantomData, render_idx: render_idx };
+    let g = Graph { mbcx, phantom: PhantomData, render_idx };
     let mut v = Vec::new();
     dot::render(&g, &mut v)?;
     debug!("print_borrowck_graph_to path: {} node_id: {}",
@@ -82,7 +82,7 @@ fn outgoing(mir: &Mir, bb: BasicBlock) -> Vec<Edge> {
 
 impl<'a, 'tcx, MWF, P> dot::Labeller<'a> for Graph<'a, 'tcx, MWF, P>
     where MWF: MirWithFlowState<'tcx>,
-          P: for <'b> Fn(&'b MWF::BD, <MWF::BD as BitDenotation>::Idx) -> &'b Debug,
+          P: Fn(&MWF::BD, <MWF::BD as BitDenotation>::Idx) -> DebugFormatted,
 {
     type Node = Node;
     type Edge = Edge;
@@ -142,7 +142,7 @@ impl<'a, 'tcx, MWF, P> dot::Labeller<'a> for Graph<'a, 'tcx, MWF, P>
         const ALIGN_RIGHT: &'static str = r#"align="right""#;
         const FACE_MONOSPACE: &'static str = r#"FACE="Courier""#;
         fn chunked_present_left<W:io::Write>(w: &mut W,
-                                             interpreted: &[&Debug],
+                                             interpreted: &[DebugFormatted],
                                              chunk_size: usize)
                                              -> io::Result<()>
         {
diff --git a/src/librustc_mir/dataflow/impls/borrows.rs b/src/librustc_mir/dataflow/impls/borrows.rs
index 25bc702764a..c61a57cdda0 100644
--- a/src/librustc_mir/dataflow/impls/borrows.rs
+++ b/src/librustc_mir/dataflow/impls/borrows.rs
@@ -11,8 +11,8 @@
 use rustc::hir;
 use rustc::hir::def_id::DefId;
 use rustc::middle::region;
-use rustc::mir::{self, Location, Mir};
-use rustc::mir::visit::Visitor;
+use rustc::mir::{self, Location, Place, Mir};
+use rustc::mir::visit::{PlaceContext, Visitor};
 use rustc::ty::{self, Region, TyCtxt};
 use rustc::ty::RegionKind;
 use rustc::ty::RegionKind::ReScope;
@@ -20,36 +20,91 @@ use rustc::util::nodemap::{FxHashMap, FxHashSet};
 
 use rustc_data_structures::bitslice::{BitwiseOperator};
 use rustc_data_structures::indexed_set::{IdxSet};
-use rustc_data_structures::indexed_vec::{IndexVec};
+use rustc_data_structures::indexed_vec::{Idx, IndexVec};
 
-use dataflow::{BitDenotation, BlockSets, DataflowOperator};
-pub use dataflow::indexes::BorrowIndex;
+use dataflow::{BitDenotation, BlockSets, InitialFlow};
+pub use dataflow::indexes::{BorrowIndex, ReserveOrActivateIndex};
 use borrow_check::nll::region_infer::RegionInferenceContext;
 use borrow_check::nll::ToRegionVid;
 
 use syntax_pos::Span;
 
 use std::fmt;
+use std::hash::Hash;
 use std::rc::Rc;
 
-// `Borrows` maps each dataflow bit to an `Rvalue::Ref`, which can be
-// uniquely identified in the MIR by the `Location` of the assigment
-// statement in which it appears on the right hand side.
+/// `Borrows` stores the data used in the analyses that track the flow
+/// of borrows.
+///
+/// It uniquely identifies every borrow (`Rvalue::Ref`) by a
+/// `BorrowIndex`, and maps each such index to a `BorrowData`
+/// describing the borrow. These indexes are used for representing the
+/// borrows in compact bitvectors.
 pub struct Borrows<'a, 'gcx: 'tcx, 'tcx: 'a> {
     tcx: TyCtxt<'a, 'gcx, 'tcx>,
     mir: &'a Mir<'tcx>,
     scope_tree: Rc<region::ScopeTree>,
     root_scope: Option<region::Scope>,
+
+    /// The fundamental map relating bitvector indexes to the borrows
+    /// in the MIR.
     borrows: IndexVec<BorrowIndex, BorrowData<'tcx>>,
+
+    /// Each borrow is also uniquely identified in the MIR by the
+    /// `Location` of the assignment statement in which it appears on
+    /// the right hand side; we map each such location to the
+    /// corresponding `BorrowIndex`.
     location_map: FxHashMap<Location, BorrowIndex>,
+
+    /// Every borrow in MIR is immediately stored into a place via an
+    /// assignment statement. This maps each such assigned place back
+    /// to its borrow-indexes.
+    assigned_map: FxHashMap<Place<'tcx>, FxHashSet<BorrowIndex>>,
+
+    /// Every borrow has a region; this maps each such regions back to
+    /// its borrow-indexes.
     region_map: FxHashMap<Region<'tcx>, FxHashSet<BorrowIndex>>,
     local_map: FxHashMap<mir::Local, FxHashSet<BorrowIndex>>,
     region_span_map: FxHashMap<RegionKind, Span>,
     nonlexical_regioncx: Option<RegionInferenceContext<'tcx>>,
 }
 
+// Two-phase borrows actually requires two flow analyses; they need
+// to be separate because the final results of the first are used to
+// construct the gen+kill sets for the second. (The dataflow system
+// is not designed to allow the gen/kill sets to change during the
+// fixed-point iteration.)
+
+/// The `Reservations` analysis is the first of the two flow analyses
+/// tracking (phased) borrows. It computes where a borrow is reserved;
+/// i.e. where it can reach in the control flow starting from its
+/// initial `assigned = &'rgn borrowed` statement, and ending
+/// whereever `'rgn` itself ends.
+pub(crate) struct Reservations<'a, 'gcx: 'tcx, 'tcx: 'a>(pub(crate) Borrows<'a, 'gcx, 'tcx>);
+
+/// The `ActiveBorrows` analysis is the second of the two flow
+/// analyses tracking (phased) borrows. It computes where any given
+/// borrow `&assigned = &'rgn borrowed` is *active*, which starts at
+/// the first use of `assigned` after the reservation has started, and
+/// ends whereever `'rgn` itself ends.
+pub(crate) struct ActiveBorrows<'a, 'gcx: 'tcx, 'tcx: 'a>(pub(crate) Borrows<'a, 'gcx, 'tcx>);
+
+impl<'a, 'gcx, 'tcx> Reservations<'a, 'gcx, 'tcx> {
+    pub(crate) fn new(b: Borrows<'a, 'gcx, 'tcx>) -> Self { Reservations(b) }
+    pub(crate) fn location(&self, idx: ReserveOrActivateIndex) -> &Location {
+        self.0.location(idx.borrow_index())
+    }
+}
+
+impl<'a, 'gcx, 'tcx> ActiveBorrows<'a, 'gcx, 'tcx> {
+    pub(crate) fn new(r: Reservations<'a, 'gcx, 'tcx>) -> Self { ActiveBorrows(r.0) }
+    pub(crate) fn location(&self, idx: ReserveOrActivateIndex) -> &Location {
+        self.0.location(idx.borrow_index())
+    }
+}
+
 // temporarily allow some dead fields: `kind` and `region` will be
-// needed by borrowck; `place` will probably be a MovePathIndex when
+// needed by borrowck; `borrowed_place` will probably be a MovePathIndex when
 // that is extended to include borrowed data paths.
 #[allow(dead_code)]
 #[derive(Debug)]
@@ -57,7 +112,8 @@ pub struct BorrowData<'tcx> {
     pub(crate) location: Location,
     pub(crate) kind: mir::BorrowKind,
     pub(crate) region: Region<'tcx>,
-    pub(crate) place: mir::Place<'tcx>,
+    pub(crate) borrowed_place: mir::Place<'tcx>,
+    pub(crate) assigned_place: mir::Place<'tcx>,
 }
 
 impl<'tcx> fmt::Display for BorrowData<'tcx> {
@@ -69,7 +125,22 @@ impl<'tcx> fmt::Display for BorrowData<'tcx> {
         };
         let region = format!("{}", self.region);
         let region = if region.len() > 0 { format!("{} ", region) } else { region };
-        write!(w, "&{}{}{:?}", region, kind, self.place)
+        write!(w, "&{}{}{:?}", region, kind, self.borrowed_place)
+    }
+}
+
+impl ReserveOrActivateIndex {
+    fn reserved(i: BorrowIndex) -> Self { ReserveOrActivateIndex::new((i.index() * 2)) }
+    fn active(i: BorrowIndex) -> Self { ReserveOrActivateIndex::new((i.index() * 2) + 1) }
+
+    pub(crate) fn is_reservation(self) -> bool { self.index() % 2 == 0 }
+    pub(crate) fn is_activation(self) -> bool { self.index() % 2 == 1}
+
+    pub(crate) fn kind(self) -> &'static str {
+        if self.is_reservation() { "reserved" } else { "active" }
+    }
+    pub(crate) fn borrow_index(self) -> BorrowIndex {
+        BorrowIndex::new(self.index() / 2)
     }
 }
 
@@ -89,6 +160,7 @@ impl<'a, 'gcx, 'tcx> Borrows<'a, 'gcx, 'tcx> {
             mir,
             idx_vec: IndexVec::new(),
             location_map: FxHashMap(),
+            assigned_map: FxHashMap(),
             region_map: FxHashMap(),
             local_map: FxHashMap(),
             region_span_map: FxHashMap()
@@ -100,6 +172,7 @@ impl<'a, 'gcx, 'tcx> Borrows<'a, 'gcx, 'tcx> {
                          scope_tree,
                          root_scope,
                          location_map: visitor.location_map,
+                         assigned_map: visitor.assigned_map,
                          region_map: visitor.region_map,
                          local_map: visitor.local_map,
                          region_span_map: visitor.region_span_map,
@@ -110,13 +183,16 @@ impl<'a, 'gcx, 'tcx> Borrows<'a, 'gcx, 'tcx> {
             mir: &'a Mir<'tcx>,
             idx_vec: IndexVec<BorrowIndex, BorrowData<'tcx>>,
             location_map: FxHashMap<Location, BorrowIndex>,
+            assigned_map: FxHashMap<Place<'tcx>, FxHashSet<BorrowIndex>>,
             region_map: FxHashMap<Region<'tcx>, FxHashSet<BorrowIndex>>,
             local_map: FxHashMap<mir::Local, FxHashSet<BorrowIndex>>,
             region_span_map: FxHashMap<RegionKind, Span>,
         }
 
         impl<'a, 'gcx, 'tcx> Visitor<'tcx> for GatherBorrows<'a, 'gcx, 'tcx> {
-            fn visit_rvalue(&mut self,
+            fn visit_assign(&mut self,
+                            block: mir::BasicBlock,
+                            assigned_place: &mir::Place<'tcx>,
                             rvalue: &mir::Rvalue<'tcx>,
                             location: mir::Location) {
                 fn root_local(mut p: &mir::Place<'_>) -> Option<mir::Local> {
@@ -127,23 +203,59 @@ impl<'a, 'gcx, 'tcx> Borrows<'a, 'gcx, 'tcx> {
                     }}
                 }
 
-                if let mir::Rvalue::Ref(region, kind, ref place) = *rvalue {
-                    if is_unsafe_place(self.tcx, self.mir, place) { return; }
+                if let mir::Rvalue::Ref(region, kind, ref borrowed_place) = *rvalue {
+                    if is_unsafe_place(self.tcx, self.mir, borrowed_place) { return; }
 
                     let borrow = BorrowData {
-                        location: location, kind: kind, region: region, place: place.clone(),
+                        location, kind, region,
+                        borrowed_place: borrowed_place.clone(),
+                        assigned_place: assigned_place.clone(),
                     };
                     let idx = self.idx_vec.push(borrow);
                     self.location_map.insert(location, idx);
 
-                    let borrows = self.region_map.entry(region).or_insert(FxHashSet());
-                    borrows.insert(idx);
+                    insert(&mut self.assigned_map, assigned_place, idx);
+                    insert(&mut self.region_map, &region, idx);
+                    if let Some(local) = root_local(borrowed_place) {
+                        insert(&mut self.local_map, &local, idx);
+                    }
+                }
 
-                    if let Some(local) = root_local(place) {
-                        let borrows = self.local_map.entry(local).or_insert(FxHashSet());
-                        borrows.insert(idx);
+                return self.super_assign(block, assigned_place, rvalue, location);
+
+                fn insert<'a, K, V>(map: &'a mut FxHashMap<K, FxHashSet<V>>,
+                                    k: &K,
+                                    v: V)
+                    where K: Clone+Eq+Hash, V: Eq+Hash
+                {
+                    map.entry(k.clone())
+                        .or_insert(FxHashSet())
+                        .insert(v);
+                }
+            }
+
+            fn visit_rvalue(&mut self,
+                            rvalue: &mir::Rvalue<'tcx>,
+                            location: mir::Location) {
+                if let mir::Rvalue::Ref(region, kind, ref place) = *rvalue {
+                    // double-check that we already registered a BorrowData for this
+
+                    let mut found_it = false;
+                    for idx in &self.region_map[region] {
+                        let bd = &self.idx_vec[*idx];
+                        if bd.location == location &&
+                            bd.kind == kind &&
+                            bd.region == region &&
+                            bd.borrowed_place == *place
+                        {
+                            found_it = true;
+                            break;
+                        }
                     }
+                    assert!(found_it, "Ref {:?} at {:?} missing BorrowData", rvalue, location);
                 }
+
+                return self.super_rvalue(rvalue, location);
             }
 
             fn visit_statement(&mut self,
@@ -153,7 +265,7 @@ impl<'a, 'gcx, 'tcx> Borrows<'a, 'gcx, 'tcx> {
                 if let mir::StatementKind::EndRegion(region_scope) = statement.kind {
                     self.region_span_map.insert(ReScope(region_scope), statement.source_info.span);
                 }
-                self.super_statement(block, statement, location);
+                return self.super_statement(block, statement, location);
             }
         }
     }
@@ -166,80 +278,95 @@ impl<'a, 'gcx, 'tcx> Borrows<'a, 'gcx, 'tcx> {
         &self.borrows[idx].location
     }
 
-    /// Returns the span for the "end point" given region. This will
-    /// return `None` if NLL is enabled, since that concept has no
-    /// meaning there.  Otherwise, return region span if it exists and
-    /// span for end of the function if it doesn't exist.
-    pub fn opt_region_end_span(&self, region: &Region) -> Option<Span> {
-        match self.nonlexical_regioncx {
-            Some(_) => None,
-            None => {
-                match self.region_span_map.get(region) {
-                    Some(span) => Some(span.end_point()),
-                    None => Some(self.mir.span.end_point())
-                }
-            }
-        }
-    }
-
     /// Add all borrows to the kill set, if those borrows are out of scope at `location`.
+    ///
+    /// `is_activations` tracks whether we are in the Reservations or
+    /// the ActiveBorrows flow analysis, and does not set the
+    /// activation kill bits in the former case. (Technically, we
+    /// could set those kill bits without such a guard, since they are
+    /// never gen'ed by Reservations in the first place.  But it makes
+    /// the instrumentation and graph renderings nicer to leave
+    /// activations out when of the Reservations kill sets.)
     fn kill_loans_out_of_scope_at_location(&self,
-                                           sets: &mut BlockSets<BorrowIndex>,
-                                           location: Location) {
+                                           sets: &mut BlockSets<ReserveOrActivateIndex>,
+                                           location: Location,
+                                           is_activations: bool) {
         if let Some(ref regioncx) = self.nonlexical_regioncx {
+            // NOTE: The state associated with a given `location`
+            // reflects the dataflow on entry to the statement. If it
+            // does not contain `borrow_region`, then then that means
+            // that the statement at `location` kills the borrow.
+            //
+            // We are careful always to call this function *before* we
+            // set up the gen-bits for the statement or
+            // termanator. That way, if the effect of the statement or
+            // terminator *does* introduce a new loan of the same
+            // region, then setting that gen-bit will override any
+            // potential kill introduced here.
             for (borrow_index, borrow_data) in self.borrows.iter_enumerated() {
                 let borrow_region = borrow_data.region.to_region_vid();
                 if !regioncx.region_contains_point(borrow_region, location) {
-                    // The region checker really considers the borrow
-                    // to start at the point **after** the location of
-                    // the borrow, but the borrow checker puts the gen
-                    // directly **on** the location of the
-                    // borrow. This results in a gen/kill both being
-                    // generated for same point if we are not
-                    // careful. Probably we should change the point of
-                    // the gen, but for now we hackily account for the
-                    // mismatch here by not generating a kill for the
-                    // location on the borrow itself.
-                    if location != borrow_data.location {
-                        sets.kill(&borrow_index);
+                    sets.kill(&ReserveOrActivateIndex::reserved(borrow_index));
+                    if is_activations {
+                        sets.kill(&ReserveOrActivateIndex::active(borrow_index));
                     }
                 }
             }
         }
     }
-}
 
-impl<'a, 'gcx, 'tcx> BitDenotation for Borrows<'a, 'gcx, 'tcx> {
-    type Idx = BorrowIndex;
-    fn name() -> &'static str { "borrows" }
-    fn bits_per_block(&self) -> usize {
-        self.borrows.len()
-    }
-    fn start_block_effect(&self, _sets: &mut IdxSet<BorrowIndex>)  {
-        // no borrows of code region_scopes have been taken prior to
-        // function execution, so this method has no effect on
-        // `_sets`.
-    }
-    fn statement_effect(&self,
-                        sets: &mut BlockSets<BorrowIndex>,
-                        location: Location) {
+    /// Models statement effect in Reservations and ActiveBorrows flow
+    /// analyses; `is activations` tells us if we are in the latter
+    /// case.
+    fn statement_effect_on_borrows(&self,
+                                   sets: &mut BlockSets<ReserveOrActivateIndex>,
+                                   location: Location,
+                                   is_activations: bool) {
         let block = &self.mir.basic_blocks().get(location.block).unwrap_or_else(|| {
             panic!("could not find block at location {:?}", location);
         });
         let stmt = block.statements.get(location.statement_index).unwrap_or_else(|| {
             panic!("could not find statement at location {:?}");
         });
+
+        // Do kills introduced by NLL before setting up any potential
+        // gens. (See NOTE in kill_loans_out_of_scope_at_location.)
+        self.kill_loans_out_of_scope_at_location(sets, location, is_activations);
+
+        if is_activations {
+            // INVARIANT: `sets.on_entry` accurately captures
+            // reservations on entry to statement (b/c
+            // accumulates_intrablock_state is overridden for
+            // ActiveBorrows).
+            //
+            // Now compute the activations generated by uses within
+            // the statement based on that reservation state.
+            let mut find = FindPlaceUses { sets, assigned_map: &self.assigned_map };
+            find.visit_statement(location.block, stmt, location);
+        }
+
         match stmt.kind {
+            // EndRegion kills any borrows (reservations and active borrows both)
             mir::StatementKind::EndRegion(region_scope) => {
                 if let Some(borrow_indexes) = self.region_map.get(&ReScope(region_scope)) {
                     assert!(self.nonlexical_regioncx.is_none());
-                    sets.kill_all(borrow_indexes);
+                    for idx in borrow_indexes {
+                        sets.kill(&ReserveOrActivateIndex::reserved(*idx));
+                        if is_activations {
+                            sets.kill(&ReserveOrActivateIndex::active(*idx));
+                        }
+                    }
                 } else {
                     // (if there is no entry, then there are no borrows to be tracked)
                 }
             }
 
             mir::StatementKind::Assign(_, ref rhs) => {
+                // NOTE: if/when the Assign case is revised to inspect
+                // the assigned_place here, make sure to also
+                // re-consider the current implementations of the
+                // propagate_call_return method.
+
                 if let mir::Rvalue::Ref(region, _, ref place) = *rhs {
                     if is_unsafe_place(self.tcx, self.mir, place) { return; }
                     if let RegionKind::ReEmpty = region {
@@ -254,7 +381,7 @@ impl<'a, 'gcx, 'tcx> BitDenotation for Borrows<'a, 'gcx, 'tcx> {
                     assert!(self.region_map.get(region).unwrap_or_else(|| {
                         panic!("could not find BorrowIndexs for region {:?}", region);
                     }).contains(&index));
-                    sets.gen(&index);
+                    sets.gen(&ReserveOrActivateIndex::reserved(*index));
                 }
             }
 
@@ -264,7 +391,12 @@ impl<'a, 'gcx, 'tcx> BitDenotation for Borrows<'a, 'gcx, 'tcx> {
                 //
                 // FIXME: expand this to variables that are assigned over.
                 if let Some(borrow_indexes) = self.local_map.get(&local) {
-                    sets.kill_all(borrow_indexes);
+                    sets.kill_all(borrow_indexes.iter()
+                                  .map(|b| ReserveOrActivateIndex::reserved(*b)));
+                    if is_activations {
+                        sets.kill_all(borrow_indexes.iter()
+                                      .map(|b| ReserveOrActivateIndex::active(*b)));
+                    }
                 }
             }
 
@@ -275,17 +407,37 @@ impl<'a, 'gcx, 'tcx> BitDenotation for Borrows<'a, 'gcx, 'tcx> {
             mir::StatementKind::Nop => {}
 
         }
-
-        self.kill_loans_out_of_scope_at_location(sets, location);
     }
 
-    fn terminator_effect(&self,
-                         sets: &mut BlockSets<BorrowIndex>,
-                         location: Location) {
+    /// Models terminator effect in Reservations and ActiveBorrows
+    /// flow analyses; `is activations` tells us if we are in the
+    /// latter case.
+    fn terminator_effect_on_borrows(&self,
+                                    sets: &mut BlockSets<ReserveOrActivateIndex>,
+                                    location: Location,
+                                    is_activations: bool) {
         let block = &self.mir.basic_blocks().get(location.block).unwrap_or_else(|| {
             panic!("could not find block at location {:?}", location);
         });
-        match block.terminator().kind {
+
+        // Do kills introduced by NLL before setting up any potential
+        // gens. (See NOTE in kill_loans_out_of_scope_at_location.)
+        self.kill_loans_out_of_scope_at_location(sets, location, is_activations);
+
+        let term = block.terminator();
+        if is_activations {
+            // INVARIANT: `sets.on_entry` accurately captures
+            // reservations on entry to terminator (b/c
+            // accumulates_intrablock_state is overridden for
+            // ActiveBorrows).
+            //
+            // Now compute effect of the terminator on the activations
+            // themselves in the ActiveBorrows state.
+            let mut find = FindPlaceUses { sets, assigned_map: &self.assigned_map };
+            find.visit_terminator(location.block, term, location);
+        }
+
+        match term.kind {
             mir::TerminatorKind::Resume |
             mir::TerminatorKind::Return |
             mir::TerminatorKind::GeneratorDrop => {
@@ -304,7 +456,10 @@ impl<'a, 'gcx, 'tcx> BitDenotation for Borrows<'a, 'gcx, 'tcx> {
                             if *scope != root_scope &&
                                 self.scope_tree.is_subscope_of(*scope, root_scope)
                             {
-                                sets.kill(&borrow_index);
+                                sets.kill(&ReserveOrActivateIndex::reserved(borrow_index));
+                                if is_activations {
+                                    sets.kill(&ReserveOrActivateIndex::active(borrow_index));
+                                }
                             }
                         }
                     }
@@ -320,29 +475,223 @@ impl<'a, 'gcx, 'tcx> BitDenotation for Borrows<'a, 'gcx, 'tcx> {
             mir::TerminatorKind::FalseEdges {..} |
             mir::TerminatorKind::Unreachable => {}
         }
-        self.kill_loans_out_of_scope_at_location(sets, location);
+    }
+}
+
+impl<'a, 'gcx, 'tcx> ActiveBorrows<'a, 'gcx, 'tcx> {
+    pub(crate) fn borrows(&self) -> &IndexVec<BorrowIndex, BorrowData<'tcx>> {
+        self.0.borrows()
+    }
+
+    /// Returns the span for the "end point" given region. This will
+    /// return `None` if NLL is enabled, since that concept has no
+    /// meaning there.  Otherwise, return region span if it exists and
+    /// span for end of the function if it doesn't exist.
+    pub(crate) fn opt_region_end_span(&self, region: &Region) -> Option<Span> {
+        match self.0.nonlexical_regioncx {
+            Some(_) => None,
+            None => {
+                match self.0.region_span_map.get(region) {
+                    Some(span) => Some(span.end_point()),
+                    None => Some(self.0.mir.span.end_point())
+                }
+            }
+        }
+    }
+}
+
+/// `FindPlaceUses` is a MIR visitor that updates `self.sets` for all
+/// of the borrows activated by a given statement or terminator.
+///
+/// ----
+///
+/// The `ActiveBorrows` flow analysis, when inspecting any given
+/// statement or terminator, needs to "generate" (i.e. set to 1) all
+/// of the bits for the borrows that are activated by that
+/// statement/terminator.
+///
+/// This struct will seek out all places that are assignment-targets
+/// for borrows (gathered in `self.assigned_map`; see also the
+/// `assigned_map` in `struct Borrows`), and set the corresponding
+/// gen-bits for activations of those borrows in `self.sets`
+struct FindPlaceUses<'a, 'b: 'a, 'tcx: 'a> {
+    assigned_map: &'a FxHashMap<Place<'tcx>, FxHashSet<BorrowIndex>>,
+    sets: &'a mut BlockSets<'b, ReserveOrActivateIndex>,
+}
+
+impl<'a, 'b, 'tcx> FindPlaceUses<'a, 'b, 'tcx> {
+    fn has_been_reserved(&self, b: &BorrowIndex) -> bool {
+        self.sets.on_entry.contains(&ReserveOrActivateIndex::reserved(*b))
+    }
+
+    /// return whether `context` should be considered a "use" of a
+    /// place found in that context. "Uses" activate associated
+    /// borrows (at least when such uses occur while the borrow also
+    /// has a reservation at the time).
+    fn is_potential_use(context: PlaceContext) -> bool {
+        match context {
+            // storage effects on an place do not activate it
+            PlaceContext::StorageLive | PlaceContext::StorageDead => false,
+
+            // validation effects do not activate an place
+            //
+            // FIXME: Should they? Is it just another read? Or can we
+            // guarantee it won't dereference the stored address? How
+            // "deep" does validation go?
+            PlaceContext::Validate => false,
+
+            // pure overwrites of an place do not activate it. (note
+            // PlaceContext::Call is solely about dest place)
+            PlaceContext::Store | PlaceContext::Call => false,
+
+            // reads of an place *do* activate it
+            PlaceContext::Move |
+            PlaceContext::Copy |
+            PlaceContext::Drop |
+            PlaceContext::Inspect |
+            PlaceContext::Borrow { .. } |
+            PlaceContext::Projection(..) => true,
+        }
+    }
+}
+
+impl<'a, 'b, 'tcx> Visitor<'tcx> for FindPlaceUses<'a, 'b, 'tcx> {
+    fn visit_place(&mut self,
+                    place: &mir::Place<'tcx>,
+                    context: PlaceContext<'tcx>,
+                    location: Location) {
+        debug!("FindPlaceUses place: {:?} assigned from borrows: {:?} \
+                used in context: {:?} at location: {:?}",
+               place, self.assigned_map.get(place), context, location);
+        if Self::is_potential_use(context) {
+            if let Some(borrows) = self.assigned_map.get(place) {
+                for borrow_idx in borrows {
+                    debug!("checking if index {:?} for {:?} is reserved ({}) \
+                            and thus needs active gen-bit set in sets {:?}",
+                           borrow_idx, place, self.has_been_reserved(&borrow_idx), self.sets);
+                    if self.has_been_reserved(&borrow_idx) {
+                        self.sets.gen(&ReserveOrActivateIndex::active(*borrow_idx));
+                    } else {
+                        // (This can certainly happen in valid code. I
+                        // just want to know about it in the short
+                        // term.)
+                        debug!("encountered use of Place {:?} of borrow_idx {:?} \
+                                at location {:?} outside of reservation",
+                               place, borrow_idx, location);
+                    }
+                }
+            }
+        }
+
+        self.super_place(place, context, location);
+    }
+}
+
+
+impl<'a, 'gcx, 'tcx> BitDenotation for Reservations<'a, 'gcx, 'tcx> {
+    type Idx = ReserveOrActivateIndex;
+    fn name() -> &'static str { "reservations" }
+    fn bits_per_block(&self) -> usize {
+        self.0.borrows.len() * 2
+    }
+    fn start_block_effect(&self, _entry_set: &mut IdxSet<ReserveOrActivateIndex>)  {
+        // no borrows of code region_scopes have been taken prior to
+        // function execution, so this method has no effect on
+        // `_sets`.
+    }
+
+    fn statement_effect(&self,
+                        sets: &mut BlockSets<ReserveOrActivateIndex>,
+                        location: Location) {
+        debug!("Reservations::statement_effect sets: {:?} location: {:?}", sets, location);
+        self.0.statement_effect_on_borrows(sets, location, false);
+    }
+
+    fn terminator_effect(&self,
+                         sets: &mut BlockSets<ReserveOrActivateIndex>,
+                         location: Location) {
+        debug!("Reservations::terminator_effect sets: {:?} location: {:?}", sets, location);
+        self.0.terminator_effect_on_borrows(sets, location, false);
     }
 
     fn propagate_call_return(&self,
-                             _in_out: &mut IdxSet<BorrowIndex>,
+                             _in_out: &mut IdxSet<ReserveOrActivateIndex>,
                              _call_bb: mir::BasicBlock,
                              _dest_bb: mir::BasicBlock,
                              _dest_place: &mir::Place) {
-        // there are no effects on the region scopes from method calls.
+        // there are no effects on borrows from method call return...
+        //
+        // ... but if overwriting a place can affect flow state, then
+        // latter is not true; see NOTE on Assign case in
+        // statement_effect_on_borrows.
+    }
+}
+
+impl<'a, 'gcx, 'tcx> BitDenotation for ActiveBorrows<'a, 'gcx, 'tcx> {
+    type Idx = ReserveOrActivateIndex;
+    fn name() -> &'static str { "active_borrows" }
+
+    /// Overriding this method; `ActiveBorrows` uses the intrablock
+    /// state in `on_entry` to track the current reservations (which
+    /// then affect the construction of the gen/kill sets for
+    /// activations).
+    fn accumulates_intrablock_state() -> bool { true }
+
+    fn bits_per_block(&self) -> usize {
+        self.0.borrows.len() * 2
+    }
+
+    fn start_block_effect(&self, _entry_sets: &mut IdxSet<ReserveOrActivateIndex>)  {
+        // no borrows of code region_scopes have been taken prior to
+        // function execution, so this method has no effect on
+        // `_sets`.
+    }
+
+    fn statement_effect(&self,
+                        sets: &mut BlockSets<ReserveOrActivateIndex>,
+                        location: Location) {
+        debug!("ActiveBorrows::statement_effect sets: {:?} location: {:?}", sets, location);
+        self.0.statement_effect_on_borrows(sets, location, true);
+    }
+
+    fn terminator_effect(&self,
+                         sets: &mut BlockSets<ReserveOrActivateIndex>,
+                         location: Location) {
+        debug!("ActiveBorrows::terminator_effect sets: {:?} location: {:?}", sets, location);
+        self.0.terminator_effect_on_borrows(sets, location, true);
+    }
+
+    fn propagate_call_return(&self,
+                             _in_out: &mut IdxSet<ReserveOrActivateIndex>,
+                             _call_bb: mir::BasicBlock,
+                             _dest_bb: mir::BasicBlock,
+                             _dest_place: &mir::Place) {
+        // there are no effects on borrows from method call return...
+        //
+        // ... but If overwriting a place can affect flow state, then
+        // latter is not true; see NOTE on Assign case in
+        // statement_effect_on_borrows.
+    }
+}
+
+impl<'a, 'gcx, 'tcx> BitwiseOperator for Reservations<'a, 'gcx, 'tcx> {
+    #[inline]
+    fn join(&self, pred1: usize, pred2: usize) -> usize {
+        pred1 | pred2 // union effects of preds when computing reservations
     }
 }
 
-impl<'a, 'gcx, 'tcx> BitwiseOperator for Borrows<'a, 'gcx, 'tcx> {
+impl<'a, 'gcx, 'tcx> BitwiseOperator for ActiveBorrows<'a, 'gcx, 'tcx> {
     #[inline]
     fn join(&self, pred1: usize, pred2: usize) -> usize {
-        pred1 | pred2 // union effects of preds when computing borrows
+        pred1 | pred2 // union effects of preds when computing activations
     }
 }
 
-impl<'a, 'gcx, 'tcx> DataflowOperator for Borrows<'a, 'gcx, 'tcx> {
+impl<'a, 'gcx, 'tcx> InitialFlow for Reservations<'a, 'gcx, 'tcx> {
     #[inline]
     fn bottom_value() -> bool {
-        false // bottom = no Rvalue::Refs are active by default
+        false // bottom = no Rvalue::Refs are reserved by default
     }
 }
 
diff --git a/src/librustc_mir/dataflow/impls/mod.rs b/src/librustc_mir/dataflow/impls/mod.rs
index 033d2a3212f..106a88e703c 100644
--- a/src/librustc_mir/dataflow/impls/mod.rs
+++ b/src/librustc_mir/dataflow/impls/mod.rs
@@ -23,7 +23,7 @@ use util::elaborate_drops::DropFlagState;
 
 use super::move_paths::{HasMoveData, MoveData, MoveOutIndex, MovePathIndex, InitIndex};
 use super::move_paths::{LookupResult, InitKind};
-use super::{BitDenotation, BlockSets, DataflowOperator};
+use super::{BitDenotation, BlockSets, InitialFlow};
 
 use super::drop_flag_effects_for_function_entry;
 use super::drop_flag_effects_for_location;
@@ -702,35 +702,35 @@ impl<'a, 'gcx, 'tcx> BitwiseOperator for EverInitializedLvals<'a, 'gcx, 'tcx> {
 // propagating, or you start at all-ones and then use Intersect as
 // your merge when propagating.
 
-impl<'a, 'gcx, 'tcx> DataflowOperator for MaybeInitializedLvals<'a, 'gcx, 'tcx> {
+impl<'a, 'gcx, 'tcx> InitialFlow for MaybeInitializedLvals<'a, 'gcx, 'tcx> {
     #[inline]
     fn bottom_value() -> bool {
         false // bottom = uninitialized
     }
 }
 
-impl<'a, 'gcx, 'tcx> DataflowOperator for MaybeUninitializedLvals<'a, 'gcx, 'tcx> {
+impl<'a, 'gcx, 'tcx> InitialFlow for MaybeUninitializedLvals<'a, 'gcx, 'tcx> {
     #[inline]
     fn bottom_value() -> bool {
         false // bottom = initialized (start_block_effect counters this at outset)
     }
 }
 
-impl<'a, 'gcx, 'tcx> DataflowOperator for DefinitelyInitializedLvals<'a, 'gcx, 'tcx> {
+impl<'a, 'gcx, 'tcx> InitialFlow for DefinitelyInitializedLvals<'a, 'gcx, 'tcx> {
     #[inline]
     fn bottom_value() -> bool {
         true // bottom = initialized (start_block_effect counters this at outset)
     }
 }
 
-impl<'a, 'gcx, 'tcx> DataflowOperator for MovingOutStatements<'a, 'gcx, 'tcx> {
+impl<'a, 'gcx, 'tcx> InitialFlow for MovingOutStatements<'a, 'gcx, 'tcx> {
     #[inline]
     fn bottom_value() -> bool {
         false // bottom = no loans in scope by default
     }
 }
 
-impl<'a, 'gcx, 'tcx> DataflowOperator for EverInitializedLvals<'a, 'gcx, 'tcx> {
+impl<'a, 'gcx, 'tcx> InitialFlow for EverInitializedLvals<'a, 'gcx, 'tcx> {
     #[inline]
     fn bottom_value() -> bool {
         false // bottom = no initialized variables by default
diff --git a/src/librustc_mir/dataflow/impls/storage_liveness.rs b/src/librustc_mir/dataflow/impls/storage_liveness.rs
index 9e5a7168378..dea61542ac4 100644
--- a/src/librustc_mir/dataflow/impls/storage_liveness.rs
+++ b/src/librustc_mir/dataflow/impls/storage_liveness.rs
@@ -74,7 +74,7 @@ impl<'a, 'tcx> BitwiseOperator for MaybeStorageLive<'a, 'tcx> {
     }
 }
 
-impl<'a, 'tcx> DataflowOperator for MaybeStorageLive<'a, 'tcx> {
+impl<'a, 'tcx> InitialFlow for MaybeStorageLive<'a, 'tcx> {
     #[inline]
     fn bottom_value() -> bool {
         false // bottom = dead
diff --git a/src/librustc_mir/dataflow/mod.rs b/src/librustc_mir/dataflow/mod.rs
index 2136b41e462..83c46e0199e 100644
--- a/src/librustc_mir/dataflow/mod.rs
+++ b/src/librustc_mir/dataflow/mod.rs
@@ -18,8 +18,8 @@ use rustc::ty::{self, TyCtxt};
 use rustc::mir::{self, Mir, BasicBlock, BasicBlockData, Location, Statement, Terminator};
 use rustc::session::Session;
 
-use std::borrow::Borrow;
-use std::fmt::{self, Debug};
+use std::borrow::{Borrow, Cow};
+use std::fmt;
 use std::io;
 use std::mem;
 use std::path::PathBuf;
@@ -29,7 +29,8 @@ pub use self::impls::{MaybeStorageLive};
 pub use self::impls::{MaybeInitializedLvals, MaybeUninitializedLvals};
 pub use self::impls::{DefinitelyInitializedLvals, MovingOutStatements};
 pub use self::impls::EverInitializedLvals;
-pub use self::impls::borrows::{Borrows, BorrowData, BorrowIndex};
+pub use self::impls::borrows::{Borrows, BorrowData};
+pub(crate) use self::impls::borrows::{ActiveBorrows, Reservations, ReserveOrActivateIndex};
 pub use self::at_location::{FlowAtLocation, FlowsAtLocation};
 pub(crate) use self::drop_flag_effects::*;
 
@@ -51,10 +52,29 @@ pub(crate) struct DataflowBuilder<'a, 'tcx: 'a, BD> where BD: BitDenotation
     print_postflow_to: Option<String>,
 }
 
-pub trait Dataflow<BD: BitDenotation> {
+/// `DebugFormatted` encapsulates the "{:?}" rendering of some
+/// arbitrary value. This way: you pay cost of allocating an extra
+/// string (as well as that of rendering up-front); in exchange, you
+/// don't have to hand over ownership of your value or deal with
+/// borrowing it.
+pub(crate) struct DebugFormatted(String);
+
+impl DebugFormatted {
+    pub fn new(input: &fmt::Debug) -> DebugFormatted {
+        DebugFormatted(format!("{:?}", input))
+    }
+}
+
+impl fmt::Debug for DebugFormatted {
+    fn fmt(&self, w: &mut fmt::Formatter) -> fmt::Result {
+        write!(w, "{}", self.0)
+    }
+}
+
+pub(crate) trait Dataflow<BD: BitDenotation> {
     /// Sets up and runs the dataflow problem, using `p` to render results if
     /// implementation so chooses.
-    fn dataflow<P>(&mut self, p: P) where P: Fn(&BD, BD::Idx) -> &Debug {
+    fn dataflow<P>(&mut self, p: P) where P: Fn(&BD, BD::Idx) -> DebugFormatted {
         let _ = p; // default implementation does not instrument process.
         self.build_sets();
         self.propagate();
@@ -69,7 +89,7 @@ pub trait Dataflow<BD: BitDenotation> {
 
 impl<'a, 'tcx: 'a, BD> Dataflow<BD> for DataflowBuilder<'a, 'tcx, BD> where BD: BitDenotation
 {
-    fn dataflow<P>(&mut self, p: P) where P: Fn(&BD, BD::Idx) -> &Debug {
+    fn dataflow<P>(&mut self, p: P) where P: Fn(&BD, BD::Idx) -> DebugFormatted {
         self.flow_state.build_sets();
         self.pre_dataflow_instrumentation(|c,i| p(c,i)).unwrap();
         self.flow_state.propagate();
@@ -101,44 +121,56 @@ pub struct MoveDataParamEnv<'gcx, 'tcx> {
 }
 
 pub(crate) fn do_dataflow<'a, 'gcx, 'tcx, BD, P>(tcx: TyCtxt<'a, 'gcx, 'tcx>,
-                                                 mir: &Mir<'tcx>,
+                                                 mir: &'a Mir<'tcx>,
                                                  node_id: ast::NodeId,
                                                  attributes: &[ast::Attribute],
                                                  dead_unwinds: &IdxSet<BasicBlock>,
                                                  bd: BD,
                                                  p: P)
                                                  -> DataflowResults<BD>
-    where BD: BitDenotation,
-          P: Fn(&BD, BD::Idx) -> &fmt::Debug
+    where BD: BitDenotation + InitialFlow,
+          P: Fn(&BD, BD::Idx) -> DebugFormatted
 {
-    let name_found = |sess: &Session, attrs: &[ast::Attribute], name| -> Option<String> {
-        if let Some(item) = has_rustc_mir_with(attrs, name) {
-            if let Some(s) = item.value_str() {
-                return Some(s.to_string())
-            } else {
-                sess.span_err(
-                    item.span,
-                    &format!("{} attribute requires a path", item.name()));
-                return None;
+    let flow_state = DataflowAnalysis::new(mir, dead_unwinds, bd);
+    flow_state.run(tcx, node_id, attributes, p)
+}
+
+impl<'a, 'gcx: 'tcx, 'tcx: 'a, BD> DataflowAnalysis<'a, 'tcx, BD> where BD: BitDenotation
+{
+    pub(crate) fn run<P>(self,
+                         tcx: TyCtxt<'a, 'gcx, 'tcx>,
+                         node_id: ast::NodeId,
+                         attributes: &[ast::Attribute],
+                         p: P) -> DataflowResults<BD>
+        where P: Fn(&BD, BD::Idx) -> DebugFormatted
+    {
+        let name_found = |sess: &Session, attrs: &[ast::Attribute], name| -> Option<String> {
+            if let Some(item) = has_rustc_mir_with(attrs, name) {
+                if let Some(s) = item.value_str() {
+                    return Some(s.to_string())
+                } else {
+                    sess.span_err(
+                        item.span,
+                        &format!("{} attribute requires a path", item.name()));
+                    return None;
+                }
             }
-        }
-        return None;
-    };
+            return None;
+        };
 
-    let print_preflow_to =
-        name_found(tcx.sess, attributes, "borrowck_graphviz_preflow");
-    let print_postflow_to =
-        name_found(tcx.sess, attributes, "borrowck_graphviz_postflow");
+        let print_preflow_to =
+            name_found(tcx.sess, attributes, "borrowck_graphviz_preflow");
+        let print_postflow_to =
+            name_found(tcx.sess, attributes, "borrowck_graphviz_postflow");
 
-    let mut mbcx = DataflowBuilder {
-        node_id,
-        print_preflow_to,
-        print_postflow_to,
-        flow_state: DataflowAnalysis::new(tcx, mir, dead_unwinds, bd),
-    };
+        let mut mbcx = DataflowBuilder {
+            node_id,
+            print_preflow_to, print_postflow_to, flow_state: self,
+        };
 
-    mbcx.dataflow(p);
-    mbcx.flow_state.results()
+        mbcx.dataflow(p);
+        mbcx.flow_state.results()
+    }
 }
 
 struct PropagationContext<'b, 'a: 'b, 'tcx: 'a, O> where O: 'b + BitDenotation
@@ -157,17 +189,12 @@ impl<'a, 'tcx: 'a, BD> DataflowAnalysis<'a, 'tcx, BD> where BD: BitDenotation
         };
         while propcx.changed {
             propcx.changed = false;
-            propcx.reset(&mut temp);
             propcx.walk_cfg(&mut temp);
         }
     }
 
     fn build_sets(&mut self) {
-        // First we need to build the entry-, gen- and kill-sets. The
-        // gather_moves information provides a high-level mapping from
-        // mir-locations to the MoveOuts (and those correspond
-        // directly to gen-sets here). But we still need to figure out
-        // the kill-sets.
+        // First we need to build the entry-, gen- and kill-sets.
 
         {
             let sets = &mut self.flow_state.sets.for_block(mir::START_BLOCK.index());
@@ -177,15 +204,28 @@ impl<'a, 'tcx: 'a, BD> DataflowAnalysis<'a, 'tcx, BD> where BD: BitDenotation
         for (bb, data) in self.mir.basic_blocks().iter_enumerated() {
             let &mir::BasicBlockData { ref statements, ref terminator, is_cleanup: _ } = data;
 
+            let mut interim_state;
             let sets = &mut self.flow_state.sets.for_block(bb.index());
+            let track_intrablock = BD::accumulates_intrablock_state();
+            if track_intrablock {
+                debug!("swapping in mutable on_entry, initially {:?}", sets.on_entry);
+                interim_state = sets.on_entry.to_owned();
+                sets.on_entry = &mut interim_state;
+            }
             for j_stmt in 0..statements.len() {
                 let location = Location { block: bb, statement_index: j_stmt };
                 self.flow_state.operator.statement_effect(sets, location);
+                if track_intrablock {
+                    sets.apply_local_effect();
+                }
             }
 
             if terminator.is_some() {
                 let location = Location { block: bb, statement_index: statements.len() };
                 self.flow_state.operator.terminator_effect(sets, location);
+                if track_intrablock {
+                    sets.apply_local_effect();
+                }
             }
         }
     }
@@ -193,13 +233,6 @@ impl<'a, 'tcx: 'a, BD> DataflowAnalysis<'a, 'tcx, BD> where BD: BitDenotation
 
 impl<'b, 'a: 'b, 'tcx: 'a, BD> PropagationContext<'b, 'a, 'tcx, BD> where BD: BitDenotation
 {
-    fn reset(&mut self, bits: &mut IdxSet<BD::Idx>) {
-        let e = if BD::bottom_value() {!0} else {0};
-        for b in bits.words_mut() {
-            *b = e;
-        }
-    }
-
     fn walk_cfg(&mut self, in_out: &mut IdxSet<BD::Idx>) {
         let mir = self.builder.mir;
         for (bb_idx, bb_data) in mir.basic_blocks().iter().enumerate() {
@@ -231,7 +264,7 @@ fn dataflow_path(context: &str, prepost: &str, path: &str) -> PathBuf {
 impl<'a, 'tcx: 'a, BD> DataflowBuilder<'a, 'tcx, BD> where BD: BitDenotation
 {
     fn pre_dataflow_instrumentation<P>(&self, p: P) -> io::Result<()>
-        where P: Fn(&BD, BD::Idx) -> &Debug
+        where P: Fn(&BD, BD::Idx) -> DebugFormatted
     {
         if let Some(ref path_str) = self.print_preflow_to {
             let path = dataflow_path(BD::name(), "preflow", path_str);
@@ -242,7 +275,7 @@ impl<'a, 'tcx: 'a, BD> DataflowBuilder<'a, 'tcx, BD> where BD: BitDenotation
     }
 
     fn post_dataflow_instrumentation<P>(&self, p: P) -> io::Result<()>
-        where P: Fn(&BD, BD::Idx) -> &Debug
+        where P: Fn(&BD, BD::Idx) -> DebugFormatted
     {
         if let Some(ref path_str) = self.print_postflow_to {
             let path = dataflow_path(BD::name(), "postflow", path_str);
@@ -255,7 +288,7 @@ impl<'a, 'tcx: 'a, BD> DataflowBuilder<'a, 'tcx, BD> where BD: BitDenotation
 
 /// Maps each block to a set of bits
 #[derive(Debug)]
-struct Bits<E:Idx> {
+pub(crate) struct Bits<E:Idx> {
     bits: IdxSetBuf<E>,
 }
 
@@ -276,7 +309,7 @@ impl<E:Idx> Bits<E> {
 /// underlying flow analysis results, because it needs to handle cases
 /// where we are combining the results of *multiple* flow analyses
 /// (e.g. borrows + inits + uninits).
-pub trait DataflowResultsConsumer<'a, 'tcx: 'a> {
+pub(crate) trait DataflowResultsConsumer<'a, 'tcx: 'a> {
     type FlowState: FlowsAtLocation;
 
     // Observation Hooks: override (at least one of) these to get analysis feedback.
@@ -403,12 +436,12 @@ impl<O: BitDenotation> DataflowState<O> {
         words.each_bit(bits_per_block, f)
     }
 
-    pub fn interpret_set<'c, P>(&self,
-                                o: &'c O,
-                                words: &IdxSet<O::Idx>,
-                                render_idx: &P)
-                                -> Vec<&'c Debug>
-        where P: Fn(&O, O::Idx) -> &Debug
+    pub(crate) fn interpret_set<'c, P>(&self,
+                                       o: &'c O,
+                                       words: &IdxSet<O::Idx>,
+                                       render_idx: &P)
+                                       -> Vec<DebugFormatted>
+        where P: Fn(&O, O::Idx) -> DebugFormatted
     {
         let mut v = Vec::new();
         self.each_bit(words, |i| {
@@ -455,6 +488,7 @@ pub struct AllSets<E: Idx> {
 /// killed during the iteration. (This is such a good idea that the
 /// `fn gen` and `fn kill` methods that set their state enforce this
 /// for you.)
+#[derive(Debug)]
 pub struct BlockSets<'a, E: Idx> {
     /// Dataflow state immediately before control flow enters the given block.
     pub(crate) on_entry: &'a mut IdxSet<E>,
@@ -496,6 +530,7 @@ impl<'a, E:Idx> BlockSets<'a, E> {
         self.gen_set.remove(e);
         self.kill_set.add(e);
     }
+
     fn kill_all<I>(&mut self, i: I)
         where I: IntoIterator,
               I::Item: Borrow<E>
@@ -504,6 +539,11 @@ impl<'a, E:Idx> BlockSets<'a, E> {
             self.kill(j.borrow());
         }
     }
+
+    fn apply_local_effect(&mut self) {
+        self.on_entry.union(&self.gen_set);
+        self.on_entry.subtract(&self.kill_set);
+    }
 }
 
 impl<E:Idx> AllSets<E> {
@@ -532,18 +572,51 @@ impl<E:Idx> AllSets<E> {
     pub fn on_entry_set_for(&self, block_idx: usize) -> &IdxSet<E> {
         self.lookup_set_for(&self.on_entry_sets, block_idx)
     }
+    pub(crate) fn entry_set_state(&self) -> &Bits<E> {
+        &self.on_entry_sets
+    }
 }
 
 /// Parameterization for the precise form of data flow that is used.
-pub trait DataflowOperator: BitwiseOperator {
+/// `InitialFlow` handles initializing the bitvectors before any
+/// code is inspected by the analysis. Analyses that need more nuanced
+/// initialization (e.g. they need to consult the results of some other
+/// dataflow analysis to set up the initial bitvectors) should not
+/// implement this.
+pub trait InitialFlow {
     /// Specifies the initial value for each bit in the `on_entry` set
     fn bottom_value() -> bool;
 }
 
-pub trait BitDenotation: DataflowOperator {
+pub trait BitDenotation: BitwiseOperator {
     /// Specifies what index type is used to access the bitvector.
     type Idx: Idx;
 
+    /// Some analyses want to accumulate knowledge within a block when
+    /// analyzing its statements for building the gen/kill sets. Override
+    /// this method to return true in such cases.
+    ///
+    /// When this returns true, the statement-effect (re)construction
+    /// will clone the `on_entry` state and pass along a reference via
+    /// `sets.on_entry` to that local clone into `statement_effect` and
+    /// `terminator_effect`).
+    ///
+    /// When its false, no local clone is constucted; instead a
+    /// reference directly into `on_entry` is passed along via
+    /// `sets.on_entry` instead, which represents the flow state at
+    /// the block's start, not necessarily the state immediately prior
+    /// to the statement/terminator under analysis.
+    ///
+    /// In either case, the passed reference is mutable; but this is a
+    /// wart from using the `BlockSets` type in the API; the intention
+    /// is that the `statement_effect` and `terminator_effect` methods
+    /// mutate only the gen/kill sets.
+    ///
+    /// FIXME: We should consider enforcing the intention described in
+    /// the previous paragraph by passing the three sets in separate
+    /// parameters to encode their distinct mutabilities.
+    fn accumulates_intrablock_state() -> bool { false }
+
     /// A name describing the dataflow analysis that this
     /// BitDenotation is supporting.  The name should be something
     /// suitable for plugging in as part of a filename e.g. avoid
@@ -618,29 +691,33 @@ pub trait BitDenotation: DataflowOperator {
                              dest_place: &mir::Place);
 }
 
-impl<'a, 'gcx, 'tcx: 'a, D> DataflowAnalysis<'a, 'tcx, D> where D: BitDenotation
+impl<'a, 'tcx, D> DataflowAnalysis<'a, 'tcx, D> where D: BitDenotation
 {
-    pub fn new(_tcx: TyCtxt<'a, 'gcx, 'tcx>,
-               mir: &'a Mir<'tcx>,
+    pub fn new(mir: &'a Mir<'tcx>,
                dead_unwinds: &'a IdxSet<mir::BasicBlock>,
-               denotation: D) -> Self {
+               denotation: D) -> Self where D: InitialFlow {
         let bits_per_block = denotation.bits_per_block();
-        let usize_bits = mem::size_of::<usize>() * 8;
-        let words_per_block = (bits_per_block + usize_bits - 1) / usize_bits;
-
-        // (now rounded up to multiple of word size)
-        let bits_per_block = words_per_block * usize_bits;
-
-        let num_blocks = mir.basic_blocks().len();
-        let num_overall = num_blocks * bits_per_block;
-
-        let zeroes = Bits::new(IdxSetBuf::new_empty(num_overall));
+        let num_overall = Self::num_bits_overall(mir, bits_per_block);
         let on_entry = Bits::new(if D::bottom_value() {
             IdxSetBuf::new_filled(num_overall)
         } else {
             IdxSetBuf::new_empty(num_overall)
         });
 
+        Self::new_with_entry_sets(mir, dead_unwinds, Cow::Owned(on_entry), denotation)
+    }
+
+    pub(crate) fn new_with_entry_sets(mir: &'a Mir<'tcx>,
+                                      dead_unwinds: &'a IdxSet<mir::BasicBlock>,
+                                      on_entry: Cow<Bits<D::Idx>>,
+                                      denotation: D)
+                                      -> Self {
+        let bits_per_block = denotation.bits_per_block();
+        let usize_bits = mem::size_of::<usize>() * 8;
+        let words_per_block = (bits_per_block + usize_bits - 1) / usize_bits;
+        let num_overall = Self::num_bits_overall(mir, bits_per_block);
+        assert_eq!(num_overall, on_entry.bits.words().len() * usize_bits);
+        let zeroes = Bits::new(IdxSetBuf::new_empty(num_overall));
         DataflowAnalysis {
             mir,
             dead_unwinds,
@@ -650,12 +727,23 @@ impl<'a, 'gcx, 'tcx: 'a, D> DataflowAnalysis<'a, 'tcx, D> where D: BitDenotation
                     words_per_block,
                     gen_sets: zeroes.clone(),
                     kill_sets: zeroes,
-                    on_entry_sets: on_entry,
+                    on_entry_sets: on_entry.into_owned(),
                 },
                 operator: denotation,
-            },
+            }
         }
+    }
 
+    fn num_bits_overall(mir: &Mir, bits_per_block: usize) -> usize {
+        let usize_bits = mem::size_of::<usize>() * 8;
+        let words_per_block = (bits_per_block + usize_bits - 1) / usize_bits;
+
+        // (now rounded up to multiple of word size)
+        let bits_per_block = words_per_block * usize_bits;
+
+        let num_blocks = mir.basic_blocks().len();
+        let num_overall = num_blocks * bits_per_block;
+        num_overall
     }
 }
 
diff --git a/src/librustc_mir/dataflow/move_paths/mod.rs b/src/librustc_mir/dataflow/move_paths/mod.rs
index 9d91e1344dc..bcf4662211e 100644
--- a/src/librustc_mir/dataflow/move_paths/mod.rs
+++ b/src/librustc_mir/dataflow/move_paths/mod.rs
@@ -65,6 +65,9 @@ pub(crate) mod indexes {
 
     /// Index into Borrows.locations
     new_index!(BorrowIndex, "bw");
+
+    /// Index into Reservations/Activations bitvector
+    new_index!(ReserveOrActivateIndex, "ra");
 }
 
 pub use self::indexes::MovePathIndex;
diff --git a/src/librustc_mir/transform/elaborate_drops.rs b/src/librustc_mir/transform/elaborate_drops.rs
index b075d2637da..106bc39d0fc 100644
--- a/src/librustc_mir/transform/elaborate_drops.rs
+++ b/src/librustc_mir/transform/elaborate_drops.rs
@@ -14,7 +14,7 @@ use dataflow::{DataflowResults};
 use dataflow::{on_all_children_bits, on_all_drop_children_bits};
 use dataflow::{drop_flag_effects_for_location, on_lookup_result_bits};
 use dataflow::MoveDataParamEnv;
-use dataflow;
+use dataflow::{self, do_dataflow, DebugFormatted};
 use rustc::hir;
 use rustc::ty::{self, TyCtxt};
 use rustc::mir::*;
@@ -59,13 +59,13 @@ impl MirPass for ElaborateDrops {
             };
             let dead_unwinds = find_dead_unwinds(tcx, mir, id, &env);
             let flow_inits =
-                dataflow::do_dataflow(tcx, mir, id, &[], &dead_unwinds,
-                                      MaybeInitializedLvals::new(tcx, mir, &env),
-                                      |bd, p| &bd.move_data().move_paths[p]);
+                do_dataflow(tcx, mir, id, &[], &dead_unwinds,
+                            MaybeInitializedLvals::new(tcx, mir, &env),
+                            |bd, p| DebugFormatted::new(&bd.move_data().move_paths[p]));
             let flow_uninits =
-                dataflow::do_dataflow(tcx, mir, id, &[], &dead_unwinds,
-                                      MaybeUninitializedLvals::new(tcx, mir, &env),
-                                      |bd, p| &bd.move_data().move_paths[p]);
+                do_dataflow(tcx, mir, id, &[], &dead_unwinds,
+                            MaybeUninitializedLvals::new(tcx, mir, &env),
+                            |bd, p| DebugFormatted::new(&bd.move_data().move_paths[p]));
 
             ElaborateDropsCtxt {
                 tcx,
@@ -96,9 +96,9 @@ fn find_dead_unwinds<'a, 'tcx>(
     // reach cleanup blocks, which can't have unwind edges themselves.
     let mut dead_unwinds = IdxSetBuf::new_empty(mir.basic_blocks().len());
     let flow_inits =
-        dataflow::do_dataflow(tcx, mir, id, &[], &dead_unwinds,
-                           MaybeInitializedLvals::new(tcx, mir, &env),
-                           |bd, p| &bd.move_data().move_paths[p]);
+        do_dataflow(tcx, mir, id, &[], &dead_unwinds,
+                    MaybeInitializedLvals::new(tcx, mir, &env),
+                    |bd, p| DebugFormatted::new(&bd.move_data().move_paths[p]));
     for (bb, bb_data) in mir.basic_blocks().iter_enumerated() {
         let location = match bb_data.terminator().kind {
             TerminatorKind::Drop { ref location, unwind: Some(_), .. } |
diff --git a/src/librustc_mir/transform/generator.rs b/src/librustc_mir/transform/generator.rs
index aaa28634eb8..455a07c04cf 100644
--- a/src/librustc_mir/transform/generator.rs
+++ b/src/librustc_mir/transform/generator.rs
@@ -78,7 +78,7 @@ use std::mem;
 use transform::{MirPass, MirSource};
 use transform::simplify;
 use transform::no_landing_pads::no_landing_pads;
-use dataflow::{self, MaybeStorageLive, state_for_location};
+use dataflow::{do_dataflow, DebugFormatted, MaybeStorageLive, state_for_location};
 
 pub struct StateTransform;
 
@@ -341,8 +341,8 @@ fn locals_live_across_suspend_points<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
     let node_id = tcx.hir.as_local_node_id(source.def_id).unwrap();
     let analysis = MaybeStorageLive::new(mir);
     let storage_live =
-        dataflow::do_dataflow(tcx, mir, node_id, &[], &dead_unwinds, analysis,
-                              |bd, p| &bd.mir().local_decls[p]);
+        do_dataflow(tcx, mir, node_id, &[], &dead_unwinds, analysis,
+                    |bd, p| DebugFormatted::new(&bd.mir().local_decls[p]));
 
     let mut ignored = StorageIgnored(IdxSetBuf::new_filled(mir.local_decls.len()));
     ignored.visit_mir(mir);
diff --git a/src/librustc_mir/transform/rustc_peek.rs b/src/librustc_mir/transform/rustc_peek.rs
index 08508143976..6b8e2b073cc 100644
--- a/src/librustc_mir/transform/rustc_peek.rs
+++ b/src/librustc_mir/transform/rustc_peek.rs
@@ -18,7 +18,7 @@ use rustc_data_structures::indexed_set::IdxSetBuf;
 use rustc_data_structures::indexed_vec::Idx;
 use transform::{MirPass, MirSource};
 
-use dataflow::do_dataflow;
+use dataflow::{do_dataflow, DebugFormatted};
 use dataflow::MoveDataParamEnv;
 use dataflow::BitDenotation;
 use dataflow::DataflowResults;
@@ -51,15 +51,15 @@ impl MirPass for SanityCheck {
         let flow_inits =
             do_dataflow(tcx, mir, id, &attributes, &dead_unwinds,
                         MaybeInitializedLvals::new(tcx, mir, &mdpe),
-                        |bd, i| &bd.move_data().move_paths[i]);
+                        |bd, i| DebugFormatted::new(&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]);
+                        |bd, i| DebugFormatted::new(&bd.move_data().move_paths[i]));
         let flow_def_inits =
             do_dataflow(tcx, mir, id, &attributes, &dead_unwinds,
                         DefinitelyInitializedLvals::new(tcx, mir, &mdpe),
-                        |bd, i| &bd.move_data().move_paths[i]);
+                        |bd, i| DebugFormatted::new(&bd.move_data().move_paths[i]));
 
         if has_rustc_mir_with(&attributes, "rustc_peek_maybe_init").is_some() {
             sanity_check_via_rustc_peek(tcx, mir, id, &attributes, &flow_inits);
diff --git a/src/test/compile-fail/borrowck/two-phase-activation-sharing-interference.rs b/src/test/compile-fail/borrowck/two-phase-activation-sharing-interference.rs
new file mode 100644
index 00000000000..b6f5e17f1f6
--- /dev/null
+++ b/src/test/compile-fail/borrowck/two-phase-activation-sharing-interference.rs
@@ -0,0 +1,62 @@
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// revisions: lxl nll
+//[lxl]compile-flags: -Z borrowck=mir -Z two-phase-borrows
+//[nll]compile-flags: -Z borrowck=mir -Z two-phase-borrows -Z nll
+
+// This is an important corner case pointed out by Niko: one is
+// allowed to initiate a shared borrow during a reservation, but it
+// *must end* before the activation occurs.
+//
+// FIXME: for clarity, diagnostics for these cases might be better off
+// if they specifically said "cannot activate mutable borrow of `x`"
+
+#![allow(dead_code)]
+
+fn read(_: &i32) { }
+
+fn ok() {
+    let mut x = 3;
+    let y = &mut x;
+    { let z = &x; read(z); }
+    *y += 1;
+}
+
+fn not_ok() {
+    let mut x = 3;
+    let y = &mut x;
+    let z = &x;
+    *y += 1;
+    //[lxl]~^  ERROR cannot borrow `x` as mutable because it is also borrowed as immutable
+    //[nll]~^^ ERROR cannot borrow `x` as mutable because it is also borrowed as immutable
+    read(z);
+}
+
+fn should_be_ok_with_nll() {
+    let mut x = 3;
+    let y = &mut x;
+    let z = &x;
+    read(z);
+    *y += 1;
+    //[lxl]~^  ERROR cannot borrow `x` as mutable because it is also borrowed as immutable
+    // (okay with nll today)
+}
+
+fn should_also_eventually_be_ok_with_nll() {
+    let mut x = 3;
+    let y = &mut x;
+    let _z = &x;
+    *y += 1;
+    //[lxl]~^  ERROR cannot borrow `x` as mutable because it is also borrowed as immutable
+    //[nll]~^^ ERROR cannot borrow `x` as mutable because it is also borrowed as immutable
+}
+
+fn main() { }
diff --git a/src/test/compile-fail/borrowck/two-phase-allow-access-during-reservation.rs b/src/test/compile-fail/borrowck/two-phase-allow-access-during-reservation.rs
new file mode 100644
index 00000000000..7695bd3e465
--- /dev/null
+++ b/src/test/compile-fail/borrowck/two-phase-allow-access-during-reservation.rs
@@ -0,0 +1,37 @@
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// revisions: lxl nll
+//[lxl]compile-flags: -Z borrowck=mir -Z two-phase-borrows
+//[nll]compile-flags: -Z borrowck=mir -Z two-phase-borrows -Z nll
+
+// This is the second counter-example from Niko's blog post
+// smallcultfollowing.com/babysteps/blog/2017/03/01/nested-method-calls-via-two-phase-borrowing/
+//
+// It is "artificial". It is meant to illustrate directly that we
+// should allow an aliasing access during reservation, but *not* while
+// the mutable borrow is active.
+
+fn main() {
+    /*0*/ let mut i = 0;
+
+    /*1*/ let p = &mut i; // (reservation of `i` starts here)
+
+    /*2*/ let j = i;      // OK: `i` is only reserved here
+
+    /*3*/ *p += 1;        // (mutable borrow of `i` starts here, since `p` is used)
+
+    /*4*/ let k = i;      //[lxl]~  ERROR cannot use `i` because it was mutably borrowed [E0503]
+                          //[nll]~^ ERROR cannot use `i` because it was mutably borrowed [E0503]
+
+    /*5*/ *p += 1;
+
+    let _ = (j, k, p);
+}
diff --git a/src/test/compile-fail/borrowck/two-phase-cannot-nest-mut-self-calls.rs b/src/test/compile-fail/borrowck/two-phase-cannot-nest-mut-self-calls.rs
new file mode 100644
index 00000000000..01b04708599
--- /dev/null
+++ b/src/test/compile-fail/borrowck/two-phase-cannot-nest-mut-self-calls.rs
@@ -0,0 +1,34 @@
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// revisions: lxl nll
+//[lxl]compile-flags: -Z borrowck=mir -Z two-phase-borrows
+//[nll]compile-flags: -Z borrowck=mir -Z two-phase-borrows -Z nll
+
+// This is the third counter-example from Niko's blog post
+// smallcultfollowing.com/babysteps/blog/2017/03/01/nested-method-calls-via-two-phase-borrowing/
+//
+// It shows that not all nested method calls on `self` are magically
+// allowed by this change. In particular, a nested `&mut` borrow is
+// still disallowed.
+
+fn main() {
+
+
+    let mut vec = vec![0, 1];
+    vec.get({
+
+        vec.push(2);
+        //[lxl]~^ ERROR cannot borrow `vec` as mutable because it is also borrowed as immutable
+        //[nll]~^^   ERROR cannot borrow `vec` as mutable because it is also borrowed as immutable
+
+        0
+    });
+}
diff --git a/src/test/compile-fail/borrowck/two-phase-reservation-sharing-interference-2.rs b/src/test/compile-fail/borrowck/two-phase-reservation-sharing-interference-2.rs
new file mode 100644
index 00000000000..fc9100c8a9a
--- /dev/null
+++ b/src/test/compile-fail/borrowck/two-phase-reservation-sharing-interference-2.rs
@@ -0,0 +1,37 @@
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// revisions: lxl nll
+//[lxl]compile-flags: -Z borrowck=mir -Z two-phase-borrows
+//[nll]compile-flags: -Z borrowck=mir -Z two-phase-borrows -Z nll
+
+// This is similar to two-phase-reservation-sharing-interference.rs
+// in that it shows a reservation that overlaps with a shared borrow.
+//
+// Currently, this test fails with lexical lifetimes, but succeeds
+// with non-lexical lifetimes. (The reason is because the activation
+// of the mutable borrow ends up overlapping with a lexically-scoped
+// shared borrow; but a non-lexical shared borrow can end before the
+// activation occurs.)
+//
+// So this test is just making a note of the current behavior.
+
+#![feature(rustc_attrs)]
+
+#[rustc_error]
+fn main() { //[nll]~ ERROR compilation successful
+    let mut v = vec![0, 1, 2];
+    let shared = &v;
+
+    v.push(shared.len());
+    //[lxl]~^  ERROR cannot borrow `v` as mutable because it is also borrowed as immutable [E0502]
+
+    assert_eq!(v, [0, 1, 2, 3]);
+}
diff --git a/src/test/compile-fail/borrowck/two-phase-reservation-sharing-interference.rs b/src/test/compile-fail/borrowck/two-phase-reservation-sharing-interference.rs
new file mode 100644
index 00000000000..cc85315263a
--- /dev/null
+++ b/src/test/compile-fail/borrowck/two-phase-reservation-sharing-interference.rs
@@ -0,0 +1,46 @@
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// revisions: lxl nll
+//[lxl]compile-flags: -Z borrowck=mir -Z two-phase-borrows
+//[nll]compile-flags: -Z borrowck=mir -Z two-phase-borrows -Z nll
+
+// This is a corner case that the current implementation is (probably)
+// treating more conservatively than is necessary. But it also does
+// not seem like a terribly important use case to cover.
+//
+// So this test is just making a note of the current behavior, with
+// the caveat that in the future, the rules may be loosened, at which
+// point this test might be thrown out.
+
+fn main() {
+    let mut vec = vec![0, 1];
+    let delay: &mut Vec<_>;
+    {
+        let shared = &vec;
+
+        // we reserve here, which could (on its own) be compatible
+        // with the shared borrow. But in the current implementation,
+        // its an error.
+        delay = &mut vec;
+        //[lxl]~^ ERROR cannot borrow `vec` as mutable because it is also borrowed as immutable
+        //[nll]~^^   ERROR cannot borrow `vec` as mutable because it is also borrowed as immutable
+
+        shared[0];
+    }
+
+    // the &mut-borrow only becomes active way down here.
+    //
+    // (At least in theory; part of the reason this test fails is that
+    // the constructed MIR throws in extra &mut reborrows which
+    // flummoxes our attmpt to delay the activation point here.)
+    delay.push(2);
+}
+
diff --git a/src/test/compile-fail/borrowck/two-phase-sneaky.rs b/src/test/compile-fail/borrowck/two-phase-sneaky.rs
new file mode 100644
index 00000000000..32747407c67
--- /dev/null
+++ b/src/test/compile-fail/borrowck/two-phase-sneaky.rs
@@ -0,0 +1,30 @@
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// revisions: lxl nll
+//[lxl]compile-flags: -Z borrowck=mir -Z two-phase-borrows
+//[nll]compile-flags: -Z borrowck=mir -Z two-phase-borrows -Z nll
+
+// This is the first counter-example from Niko's blog post
+// smallcultfollowing.com/babysteps/blog/2017/03/01/nested-method-calls-via-two-phase-borrowing/
+// of a danger for code to crash if we just turned off the check for whether
+// a mutable-borrow aliases another borrow.
+
+fn main() {
+    let mut v: Vec<String> = vec![format!("Hello, ")];
+    v[0].push_str({
+
+        v.push(format!("foo"));
+        //[lxl]~^ ERROR cannot borrow `v` as mutable more than once at a time [E0499]
+        //[nll]~^^   ERROR cannot borrow `v` as mutable more than once at a time [E0499]
+
+        "World!"
+    });
+}
diff --git a/src/test/run-pass/borrowck/two-phase-baseline.rs b/src/test/run-pass/borrowck/two-phase-baseline.rs
new file mode 100644
index 00000000000..66234449263
--- /dev/null
+++ b/src/test/run-pass/borrowck/two-phase-baseline.rs
@@ -0,0 +1,21 @@
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// revisions: lxl nll
+//[lxl]compile-flags: -Z borrowck=mir -Z two-phase-borrows
+//[nll]compile-flags: -Z borrowck=mir -Z two-phase-borrows -Z nll
+
+// This is the "goto example" for why we want two phase borrows.
+
+fn main() {
+    let mut v = vec![0, 1, 2];
+    v.push(v.len());
+    assert_eq!(v, [0, 1, 2, 3]);
+}
diff --git a/src/test/run-pass/borrowck/two-phase-control-flow-split-before-activation.rs b/src/test/run-pass/borrowck/two-phase-control-flow-split-before-activation.rs
new file mode 100644
index 00000000000..a891e6072a7
--- /dev/null
+++ b/src/test/run-pass/borrowck/two-phase-control-flow-split-before-activation.rs
@@ -0,0 +1,27 @@
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// revisions: lxl nll
+//[lxl]compile-flags: -Z borrowck=mir -Z two-phase-borrows
+//[nll]compile-flags: -Z borrowck=mir -Z two-phase-borrows -Z nll
+
+fn main() {
+    let mut a = 0;
+    let mut b = 0;
+    let p = if maybe() {
+        &mut a
+    } else {
+        &mut b
+    };
+    use_(p);
+}
+
+fn maybe() -> bool { false }
+fn use_<T>(_: T) { }