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.)

Author: bors

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>,

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,

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()

src/librustc_driver/pretty.rs

@@ -423,24 +423,28 @@ 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()?;
                 s.synth_comment(id.to_string())
             }
             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))
             }
         }
     }

src/librustc_mir/borrow_check/error_reporting.rs

@@ -11,15 +11,15 @@
 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;
 
 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);

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("] ");

src/librustc_mir/borrow_check/mod.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,
         };

src/librustc_mir/dataflow/at_location.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<()>
         {

src/librustc_mir/dataflow/graphviz.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

src/librustc_mir/dataflow/impls/borrows.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

src/librustc_mir/dataflow/impls/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;

src/librustc_mir/dataflow/impls/storage_liveness.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(_), .. } |

src/librustc_mir/dataflow/mod.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);

src/librustc_mir/dataflow/move_paths/mod.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);

src/librustc_mir/transform/elaborate_drops.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() { }

src/librustc_mir/transform/generator.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);
+}

src/librustc_mir/transform/rustc_peek.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
+    });
+}

src/test/compile-fail/borrowck/two-phase-activation-sharing-interference.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]);
+}

src/test/compile-fail/borrowck/two-phase-allow-access-during-reservation.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);
+}
+

src/test/compile-fail/borrowck/two-phase-cannot-nest-mut-self-calls.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!"
+    });
+}

src/test/compile-fail/borrowck/two-phase-reservation-sharing-interference-2.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]);
+}

src/test/compile-fail/borrowck/two-phase-reservation-sharing-interference.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) { }