Auto merge of #43108 - pnkfelix:mir-borrowck3c, r=arielb1

MIR borrow check (under debug flag)

Here is the current state of MIR borrow check.

It consists of (1.) some refactoring, (2.) a dataflow analysis to identify the borrows themselves, and (3.) a mir "transform" that does the borrow check itself based on the aforementioned dataflow results.

(There's also a drive-by fix to dataflow that I can factor into a separate PR if necessary. Interestingly I could not find a way to observe the bug outside of MIR borrowck.)

To be clear, this branch is not ready to be used as the default borrow check. Thus the code is guarded: To get mir-borrowck to run, you need to either supply an attribute `#[rustc_mir_borrowck]` or a debug flag `-Z borrowck-mir`.

Here are the main issues with the current MIR borrowck as it stands in this PR:

 * No Notes emitted yet, just errors. (So the feedback is definitely inferior compared to AST borrowck today)
 * Lvalue rendering differs between Ast and Mir. (Mostly minor, but replacement of field names with indices is very bad; big priority for me to fix ASAP.)
 * Lots of ICEs (presumably because some MIR operations used here have well-formedness assumptions that are violated in borrowck-broken code)
 * Conflates lots of cases that are distinguished by AST-borrowck
 * Conflates "uninitialized" with "moved" (special case of previous bullet, one that I think should be fixed ASAP)

 (I am hoping to fix as many of the above issues as I can in the near term, but I also would like to land this even if they are *not* all fixed, because the rebasing effort is getting to be a real drag.)

Author: bors

src/Cargo.lock

@@ -918,6 +918,8 @@ options! {DebuggingOptions, DebuggingSetter, basic_debugging_options,
         "when debug-printing compiler state, do not include spans"), // o/w tests have closure@path
     identify_regions: bool = (false, parse_bool, [UNTRACKED],
         "make unnamed regions display as '# (where # is some non-ident unique id)"),
+    borrowck_mir: bool = (false, parse_bool, [UNTRACKED],
+        "implicitly treat functions as if they have `#[rustc_mir_borrowck]` attribute"),
     time_passes: bool = (false, parse_bool, [UNTRACKED],
         "measure time of each rustc pass"),
     count_llvm_insns: bool = (false, parse_bool,

src/librustc/session/config.rs

@@ -29,6 +29,7 @@ use rustc::ty::{self, TyCtxt};
 use syntax::ast;
 use syntax_pos::Span;
 use rustc::hir;
+use rustc_mir::util::borrowck_errors::{BorrowckErrors, Origin};
 
 use std::rc::Rc;
 
@@ -465,10 +466,8 @@ impl<'a, 'tcx> CheckLoanCtxt<'a, 'tcx> {
 
             let mut err = match (new_loan.kind, old_loan.kind) {
                 (ty::MutBorrow, ty::MutBorrow) => {
-                    let mut err = struct_span_err!(self.bccx, new_loan.span, E0499,
-                                                      "cannot borrow `{}`{} as mutable \
-                                                      more than once at a time",
-                                                      nl, new_loan_msg);
+                    let mut err = self.bccx.cannot_mutably_borrow_multiply(
+                        new_loan.span, &nl, &new_loan_msg, Origin::Ast);
 
                     if new_loan.span == old_loan.span {
                         // Both borrows are happening in the same place
@@ -496,10 +495,8 @@ impl<'a, 'tcx> CheckLoanCtxt<'a, 'tcx> {
                 }
 
                 (ty::UniqueImmBorrow, ty::UniqueImmBorrow) => {
-                    let mut err = struct_span_err!(self.bccx, new_loan.span, E0524,
-                                     "two closures require unique access to `{}` \
-                                      at the same time",
-                                     nl);
+                    let mut err = self.bccx.cannot_uniquely_borrow_by_two_closures(
+                        new_loan.span, &nl, Origin::Ast);
                     err.span_label(
                             old_loan.span,
                             "first closure is constructed here");
@@ -513,10 +510,8 @@ impl<'a, 'tcx> CheckLoanCtxt<'a, 'tcx> {
                 }
 
                 (ty::UniqueImmBorrow, _) => {
-                    let mut err = struct_span_err!(self.bccx, new_loan.span, E0500,
-                                                   "closure requires unique access to `{}` \
-                                                   but {} is already borrowed{}",
-                                                   nl, ol_pronoun, old_loan_msg);
+                    let mut err = self.bccx.cannot_uniquely_borrow_by_one_closure(
+                        new_loan.span, &nl, &ol_pronoun, &old_loan_msg, Origin::Ast);
                     err.span_label(
                             new_loan.span,
                             format!("closure construction occurs here{}", new_loan_msg));
@@ -530,10 +525,9 @@ impl<'a, 'tcx> CheckLoanCtxt<'a, 'tcx> {
                 }
 
                 (_, ty::UniqueImmBorrow) => {
-                    let mut err = struct_span_err!(self.bccx, new_loan.span, E0501,
-                                                   "cannot borrow `{}`{} as {} because \
-                                                   previous closure requires unique access",
-                                                   nl, new_loan_msg, new_loan.kind.to_user_str());
+                    let new_loan_str = &new_loan.kind.to_user_str();
+                    let mut err = self.bccx.cannot_reborrow_already_uniquely_borrowed(
+                        new_loan.span, &nl, &new_loan_msg, new_loan_str, Origin::Ast);
                     err.span_label(
                             new_loan.span,
                             format!("borrow occurs here{}", new_loan_msg));
@@ -547,15 +541,10 @@ impl<'a, 'tcx> CheckLoanCtxt<'a, 'tcx> {
                 }
 
                 (..) => {
-                    let mut err = struct_span_err!(self.bccx, new_loan.span, E0502,
-                                                   "cannot borrow `{}`{} as {} because \
-                                                   {} is also borrowed as {}{}",
-                                                   nl,
-                                                   new_loan_msg,
-                                                   new_loan.kind.to_user_str(),
-                                                   ol_pronoun,
-                                                   old_loan.kind.to_user_str(),
-                                                   old_loan_msg);
+                    let mut err = self.bccx.cannot_reborrow_already_borrowed(
+                        new_loan.span,
+                        &nl, &new_loan_msg, &new_loan.kind.to_user_str(),
+                        &ol_pronoun, &old_loan.kind.to_user_str(), &old_loan_msg, Origin::Ast);
                     err.span_label(
                             new_loan.span,
                             format!("{} borrow occurs here{}",
@@ -645,9 +634,8 @@ impl<'a, 'tcx> CheckLoanCtxt<'a, 'tcx> {
         match self.analyze_restrictions_on_use(id, copy_path, ty::ImmBorrow) {
             UseOk => { }
             UseWhileBorrowed(loan_path, loan_span) => {
-                struct_span_err!(self.bccx, span, E0503,
-                                 "cannot use `{}` because it was mutably borrowed",
-                                 &self.bccx.loan_path_to_string(copy_path))
+                let desc = self.bccx.loan_path_to_string(copy_path);
+                self.bccx.cannot_use_when_mutably_borrowed(span, &desc, Origin::Ast)
                     .span_label(loan_span,
                                format!("borrow of `{}` occurs here",
                                        &self.bccx.loan_path_to_string(&loan_path))
@@ -673,9 +661,8 @@ impl<'a, 'tcx> CheckLoanCtxt<'a, 'tcx> {
             UseWhileBorrowed(loan_path, loan_span) => {
                 let mut err = match move_kind {
                     move_data::Captured => {
-                        let mut err = struct_span_err!(self.bccx, span, E0504,
-                                         "cannot move `{}` into closure because it is borrowed",
-                                         &self.bccx.loan_path_to_string(move_path));
+                        let mut err = self.bccx.cannot_move_into_closure(
+                            span, &self.bccx.loan_path_to_string(move_path), Origin::Ast);
                         err.span_label(
                             loan_span,
                             format!("borrow of `{}` occurs here",
@@ -690,9 +677,8 @@ impl<'a, 'tcx> CheckLoanCtxt<'a, 'tcx> {
                     move_data::Declared |
                     move_data::MoveExpr |
                     move_data::MovePat => {
-                        let mut err = struct_span_err!(self.bccx, span, E0505,
-                                         "cannot move out of `{}` because it is borrowed",
-                                         &self.bccx.loan_path_to_string(move_path));
+                        let desc = self.bccx.loan_path_to_string(move_path);
+                        let mut err = self.bccx.cannot_move_when_borrowed(span, &desc, Origin::Ast);
                         err.span_label(
                             loan_span,
                             format!("borrow of `{}` occurs here",
@@ -874,9 +860,8 @@ impl<'a, 'tcx> CheckLoanCtxt<'a, 'tcx> {
                                    span: Span,
                                    loan_path: &LoanPath<'tcx>,
                                    loan: &Loan) {
-        struct_span_err!(self.bccx, span, E0506,
-                         "cannot assign to `{}` because it is borrowed",
-                         self.bccx.loan_path_to_string(loan_path))
+        self.bccx.cannot_assign_to_borrowed(
+            span, &self.bccx.loan_path_to_string(loan_path), Origin::Ast)
             .span_label(loan.span,
                        format!("borrow of `{}` occurs here",
                                self.bccx.loan_path_to_string(loan_path)))

src/librustc_borrowck/borrowck/check_loans.rs

@@ -37,6 +37,8 @@ use rustc::middle::free_region::RegionRelations;
 use rustc::ty::{self, TyCtxt};
 use rustc::ty::maps::Providers;
 
+use rustc_mir::util::borrowck_errors::{BorrowckErrors, Origin};
+
 use std::fmt;
 use std::rc::Rc;
 use std::hash::{Hash, Hasher};
@@ -218,6 +220,25 @@ pub struct BorrowckCtxt<'a, 'tcx: 'a> {
     owner_def_id: DefId,
 }
 
+impl<'b, 'tcx: 'b> BorrowckErrors for BorrowckCtxt<'b, 'tcx> {
+    fn struct_span_err_with_code<'a, S: Into<MultiSpan>>(&'a self,
+                                                         sp: S,
+                                                         msg: &str,
+                                                         code: &str)
+                                                         -> DiagnosticBuilder<'a>
+    {
+        self.tcx.sess.struct_span_err_with_code(sp, msg, code)
+    }
+
+    fn struct_span_err<'a, S: Into<MultiSpan>>(&'a self,
+                                               sp: S,
+                                               msg: &str)
+                                               -> DiagnosticBuilder<'a>
+    {
+        self.tcx.sess.struct_span_err(sp, msg)
+    }
+}
+
 ///////////////////////////////////////////////////////////////////////////
 // Loans and loan paths
 
@@ -549,14 +570,13 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> {
             move_data::Declared => {
                 // If this is an uninitialized variable, just emit a simple warning
                 // and return.
-                struct_span_err!(
-                    self.tcx.sess, use_span, E0381,
-                    "{} of possibly uninitialized variable: `{}`",
-                    verb,
-                    self.loan_path_to_string(lp))
-                .span_label(use_span, format!("use of possibly uninitialized `{}`",
-                    self.loan_path_to_string(lp)))
-                .emit();
+                self.cannot_act_on_uninitialized_variable(use_span,
+                                                          verb,
+                                                          &self.loan_path_to_string(lp),
+                                                          Origin::Ast)
+                    .span_label(use_span, format!("use of possibly uninitialized `{}`",
+                                                  self.loan_path_to_string(lp)))
+                    .emit();
                 return;
             }
             _ => {
@@ -683,10 +703,9 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> {
                                                 lp: &LoanPath<'tcx>,
                                                 assign:
                                                 &move_data::Assignment) {
-        let mut err = struct_span_err!(
-            self.tcx.sess, span, E0384,
-            "re-assignment of immutable variable `{}`",
-            self.loan_path_to_string(lp));
+        let mut err = self.cannot_reassign_immutable(span,
+                                                     &self.loan_path_to_string(lp),
+                                                     Origin::Ast);
         err.span_label(span, "re-assignment of immutable variable");
         if span != assign.span {
             err.span_label(assign.span, format!("first assignment to `{}`",

src/librustc_borrowck/borrowck/mod.rs

@@ -153,4 +153,68 @@ impl<T: Idx> IdxSet<T> {
     pub fn subtract(&mut self, other: &IdxSet<T>) -> bool {
         bitwise(self.words_mut(), other.words(), &Subtract)
     }
+
+    /// Calls `f` on each index value held in this set, up to the
+    /// bound `max_bits` on the size of universe of indexes.
+    pub fn each_bit<F>(&self, max_bits: usize, f: F) where F: FnMut(T) {
+        each_bit(self, max_bits, f)
+    }
+
+    /// Removes all elements from this set.
+    pub fn reset_to_empty(&mut self) {
+        for word in self.words_mut() { *word = 0; }
+    }
+
+    pub fn elems(&self, universe_size: usize) -> Elems<T> {
+        Elems { i: 0, set: self, universe_size: universe_size }
+    }
+}
+
+pub struct Elems<'a, T: Idx> { i: usize, set: &'a IdxSet<T>, universe_size: usize }
+
+impl<'a, T: Idx> Iterator for Elems<'a, T> {
+    type Item = T;
+    fn next(&mut self) -> Option<T> {
+        if self.i >= self.universe_size { return None; }
+        let mut i = self.i;
+        loop {
+            if i >= self.universe_size {
+                self.i = i; // (mark iteration as complete.)
+                return None;
+            }
+            if self.set.contains(&T::new(i)) {
+                self.i = i + 1; // (next element to start at.)
+                return Some(T::new(i));
+            }
+            i = i + 1;
+        }
+    }
+}
+
+fn each_bit<T: Idx, F>(words: &IdxSet<T>, max_bits: usize, mut f: F) where F: FnMut(T) {
+    let usize_bits: usize = mem::size_of::<usize>() * 8;
+
+    for (word_index, &word) in words.words().iter().enumerate() {
+        if word != 0 {
+            let base_index = word_index * usize_bits;
+            for offset in 0..usize_bits {
+                let bit = 1 << offset;
+                if (word & bit) != 0 {
+                    // NB: we round up the total number of bits
+                    // that we store in any given bit set so that
+                    // it is an even multiple of usize::BITS. This
+                    // means that there may be some stray bits at
+                    // the end that do not correspond to any
+                    // actual value; that's why we first check
+                    // that we are in range of bits_per_block.
+                    let bit_index = base_index + offset as usize;
+                    if bit_index >= max_bits {
+                        return;
+                    } else {
+                        f(Idx::new(bit_index));
+                    }
+                }
+            }
+        }
+    }
 }

src/librustc_borrowck/diagnostics.rs

@@ -970,14 +970,23 @@ pub fn phase_3_run_analysis_passes<'tcx, F, R>(sess: &'tcx Session,
     // We compute "constant qualifications" between MIR_CONST and MIR_VALIDATED.
 
     // What we need to run borrowck etc.
+
     passes.push_pass(MIR_VALIDATED, mir::transform::qualify_consts::QualifyAndPromoteConstants);
+
+    // FIXME: ariel points SimplifyBranches should run after
+    // mir-borrowck; otherwise code within `if false { ... }` would
+    // not be checked.
     passes.push_pass(MIR_VALIDATED,
                      mir::transform::simplify_branches::SimplifyBranches::new("initial"));
     passes.push_pass(MIR_VALIDATED, mir::transform::simplify::SimplifyCfg::new("qualify-consts"));
     passes.push_pass(MIR_VALIDATED, mir::transform::nll::NLL);
 
     // borrowck runs between MIR_VALIDATED and MIR_OPTIMIZED.
 
+    // FIXME: niko says this should be a query (see rustc::ty::maps)
+    // instead of a pass.
+    passes.push_pass(MIR_VALIDATED, mir::transform::borrow_check::BorrowckMir);
+
     // These next passes must be executed together
     passes.push_pass(MIR_OPTIMIZED, mir::transform::no_landing_pads::NoLandingPads);
     passes.push_pass(MIR_OPTIMIZED, mir::transform::add_call_guards::CriticalCallEdges);

src/librustc_data_structures/indexed_set.rs

@@ -15,6 +15,7 @@ rustc = { path = "../librustc" }
 rustc_const_eval = { path = "../librustc_const_eval" }
 rustc_const_math = { path = "../librustc_const_math" }
 rustc_data_structures = { path = "../librustc_data_structures" }
+rustc_errors = { path = "../librustc_errors" }
 rustc_bitflags = { path = "../librustc_bitflags" }
 syntax = { path = "../libsyntax" }
 syntax_pos = { path = "../libsyntax_pos" }

src/librustc_driver/driver.rs

@@ -8,84 +8,16 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use syntax::ast::{self, MetaItem};
 use syntax_pos::DUMMY_SP;
 
-
-use rustc::mir::{self, Mir, BasicBlock, Location};
-use rustc::session::Session;
+use rustc::mir::{self, Mir, Location};
 use rustc::ty::{self, TyCtxt};
 use util::elaborate_drops::DropFlagState;
-use rustc_data_structures::indexed_set::{IdxSet};
-
-use std::fmt;
 
-use super::{Dataflow, DataflowBuilder, DataflowAnalysis};
-use super::{BitDenotation, DataflowOperator, DataflowResults};
+use super::{MoveDataParamEnv};
 use super::indexes::MovePathIndex;
 use super::move_paths::{MoveData, LookupResult};
 
-pub(crate) fn has_rustc_mir_with(attrs: &[ast::Attribute], name: &str) -> Option<MetaItem> {
-    for attr in attrs {
-        if attr.check_name("rustc_mir") {
-            let items = attr.meta_item_list();
-            for item in items.iter().flat_map(|l| l.iter()) {
-                match item.meta_item() {
-                    Some(mi) if mi.check_name(name) => return Some(mi.clone()),
-                    _ => continue
-                }
-            }
-        }
-    }
-    return None;
-}
-
-pub struct MoveDataParamEnv<'tcx> {
-    pub(crate) move_data: MoveData<'tcx>,
-    pub(crate) param_env: ty::ParamEnv<'tcx>,
-}
-
-pub(crate) fn do_dataflow<'a, 'tcx, BD, P>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
-                                mir: &Mir<'tcx>,
-                                node_id: ast::NodeId,
-                                attributes: &[ast::Attribute],
-                                dead_unwinds: &IdxSet<BasicBlock>,
-                                bd: BD,
-                                p: P)
-                                -> DataflowResults<BD>
-    where BD: BitDenotation<Idx=MovePathIndex> + DataflowOperator,
-          P: Fn(&BD, BD::Idx) -> &fmt::Debug
-{
-    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;
-    };
-
-    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),
-    };
-
-    mbcx.dataflow(p);
-    mbcx.flow_state.results()
-}
-
 pub fn move_path_children_matching<'tcx, F>(move_data: &MoveData<'tcx>,
                                         path: MovePathIndex,
                                         mut cond: F)

src/librustc_mir/Cargo.toml

@@ -13,7 +13,6 @@
 use syntax::ast::NodeId;
 use rustc::mir::{BasicBlock, Mir};
 use rustc_data_structures::bitslice::bits_to_string;
-use rustc_data_structures::indexed_set::{IdxSet};
 use rustc_data_structures::indexed_vec::Idx;
 
 use dot;
@@ -24,62 +23,13 @@ use std::fs::File;
 use std::io;
 use std::io::prelude::*;
 use std::marker::PhantomData;
-use std::mem;
 use std::path::Path;
 
 use util;
 
 use super::{BitDenotation, DataflowState};
 use super::DataflowBuilder;
 
-impl<O: BitDenotation> DataflowState<O> {
-    fn each_bit<F>(&self, words: &IdxSet<O::Idx>, mut f: F)
-        where F: FnMut(O::Idx) {
-        //! Helper for iterating over the bits in a bitvector.
-
-        let bits_per_block = self.operator.bits_per_block();
-        let usize_bits: usize = mem::size_of::<usize>() * 8;
-
-        for (word_index, &word) in words.words().iter().enumerate() {
-            if word != 0 {
-                let base_index = word_index * usize_bits;
-                for offset in 0..usize_bits {
-                    let bit = 1 << offset;
-                    if (word & bit) != 0 {
-                        // NB: we round up the total number of bits
-                        // that we store in any given bit set so that
-                        // it is an even multiple of usize::BITS. This
-                        // means that there may be some stray bits at
-                        // the end that do not correspond to any
-                        // actual value; that's why we first check
-                        // that we are in range of bits_per_block.
-                        let bit_index = base_index + offset as usize;
-                        if bit_index >= bits_per_block {
-                            return;
-                        } else {
-                            f(O::Idx::new(bit_index));
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    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
-    {
-        let mut v = Vec::new();
-        self.each_bit(words, |i| {
-            v.push(render_idx(o, i));
-        });
-        v
-    }
-}
-
 pub trait MirWithFlowState<'tcx> {
     type BD: BitDenotation;
     fn node_id(&self) -> NodeId;

src/librustc_mir/dataflow/drop_flag_effects.rs

@@ -0,0 +1,180 @@
+// Copyright 2012-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.
+
+use rustc::mir::{self, Location, Mir};
+use rustc::mir::visit::Visitor;
+use rustc::ty::{Region, TyCtxt};
+use rustc::ty::RegionKind::ReScope;
+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 dataflow::{BitDenotation, BlockSets, DataflowOperator};
+pub use dataflow::indexes::BorrowIndex;
+
+use std::fmt;
+
+// `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.
+pub struct Borrows<'a, 'tcx: 'a> {
+    tcx: TyCtxt<'a, 'tcx, 'tcx>,
+    mir: &'a Mir<'tcx>,
+    borrows: IndexVec<BorrowIndex, BorrowData<'tcx>>,
+    location_map: FxHashMap<Location, BorrowIndex>,
+    region_map: FxHashMap<Region<'tcx>, FxHashSet<BorrowIndex>>,
+}
+
+// temporarily allow some dead fields: `kind` and `region` will be
+// needed by borrowck; `lvalue` will probably be a MovePathIndex when
+// that is extended to include borrowed data paths.
+#[allow(dead_code)]
+#[derive(Debug)]
+pub struct BorrowData<'tcx> {
+    pub(crate) location: Location,
+    pub(crate) kind: mir::BorrowKind,
+    pub(crate) region: Region<'tcx>,
+    pub(crate) lvalue: mir::Lvalue<'tcx>,
+}
+
+impl<'tcx> fmt::Display for BorrowData<'tcx> {
+    fn fmt(&self, w: &mut fmt::Formatter) -> fmt::Result {
+        let kind = match self.kind {
+            mir::BorrowKind::Shared => "",
+            mir::BorrowKind::Unique => "uniq ",
+            mir::BorrowKind::Mut => "mut ",
+        };
+        let region = format!("{}", self.region);
+        let region = if region.len() > 0 { format!("{} ", region) } else { region };
+        write!(w, "&{}{}{:?}", region, kind, self.lvalue)
+    }
+}
+
+impl<'a, 'tcx> Borrows<'a, 'tcx> {
+    pub fn new(tcx: TyCtxt<'a, 'tcx, 'tcx>, mir: &'a Mir<'tcx>) -> Self {
+        let mut visitor = GatherBorrows { idx_vec: IndexVec::new(),
+                                          location_map: FxHashMap(),
+                                          region_map: FxHashMap(), };
+        visitor.visit_mir(mir);
+        return Borrows { tcx: tcx,
+                         mir: mir,
+                         borrows: visitor.idx_vec,
+                         location_map: visitor.location_map,
+                         region_map: visitor.region_map, };
+
+        struct GatherBorrows<'tcx> {
+            idx_vec: IndexVec<BorrowIndex, BorrowData<'tcx>>,
+            location_map: FxHashMap<Location, BorrowIndex>,
+            region_map: FxHashMap<Region<'tcx>, FxHashSet<BorrowIndex>>,
+        }
+        impl<'tcx> Visitor<'tcx> for GatherBorrows<'tcx> {
+            fn visit_rvalue(&mut self,
+                            rvalue: &mir::Rvalue<'tcx>,
+                            location: mir::Location) {
+                if let mir::Rvalue::Ref(region, kind, ref lvalue) = *rvalue {
+                    let borrow = BorrowData {
+                        location: location, kind: kind, region: region, lvalue: lvalue.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);
+                }
+            }
+        }
+    }
+
+    pub fn borrows(&self) -> &IndexVec<BorrowIndex, BorrowData<'tcx>> { &self.borrows }
+
+    pub fn location(&self, idx: BorrowIndex) -> &Location {
+        &self.borrows[idx].location
+    }
+}
+
+impl<'a, 'tcx> BitDenotation for Borrows<'a, '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 BlockSets<BorrowIndex>)  {
+        // no borrows of code extents 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) {
+        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 {:?}");
+        });
+        match stmt.kind {
+            mir::StatementKind::EndRegion(extent) => {
+                let borrow_indexes = self.region_map.get(&ReScope(extent)).unwrap_or_else(|| {
+                    panic!("could not find BorrowIndexs for code-extent {:?}", extent);
+                });
+
+                for idx in borrow_indexes { sets.kill(&idx); }
+            }
+
+            mir::StatementKind::Assign(_, ref rhs) => {
+                if let mir::Rvalue::Ref(region, _, _) = *rhs {
+                    let index = self.location_map.get(&location).unwrap_or_else(|| {
+                        panic!("could not find BorrowIndex for location {:?}", location);
+                    });
+                    assert!(self.region_map.get(region).unwrap_or_else(|| {
+                        panic!("could not find BorrowIndexs for region {:?}", region);
+                    }).contains(&index));
+                    sets.gen(&index);
+                }
+            }
+
+            mir::StatementKind::InlineAsm { .. } |
+            mir::StatementKind::SetDiscriminant { .. } |
+            mir::StatementKind::StorageLive(..) |
+            mir::StatementKind::StorageDead(..) |
+            mir::StatementKind::Validate(..) |
+            mir::StatementKind::Nop => {}
+
+        }
+    }
+    fn terminator_effect(&self,
+                         _sets: &mut BlockSets<BorrowIndex>,
+                         _location: Location) {
+        // no terminators start nor end code extents.
+    }
+
+    fn propagate_call_return(&self,
+                             _in_out: &mut IdxSet<BorrowIndex>,
+                             _call_bb: mir::BasicBlock,
+                             _dest_bb: mir::BasicBlock,
+                             _dest_lval: &mir::Lvalue) {
+        // there are no effects on the extents from method calls.
+    }
+}
+
+impl<'a, 'tcx> BitwiseOperator for Borrows<'a, 'tcx> {
+    #[inline]
+    fn join(&self, pred1: usize, pred2: usize) -> usize {
+        pred1 | pred2 // union effects of preds when computing borrows
+    }
+}
+
+impl<'a, 'tcx> DataflowOperator for Borrows<'a, 'tcx> {
+    #[inline]
+    fn bottom_value() -> bool {
+        false // bottom = no Rvalue::Refs are active by default
+    }
+}

src/librustc_mir/dataflow/graphviz.rs

@@ -30,6 +30,9 @@ use super::drop_flag_effects_for_function_entry;
 use super::drop_flag_effects_for_location;
 use super::on_lookup_result_bits;
 
+#[allow(dead_code)]
+pub(super) mod borrows;
+
 /// `MaybeInitializedLvals` tracks all l-values that might be
 /// initialized upon reaching a particular point in the control flow
 /// for a function.
@@ -287,24 +290,22 @@ impl<'a, 'tcx> BitDenotation for MaybeInitializedLvals<'a, 'tcx> {
 
     fn statement_effect(&self,
                         sets: &mut BlockSets<MovePathIndex>,
-                        bb: mir::BasicBlock,
-                        idx: usize)
+                        location: Location)
     {
         drop_flag_effects_for_location(
             self.tcx, self.mir, self.mdpe,
-            Location { block: bb, statement_index: idx },
+            location,
             |path, s| Self::update_bits(sets, path, s)
         )
     }
 
     fn terminator_effect(&self,
                          sets: &mut BlockSets<MovePathIndex>,
-                         bb: mir::BasicBlock,
-                         statements_len: usize)
+                         location: Location)
     {
         drop_flag_effects_for_location(
             self.tcx, self.mir, self.mdpe,
-            Location { block: bb, statement_index: statements_len },
+            location,
             |path, s| Self::update_bits(sets, path, s)
         )
     }
@@ -344,24 +345,22 @@ impl<'a, 'tcx> BitDenotation for MaybeUninitializedLvals<'a, 'tcx> {
 
     fn statement_effect(&self,
                         sets: &mut BlockSets<MovePathIndex>,
-                        bb: mir::BasicBlock,
-                        idx: usize)
+                        location: Location)
     {
         drop_flag_effects_for_location(
             self.tcx, self.mir, self.mdpe,
-            Location { block: bb, statement_index: idx },
+            location,
             |path, s| Self::update_bits(sets, path, s)
         )
     }
 
     fn terminator_effect(&self,
                          sets: &mut BlockSets<MovePathIndex>,
-                         bb: mir::BasicBlock,
-                         statements_len: usize)
+                         location: Location)
     {
         drop_flag_effects_for_location(
             self.tcx, self.mir, self.mdpe,
-            Location { block: bb, statement_index: statements_len },
+            location,
             |path, s| Self::update_bits(sets, path, s)
         )
     }
@@ -400,24 +399,22 @@ impl<'a, 'tcx> BitDenotation for DefinitelyInitializedLvals<'a, 'tcx> {
 
     fn statement_effect(&self,
                         sets: &mut BlockSets<MovePathIndex>,
-                        bb: mir::BasicBlock,
-                        idx: usize)
+                        location: Location)
     {
         drop_flag_effects_for_location(
             self.tcx, self.mir, self.mdpe,
-            Location { block: bb, statement_index: idx },
+            location,
             |path, s| Self::update_bits(sets, path, s)
         )
     }
 
     fn terminator_effect(&self,
                          sets: &mut BlockSets<MovePathIndex>,
-                         bb: mir::BasicBlock,
-                         statements_len: usize)
+                         location: Location)
     {
         drop_flag_effects_for_location(
             self.tcx, self.mir, self.mdpe,
-            Location { block: bb, statement_index: statements_len },
+            location,
             |path, s| Self::update_bits(sets, path, s)
         )
     }
@@ -448,18 +445,16 @@ impl<'a, 'tcx> BitDenotation for MovingOutStatements<'a, 'tcx> {
     }
     fn statement_effect(&self,
                         sets: &mut BlockSets<MoveOutIndex>,
-                        bb: mir::BasicBlock,
-                        idx: usize) {
+                        location: Location) {
         let (tcx, mir, move_data) = (self.tcx, self.mir, self.move_data());
-        let stmt = &mir[bb].statements[idx];
+        let stmt = &mir[location.block].statements[location.statement_index];
         let loc_map = &move_data.loc_map;
         let path_map = &move_data.path_map;
         let rev_lookup = &move_data.rev_lookup;
 
-        let loc = Location { block: bb, statement_index: idx };
         debug!("stmt {:?} at loc {:?} moves out of move_indexes {:?}",
-               stmt, loc, &loc_map[loc]);
-        for move_index in &loc_map[loc] {
+               stmt, location, &loc_map[location]);
+        for move_index in &loc_map[location] {
             // Every path deinitialized by a *particular move*
             // has corresponding bit, "gen'ed" (i.e. set)
             // here, in dataflow vector
@@ -506,17 +501,15 @@ impl<'a, 'tcx> BitDenotation for MovingOutStatements<'a, 'tcx> {
 
     fn terminator_effect(&self,
                          sets: &mut BlockSets<MoveOutIndex>,
-                         bb: mir::BasicBlock,
-                         statements_len: usize)
+                         location: Location)
     {
         let (mir, move_data) = (self.mir, self.move_data());
-        let term = mir[bb].terminator();
+        let term = mir[location.block].terminator();
         let loc_map = &move_data.loc_map;
-        let loc = Location { block: bb, statement_index: statements_len };
         debug!("terminator {:?} at loc {:?} moves out of move_indexes {:?}",
-               term, loc, &loc_map[loc]);
+               term, location, &loc_map[location]);
         let bits_per_block = self.bits_per_block();
-        for move_index in &loc_map[loc] {
+        for move_index in &loc_map[location] {
             assert!(move_index.index() < bits_per_block);
             zero_to_one(sets.gen_set.words_mut(), *move_index);
         }

src/librustc_mir/dataflow/impls/borrows.rs

@@ -0,0 +1,332 @@
+// 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.
+
+use rustc::ty::{self, TyCtxt};
+use rustc::mir::*;
+use rustc::mir::tcx::RvalueInitializationState;
+use rustc::util::nodemap::FxHashMap;
+use rustc_data_structures::indexed_vec::{IndexVec};
+
+use syntax::codemap::DUMMY_SP;
+
+use std::collections::hash_map::Entry;
+use std::mem;
+
+use super::abs_domain::Lift;
+
+use super::{LocationMap, MoveData, MovePath, MovePathLookup, MovePathIndex, MoveOut, MoveOutIndex};
+
+pub(super) struct MoveDataBuilder<'a, 'tcx: 'a> {
+    mir: &'a Mir<'tcx>,
+    tcx: TyCtxt<'a, 'tcx, 'tcx>,
+    param_env: ty::ParamEnv<'tcx>,
+    data: MoveData<'tcx>,
+}
+
+pub enum MovePathError {
+    IllegalMove,
+    UnionMove { path: MovePathIndex },
+}
+
+impl<'a, 'tcx> MoveDataBuilder<'a, 'tcx> {
+    fn new(mir: &'a Mir<'tcx>,
+           tcx: TyCtxt<'a, 'tcx, 'tcx>,
+           param_env: ty::ParamEnv<'tcx>)
+           -> Self {
+        let mut move_paths = IndexVec::new();
+        let mut path_map = IndexVec::new();
+
+        MoveDataBuilder {
+            mir,
+            tcx,
+            param_env,
+            data: MoveData {
+                moves: IndexVec::new(),
+                loc_map: LocationMap::new(mir),
+                rev_lookup: MovePathLookup {
+                    locals: mir.local_decls.indices().map(Lvalue::Local).map(|v| {
+                        Self::new_move_path(&mut move_paths, &mut path_map, None, v)
+                    }).collect(),
+                    projections: FxHashMap(),
+                },
+                move_paths,
+                path_map,
+            }
+        }
+    }
+
+    fn new_move_path(move_paths: &mut IndexVec<MovePathIndex, MovePath<'tcx>>,
+                     path_map: &mut IndexVec<MovePathIndex, Vec<MoveOutIndex>>,
+                     parent: Option<MovePathIndex>,
+                     lvalue: Lvalue<'tcx>)
+                     -> MovePathIndex
+    {
+        let move_path = move_paths.push(MovePath {
+            next_sibling: None,
+            first_child: None,
+            parent,
+            lvalue,
+        });
+
+        if let Some(parent) = parent {
+            let next_sibling =
+                mem::replace(&mut move_paths[parent].first_child, Some(move_path));
+            move_paths[move_path].next_sibling = next_sibling;
+        }
+
+        let path_map_ent = path_map.push(vec![]);
+        assert_eq!(path_map_ent, move_path);
+        move_path
+    }
+
+    /// This creates a MovePath for a given lvalue, returning an `MovePathError`
+    /// if that lvalue can't be moved from.
+    ///
+    /// NOTE: lvalues behind references *do not* get a move path, which is
+    /// problematic for borrowck.
+    ///
+    /// Maybe we should have separate "borrowck" and "moveck" modes.
+    fn move_path_for(&mut self, lval: &Lvalue<'tcx>)
+                     -> Result<MovePathIndex, MovePathError>
+    {
+        debug!("lookup({:?})", lval);
+        match *lval {
+            Lvalue::Local(local) => Ok(self.data.rev_lookup.locals[local]),
+            // error: can't move out of a static
+            Lvalue::Static(..) => Err(MovePathError::IllegalMove),
+            Lvalue::Projection(ref proj) => {
+                self.move_path_for_projection(lval, proj)
+            }
+        }
+    }
+
+    fn create_move_path(&mut self, lval: &Lvalue<'tcx>) {
+        // This is an assignment, not a move, so this not being a valid
+        // move path is OK.
+        let _ = self.move_path_for(lval);
+    }
+
+    fn move_path_for_projection(&mut self,
+                                lval: &Lvalue<'tcx>,
+                                proj: &LvalueProjection<'tcx>)
+                                -> Result<MovePathIndex, MovePathError>
+    {
+        let base = try!(self.move_path_for(&proj.base));
+        let lv_ty = proj.base.ty(self.mir, self.tcx).to_ty(self.tcx);
+        match lv_ty.sty {
+            // error: can't move out of borrowed content
+            ty::TyRef(..) | ty::TyRawPtr(..) => return Err(MovePathError::IllegalMove),
+            // error: can't move out of struct with destructor
+            ty::TyAdt(adt, _) if adt.has_dtor(self.tcx) && !adt.is_box() =>
+                return Err(MovePathError::IllegalMove),
+            // move out of union - always move the entire union
+            ty::TyAdt(adt, _) if adt.is_union() =>
+                return Err(MovePathError::UnionMove { path: base }),
+            // error: can't move out of a slice
+            ty::TySlice(..) =>
+                return Err(MovePathError::IllegalMove),
+            ty::TyArray(..) => match proj.elem {
+                // error: can't move out of an array
+                ProjectionElem::Index(..) => return Err(MovePathError::IllegalMove),
+                _ => {
+                    // FIXME: still badly broken
+                }
+            },
+            _ => {}
+        };
+        match self.data.rev_lookup.projections.entry((base, proj.elem.lift())) {
+            Entry::Occupied(ent) => Ok(*ent.get()),
+            Entry::Vacant(ent) => {
+                let path = Self::new_move_path(
+                    &mut self.data.move_paths,
+                    &mut self.data.path_map,
+                    Some(base),
+                    lval.clone()
+                );
+                ent.insert(path);
+                Ok(path)
+            }
+        }
+    }
+
+    fn finalize(self) -> MoveData<'tcx> {
+        debug!("{}", {
+            debug!("moves for {:?}:", self.mir.span);
+            for (j, mo) in self.data.moves.iter_enumerated() {
+                debug!("    {:?} = {:?}", j, mo);
+            }
+            debug!("move paths for {:?}:", self.mir.span);
+            for (j, path) in self.data.move_paths.iter_enumerated() {
+                debug!("    {:?} = {:?}", j, path);
+            }
+            "done dumping moves"
+        });
+        self.data
+    }
+}
+
+pub(super) fn gather_moves<'a, 'tcx>(mir: &Mir<'tcx>,
+                                     tcx: TyCtxt<'a, 'tcx, 'tcx>,
+                                     param_env: ty::ParamEnv<'tcx>)
+                                     -> MoveData<'tcx> {
+    let mut builder = MoveDataBuilder::new(mir, tcx, param_env);
+
+    for (bb, block) in mir.basic_blocks().iter_enumerated() {
+        for (i, stmt) in block.statements.iter().enumerate() {
+            let source = Location { block: bb, statement_index: i };
+            builder.gather_statement(source, stmt);
+        }
+
+        let terminator_loc = Location {
+            block: bb,
+            statement_index: block.statements.len()
+        };
+        builder.gather_terminator(terminator_loc, block.terminator());
+    }
+
+    builder.finalize()
+}
+
+impl<'a, 'tcx> MoveDataBuilder<'a, 'tcx> {
+    fn gather_statement(&mut self, loc: Location, stmt: &Statement<'tcx>) {
+        debug!("gather_statement({:?}, {:?})", loc, stmt);
+        match stmt.kind {
+            StatementKind::Assign(ref lval, ref rval) => {
+                self.create_move_path(lval);
+                if let RvalueInitializationState::Shallow = rval.initialization_state() {
+                    // Box starts out uninitialized - need to create a separate
+                    // move-path for the interior so it will be separate from
+                    // the exterior.
+                    self.create_move_path(&lval.clone().deref());
+                }
+                self.gather_rvalue(loc, rval);
+            }
+            StatementKind::StorageLive(_) |
+            StatementKind::StorageDead(_) => {}
+            StatementKind::SetDiscriminant{ .. } => {
+                span_bug!(stmt.source_info.span,
+                          "SetDiscriminant should not exist during borrowck");
+            }
+            StatementKind::InlineAsm { .. } |
+            StatementKind::EndRegion(_) |
+            StatementKind::Validate(..) |
+            StatementKind::Nop => {}
+        }
+    }
+
+    fn gather_rvalue(&mut self, loc: Location, rvalue: &Rvalue<'tcx>) {
+        match *rvalue {
+            Rvalue::Use(ref operand) |
+            Rvalue::Repeat(ref operand, _) |
+            Rvalue::Cast(_, ref operand, _) |
+            Rvalue::UnaryOp(_, ref operand) => {
+                self.gather_operand(loc, operand)
+            }
+            Rvalue::BinaryOp(ref _binop, ref lhs, ref rhs) |
+            Rvalue::CheckedBinaryOp(ref _binop, ref lhs, ref rhs) => {
+                self.gather_operand(loc, lhs);
+                self.gather_operand(loc, rhs);
+            }
+            Rvalue::Aggregate(ref _kind, ref operands) => {
+                for operand in operands {
+                    self.gather_operand(loc, operand);
+                }
+            }
+            Rvalue::Ref(..) |
+            Rvalue::Discriminant(..) |
+            Rvalue::Len(..) |
+            Rvalue::NullaryOp(NullOp::SizeOf, _) |
+            Rvalue::NullaryOp(NullOp::Box, _) => {
+                // This returns an rvalue with uninitialized contents. We can't
+                // move out of it here because it is an rvalue - assignments always
+                // completely initialize their lvalue.
+                //
+                // However, this does not matter - MIR building is careful to
+                // only emit a shallow free for the partially-initialized
+                // temporary.
+                //
+                // In any case, if we want to fix this, we have to register a
+                // special move and change the `statement_effect` functions.
+            }
+        }
+    }
+
+    fn gather_terminator(&mut self, loc: Location, term: &Terminator<'tcx>) {
+        debug!("gather_terminator({:?}, {:?})", loc, term);
+        match term.kind {
+            TerminatorKind::Goto { target: _ } |
+            TerminatorKind::Resume |
+            TerminatorKind::Unreachable => { }
+
+            TerminatorKind::Return => {
+                self.gather_move(loc, &Lvalue::Local(RETURN_POINTER));
+            }
+
+            TerminatorKind::Assert { .. } |
+            TerminatorKind::SwitchInt { .. } => {
+                // branching terminators - these don't move anything
+            }
+
+            TerminatorKind::Drop { ref location, target: _, unwind: _ } => {
+                self.gather_move(loc, location);
+            }
+            TerminatorKind::DropAndReplace { ref location, ref value, .. } => {
+                self.create_move_path(location);
+                self.gather_operand(loc, value);
+            }
+            TerminatorKind::Call { ref func, ref args, ref destination, cleanup: _ } => {
+                self.gather_operand(loc, func);
+                for arg in args {
+                    self.gather_operand(loc, arg);
+                }
+                if let Some((ref destination, _bb)) = *destination {
+                    self.create_move_path(destination);
+                }
+            }
+        }
+    }
+
+    fn gather_operand(&mut self, loc: Location, operand: &Operand<'tcx>) {
+        match *operand {
+            Operand::Constant(..) => {} // not-a-move
+            Operand::Consume(ref lval) => { // a move
+                self.gather_move(loc, lval);
+            }
+        }
+    }
+
+    fn gather_move(&mut self, loc: Location, lval: &Lvalue<'tcx>) {
+        debug!("gather_move({:?}, {:?})", loc, lval);
+
+        let lv_ty = lval.ty(self.mir, self.tcx).to_ty(self.tcx);
+        if !lv_ty.moves_by_default(self.tcx, self.param_env, DUMMY_SP) {
+            debug!("gather_move({:?}, {:?}) - {:?} is Copy. skipping", loc, lval, lv_ty);
+            return
+        }
+
+        let path = match self.move_path_for(lval) {
+            Ok(path) | Err(MovePathError::UnionMove { path }) => path,
+            Err(MovePathError::IllegalMove) => {
+                // Moving out of a bad path. Eventually, this should be a MIR
+                // borrowck error instead of a bug.
+                span_bug!(self.mir.span,
+                          "Broken MIR: moving out of lvalue {:?}: {:?} at {:?}",
+                          lval, lv_ty, loc);
+            }
+        };
+        let move_out = self.data.moves.push(MoveOut { path: path, source: loc });
+
+        debug!("gather_move({:?}, {:?}): adding move {:?} of {:?}",
+               loc, lval, move_out, path);
+
+        self.data.path_map[path].push(move_out);
+        self.data.loc_map[loc].push(move_out);
+    }
+}

src/librustc_mir/dataflow/impls/mod.rs

@@ -11,15 +11,10 @@
 
 use rustc::ty::{self, TyCtxt};
 use rustc::mir::*;
-use rustc::mir::tcx::RvalueInitializationState;
 use rustc::util::nodemap::FxHashMap;
 use rustc_data_structures::indexed_vec::{IndexVec};
 
-use syntax::codemap::DUMMY_SP;
-
-use std::collections::hash_map::Entry;
 use std::fmt;
-use std::mem;
 use std::ops::{Index, IndexMut};
 
 use self::abs_domain::{AbstractElem, Lift};
@@ -63,6 +58,9 @@ pub(crate) mod indexes {
 
     /// Index into MoveData.moves.
     new_index!(MoveOutIndex, "mo");
+
+    /// Index into Borrows.locations
+    new_index!(BorrowIndex, "bw");
 }
 
 pub use self::indexes::MovePathIndex;
@@ -110,6 +108,12 @@ impl<'tcx> fmt::Debug for MovePath<'tcx> {
     }
 }
 
+impl<'tcx> fmt::Display for MovePath<'tcx> {
+    fn fmt(&self, w: &mut fmt::Formatter) -> fmt::Result {
+        write!(w, "{:?}", self.lvalue)
+    }
+}
+
 #[derive(Debug)]
 pub struct MoveData<'tcx> {
     pub move_paths: IndexVec<MovePathIndex, MovePath<'tcx>>,
@@ -191,154 +195,7 @@ pub struct MovePathLookup<'tcx> {
     projections: FxHashMap<(MovePathIndex, AbstractElem<'tcx>), MovePathIndex>
 }
 
-pub(super) struct MoveDataBuilder<'a, 'tcx: 'a> {
-    mir: &'a Mir<'tcx>,
-    tcx: TyCtxt<'a, 'tcx, 'tcx>,
-    param_env: ty::ParamEnv<'tcx>,
-    data: MoveData<'tcx>,
-}
-
-pub enum MovePathError {
-    IllegalMove,
-    UnionMove { path: MovePathIndex },
-}
-
-impl<'a, 'tcx> MoveDataBuilder<'a, 'tcx> {
-    fn new(mir: &'a Mir<'tcx>,
-           tcx: TyCtxt<'a, 'tcx, 'tcx>,
-           param_env: ty::ParamEnv<'tcx>)
-           -> Self {
-        let mut move_paths = IndexVec::new();
-        let mut path_map = IndexVec::new();
-
-        MoveDataBuilder {
-            mir,
-            tcx,
-            param_env,
-            data: MoveData {
-                moves: IndexVec::new(),
-                loc_map: LocationMap::new(mir),
-                rev_lookup: MovePathLookup {
-                    locals: mir.local_decls.indices().map(Lvalue::Local).map(|v| {
-                        Self::new_move_path(&mut move_paths, &mut path_map, None, v)
-                    }).collect(),
-                    projections: FxHashMap(),
-                },
-                move_paths,
-                path_map,
-            }
-        }
-    }
-
-    fn new_move_path(move_paths: &mut IndexVec<MovePathIndex, MovePath<'tcx>>,
-                     path_map: &mut IndexVec<MovePathIndex, Vec<MoveOutIndex>>,
-                     parent: Option<MovePathIndex>,
-                     lvalue: Lvalue<'tcx>)
-                     -> MovePathIndex
-    {
-        let move_path = move_paths.push(MovePath {
-            next_sibling: None,
-            first_child: None,
-            parent,
-            lvalue,
-        });
-
-        if let Some(parent) = parent {
-            let next_sibling =
-                mem::replace(&mut move_paths[parent].first_child, Some(move_path));
-            move_paths[move_path].next_sibling = next_sibling;
-        }
-
-        let path_map_ent = path_map.push(vec![]);
-        assert_eq!(path_map_ent, move_path);
-        move_path
-    }
-
-    /// This creates a MovePath for a given lvalue, returning an `MovePathError`
-    /// if that lvalue can't be moved from.
-    ///
-    /// NOTE: lvalues behind references *do not* get a move path, which is
-    /// problematic for borrowck.
-    ///
-    /// Maybe we should have separate "borrowck" and "moveck" modes.
-    fn move_path_for(&mut self, lval: &Lvalue<'tcx>)
-                     -> Result<MovePathIndex, MovePathError>
-    {
-        debug!("lookup({:?})", lval);
-        match *lval {
-            Lvalue::Local(local) => Ok(self.data.rev_lookup.locals[local]),
-            // error: can't move out of a static
-            Lvalue::Static(..) => Err(MovePathError::IllegalMove),
-            Lvalue::Projection(ref proj) => {
-                self.move_path_for_projection(lval, proj)
-            }
-        }
-    }
-
-    fn create_move_path(&mut self, lval: &Lvalue<'tcx>) {
-        // This is an assignment, not a move, so this not being a valid
-        // move path is OK.
-        let _ = self.move_path_for(lval);
-    }
-
-    fn move_path_for_projection(&mut self,
-                                lval: &Lvalue<'tcx>,
-                                proj: &LvalueProjection<'tcx>)
-                                -> Result<MovePathIndex, MovePathError>
-    {
-        let base = try!(self.move_path_for(&proj.base));
-        let lv_ty = proj.base.ty(self.mir, self.tcx).to_ty(self.tcx);
-        match lv_ty.sty {
-            // error: can't move out of borrowed content
-            ty::TyRef(..) | ty::TyRawPtr(..) => return Err(MovePathError::IllegalMove),
-            // error: can't move out of struct with destructor
-            ty::TyAdt(adt, _) if adt.has_dtor(self.tcx) && !adt.is_box() =>
-                return Err(MovePathError::IllegalMove),
-            // move out of union - always move the entire union
-            ty::TyAdt(adt, _) if adt.is_union() =>
-                return Err(MovePathError::UnionMove { path: base }),
-            // error: can't move out of a slice
-            ty::TySlice(..) =>
-                return Err(MovePathError::IllegalMove),
-            ty::TyArray(..) => match proj.elem {
-                // error: can't move out of an array
-                ProjectionElem::Index(..) => return Err(MovePathError::IllegalMove),
-                _ => {
-                    // FIXME: still badly broken
-                }
-            },
-            _ => {}
-        };
-        match self.data.rev_lookup.projections.entry((base, proj.elem.lift())) {
-            Entry::Occupied(ent) => Ok(*ent.get()),
-            Entry::Vacant(ent) => {
-                let path = Self::new_move_path(
-                    &mut self.data.move_paths,
-                    &mut self.data.path_map,
-                    Some(base),
-                    lval.clone()
-                );
-                ent.insert(path);
-                Ok(path)
-            }
-        }
-    }
-
-    fn finalize(self) -> MoveData<'tcx> {
-        debug!("{}", {
-            debug!("moves for {:?}:", self.mir.span);
-            for (j, mo) in self.data.moves.iter_enumerated() {
-                debug!("    {:?} = {:?}", j, mo);
-            }
-            debug!("move paths for {:?}:", self.mir.span);
-            for (j, path) in self.data.move_paths.iter_enumerated() {
-                debug!("    {:?} = {:?}", j, path);
-            }
-            "done dumping moves"
-        });
-        self.data
-    }
-}
+mod builder;
 
 #[derive(Copy, Clone, Debug)]
 pub enum LookupResult {
@@ -375,165 +232,6 @@ impl<'a, 'tcx> MoveData<'tcx> {
                         tcx: TyCtxt<'a, 'tcx, 'tcx>,
                         param_env: ty::ParamEnv<'tcx>)
                         -> Self {
-        gather_moves(mir, tcx, param_env)
-    }
-}
-
-fn gather_moves<'a, 'tcx>(mir: &Mir<'tcx>,
-                          tcx: TyCtxt<'a, 'tcx, 'tcx>,
-                          param_env: ty::ParamEnv<'tcx>)
-                          -> MoveData<'tcx> {
-    let mut builder = MoveDataBuilder::new(mir, tcx, param_env);
-
-    for (bb, block) in mir.basic_blocks().iter_enumerated() {
-        for (i, stmt) in block.statements.iter().enumerate() {
-            let source = Location { block: bb, statement_index: i };
-            builder.gather_statement(source, stmt);
-        }
-
-        let terminator_loc = Location {
-            block: bb,
-            statement_index: block.statements.len()
-        };
-        builder.gather_terminator(terminator_loc, block.terminator());
-    }
-
-    builder.finalize()
-}
-
-impl<'a, 'tcx> MoveDataBuilder<'a, 'tcx> {
-    fn gather_statement(&mut self, loc: Location, stmt: &Statement<'tcx>) {
-        debug!("gather_statement({:?}, {:?})", loc, stmt);
-        match stmt.kind {
-            StatementKind::Assign(ref lval, ref rval) => {
-                self.create_move_path(lval);
-                if let RvalueInitializationState::Shallow = rval.initialization_state() {
-                    // Box starts out uninitialized - need to create a separate
-                    // move-path for the interior so it will be separate from
-                    // the exterior.
-                    self.create_move_path(&lval.clone().deref());
-                }
-                self.gather_rvalue(loc, rval);
-            }
-            StatementKind::StorageLive(_) |
-            StatementKind::StorageDead(_) => {}
-            StatementKind::SetDiscriminant{ .. } => {
-                span_bug!(stmt.source_info.span,
-                          "SetDiscriminant should not exist during borrowck");
-            }
-            StatementKind::InlineAsm { .. } |
-            StatementKind::EndRegion(_) |
-            StatementKind::Validate(..) |
-            StatementKind::Nop => {}
-        }
-    }
-
-    fn gather_rvalue(&mut self, loc: Location, rvalue: &Rvalue<'tcx>) {
-        match *rvalue {
-            Rvalue::Use(ref operand) |
-            Rvalue::Repeat(ref operand, _) |
-            Rvalue::Cast(_, ref operand, _) |
-            Rvalue::UnaryOp(_, ref operand) => {
-                self.gather_operand(loc, operand)
-            }
-            Rvalue::BinaryOp(ref _binop, ref lhs, ref rhs) |
-            Rvalue::CheckedBinaryOp(ref _binop, ref lhs, ref rhs) => {
-                self.gather_operand(loc, lhs);
-                self.gather_operand(loc, rhs);
-            }
-            Rvalue::Aggregate(ref _kind, ref operands) => {
-                for operand in operands {
-                    self.gather_operand(loc, operand);
-                }
-            }
-            Rvalue::Ref(..) |
-            Rvalue::Discriminant(..) |
-            Rvalue::Len(..) |
-            Rvalue::NullaryOp(NullOp::SizeOf, _) |
-            Rvalue::NullaryOp(NullOp::Box, _) => {
-                // This returns an rvalue with uninitialized contents. We can't
-                // move out of it here because it is an rvalue - assignments always
-                // completely initialize their lvalue.
-                //
-                // However, this does not matter - MIR building is careful to
-                // only emit a shallow free for the partially-initialized
-                // temporary.
-                //
-                // In any case, if we want to fix this, we have to register a
-                // special move and change the `statement_effect` functions.
-            }
-        }
-    }
-
-    fn gather_terminator(&mut self, loc: Location, term: &Terminator<'tcx>) {
-        debug!("gather_terminator({:?}, {:?})", loc, term);
-        match term.kind {
-            TerminatorKind::Goto { target: _ } |
-            TerminatorKind::Resume |
-            TerminatorKind::Unreachable => { }
-
-            TerminatorKind::Return => {
-                self.gather_move(loc, &Lvalue::Local(RETURN_POINTER));
-            }
-
-            TerminatorKind::Assert { .. } |
-            TerminatorKind::SwitchInt { .. } => {
-                // branching terminators - these don't move anything
-            }
-
-            TerminatorKind::Drop { ref location, target: _, unwind: _ } => {
-                self.gather_move(loc, location);
-            }
-            TerminatorKind::DropAndReplace { ref location, ref value, .. } => {
-                self.create_move_path(location);
-                self.gather_operand(loc, value);
-            }
-            TerminatorKind::Call { ref func, ref args, ref destination, cleanup: _ } => {
-                self.gather_operand(loc, func);
-                for arg in args {
-                    self.gather_operand(loc, arg);
-                }
-                if let Some((ref destination, _bb)) = *destination {
-                    self.create_move_path(destination);
-                }
-            }
-        }
-    }
-
-    fn gather_operand(&mut self, loc: Location, operand: &Operand<'tcx>) {
-        match *operand {
-            Operand::Constant(..) => {} // not-a-move
-            Operand::Consume(ref lval) => { // a move
-                self.gather_move(loc, lval);
-            }
-        }
-    }
-
-    fn gather_move(&mut self, loc: Location, lval: &Lvalue<'tcx>) {
-        debug!("gather_move({:?}, {:?})", loc, lval);
-
-        let lv_ty = lval.ty(self.mir, self.tcx).to_ty(self.tcx);
-        if !lv_ty.moves_by_default(self.tcx, self.param_env, DUMMY_SP) {
-            debug!("gather_move({:?}, {:?}) - {:?} is Copy. skipping", loc, lval, lv_ty);
-            return
-        }
-
-        let path = match self.move_path_for(lval) {
-            Ok(path) | Err(MovePathError::UnionMove { path }) => path,
-            Err(MovePathError::IllegalMove) => {
-                // Moving out of a bad path. Eventually, this should be a MIR
-                // borrowck error instead of a bug.
-                span_bug!(self.mir.span,
-                          "Broken MIR: moving out of lvalue {:?}: {:?} at {:?}",
-                          lval, lv_ty, loc);
-            }
-        };
-        let move_out = self.data.moves.push(MoveOut { path: path, source: loc });
-
-        debug!("gather_move({:?}, {:?}): adding move {:?} of {:?}",
-               loc, lval, move_out, path);
-
-        self.data.path_map[path].push(move_out);
-        self.data.loc_map[loc].push(move_out);
+        builder::gather_moves(mir, tcx, param_env)
     }
 }

src/librustc_mir/dataflow/mod.rs

@@ -32,6 +32,7 @@ extern crate graphviz as dot;
 #[macro_use]
 extern crate rustc;
 extern crate rustc_data_structures;
+extern crate rustc_errors;
 #[macro_use]
 #[no_link]
 extern crate rustc_bitflags;

src/librustc_mir/dataflow/move_paths/builder.rs

@@ -31,6 +31,7 @@ pub mod simplify;
 pub mod erase_regions;
 pub mod no_landing_pads;
 pub mod type_check;
+pub mod borrow_check;
 pub mod rustc_peek;
 pub mod elaborate_drops;
 pub mod add_call_guards;

src/librustc_mir/dataflow/move_paths/mod.rs

@@ -13,7 +13,7 @@ use syntax::ast;
 use syntax_pos::Span;
 
 use rustc::ty::{self, TyCtxt};
-use rustc::mir::{self, Mir};
+use rustc::mir::{self, Mir, Location};
 use rustc::mir::transform::{MirPass, MirSource};
 use rustc_data_structures::indexed_set::IdxSetBuf;
 use rustc_data_structures::indexed_vec::Idx;
@@ -202,7 +202,7 @@ fn each_block<'a, 'tcx, O>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
         // reset GEN and KILL sets before emulating their effect.
         for e in sets.gen_set.words_mut() { *e = 0; }
         for e in sets.kill_set.words_mut() { *e = 0; }
-        results.0.operator.statement_effect(&mut sets, bb, j);
+        results.0.operator.statement_effect(&mut sets, Location { block: bb, statement_index: j });
         sets.on_entry.union(sets.gen_set);
         sets.on_entry.subtract(sets.kill_set);
     }

src/librustc_mir/diagnostics.rs

@@ -0,0 +1,192 @@
+// Copyright 2012-2015 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.
+
+use rustc::ty::{self, TyCtxt};
+use rustc_errors::DiagnosticBuilder;
+use syntax_pos::{MultiSpan, Span};
+
+use std::fmt;
+
+#[derive(Copy, Clone, PartialEq, Eq, Debug)]
+pub enum Origin { Ast, Mir }
+
+impl fmt::Display for Origin {
+    fn fmt(&self, w: &mut fmt::Formatter) -> fmt::Result {
+        match *self {
+            Origin::Mir => write!(w, " (Mir)"),
+            Origin::Ast => ty::tls::with_opt(|opt_tcx| {
+                // If user passed `-Z borrowck-mir`, then include an
+                // AST origin as part of the error report
+                if let Some(tcx) = opt_tcx {
+                    if tcx.sess.opts.debugging_opts.borrowck_mir {
+                        return write!(w, " (Ast)");
+                    }
+                }
+                // otherwise, do not include the origin (i.e., print
+                // nothing at all)
+                Ok(())
+            }),
+        }
+    }
+}
+
+pub trait BorrowckErrors {
+    fn struct_span_err_with_code<'a, S: Into<MultiSpan>>(&'a self,
+                                                         sp: S,
+                                                         msg: &str,
+                                                         code: &str)
+                                                         -> DiagnosticBuilder<'a>;
+
+    fn struct_span_err<'a, S: Into<MultiSpan>>(&'a self,
+                                               sp: S,
+                                               msg: &str)
+                                               -> DiagnosticBuilder<'a>;
+
+    fn cannot_move_when_borrowed(&self, span: Span, desc: &str, o: Origin)
+                                 -> DiagnosticBuilder
+    {
+        struct_span_err!(self, span, E0505,
+                         "cannot move out of `{}` because it is borrowed{OGN}",
+                         desc, OGN=o)
+    }
+
+    fn cannot_use_when_mutably_borrowed(&self, span: Span, desc: &str, o: Origin)
+                                        -> DiagnosticBuilder
+    {
+        struct_span_err!(self, span, E0503,
+                         "cannot use `{}` because it was mutably borrowed{OGN}",
+                         desc, OGN=o)
+    }
+
+    fn cannot_act_on_uninitialized_variable(&self,
+                                            span: Span,
+                                            verb: &str,
+                                            desc: &str,
+                                            o: Origin)
+                                            -> DiagnosticBuilder
+    {
+        struct_span_err!(self, span, E0381,
+                         "{} of possibly uninitialized variable: `{}`{OGN}",
+                         verb, desc, OGN=o)
+    }
+
+    fn cannot_mutably_borrow_multiply(&self,
+                                      span: Span,
+                                      desc: &str,
+                                      opt_via: &str,
+                                      o: Origin)
+                                      -> DiagnosticBuilder
+    {
+        struct_span_err!(self, span, E0499,
+                         "cannot borrow `{}`{} as mutable more than once at a time{OGN}",
+                         desc, opt_via, OGN=o)
+    }
+
+    fn cannot_uniquely_borrow_by_two_closures(&self, span: Span, desc: &str, o: Origin)
+                                              -> DiagnosticBuilder
+    {
+        struct_span_err!(self, span, E0524,
+                         "two closures require unique access to `{}` at the same time{OGN}",
+                         desc, OGN=o)
+    }
+
+    fn cannot_uniquely_borrow_by_one_closure(&self,
+                                             span: Span,
+                                             desc_new: &str,
+                                             noun_old: &str,
+                                             msg_old: &str,
+                                             o: Origin)
+                                             -> DiagnosticBuilder
+    {
+        struct_span_err!(self, span, E0500,
+                         "closure requires unique access to `{}` but {} is already borrowed{}{OGN}",
+                         desc_new, noun_old, msg_old, OGN=o)
+    }
+
+    fn cannot_reborrow_already_uniquely_borrowed(&self,
+                                                 span: Span,
+                                                 desc_new: &str,
+                                                 msg_new: &str,
+                                                 kind_new: &str,
+                                                 o: Origin)
+                                                 -> DiagnosticBuilder
+    {
+        struct_span_err!(self, span, E0501,
+                         "cannot borrow `{}`{} as {} because previous closure \
+                          requires unique access{OGN}",
+                         desc_new, msg_new, kind_new, OGN=o)
+    }
+
+    fn cannot_reborrow_already_borrowed(&self,
+                                        span: Span,
+                                        desc_new: &str,
+                                        msg_new: &str,
+                                        kind_new: &str,
+                                        noun_old: &str,
+                                        kind_old: &str,
+                                        msg_old: &str,
+                                        o: Origin)
+                                        -> DiagnosticBuilder
+    {
+        struct_span_err!(self, span, E0502,
+                         "cannot borrow `{}`{} as {} because {} is also borrowed as {}{}{OGN}",
+                         desc_new, msg_new, kind_new, noun_old, kind_old, msg_old, OGN=o)
+    }
+
+    fn cannot_assign_to_borrowed(&self, span: Span, desc: &str, o: Origin)
+                                 -> DiagnosticBuilder
+    {
+        struct_span_err!(self, span, E0506,
+                         "cannot assign to `{}` because it is borrowed{OGN}",
+                         desc, OGN=o)
+    }
+
+    fn cannot_move_into_closure(&self, span: Span, desc: &str, o: Origin)
+                                -> DiagnosticBuilder
+    {
+        struct_span_err!(self, span, E0504,
+                         "cannot move `{}` into closure because it is borrowed{OGN}",
+                         desc, OGN=o)
+    }
+
+    fn cannot_reassign_immutable(&self, span: Span, desc: &str, o: Origin)
+                                 -> DiagnosticBuilder
+    {
+        struct_span_err!(self, span, E0384,
+                         "re-assignment of immutable variable `{}`{OGN}",
+                         desc, OGN=o)
+    }
+
+    fn cannot_assign_static(&self, span: Span, desc: &str, o: Origin)
+                            -> DiagnosticBuilder
+    {
+        self.struct_span_err(span, &format!("cannot assign to immutable static item {}{OGN}",
+                                            desc, OGN=o))
+    }
+}
+
+impl<'b, 'tcx, 'gcx> BorrowckErrors for TyCtxt<'b, 'tcx, 'gcx> {
+    fn struct_span_err_with_code<'a, S: Into<MultiSpan>>(&'a self,
+                                                         sp: S,
+                                                         msg: &str,
+                                                         code: &str)
+                                                         -> DiagnosticBuilder<'a>
+    {
+        self.sess.struct_span_err_with_code(sp, msg, code)
+    }
+
+    fn struct_span_err<'a, S: Into<MultiSpan>>(&'a self,
+                                               sp: S,
+                                               msg: &str)
+                                               -> DiagnosticBuilder<'a>
+    {
+        self.sess.struct_span_err(sp, msg)
+    }
+}

src/librustc_mir/lib.rs

@@ -8,6 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+pub mod borrowck_errors;
 pub mod elaborate_drops;
 pub mod def_use;
 pub mod patch;