diff --git a/src/librustc/mir/mod.rs b/src/librustc/mir/mod.rs index 64e601ab1e734..36bee69d8f067 100644 --- a/src/librustc/mir/mod.rs +++ b/src/librustc/mir/mod.rs @@ -1136,7 +1136,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), @@ -1150,7 +1150,7 @@ pub enum Place<'tcx> { /// The def-id of a static, along with its normalized type (which is /// stored to avoid requiring normalization when reading MIR). -#[derive(Clone, PartialEq, RustcEncodable, RustcDecodable)] +#[derive(Clone, PartialEq, Eq, Hash, RustcEncodable, RustcDecodable)] pub struct Static<'tcx> { pub def_id: DefId, pub ty: Ty<'tcx>, diff --git a/src/librustc/session/config.rs b/src/librustc/session/config.rs index 0dcd3e8081080..bff31afb5e5f1 100644 --- a/src/librustc/session/config.rs +++ b/src/librustc/session/config.rs @@ -1011,6 +1011,8 @@ options! {DebuggingOptions, DebuggingSetter, basic_debugging_options, "emit EndRegion as part of MIR; enable transforms that solely process EndRegion"), borrowck: Option = (None, parse_opt_string, [UNTRACKED], "select which borrowck is used (`ast`, `mir`, or `compare`)"), + two_phase_borrows: bool = (false, parse_bool, [UNTRACKED], + "use two-phase reserved/active distinction for `&mut` borrows in MIR borrowck"), time_passes: bool = (false, parse_bool, [UNTRACKED], "measure time of each rustc pass"), count_llvm_insns: bool = (false, parse_bool, diff --git a/src/librustc_data_structures/indexed_set.rs b/src/librustc_data_structures/indexed_set.rs index 5d7139507b33f..223e08de826ce 100644 --- a/src/librustc_data_structures/indexed_set.rs +++ b/src/librustc_data_structures/indexed_set.rs @@ -8,6 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::borrow::{Borrow, BorrowMut, ToOwned}; use std::fmt; use std::iter; use std::marker::PhantomData; @@ -73,6 +74,25 @@ pub struct IdxSet { bits: [Word], } +impl Borrow> for IdxSetBuf { + fn borrow(&self) -> &IdxSet { + &*self + } +} + +impl BorrowMut> for IdxSetBuf { + fn borrow_mut(&mut self) -> &mut IdxSet { + &mut *self + } +} + +impl ToOwned for IdxSet { + type Owned = IdxSetBuf; + fn to_owned(&self) -> Self::Owned { + IdxSet::to_owned(self) + } +} + impl fmt::Debug for IdxSetBuf { fn fmt(&self, w: &mut fmt::Formatter) -> fmt::Result { w.debug_list() diff --git a/src/librustc_driver/pretty.rs b/src/librustc_driver/pretty.rs index d930739c9f014..7fdcbfc4d2982 100644 --- a/src/librustc_driver/pretty.rs +++ b/src/librustc_driver/pretty.rs @@ -423,7 +423,8 @@ impl<'hir> pprust_hir::PpAnn for IdentifiedAnnotation<'hir> { pprust_hir::NodeName(_) => Ok(()), pprust_hir::NodeItem(item) => { s.s.space()?; - s.synth_comment(item.id.to_string()) + s.synth_comment(format!("node_id: {} hir local_id: {}", + item.id, item.hir_id.local_id.0)) } pprust_hir::NodeSubItem(id) => { s.s.space()?; @@ -431,16 +432,19 @@ impl<'hir> pprust_hir::PpAnn for IdentifiedAnnotation<'hir> { } pprust_hir::NodeBlock(blk) => { s.s.space()?; - s.synth_comment(format!("block {}", blk.id)) + s.synth_comment(format!("block node_id: {} hir local_id: {}", + blk.id, blk.hir_id.local_id.0)) } pprust_hir::NodeExpr(expr) => { s.s.space()?; - s.synth_comment(expr.id.to_string())?; + s.synth_comment(format!("node_id: {} hir local_id: {}", + expr.id, expr.hir_id.local_id.0))?; s.pclose() } pprust_hir::NodePat(pat) => { s.s.space()?; - s.synth_comment(format!("pat {}", pat.id)) + s.synth_comment(format!("pat node_id: {} hir local_id: {}", + pat.id, pat.hir_id.local_id.0)) } } } diff --git a/src/librustc_mir/borrow_check/error_reporting.rs b/src/librustc_mir/borrow_check/error_reporting.rs index 186598001da6a..31a94499fd0cc 100644 --- a/src/librustc_mir/borrow_check/error_reporting.rs +++ b/src/librustc_mir/borrow_check/error_reporting.rs @@ -11,7 +11,7 @@ use syntax_pos::Span; use rustc::middle::region::ScopeTree; use rustc::mir::{BorrowKind, Field, Local, Location, Operand}; -use rustc::mir::{Place, ProjectionElem, Rvalue, StatementKind}; +use rustc::mir::{Place, ProjectionElem, Rvalue, Statement, StatementKind}; use rustc::ty::{self, RegionKind}; use rustc_data_structures::indexed_vec::Idx; @@ -19,7 +19,7 @@ use std::rc::Rc; use super::{MirBorrowckCtxt, Context}; use super::{InitializationRequiringAction, PrefixSet}; -use dataflow::{BorrowData, Borrows, FlowAtLocation, MovingOutStatements}; +use dataflow::{ActiveBorrows, BorrowData, FlowAtLocation, MovingOutStatements}; use dataflow::move_paths::MovePathIndex; use util::borrowck_errors::{BorrowckErrors, Origin}; @@ -96,7 +96,7 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> { Some(name) => format!("`{}`", name), None => "value".to_owned(), }; - let borrow_msg = match self.describe_place(&borrow.place) { + let borrow_msg = match self.describe_place(&borrow.borrowed_place) { Some(name) => format!("`{}`", name), None => "value".to_owned(), }; @@ -124,7 +124,7 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> { span, &self.describe_place(place).unwrap_or("_".to_owned()), self.retrieve_borrow_span(borrow), - &self.describe_place(&borrow.place).unwrap_or("_".to_owned()), + &self.describe_place(&borrow.borrowed_place).unwrap_or("_".to_owned()), Origin::Mir, ); @@ -143,12 +143,9 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> { use rustc::hir::ExprClosure; use rustc::mir::AggregateKind; - let local = if let StatementKind::Assign(Place::Local(local), _) = - self.mir[location.block].statements[location.statement_index].kind - { - local - } else { - return None; + let local = match self.mir[location.block].statements.get(location.statement_index) { + Some(&Statement { kind: StatementKind::Assign(Place::Local(local), _), .. }) => local, + _ => return None, }; for stmt in &self.mir[location.block].statements[location.statement_index + 1..] { @@ -324,11 +321,11 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> { _: Context, borrow: &BorrowData<'tcx>, drop_span: Span, - borrows: &Borrows<'cx, 'gcx, 'tcx> + borrows: &ActiveBorrows<'cx, 'gcx, 'tcx> ) { let end_span = borrows.opt_region_end_span(&borrow.region); - let scope_tree = borrows.scope_tree(); - let root_place = self.prefixes(&borrow.place, PrefixSet::All).last().unwrap(); + let scope_tree = borrows.0.scope_tree(); + let root_place = self.prefixes(&borrow.borrowed_place, PrefixSet::All).last().unwrap(); match root_place { &Place::Local(local) => { @@ -357,7 +354,7 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> { _ => drop_span, }; - match (borrow.region, &self.describe_place(&borrow.place)) { + match (borrow.region, &self.describe_place(&borrow.borrowed_place)) { (RegionKind::ReScope(_), Some(name)) => { self.report_scoped_local_value_does_not_live_long_enough( name, &scope_tree, &borrow, drop_span, borrow_span, proper_span, end_span); diff --git a/src/librustc_mir/borrow_check/flows.rs b/src/librustc_mir/borrow_check/flows.rs index 449062989e07e..69a08c7a30df3 100644 --- a/src/librustc_mir/borrow_check/flows.rs +++ b/src/librustc_mir/borrow_check/flows.rs @@ -17,13 +17,13 @@ use rustc::mir::{BasicBlock, Location}; use dataflow::{MaybeInitializedLvals, MaybeUninitializedLvals}; use dataflow::{EverInitializedLvals, MovingOutStatements}; -use dataflow::{Borrows, FlowAtLocation, FlowsAtLocation}; +use dataflow::{ActiveBorrows, FlowAtLocation, FlowsAtLocation}; use dataflow::move_paths::HasMoveData; use std::fmt; // (forced to be `pub` due to its use as an associated type below.) -pub struct Flows<'b, 'gcx: 'tcx, 'tcx: 'b> { - pub borrows: FlowAtLocation>, +pub(crate) struct Flows<'b, 'gcx: 'tcx, 'tcx: 'b> { + pub borrows: FlowAtLocation>, pub inits: FlowAtLocation>, pub uninits: FlowAtLocation>, pub move_outs: FlowAtLocation>, @@ -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: FlowAtLocation>, inits: FlowAtLocation>, uninits: FlowAtLocation>, move_outs: FlowAtLocation>, @@ -87,7 +87,7 @@ impl<'b, 'gcx, 'tcx> fmt::Display for Flows<'b, 'gcx, 'tcx> { s.push_str(", "); }; saw_one = true; - let borrow_data = &self.borrows.operator().borrows()[borrow]; + let borrow_data = &self.borrows.operator().borrows()[borrow.borrow_index()]; s.push_str(&format!("{}", borrow_data)); }); s.push_str("] "); @@ -99,7 +99,7 @@ impl<'b, 'gcx, 'tcx> fmt::Display for Flows<'b, 'gcx, 'tcx> { s.push_str(", "); }; saw_one = true; - let borrow_data = &self.borrows.operator().borrows()[borrow]; + let borrow_data = &self.borrows.operator().borrows()[borrow.borrow_index()]; s.push_str(&format!("{}", borrow_data)); }); s.push_str("] "); diff --git a/src/librustc_mir/borrow_check/mod.rs b/src/librustc_mir/borrow_check/mod.rs index 128052e58949d..39bcd2b6ae063 100644 --- a/src/librustc_mir/borrow_check/mod.rs +++ b/src/librustc_mir/borrow_check/mod.rs @@ -28,13 +28,15 @@ use rustc_data_structures::indexed_vec::Idx; use syntax::ast; use syntax_pos::Span; -use dataflow::do_dataflow; +use dataflow::{do_dataflow, DebugFormatted}; use dataflow::MoveDataParamEnv; -use dataflow::DataflowResultsConsumer; +use dataflow::{DataflowAnalysis, DataflowResultsConsumer}; use dataflow::{FlowAtLocation, FlowsAtLocation}; use dataflow::{MaybeInitializedLvals, MaybeUninitializedLvals}; use dataflow::{EverInitializedLvals, MovingOutStatements}; -use dataflow::{BorrowData, BorrowIndex, Borrows}; +use dataflow::{Borrows, BorrowData, ReserveOrActivateIndex}; +use dataflow::{ActiveBorrows, Reservations}; +use dataflow::indexes::{BorrowIndex}; use dataflow::move_paths::{IllegalMoveOriginKind, MoveError}; use dataflow::move_paths::{HasMoveData, LookupResult, MoveData, MovePathIndex}; use util::borrowck_errors::{BorrowckErrors, Origin}; @@ -48,6 +50,9 @@ use self::MutateMode::{JustWrite, WriteAndRead}; mod error_reporting; mod flows; mod prefixes; + +use std::borrow::Cow; + pub(crate) mod nll; pub fn provide(providers: &mut Providers) { @@ -157,7 +162,7 @@ fn do_mir_borrowck<'a, 'gcx, 'tcx>( &attributes, &dead_unwinds, MaybeInitializedLvals::new(tcx, mir, &mdpe), - |bd, i| &bd.move_data().move_paths[i], + |bd, i| DebugFormatted::new(&bd.move_data().move_paths[i]), )); let flow_uninits = FlowAtLocation::new(do_dataflow( tcx, @@ -166,7 +171,7 @@ fn do_mir_borrowck<'a, 'gcx, 'tcx>( &attributes, &dead_unwinds, MaybeUninitializedLvals::new(tcx, mir, &mdpe), - |bd, i| &bd.move_data().move_paths[i], + |bd, i| DebugFormatted::new(&bd.move_data().move_paths[i]), )); let flow_move_outs = FlowAtLocation::new(do_dataflow( tcx, @@ -175,7 +180,7 @@ fn do_mir_borrowck<'a, 'gcx, 'tcx>( &attributes, &dead_unwinds, MovingOutStatements::new(tcx, mir, &mdpe), - |bd, i| &bd.move_data().moves[i], + |bd, i| DebugFormatted::new(&bd.move_data().moves[i]), )); let flow_ever_inits = FlowAtLocation::new(do_dataflow( tcx, @@ -184,7 +189,7 @@ fn do_mir_borrowck<'a, 'gcx, 'tcx>( &attributes, &dead_unwinds, EverInitializedLvals::new(tcx, mir, &mdpe), - |bd, i| &bd.move_data().inits[i], + |bd, i| DebugFormatted::new(&bd.move_data().inits[i]), )); // If we are in non-lexical mode, compute the non-lexical lifetimes. @@ -205,23 +210,6 @@ fn do_mir_borrowck<'a, 'gcx, 'tcx>( }; let flow_inits = flow_inits; // remove mut - let flow_borrows = FlowAtLocation::new(do_dataflow( - tcx, - mir, - id, - &attributes, - &dead_unwinds, - Borrows::new(tcx, mir, opt_regioncx, def_id, body_id), - |bd, i| bd.location(i), - )); - - let mut state = Flows::new( - flow_borrows, - flow_inits, - flow_uninits, - flow_move_outs, - flow_ever_inits, - ); let mut mbcx = MirBorrowckCtxt { tcx: tcx, mir: mir, @@ -235,8 +223,47 @@ fn do_mir_borrowck<'a, 'gcx, 'tcx>( }, storage_dead_or_drop_error_reported_l: FxHashSet(), storage_dead_or_drop_error_reported_s: FxHashSet(), + reservation_error_reported: FxHashSet(), + }; + + let borrows = Borrows::new(tcx, mir, opt_regioncx, def_id, body_id); + let flow_reservations = do_dataflow( + tcx, + mir, + id, + &attributes, + &dead_unwinds, + Reservations::new(borrows), + |rs, i| { + // In principle we could make the dataflow ensure that + // only reservation bits show up, and assert so here. + // + // In practice it is easier to be looser; in particular, + // it is okay for the kill-sets to hold activation bits. + DebugFormatted::new(&(i.kind(), rs.location(i))) + }); + let flow_active_borrows = { + let reservations_on_entry = flow_reservations.0.sets.entry_set_state(); + let reservations = flow_reservations.0.operator; + let a = DataflowAnalysis::new_with_entry_sets(mir, + &dead_unwinds, + Cow::Borrowed(reservations_on_entry), + ActiveBorrows::new(reservations)); + let results = a.run(tcx, + id, + &attributes, + |ab, i| DebugFormatted::new(&(i.kind(), ab.location(i)))); + FlowAtLocation::new(results) }; + let mut state = Flows::new( + flow_active_borrows, + flow_inits, + flow_uninits, + flow_move_outs, + flow_ever_inits, + ); + mbcx.analyze_results(&mut state); // entry point for DataflowResultsConsumer opt_closure_req @@ -262,6 +289,14 @@ pub struct MirBorrowckCtxt<'cx, 'gcx: 'tcx, 'tcx: 'cx> { storage_dead_or_drop_error_reported_l: FxHashSet, /// Same as the above, but for statics (thread-locals) storage_dead_or_drop_error_reported_s: FxHashSet, + /// This field keeps track of when borrow conflict errors are reported + /// for reservations, so that we don't report seemingly duplicate + /// errors for corresponding activations + /// + /// FIXME: Ideally this would be a set of BorrowIndex, not Places, + /// but it is currently inconvenient to track down the BorrowIndex + /// at the time we detect and report a reservation error. + reservation_error_reported: FxHashSet>, } // Check that: @@ -293,6 +328,9 @@ impl<'cx, 'gcx, 'tcx> DataflowResultsConsumer<'cx, 'tcx> for MirBorrowckCtxt<'cx flow_state ); let span = stmt.source_info.span; + + self.check_activations(location, span, flow_state); + match stmt.kind { StatementKind::Assign(ref lhs, ref rhs) => { // NOTE: NLL RFC calls for *shallow* write; using Deep @@ -399,6 +437,9 @@ impl<'cx, 'gcx, 'tcx> DataflowResultsConsumer<'cx, 'tcx> for MirBorrowckCtxt<'cx flow_state ); let span = term.source_info.span; + + self.check_activations(location, span, flow_state); + match term.kind { TerminatorKind::SwitchInt { ref discr, @@ -504,9 +545,8 @@ impl<'cx, 'gcx, 'tcx> DataflowResultsConsumer<'cx, 'tcx> for MirBorrowckCtxt<'cx let data = domain.borrows(); flow_state.borrows.with_elems_outgoing(|borrows| { for i in borrows { - let borrow = &data[i]; + let borrow = &data[i.borrow_index()]; let context = ContextKind::StorageDead.new(loc); - self.check_for_invalidation_at_exit(context, borrow, span, flow_state); } }); @@ -533,7 +573,7 @@ enum Control { } use self::ShallowOrDeep::{Deep, Shallow}; -use self::ReadOrWrite::{Read, Write}; +use self::ReadOrWrite::{Activation, Read, Reservation, Write}; #[derive(Copy, Clone, PartialEq, Eq, Debug)] enum ArtificialField { @@ -568,6 +608,12 @@ enum ReadOrWrite { /// new values or otherwise invalidated (for example, it could be /// de-initialized, as in a move operation). Write(WriteKind), + + /// For two-phase borrows, we distinguish a reservation (which is treated + /// like a Read) from an activation (which is treated like a write), and + /// each of those is furthermore distinguished from Reads/Writes above. + Reservation(WriteKind), + Activation(WriteKind, BorrowIndex), } /// Kind of read access to a value @@ -656,6 +702,14 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> { ) -> AccessErrorsReported { let (sd, rw) = kind; + if let Activation(_, borrow_index) = rw { + if self.reservation_error_reported.contains(&place_span.0) { + debug!("skipping access_place for activation of invalid reservation \ + place: {:?} borrow_index: {:?}", place_span.0, borrow_index); + return AccessErrorsReported { mutability_error: false, conflict_error: true }; + } + } + let mutability_error = self.check_access_permissions(place_span, rw, is_local_mutation_allowed); let conflict_error = @@ -677,9 +731,33 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> { context, (sd, place_span.0), flow_state, - |this, _index, borrow| match (rw, borrow.kind) { - (Read(_), BorrowKind::Shared) => Control::Continue, - (Read(kind), BorrowKind::Unique) | (Read(kind), BorrowKind::Mut) => { + |this, index, borrow| match (rw, borrow.kind) { + // Obviously an activation is compatible with its own + // reservation (or even prior activating uses of same + // borrow); so don't check if they interfere. + // + // NOTE: *reservations* do conflict with themselves; + // thus aren't injecting unsoundenss w/ this check.) + (Activation(_, activating), _) if activating == index.borrow_index() => + { + debug!("check_access_for_conflict place_span: {:?} sd: {:?} rw: {:?} \ + skipping {:?} b/c activation of same borrow_index: {:?}", + place_span, sd, rw, (index, borrow), index.borrow_index()); + Control::Continue + } + + (Read(_), BorrowKind::Shared) | + (Reservation(..), BorrowKind::Shared) => Control::Continue, + + (Read(kind), BorrowKind::Unique) | + (Read(kind), BorrowKind::Mut) => { + // Reading from mere reservations of mutable-borrows is OK. + if this.tcx.sess.opts.debugging_opts.two_phase_borrows && + index.is_reservation() + { + return Control::Continue; + } + match kind { ReadKind::Copy => { error_reported = true; @@ -702,13 +780,32 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> { } Control::Break } + + (Reservation(kind), BorrowKind::Unique) | + (Reservation(kind), BorrowKind::Mut) | + (Activation(kind, _), _) | (Write(kind), _) => { + + match rw { + Reservation(_) => { + debug!("recording invalid reservation of \ + place: {:?}", place_span.0); + this.reservation_error_reported.insert(place_span.0.clone()); + } + Activation(_, activating) => { + debug!("observing check_place for activation of \ + borrow_index: {:?}", activating); + } + Read(..) | Write(..) => {} + } + match kind { WriteKind::MutableBorrow(bk) => { let end_issued_loan_span = flow_state .borrows .operator() .opt_region_end_span(&borrow.region); + error_reported = true; this.report_conflicting_borrow( context, @@ -721,7 +818,8 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> { WriteKind::StorageDeadOrDrop => { error_reported = true; this.report_borrowed_value_does_not_live_long_enough( - context, borrow, place_span.1, flow_state.borrows.operator()); + context, borrow, place_span.1, + flow_state.borrows.operator()); } WriteKind::Mutate => { error_reported = true; @@ -794,9 +892,15 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> { let access_kind = match bk { BorrowKind::Shared => (Deep, Read(ReadKind::Borrow(bk))), BorrowKind::Unique | BorrowKind::Mut => { - (Deep, Write(WriteKind::MutableBorrow(bk))) + let wk = WriteKind::MutableBorrow(bk); + if self.tcx.sess.opts.debugging_opts.two_phase_borrows { + (Deep, Reservation(wk)) + } else { + (Deep, Write(wk)) + } } }; + self.access_place( context, (place, span), @@ -804,6 +908,7 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> { LocalMutationIsAllowed::No, flow_state, ); + self.check_if_path_is_moved( context, InitializationRequiringAction::Borrow, @@ -917,7 +1022,7 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> { flow_state: &Flows<'cx, 'gcx, 'tcx>) { debug!("check_for_invalidation_at_exit({:?})", borrow); - let place = &borrow.place; + let place = &borrow.borrowed_place; let root_place = self.prefixes(place, PrefixSet::All).last().unwrap(); // FIXME(nll-rfc#40): do more precise destructor tracking here. For now @@ -974,6 +1079,48 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> { ) } } + + fn check_activations(&mut self, + location: Location, + span: Span, + flow_state: &Flows<'cx, 'gcx, 'tcx>) + { + if !self.tcx.sess.opts.debugging_opts.two_phase_borrows { + return; + } + + // Two-phase borrow support: For each activation that is newly + // generated at this statement, check if it interferes with + // another borrow. + let domain = flow_state.borrows.operator(); + let data = domain.borrows(); + flow_state.borrows.each_gen_bit(|gen| { + if gen.is_activation() + { + let borrow_index = gen.borrow_index(); + let borrow = &data[borrow_index]; + // currently the flow analysis registers + // activations for both mutable and immutable + // borrows. So make sure we are talking about a + // mutable borrow before we check it. + match borrow.kind { + BorrowKind::Shared => return, + BorrowKind::Unique | + BorrowKind::Mut => {} + } + + self.access_place(ContextKind::Activation.new(location), + (&borrow.borrowed_place, span), + (Deep, Activation(WriteKind::MutableBorrow(borrow.kind), + borrow_index)), + LocalMutationIsAllowed::No, + flow_state); + // We do not need to call `check_if_path_is_moved` + // again, as we already called it when we made the + // initial reservation. + } + }); + } } impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> { @@ -1217,11 +1364,13 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> { ); let mut error_reported = false; match kind { + Reservation(WriteKind::MutableBorrow(BorrowKind::Unique)) | Write(WriteKind::MutableBorrow(BorrowKind::Unique)) => { if let Err(_place_err) = self.is_mutable(place, LocalMutationIsAllowed::Yes) { span_bug!(span, "&unique borrow for {:?} should not fail", place); } } + Reservation(WriteKind::MutableBorrow(BorrowKind::Mut)) | Write(WriteKind::MutableBorrow(BorrowKind::Mut)) => if let Err(place_err) = self.is_mutable(place, is_local_mutation_allowed) { @@ -1244,6 +1393,7 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> { err.emit(); }, + Reservation(WriteKind::Mutate) | Write(WriteKind::Mutate) => { if let Err(place_err) = self.is_mutable(place, is_local_mutation_allowed) { error_reported = true; @@ -1265,6 +1415,9 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> { err.emit(); } } + Reservation(WriteKind::Move) | + Reservation(WriteKind::StorageDeadOrDrop) | + Reservation(WriteKind::MutableBorrow(BorrowKind::Shared)) | Write(WriteKind::Move) | Write(WriteKind::StorageDeadOrDrop) | Write(WriteKind::MutableBorrow(BorrowKind::Shared)) => { @@ -1279,6 +1432,9 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> { ); } } + + Activation(..) => {} // permission checks are done at Reservation point. + Read(ReadKind::Borrow(BorrowKind::Unique)) | Read(ReadKind::Borrow(BorrowKind::Mut)) | Read(ReadKind::Borrow(BorrowKind::Shared)) | @@ -1771,6 +1927,18 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> { unreachable!("iter::repeat returned None") } + /// This function iterates over all of the current borrows + /// (represented by 1-bits in `flow_state.borrows`) that conflict + /// with an access to a place, invoking the `op` callback for each + /// one. + /// + /// "Current borrow" here means a borrow that reaches the point in + /// the control-flow where the access occurs. + /// + /// The borrow's phase is represented by the ReserveOrActivateIndex + /// passed to the callback: one can call `is_reservation()` and + /// `is_activation()` to determine what phase the borrow is + /// currently in, when such distinction matters. fn each_borrow_involving_path( &mut self, _context: Context, @@ -1778,7 +1946,7 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> { flow_state: &Flows<'cx, 'gcx, 'tcx>, mut op: F, ) where - F: FnMut(&mut Self, BorrowIndex, &BorrowData<'tcx>) -> Control, + F: FnMut(&mut Self, ReserveOrActivateIndex, &BorrowData<'tcx>) -> Control, { let (access, place) = access_place; @@ -1789,10 +1957,11 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> { // check for loan restricting path P being used. Accounts for // borrows of P, P.a.b, etc. - for i in flow_state.borrows.elems_incoming() { - let borrowed = &data[i]; + let mut elems_incoming = flow_state.borrows.elems_incoming(); + while let Some(i) = elems_incoming.next() { + let borrowed = &data[i.borrow_index()]; - if self.places_conflict(&borrowed.place, place, access) { + if self.places_conflict(&borrowed.borrowed_place, place, access) { let ctrl = op(self, i, borrowed); if ctrl == Control::Break { return; } } @@ -1836,6 +2005,7 @@ struct Context { #[derive(Copy, Clone, PartialEq, Eq, Debug)] enum ContextKind { + Activation, AssignLhs, AssignRhs, SetDiscrim, diff --git a/src/librustc_mir/dataflow/at_location.rs b/src/librustc_mir/dataflow/at_location.rs index 90ebb45123ed8..a6c3398489ad7 100644 --- a/src/librustc_mir/dataflow/at_location.rs +++ b/src/librustc_mir/dataflow/at_location.rs @@ -18,6 +18,8 @@ use rustc_data_structures::indexed_vec::Idx; use dataflow::{BitDenotation, BlockSets, DataflowResults}; use dataflow::move_paths::{HasMoveData, MovePathIndex}; +use std::iter; + /// A trait for "cartesian products" of multiple FlowAtLocation. /// /// There's probably a way to auto-impl this, but I think @@ -94,9 +96,9 @@ where self.curr_state.contains(x) } - pub fn elems_incoming(&self) -> indexed_set::Elems { + pub fn elems_incoming(&self) -> iter::Peekable> { 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(&self, f: F) @@ -121,9 +123,8 @@ impl FlowsAtLocation for FlowAtLocation 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 FlowsAtLocation for FlowAtLocation fn reconstruct_terminator_effect(&mut self, loc: Location) { self.stmt_gen.reset_to_empty(); self.stmt_kill.reset_to_empty(); - let mut ignored = IdxSetBuf::new_empty(0); let mut sets = BlockSets { - on_entry: &mut ignored, + on_entry: &mut self.curr_state, gen_set: &mut self.stmt_gen, kill_set: &mut self.stmt_kill, }; diff --git a/src/librustc_mir/dataflow/graphviz.rs b/src/librustc_mir/dataflow/graphviz.rs index 7ff4fbcf199e0..b79e044b24f20 100644 --- a/src/librustc_mir/dataflow/graphviz.rs +++ b/src/librustc_mir/dataflow/graphviz.rs @@ -18,7 +18,6 @@ use rustc_data_structures::indexed_vec::Idx; use dot; use dot::IntoCow; -use std::fmt::Debug; use std::fs::File; use std::io; use std::io::prelude::*; @@ -29,6 +28,7 @@ use util; use super::{BitDenotation, DataflowState}; use super::DataflowBuilder; +use super::DebugFormatted; pub trait MirWithFlowState<'tcx> { type BD: BitDenotation; @@ -60,9 +60,9 @@ pub(crate) fn print_borrowck_graph_to<'a, 'tcx, BD, P>( render_idx: P) -> io::Result<()> where BD: BitDenotation, - P: Fn(&BD, BD::Idx) -> &Debug + P: Fn(&BD, BD::Idx) -> DebugFormatted { - let g = Graph { mbcx: mbcx, phantom: PhantomData, render_idx: render_idx }; + let g = Graph { mbcx, phantom: PhantomData, render_idx }; let mut v = Vec::new(); dot::render(&g, &mut v)?; debug!("print_borrowck_graph_to path: {} node_id: {}", @@ -82,7 +82,7 @@ fn outgoing(mir: &Mir, bb: BasicBlock) -> Vec { 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, ::Idx) -> &'b Debug, + P: Fn(&MWF::BD, ::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: &mut W, - interpreted: &[&Debug], + interpreted: &[DebugFormatted], chunk_size: usize) -> io::Result<()> { diff --git a/src/librustc_mir/dataflow/impls/borrows.rs b/src/librustc_mir/dataflow/impls/borrows.rs index 25bc702764a34..c61a57cdda0e9 100644 --- a/src/librustc_mir/dataflow/impls/borrows.rs +++ b/src/librustc_mir/dataflow/impls/borrows.rs @@ -11,8 +11,8 @@ use rustc::hir; use rustc::hir::def_id::DefId; use rustc::middle::region; -use rustc::mir::{self, Location, Mir}; -use rustc::mir::visit::Visitor; +use rustc::mir::{self, Location, Place, Mir}; +use rustc::mir::visit::{PlaceContext, Visitor}; use rustc::ty::{self, Region, TyCtxt}; use rustc::ty::RegionKind; use rustc::ty::RegionKind::ReScope; @@ -20,36 +20,91 @@ use rustc::util::nodemap::{FxHashMap, FxHashSet}; use rustc_data_structures::bitslice::{BitwiseOperator}; use rustc_data_structures::indexed_set::{IdxSet}; -use rustc_data_structures::indexed_vec::{IndexVec}; +use rustc_data_structures::indexed_vec::{Idx, IndexVec}; -use dataflow::{BitDenotation, BlockSets, DataflowOperator}; -pub use dataflow::indexes::BorrowIndex; +use dataflow::{BitDenotation, BlockSets, InitialFlow}; +pub use dataflow::indexes::{BorrowIndex, ReserveOrActivateIndex}; use borrow_check::nll::region_infer::RegionInferenceContext; use borrow_check::nll::ToRegionVid; use syntax_pos::Span; use std::fmt; +use std::hash::Hash; use std::rc::Rc; -// `Borrows` maps each dataflow bit to an `Rvalue::Ref`, which can be -// uniquely identified in the MIR by the `Location` of the assigment -// statement in which it appears on the right hand side. +/// `Borrows` stores the data used in the analyses that track the flow +/// of borrows. +/// +/// It uniquely identifies every borrow (`Rvalue::Ref`) by a +/// `BorrowIndex`, and maps each such index to a `BorrowData` +/// describing the borrow. These indexes are used for representing the +/// borrows in compact bitvectors. pub struct Borrows<'a, 'gcx: 'tcx, 'tcx: 'a> { tcx: TyCtxt<'a, 'gcx, 'tcx>, mir: &'a Mir<'tcx>, scope_tree: Rc, root_scope: Option, + + /// The fundamental map relating bitvector indexes to the borrows + /// in the MIR. borrows: IndexVec>, + + /// Each borrow is also uniquely identified in the MIR by the + /// `Location` of the assignment statement in which it appears on + /// the right hand side; we map each such location to the + /// corresponding `BorrowIndex`. location_map: FxHashMap, + + /// Every borrow in MIR is immediately stored into a place via an + /// assignment statement. This maps each such assigned place back + /// to its borrow-indexes. + assigned_map: FxHashMap, FxHashSet>, + + /// Every borrow has a region; this maps each such regions back to + /// its borrow-indexes. region_map: FxHashMap, FxHashSet>, local_map: FxHashMap>, region_span_map: FxHashMap, nonlexical_regioncx: Option>, } +// Two-phase borrows actually requires two flow analyses; they need +// to be separate because the final results of the first are used to +// construct the gen+kill sets for the second. (The dataflow system +// is not designed to allow the gen/kill sets to change during the +// fixed-point iteration.) + +/// The `Reservations` analysis is the first of the two flow analyses +/// tracking (phased) borrows. It computes where a borrow is reserved; +/// i.e. where it can reach in the control flow starting from its +/// initial `assigned = &'rgn borrowed` statement, and ending +/// whereever `'rgn` itself ends. +pub(crate) struct Reservations<'a, 'gcx: 'tcx, 'tcx: 'a>(pub(crate) Borrows<'a, 'gcx, 'tcx>); + +/// The `ActiveBorrows` analysis is the second of the two flow +/// analyses tracking (phased) borrows. It computes where any given +/// borrow `&assigned = &'rgn borrowed` is *active*, which starts at +/// the first use of `assigned` after the reservation has started, and +/// ends whereever `'rgn` itself ends. +pub(crate) struct ActiveBorrows<'a, 'gcx: 'tcx, 'tcx: 'a>(pub(crate) Borrows<'a, 'gcx, 'tcx>); + +impl<'a, 'gcx, 'tcx> Reservations<'a, 'gcx, 'tcx> { + pub(crate) fn new(b: Borrows<'a, 'gcx, 'tcx>) -> Self { Reservations(b) } + pub(crate) fn location(&self, idx: ReserveOrActivateIndex) -> &Location { + self.0.location(idx.borrow_index()) + } +} + +impl<'a, 'gcx, 'tcx> ActiveBorrows<'a, 'gcx, 'tcx> { + pub(crate) fn new(r: Reservations<'a, 'gcx, 'tcx>) -> Self { ActiveBorrows(r.0) } + pub(crate) fn location(&self, idx: ReserveOrActivateIndex) -> &Location { + self.0.location(idx.borrow_index()) + } +} + // temporarily allow some dead fields: `kind` and `region` will be -// needed by borrowck; `place` will probably be a MovePathIndex when +// needed by borrowck; `borrowed_place` will probably be a MovePathIndex when // that is extended to include borrowed data paths. #[allow(dead_code)] #[derive(Debug)] @@ -57,7 +112,8 @@ pub struct BorrowData<'tcx> { pub(crate) location: Location, pub(crate) kind: mir::BorrowKind, pub(crate) region: Region<'tcx>, - pub(crate) place: mir::Place<'tcx>, + pub(crate) borrowed_place: mir::Place<'tcx>, + pub(crate) assigned_place: mir::Place<'tcx>, } impl<'tcx> fmt::Display for BorrowData<'tcx> { @@ -69,7 +125,22 @@ impl<'tcx> fmt::Display for BorrowData<'tcx> { }; let region = format!("{}", self.region); let region = if region.len() > 0 { format!("{} ", region) } else { region }; - write!(w, "&{}{}{:?}", region, kind, self.place) + write!(w, "&{}{}{:?}", region, kind, self.borrowed_place) + } +} + +impl ReserveOrActivateIndex { + fn reserved(i: BorrowIndex) -> Self { ReserveOrActivateIndex::new((i.index() * 2)) } + fn active(i: BorrowIndex) -> Self { ReserveOrActivateIndex::new((i.index() * 2) + 1) } + + pub(crate) fn is_reservation(self) -> bool { self.index() % 2 == 0 } + pub(crate) fn is_activation(self) -> bool { self.index() % 2 == 1} + + pub(crate) fn kind(self) -> &'static str { + if self.is_reservation() { "reserved" } else { "active" } + } + pub(crate) fn borrow_index(self) -> BorrowIndex { + BorrowIndex::new(self.index() / 2) } } @@ -89,6 +160,7 @@ impl<'a, 'gcx, 'tcx> Borrows<'a, 'gcx, 'tcx> { mir, idx_vec: IndexVec::new(), location_map: FxHashMap(), + assigned_map: FxHashMap(), region_map: FxHashMap(), local_map: FxHashMap(), region_span_map: FxHashMap() @@ -100,6 +172,7 @@ impl<'a, 'gcx, 'tcx> Borrows<'a, 'gcx, 'tcx> { scope_tree, root_scope, location_map: visitor.location_map, + assigned_map: visitor.assigned_map, region_map: visitor.region_map, local_map: visitor.local_map, region_span_map: visitor.region_span_map, @@ -110,13 +183,16 @@ impl<'a, 'gcx, 'tcx> Borrows<'a, 'gcx, 'tcx> { mir: &'a Mir<'tcx>, idx_vec: IndexVec>, location_map: FxHashMap, + assigned_map: FxHashMap, FxHashSet>, region_map: FxHashMap, FxHashSet>, local_map: FxHashMap>, region_span_map: FxHashMap, } impl<'a, 'gcx, 'tcx> Visitor<'tcx> for GatherBorrows<'a, 'gcx, 'tcx> { - fn visit_rvalue(&mut self, + fn visit_assign(&mut self, + block: mir::BasicBlock, + assigned_place: &mir::Place<'tcx>, rvalue: &mir::Rvalue<'tcx>, location: mir::Location) { fn root_local(mut p: &mir::Place<'_>) -> Option { @@ -127,23 +203,59 @@ impl<'a, 'gcx, 'tcx> Borrows<'a, 'gcx, 'tcx> { }} } - if let mir::Rvalue::Ref(region, kind, ref place) = *rvalue { - if is_unsafe_place(self.tcx, self.mir, place) { return; } + if let mir::Rvalue::Ref(region, kind, ref borrowed_place) = *rvalue { + if is_unsafe_place(self.tcx, self.mir, borrowed_place) { return; } let borrow = BorrowData { - location: location, kind: kind, region: region, place: place.clone(), + location, kind, region, + borrowed_place: borrowed_place.clone(), + assigned_place: assigned_place.clone(), }; let idx = self.idx_vec.push(borrow); self.location_map.insert(location, idx); - let borrows = self.region_map.entry(region).or_insert(FxHashSet()); - borrows.insert(idx); + insert(&mut self.assigned_map, assigned_place, idx); + insert(&mut self.region_map, ®ion, idx); + if let Some(local) = root_local(borrowed_place) { + insert(&mut self.local_map, &local, idx); + } + } - if let Some(local) = root_local(place) { - let borrows = self.local_map.entry(local).or_insert(FxHashSet()); - borrows.insert(idx); + return self.super_assign(block, assigned_place, rvalue, location); + + fn insert<'a, K, V>(map: &'a mut FxHashMap>, + k: &K, + v: V) + where K: Clone+Eq+Hash, V: Eq+Hash + { + map.entry(k.clone()) + .or_insert(FxHashSet()) + .insert(v); + } + } + + fn visit_rvalue(&mut self, + rvalue: &mir::Rvalue<'tcx>, + location: mir::Location) { + if let mir::Rvalue::Ref(region, kind, ref place) = *rvalue { + // double-check that we already registered a BorrowData for this + + let mut found_it = false; + for idx in &self.region_map[region] { + let bd = &self.idx_vec[*idx]; + if bd.location == location && + bd.kind == kind && + bd.region == region && + bd.borrowed_place == *place + { + found_it = true; + break; + } } + assert!(found_it, "Ref {:?} at {:?} missing BorrowData", rvalue, location); } + + return self.super_rvalue(rvalue, location); } fn visit_statement(&mut self, @@ -153,7 +265,7 @@ impl<'a, 'gcx, 'tcx> Borrows<'a, 'gcx, 'tcx> { if let mir::StatementKind::EndRegion(region_scope) = statement.kind { self.region_span_map.insert(ReScope(region_scope), statement.source_info.span); } - self.super_statement(block, statement, location); + return self.super_statement(block, statement, location); } } } @@ -166,80 +278,95 @@ impl<'a, 'gcx, 'tcx> Borrows<'a, 'gcx, 'tcx> { &self.borrows[idx].location } - /// Returns the span for the "end point" given region. This will - /// return `None` if NLL is enabled, since that concept has no - /// meaning there. Otherwise, return region span if it exists and - /// span for end of the function if it doesn't exist. - pub fn opt_region_end_span(&self, region: &Region) -> Option { - match self.nonlexical_regioncx { - Some(_) => None, - None => { - match self.region_span_map.get(region) { - Some(span) => Some(span.end_point()), - None => Some(self.mir.span.end_point()) - } - } - } - } - /// Add all borrows to the kill set, if those borrows are out of scope at `location`. + /// + /// `is_activations` tracks whether we are in the Reservations or + /// the ActiveBorrows flow analysis, and does not set the + /// activation kill bits in the former case. (Technically, we + /// could set those kill bits without such a guard, since they are + /// never gen'ed by Reservations in the first place. But it makes + /// the instrumentation and graph renderings nicer to leave + /// activations out when of the Reservations kill sets.) fn kill_loans_out_of_scope_at_location(&self, - sets: &mut BlockSets, - location: Location) { + sets: &mut BlockSets, + location: Location, + is_activations: bool) { if let Some(ref regioncx) = self.nonlexical_regioncx { + // NOTE: The state associated with a given `location` + // reflects the dataflow on entry to the statement. If it + // does not contain `borrow_region`, then then that means + // that the statement at `location` kills the borrow. + // + // We are careful always to call this function *before* we + // set up the gen-bits for the statement or + // termanator. That way, if the effect of the statement or + // terminator *does* introduce a new loan of the same + // region, then setting that gen-bit will override any + // potential kill introduced here. for (borrow_index, borrow_data) in self.borrows.iter_enumerated() { let borrow_region = borrow_data.region.to_region_vid(); if !regioncx.region_contains_point(borrow_region, location) { - // The region checker really considers the borrow - // to start at the point **after** the location of - // the borrow, but the borrow checker puts the gen - // directly **on** the location of the - // borrow. This results in a gen/kill both being - // generated for same point if we are not - // careful. Probably we should change the point of - // the gen, but for now we hackily account for the - // mismatch here by not generating a kill for the - // location on the borrow itself. - if location != borrow_data.location { - sets.kill(&borrow_index); + sets.kill(&ReserveOrActivateIndex::reserved(borrow_index)); + if is_activations { + sets.kill(&ReserveOrActivateIndex::active(borrow_index)); } } } } } -} -impl<'a, 'gcx, 'tcx> BitDenotation for Borrows<'a, 'gcx, 'tcx> { - type Idx = BorrowIndex; - fn name() -> &'static str { "borrows" } - fn bits_per_block(&self) -> usize { - self.borrows.len() - } - fn start_block_effect(&self, _sets: &mut IdxSet) { - // no borrows of code region_scopes have been taken prior to - // function execution, so this method has no effect on - // `_sets`. - } - fn statement_effect(&self, - sets: &mut BlockSets, - location: Location) { + /// Models statement effect in Reservations and ActiveBorrows flow + /// analyses; `is activations` tells us if we are in the latter + /// case. + fn statement_effect_on_borrows(&self, + sets: &mut BlockSets, + location: Location, + is_activations: bool) { let block = &self.mir.basic_blocks().get(location.block).unwrap_or_else(|| { panic!("could not find block at location {:?}", location); }); let stmt = block.statements.get(location.statement_index).unwrap_or_else(|| { panic!("could not find statement at location {:?}"); }); + + // Do kills introduced by NLL before setting up any potential + // gens. (See NOTE in kill_loans_out_of_scope_at_location.) + self.kill_loans_out_of_scope_at_location(sets, location, is_activations); + + if is_activations { + // INVARIANT: `sets.on_entry` accurately captures + // reservations on entry to statement (b/c + // accumulates_intrablock_state is overridden for + // ActiveBorrows). + // + // Now compute the activations generated by uses within + // the statement based on that reservation state. + let mut find = FindPlaceUses { sets, assigned_map: &self.assigned_map }; + find.visit_statement(location.block, stmt, location); + } + match stmt.kind { + // EndRegion kills any borrows (reservations and active borrows both) mir::StatementKind::EndRegion(region_scope) => { if let Some(borrow_indexes) = self.region_map.get(&ReScope(region_scope)) { assert!(self.nonlexical_regioncx.is_none()); - sets.kill_all(borrow_indexes); + for idx in borrow_indexes { + sets.kill(&ReserveOrActivateIndex::reserved(*idx)); + if is_activations { + sets.kill(&ReserveOrActivateIndex::active(*idx)); + } + } } else { // (if there is no entry, then there are no borrows to be tracked) } } mir::StatementKind::Assign(_, ref rhs) => { + // NOTE: if/when the Assign case is revised to inspect + // the assigned_place here, make sure to also + // re-consider the current implementations of the + // propagate_call_return method. + if let mir::Rvalue::Ref(region, _, ref place) = *rhs { if is_unsafe_place(self.tcx, self.mir, place) { return; } if let RegionKind::ReEmpty = region { @@ -254,7 +381,7 @@ impl<'a, 'gcx, 'tcx> BitDenotation for Borrows<'a, 'gcx, 'tcx> { assert!(self.region_map.get(region).unwrap_or_else(|| { panic!("could not find BorrowIndexs for region {:?}", region); }).contains(&index)); - sets.gen(&index); + sets.gen(&ReserveOrActivateIndex::reserved(*index)); } } @@ -264,7 +391,12 @@ impl<'a, 'gcx, 'tcx> BitDenotation for Borrows<'a, 'gcx, 'tcx> { // // FIXME: expand this to variables that are assigned over. if let Some(borrow_indexes) = self.local_map.get(&local) { - sets.kill_all(borrow_indexes); + sets.kill_all(borrow_indexes.iter() + .map(|b| ReserveOrActivateIndex::reserved(*b))); + if is_activations { + sets.kill_all(borrow_indexes.iter() + .map(|b| ReserveOrActivateIndex::active(*b))); + } } } @@ -275,17 +407,37 @@ impl<'a, 'gcx, 'tcx> BitDenotation for Borrows<'a, 'gcx, 'tcx> { mir::StatementKind::Nop => {} } - - self.kill_loans_out_of_scope_at_location(sets, location); } - fn terminator_effect(&self, - sets: &mut BlockSets, - location: Location) { + /// Models terminator effect in Reservations and ActiveBorrows + /// flow analyses; `is activations` tells us if we are in the + /// latter case. + fn terminator_effect_on_borrows(&self, + sets: &mut BlockSets, + location: Location, + is_activations: bool) { let block = &self.mir.basic_blocks().get(location.block).unwrap_or_else(|| { panic!("could not find block at location {:?}", location); }); - match block.terminator().kind { + + // Do kills introduced by NLL before setting up any potential + // gens. (See NOTE in kill_loans_out_of_scope_at_location.) + self.kill_loans_out_of_scope_at_location(sets, location, is_activations); + + let term = block.terminator(); + if is_activations { + // INVARIANT: `sets.on_entry` accurately captures + // reservations on entry to terminator (b/c + // accumulates_intrablock_state is overridden for + // ActiveBorrows). + // + // Now compute effect of the terminator on the activations + // themselves in the ActiveBorrows state. + let mut find = FindPlaceUses { sets, assigned_map: &self.assigned_map }; + find.visit_terminator(location.block, term, location); + } + + match term.kind { mir::TerminatorKind::Resume | mir::TerminatorKind::Return | mir::TerminatorKind::GeneratorDrop => { @@ -304,7 +456,10 @@ impl<'a, 'gcx, 'tcx> BitDenotation for Borrows<'a, 'gcx, 'tcx> { if *scope != root_scope && self.scope_tree.is_subscope_of(*scope, root_scope) { - sets.kill(&borrow_index); + sets.kill(&ReserveOrActivateIndex::reserved(borrow_index)); + if is_activations { + sets.kill(&ReserveOrActivateIndex::active(borrow_index)); + } } } } @@ -320,29 +475,223 @@ impl<'a, 'gcx, 'tcx> BitDenotation for Borrows<'a, 'gcx, 'tcx> { mir::TerminatorKind::FalseEdges {..} | mir::TerminatorKind::Unreachable => {} } - self.kill_loans_out_of_scope_at_location(sets, location); + } +} + +impl<'a, 'gcx, 'tcx> ActiveBorrows<'a, 'gcx, 'tcx> { + pub(crate) fn borrows(&self) -> &IndexVec> { + self.0.borrows() + } + + /// Returns the span for the "end point" given region. This will + /// return `None` if NLL is enabled, since that concept has no + /// meaning there. Otherwise, return region span if it exists and + /// span for end of the function if it doesn't exist. + pub(crate) fn opt_region_end_span(&self, region: &Region) -> Option { + match self.0.nonlexical_regioncx { + Some(_) => None, + None => { + match self.0.region_span_map.get(region) { + Some(span) => Some(span.end_point()), + None => Some(self.0.mir.span.end_point()) + } + } + } + } +} + +/// `FindPlaceUses` is a MIR visitor that updates `self.sets` for all +/// of the borrows activated by a given statement or terminator. +/// +/// ---- +/// +/// The `ActiveBorrows` flow analysis, when inspecting any given +/// statement or terminator, needs to "generate" (i.e. set to 1) all +/// of the bits for the borrows that are activated by that +/// statement/terminator. +/// +/// This struct will seek out all places that are assignment-targets +/// for borrows (gathered in `self.assigned_map`; see also the +/// `assigned_map` in `struct Borrows`), and set the corresponding +/// gen-bits for activations of those borrows in `self.sets` +struct FindPlaceUses<'a, 'b: 'a, 'tcx: 'a> { + assigned_map: &'a FxHashMap, FxHashSet>, + sets: &'a mut BlockSets<'b, ReserveOrActivateIndex>, +} + +impl<'a, 'b, 'tcx> FindPlaceUses<'a, 'b, 'tcx> { + fn has_been_reserved(&self, b: &BorrowIndex) -> bool { + self.sets.on_entry.contains(&ReserveOrActivateIndex::reserved(*b)) + } + + /// return whether `context` should be considered a "use" of a + /// place found in that context. "Uses" activate associated + /// borrows (at least when such uses occur while the borrow also + /// has a reservation at the time). + fn is_potential_use(context: PlaceContext) -> bool { + match context { + // storage effects on an place do not activate it + PlaceContext::StorageLive | PlaceContext::StorageDead => false, + + // validation effects do not activate an place + // + // FIXME: Should they? Is it just another read? Or can we + // guarantee it won't dereference the stored address? How + // "deep" does validation go? + PlaceContext::Validate => false, + + // pure overwrites of an place do not activate it. (note + // PlaceContext::Call is solely about dest place) + PlaceContext::Store | PlaceContext::Call => false, + + // reads of an place *do* activate it + PlaceContext::Move | + PlaceContext::Copy | + PlaceContext::Drop | + PlaceContext::Inspect | + PlaceContext::Borrow { .. } | + PlaceContext::Projection(..) => true, + } + } +} + +impl<'a, 'b, 'tcx> Visitor<'tcx> for FindPlaceUses<'a, 'b, 'tcx> { + fn visit_place(&mut self, + place: &mir::Place<'tcx>, + context: PlaceContext<'tcx>, + location: Location) { + debug!("FindPlaceUses place: {:?} assigned from borrows: {:?} \ + used in context: {:?} at location: {:?}", + place, self.assigned_map.get(place), context, location); + if Self::is_potential_use(context) { + if let Some(borrows) = self.assigned_map.get(place) { + for borrow_idx in borrows { + debug!("checking if index {:?} for {:?} is reserved ({}) \ + and thus needs active gen-bit set in sets {:?}", + borrow_idx, place, self.has_been_reserved(&borrow_idx), self.sets); + if self.has_been_reserved(&borrow_idx) { + self.sets.gen(&ReserveOrActivateIndex::active(*borrow_idx)); + } else { + // (This can certainly happen in valid code. I + // just want to know about it in the short + // term.) + debug!("encountered use of Place {:?} of borrow_idx {:?} \ + at location {:?} outside of reservation", + place, borrow_idx, location); + } + } + } + } + + self.super_place(place, context, location); + } +} + + +impl<'a, 'gcx, 'tcx> BitDenotation for Reservations<'a, 'gcx, 'tcx> { + type Idx = ReserveOrActivateIndex; + fn name() -> &'static str { "reservations" } + fn bits_per_block(&self) -> usize { + self.0.borrows.len() * 2 + } + fn start_block_effect(&self, _entry_set: &mut IdxSet) { + // no borrows of code region_scopes have been taken prior to + // function execution, so this method has no effect on + // `_sets`. + } + + fn statement_effect(&self, + sets: &mut BlockSets, + location: Location) { + debug!("Reservations::statement_effect sets: {:?} location: {:?}", sets, location); + self.0.statement_effect_on_borrows(sets, location, false); + } + + fn terminator_effect(&self, + sets: &mut BlockSets, + location: Location) { + debug!("Reservations::terminator_effect sets: {:?} location: {:?}", sets, location); + self.0.terminator_effect_on_borrows(sets, location, false); } fn propagate_call_return(&self, - _in_out: &mut IdxSet, + _in_out: &mut IdxSet, _call_bb: mir::BasicBlock, _dest_bb: mir::BasicBlock, _dest_place: &mir::Place) { - // there are no effects on the region scopes from method calls. + // there are no effects on borrows from method call return... + // + // ... but if overwriting a place can affect flow state, then + // latter is not true; see NOTE on Assign case in + // statement_effect_on_borrows. + } +} + +impl<'a, 'gcx, 'tcx> BitDenotation for ActiveBorrows<'a, 'gcx, 'tcx> { + type Idx = ReserveOrActivateIndex; + fn name() -> &'static str { "active_borrows" } + + /// Overriding this method; `ActiveBorrows` uses the intrablock + /// state in `on_entry` to track the current reservations (which + /// then affect the construction of the gen/kill sets for + /// activations). + fn accumulates_intrablock_state() -> bool { true } + + fn bits_per_block(&self) -> usize { + self.0.borrows.len() * 2 + } + + fn start_block_effect(&self, _entry_sets: &mut IdxSet) { + // no borrows of code region_scopes have been taken prior to + // function execution, so this method has no effect on + // `_sets`. + } + + fn statement_effect(&self, + sets: &mut BlockSets, + location: Location) { + debug!("ActiveBorrows::statement_effect sets: {:?} location: {:?}", sets, location); + self.0.statement_effect_on_borrows(sets, location, true); + } + + fn terminator_effect(&self, + sets: &mut BlockSets, + location: Location) { + debug!("ActiveBorrows::terminator_effect sets: {:?} location: {:?}", sets, location); + self.0.terminator_effect_on_borrows(sets, location, true); + } + + fn propagate_call_return(&self, + _in_out: &mut IdxSet, + _call_bb: mir::BasicBlock, + _dest_bb: mir::BasicBlock, + _dest_place: &mir::Place) { + // there are no effects on borrows from method call return... + // + // ... but If overwriting a place can affect flow state, then + // latter is not true; see NOTE on Assign case in + // statement_effect_on_borrows. + } +} + +impl<'a, 'gcx, 'tcx> BitwiseOperator for Reservations<'a, 'gcx, 'tcx> { + #[inline] + fn join(&self, pred1: usize, pred2: usize) -> usize { + pred1 | pred2 // union effects of preds when computing reservations } } -impl<'a, 'gcx, 'tcx> BitwiseOperator for Borrows<'a, 'gcx, 'tcx> { +impl<'a, 'gcx, 'tcx> BitwiseOperator for ActiveBorrows<'a, 'gcx, 'tcx> { #[inline] fn join(&self, pred1: usize, pred2: usize) -> usize { - pred1 | pred2 // union effects of preds when computing borrows + pred1 | pred2 // union effects of preds when computing activations } } -impl<'a, 'gcx, 'tcx> DataflowOperator for Borrows<'a, 'gcx, 'tcx> { +impl<'a, 'gcx, 'tcx> InitialFlow for Reservations<'a, 'gcx, 'tcx> { #[inline] fn bottom_value() -> bool { - false // bottom = no Rvalue::Refs are active by default + false // bottom = no Rvalue::Refs are reserved by default } } diff --git a/src/librustc_mir/dataflow/impls/mod.rs b/src/librustc_mir/dataflow/impls/mod.rs index 033d2a3212f8c..106a88e703c79 100644 --- a/src/librustc_mir/dataflow/impls/mod.rs +++ b/src/librustc_mir/dataflow/impls/mod.rs @@ -23,7 +23,7 @@ use util::elaborate_drops::DropFlagState; use super::move_paths::{HasMoveData, MoveData, MoveOutIndex, MovePathIndex, InitIndex}; use super::move_paths::{LookupResult, InitKind}; -use super::{BitDenotation, BlockSets, DataflowOperator}; +use super::{BitDenotation, BlockSets, InitialFlow}; use super::drop_flag_effects_for_function_entry; use super::drop_flag_effects_for_location; @@ -702,35 +702,35 @@ impl<'a, 'gcx, 'tcx> BitwiseOperator for EverInitializedLvals<'a, 'gcx, 'tcx> { // propagating, or you start at all-ones and then use Intersect as // your merge when propagating. -impl<'a, 'gcx, 'tcx> DataflowOperator for MaybeInitializedLvals<'a, 'gcx, 'tcx> { +impl<'a, 'gcx, 'tcx> InitialFlow for MaybeInitializedLvals<'a, 'gcx, 'tcx> { #[inline] fn bottom_value() -> bool { false // bottom = uninitialized } } -impl<'a, 'gcx, 'tcx> DataflowOperator for MaybeUninitializedLvals<'a, 'gcx, 'tcx> { +impl<'a, 'gcx, 'tcx> InitialFlow for MaybeUninitializedLvals<'a, 'gcx, 'tcx> { #[inline] fn bottom_value() -> bool { false // bottom = initialized (start_block_effect counters this at outset) } } -impl<'a, 'gcx, 'tcx> DataflowOperator for DefinitelyInitializedLvals<'a, 'gcx, 'tcx> { +impl<'a, 'gcx, 'tcx> InitialFlow for DefinitelyInitializedLvals<'a, 'gcx, 'tcx> { #[inline] fn bottom_value() -> bool { true // bottom = initialized (start_block_effect counters this at outset) } } -impl<'a, 'gcx, 'tcx> DataflowOperator for MovingOutStatements<'a, 'gcx, 'tcx> { +impl<'a, 'gcx, 'tcx> InitialFlow for MovingOutStatements<'a, 'gcx, 'tcx> { #[inline] fn bottom_value() -> bool { false // bottom = no loans in scope by default } } -impl<'a, 'gcx, 'tcx> DataflowOperator for EverInitializedLvals<'a, 'gcx, 'tcx> { +impl<'a, 'gcx, 'tcx> InitialFlow for EverInitializedLvals<'a, 'gcx, 'tcx> { #[inline] fn bottom_value() -> bool { false // bottom = no initialized variables by default diff --git a/src/librustc_mir/dataflow/impls/storage_liveness.rs b/src/librustc_mir/dataflow/impls/storage_liveness.rs index 9e5a71683781b..dea61542ac4e2 100644 --- a/src/librustc_mir/dataflow/impls/storage_liveness.rs +++ b/src/librustc_mir/dataflow/impls/storage_liveness.rs @@ -74,7 +74,7 @@ impl<'a, 'tcx> BitwiseOperator for MaybeStorageLive<'a, 'tcx> { } } -impl<'a, 'tcx> DataflowOperator for MaybeStorageLive<'a, 'tcx> { +impl<'a, 'tcx> InitialFlow for MaybeStorageLive<'a, 'tcx> { #[inline] fn bottom_value() -> bool { false // bottom = dead diff --git a/src/librustc_mir/dataflow/mod.rs b/src/librustc_mir/dataflow/mod.rs index 2136b41e46222..83c46e0199eeb 100644 --- a/src/librustc_mir/dataflow/mod.rs +++ b/src/librustc_mir/dataflow/mod.rs @@ -18,8 +18,8 @@ use rustc::ty::{self, TyCtxt}; use rustc::mir::{self, Mir, BasicBlock, BasicBlockData, Location, Statement, Terminator}; use rustc::session::Session; -use std::borrow::Borrow; -use std::fmt::{self, Debug}; +use std::borrow::{Borrow, Cow}; +use std::fmt; use std::io; use std::mem; use std::path::PathBuf; @@ -29,7 +29,8 @@ pub use self::impls::{MaybeStorageLive}; pub use self::impls::{MaybeInitializedLvals, MaybeUninitializedLvals}; pub use self::impls::{DefinitelyInitializedLvals, MovingOutStatements}; pub use self::impls::EverInitializedLvals; -pub use self::impls::borrows::{Borrows, BorrowData, BorrowIndex}; +pub use self::impls::borrows::{Borrows, BorrowData}; +pub(crate) use self::impls::borrows::{ActiveBorrows, Reservations, ReserveOrActivateIndex}; pub use self::at_location::{FlowAtLocation, FlowsAtLocation}; pub(crate) use self::drop_flag_effects::*; @@ -51,10 +52,29 @@ pub(crate) struct DataflowBuilder<'a, 'tcx: 'a, BD> where BD: BitDenotation print_postflow_to: Option, } -pub trait Dataflow { +/// `DebugFormatted` encapsulates the "{:?}" rendering of some +/// arbitrary value. This way: you pay cost of allocating an extra +/// string (as well as that of rendering up-front); in exchange, you +/// don't have to hand over ownership of your value or deal with +/// borrowing it. +pub(crate) struct DebugFormatted(String); + +impl DebugFormatted { + pub fn new(input: &fmt::Debug) -> DebugFormatted { + DebugFormatted(format!("{:?}", input)) + } +} + +impl fmt::Debug for DebugFormatted { + fn fmt(&self, w: &mut fmt::Formatter) -> fmt::Result { + write!(w, "{}", self.0) + } +} + +pub(crate) trait Dataflow { /// Sets up and runs the dataflow problem, using `p` to render results if /// implementation so chooses. - fn dataflow

(&mut self, p: P) where P: Fn(&BD, BD::Idx) -> &Debug { + fn dataflow

(&mut self, p: P) where P: Fn(&BD, BD::Idx) -> DebugFormatted { let _ = p; // default implementation does not instrument process. self.build_sets(); self.propagate(); @@ -69,7 +89,7 @@ pub trait Dataflow { impl<'a, 'tcx: 'a, BD> Dataflow for DataflowBuilder<'a, 'tcx, BD> where BD: BitDenotation { - fn dataflow

(&mut self, p: P) where P: Fn(&BD, BD::Idx) -> &Debug { + fn dataflow

(&mut self, p: P) where P: Fn(&BD, BD::Idx) -> DebugFormatted { self.flow_state.build_sets(); self.pre_dataflow_instrumentation(|c,i| p(c,i)).unwrap(); self.flow_state.propagate(); @@ -101,44 +121,56 @@ pub struct MoveDataParamEnv<'gcx, 'tcx> { } pub(crate) fn do_dataflow<'a, 'gcx, 'tcx, BD, P>(tcx: TyCtxt<'a, 'gcx, 'tcx>, - mir: &Mir<'tcx>, + mir: &'a Mir<'tcx>, node_id: ast::NodeId, attributes: &[ast::Attribute], dead_unwinds: &IdxSet, bd: BD, p: P) -> DataflowResults - where BD: BitDenotation, - P: Fn(&BD, BD::Idx) -> &fmt::Debug + where BD: BitDenotation + InitialFlow, + P: Fn(&BD, BD::Idx) -> DebugFormatted { - let name_found = |sess: &Session, attrs: &[ast::Attribute], name| -> Option { - if let Some(item) = has_rustc_mir_with(attrs, name) { - if let Some(s) = item.value_str() { - return Some(s.to_string()) - } else { - sess.span_err( - item.span, - &format!("{} attribute requires a path", item.name())); - return None; + let flow_state = DataflowAnalysis::new(mir, dead_unwinds, bd); + flow_state.run(tcx, node_id, attributes, p) +} + +impl<'a, 'gcx: 'tcx, 'tcx: 'a, BD> DataflowAnalysis<'a, 'tcx, BD> where BD: BitDenotation +{ + pub(crate) fn run

(self, + tcx: TyCtxt<'a, 'gcx, 'tcx>, + node_id: ast::NodeId, + attributes: &[ast::Attribute], + p: P) -> DataflowResults + where P: Fn(&BD, BD::Idx) -> DebugFormatted + { + let name_found = |sess: &Session, attrs: &[ast::Attribute], name| -> Option { + if let Some(item) = has_rustc_mir_with(attrs, name) { + if let Some(s) = item.value_str() { + return Some(s.to_string()) + } else { + sess.span_err( + item.span, + &format!("{} attribute requires a path", item.name())); + return None; + } } - } - return None; - }; + return None; + }; - let print_preflow_to = - name_found(tcx.sess, attributes, "borrowck_graphviz_preflow"); - let print_postflow_to = - name_found(tcx.sess, attributes, "borrowck_graphviz_postflow"); + let print_preflow_to = + name_found(tcx.sess, attributes, "borrowck_graphviz_preflow"); + let print_postflow_to = + name_found(tcx.sess, attributes, "borrowck_graphviz_postflow"); - let mut mbcx = DataflowBuilder { - node_id, - print_preflow_to, - print_postflow_to, - flow_state: DataflowAnalysis::new(tcx, mir, dead_unwinds, bd), - }; + let mut mbcx = DataflowBuilder { + node_id, + print_preflow_to, print_postflow_to, flow_state: self, + }; - mbcx.dataflow(p); - mbcx.flow_state.results() + mbcx.dataflow(p); + mbcx.flow_state.results() + } } struct PropagationContext<'b, 'a: 'b, 'tcx: 'a, O> where O: 'b + BitDenotation @@ -157,17 +189,12 @@ impl<'a, 'tcx: 'a, BD> DataflowAnalysis<'a, 'tcx, BD> where BD: BitDenotation }; while propcx.changed { propcx.changed = false; - propcx.reset(&mut temp); propcx.walk_cfg(&mut temp); } } fn build_sets(&mut self) { - // First we need to build the entry-, gen- and kill-sets. The - // gather_moves information provides a high-level mapping from - // mir-locations to the MoveOuts (and those correspond - // directly to gen-sets here). But we still need to figure out - // the kill-sets. + // First we need to build the entry-, gen- and kill-sets. { let sets = &mut self.flow_state.sets.for_block(mir::START_BLOCK.index()); @@ -177,15 +204,28 @@ impl<'a, 'tcx: 'a, BD> DataflowAnalysis<'a, 'tcx, BD> where BD: BitDenotation for (bb, data) in self.mir.basic_blocks().iter_enumerated() { let &mir::BasicBlockData { ref statements, ref terminator, is_cleanup: _ } = data; + let mut interim_state; let sets = &mut self.flow_state.sets.for_block(bb.index()); + let track_intrablock = BD::accumulates_intrablock_state(); + if track_intrablock { + debug!("swapping in mutable on_entry, initially {:?}", sets.on_entry); + interim_state = sets.on_entry.to_owned(); + sets.on_entry = &mut interim_state; + } for j_stmt in 0..statements.len() { let location = Location { block: bb, statement_index: j_stmt }; self.flow_state.operator.statement_effect(sets, location); + if track_intrablock { + sets.apply_local_effect(); + } } if terminator.is_some() { let location = Location { block: bb, statement_index: statements.len() }; self.flow_state.operator.terminator_effect(sets, location); + if track_intrablock { + sets.apply_local_effect(); + } } } } @@ -193,13 +233,6 @@ impl<'a, 'tcx: 'a, BD> DataflowAnalysis<'a, 'tcx, BD> where BD: BitDenotation impl<'b, 'a: 'b, 'tcx: 'a, BD> PropagationContext<'b, 'a, 'tcx, BD> where BD: BitDenotation { - fn reset(&mut self, bits: &mut IdxSet) { - let e = if BD::bottom_value() {!0} else {0}; - for b in bits.words_mut() { - *b = e; - } - } - fn walk_cfg(&mut self, in_out: &mut IdxSet) { let mir = self.builder.mir; for (bb_idx, bb_data) in mir.basic_blocks().iter().enumerate() { @@ -231,7 +264,7 @@ fn dataflow_path(context: &str, prepost: &str, path: &str) -> PathBuf { impl<'a, 'tcx: 'a, BD> DataflowBuilder<'a, 'tcx, BD> where BD: BitDenotation { fn pre_dataflow_instrumentation

(&self, p: P) -> io::Result<()> - where P: Fn(&BD, BD::Idx) -> &Debug + where P: Fn(&BD, BD::Idx) -> DebugFormatted { if let Some(ref path_str) = self.print_preflow_to { let path = dataflow_path(BD::name(), "preflow", path_str); @@ -242,7 +275,7 @@ impl<'a, 'tcx: 'a, BD> DataflowBuilder<'a, 'tcx, BD> where BD: BitDenotation } fn post_dataflow_instrumentation

(&self, p: P) -> io::Result<()> - where P: Fn(&BD, BD::Idx) -> &Debug + where P: Fn(&BD, BD::Idx) -> DebugFormatted { if let Some(ref path_str) = self.print_postflow_to { let path = dataflow_path(BD::name(), "postflow", path_str); @@ -255,7 +288,7 @@ impl<'a, 'tcx: 'a, BD> DataflowBuilder<'a, 'tcx, BD> where BD: BitDenotation /// Maps each block to a set of bits #[derive(Debug)] -struct Bits { +pub(crate) struct Bits { bits: IdxSetBuf, } @@ -276,7 +309,7 @@ impl Bits { /// underlying flow analysis results, because it needs to handle cases /// where we are combining the results of *multiple* flow analyses /// (e.g. borrows + inits + uninits). -pub trait DataflowResultsConsumer<'a, 'tcx: 'a> { +pub(crate) trait DataflowResultsConsumer<'a, 'tcx: 'a> { type FlowState: FlowsAtLocation; // Observation Hooks: override (at least one of) these to get analysis feedback. @@ -403,12 +436,12 @@ impl DataflowState { words.each_bit(bits_per_block, f) } - pub fn interpret_set<'c, P>(&self, - o: &'c O, - words: &IdxSet, - render_idx: &P) - -> Vec<&'c Debug> - where P: Fn(&O, O::Idx) -> &Debug + pub(crate) fn interpret_set<'c, P>(&self, + o: &'c O, + words: &IdxSet, + render_idx: &P) + -> Vec + where P: Fn(&O, O::Idx) -> DebugFormatted { let mut v = Vec::new(); self.each_bit(words, |i| { @@ -455,6 +488,7 @@ pub struct AllSets { /// killed during the iteration. (This is such a good idea that the /// `fn gen` and `fn kill` methods that set their state enforce this /// for you.) +#[derive(Debug)] pub struct BlockSets<'a, E: Idx> { /// Dataflow state immediately before control flow enters the given block. pub(crate) on_entry: &'a mut IdxSet, @@ -496,6 +530,7 @@ impl<'a, E:Idx> BlockSets<'a, E> { self.gen_set.remove(e); self.kill_set.add(e); } + fn kill_all(&mut self, i: I) where I: IntoIterator, I::Item: Borrow @@ -504,6 +539,11 @@ impl<'a, E:Idx> BlockSets<'a, E> { self.kill(j.borrow()); } } + + fn apply_local_effect(&mut self) { + self.on_entry.union(&self.gen_set); + self.on_entry.subtract(&self.kill_set); + } } impl AllSets { @@ -532,18 +572,51 @@ impl AllSets { pub fn on_entry_set_for(&self, block_idx: usize) -> &IdxSet { self.lookup_set_for(&self.on_entry_sets, block_idx) } + pub(crate) fn entry_set_state(&self) -> &Bits { + &self.on_entry_sets + } } /// Parameterization for the precise form of data flow that is used. -pub trait DataflowOperator: BitwiseOperator { +/// `InitialFlow` handles initializing the bitvectors before any +/// code is inspected by the analysis. Analyses that need more nuanced +/// initialization (e.g. they need to consult the results of some other +/// dataflow analysis to set up the initial bitvectors) should not +/// implement this. +pub trait InitialFlow { /// Specifies the initial value for each bit in the `on_entry` set fn bottom_value() -> bool; } -pub trait BitDenotation: DataflowOperator { +pub trait BitDenotation: BitwiseOperator { /// Specifies what index type is used to access the bitvector. type Idx: Idx; + /// Some analyses want to accumulate knowledge within a block when + /// analyzing its statements for building the gen/kill sets. Override + /// this method to return true in such cases. + /// + /// When this returns true, the statement-effect (re)construction + /// will clone the `on_entry` state and pass along a reference via + /// `sets.on_entry` to that local clone into `statement_effect` and + /// `terminator_effect`). + /// + /// When its false, no local clone is constucted; instead a + /// reference directly into `on_entry` is passed along via + /// `sets.on_entry` instead, which represents the flow state at + /// the block's start, not necessarily the state immediately prior + /// to the statement/terminator under analysis. + /// + /// In either case, the passed reference is mutable; but this is a + /// wart from using the `BlockSets` type in the API; the intention + /// is that the `statement_effect` and `terminator_effect` methods + /// mutate only the gen/kill sets. + /// + /// FIXME: We should consider enforcing the intention described in + /// the previous paragraph by passing the three sets in separate + /// parameters to encode their distinct mutabilities. + fn accumulates_intrablock_state() -> bool { false } + /// A name describing the dataflow analysis that this /// BitDenotation is supporting. The name should be something /// suitable for plugging in as part of a filename e.g. avoid @@ -618,29 +691,33 @@ pub trait BitDenotation: DataflowOperator { dest_place: &mir::Place); } -impl<'a, 'gcx, 'tcx: 'a, D> DataflowAnalysis<'a, 'tcx, D> where D: BitDenotation +impl<'a, 'tcx, D> DataflowAnalysis<'a, 'tcx, D> where D: BitDenotation { - pub fn new(_tcx: TyCtxt<'a, 'gcx, 'tcx>, - mir: &'a Mir<'tcx>, + pub fn new(mir: &'a Mir<'tcx>, dead_unwinds: &'a IdxSet, - denotation: D) -> Self { + denotation: D) -> Self where D: InitialFlow { let bits_per_block = denotation.bits_per_block(); - let usize_bits = mem::size_of::() * 8; - let words_per_block = (bits_per_block + usize_bits - 1) / usize_bits; - - // (now rounded up to multiple of word size) - let bits_per_block = words_per_block * usize_bits; - - let num_blocks = mir.basic_blocks().len(); - let num_overall = num_blocks * bits_per_block; - - let zeroes = Bits::new(IdxSetBuf::new_empty(num_overall)); + let num_overall = Self::num_bits_overall(mir, bits_per_block); let on_entry = Bits::new(if D::bottom_value() { IdxSetBuf::new_filled(num_overall) } else { IdxSetBuf::new_empty(num_overall) }); + Self::new_with_entry_sets(mir, dead_unwinds, Cow::Owned(on_entry), denotation) + } + + pub(crate) fn new_with_entry_sets(mir: &'a Mir<'tcx>, + dead_unwinds: &'a IdxSet, + on_entry: Cow>, + denotation: D) + -> Self { + let bits_per_block = denotation.bits_per_block(); + let usize_bits = mem::size_of::() * 8; + let words_per_block = (bits_per_block + usize_bits - 1) / usize_bits; + let num_overall = Self::num_bits_overall(mir, bits_per_block); + assert_eq!(num_overall, on_entry.bits.words().len() * usize_bits); + let zeroes = Bits::new(IdxSetBuf::new_empty(num_overall)); DataflowAnalysis { mir, dead_unwinds, @@ -650,12 +727,23 @@ impl<'a, 'gcx, 'tcx: 'a, D> DataflowAnalysis<'a, 'tcx, D> where D: BitDenotation words_per_block, gen_sets: zeroes.clone(), kill_sets: zeroes, - on_entry_sets: on_entry, + on_entry_sets: on_entry.into_owned(), }, operator: denotation, - }, + } } + } + fn num_bits_overall(mir: &Mir, bits_per_block: usize) -> usize { + let usize_bits = mem::size_of::() * 8; + let words_per_block = (bits_per_block + usize_bits - 1) / usize_bits; + + // (now rounded up to multiple of word size) + let bits_per_block = words_per_block * usize_bits; + + let num_blocks = mir.basic_blocks().len(); + let num_overall = num_blocks * bits_per_block; + num_overall } } diff --git a/src/librustc_mir/dataflow/move_paths/mod.rs b/src/librustc_mir/dataflow/move_paths/mod.rs index 9d91e1344dc37..bcf4662211e8b 100644 --- a/src/librustc_mir/dataflow/move_paths/mod.rs +++ b/src/librustc_mir/dataflow/move_paths/mod.rs @@ -65,6 +65,9 @@ pub(crate) mod indexes { /// Index into Borrows.locations new_index!(BorrowIndex, "bw"); + + /// Index into Reservations/Activations bitvector + new_index!(ReserveOrActivateIndex, "ra"); } pub use self::indexes::MovePathIndex; diff --git a/src/librustc_mir/transform/elaborate_drops.rs b/src/librustc_mir/transform/elaborate_drops.rs index b075d2637da9b..106bc39d0fc5b 100644 --- a/src/librustc_mir/transform/elaborate_drops.rs +++ b/src/librustc_mir/transform/elaborate_drops.rs @@ -14,7 +14,7 @@ use dataflow::{DataflowResults}; use dataflow::{on_all_children_bits, on_all_drop_children_bits}; use dataflow::{drop_flag_effects_for_location, on_lookup_result_bits}; use dataflow::MoveDataParamEnv; -use dataflow; +use dataflow::{self, do_dataflow, DebugFormatted}; use rustc::hir; use rustc::ty::{self, TyCtxt}; use rustc::mir::*; @@ -59,13 +59,13 @@ impl MirPass for ElaborateDrops { }; let dead_unwinds = find_dead_unwinds(tcx, mir, id, &env); let flow_inits = - dataflow::do_dataflow(tcx, mir, id, &[], &dead_unwinds, - MaybeInitializedLvals::new(tcx, mir, &env), - |bd, p| &bd.move_data().move_paths[p]); + do_dataflow(tcx, mir, id, &[], &dead_unwinds, + MaybeInitializedLvals::new(tcx, mir, &env), + |bd, p| DebugFormatted::new(&bd.move_data().move_paths[p])); let flow_uninits = - dataflow::do_dataflow(tcx, mir, id, &[], &dead_unwinds, - MaybeUninitializedLvals::new(tcx, mir, &env), - |bd, p| &bd.move_data().move_paths[p]); + do_dataflow(tcx, mir, id, &[], &dead_unwinds, + MaybeUninitializedLvals::new(tcx, mir, &env), + |bd, p| DebugFormatted::new(&bd.move_data().move_paths[p])); ElaborateDropsCtxt { tcx, @@ -96,9 +96,9 @@ fn find_dead_unwinds<'a, 'tcx>( // reach cleanup blocks, which can't have unwind edges themselves. let mut dead_unwinds = IdxSetBuf::new_empty(mir.basic_blocks().len()); let flow_inits = - dataflow::do_dataflow(tcx, mir, id, &[], &dead_unwinds, - MaybeInitializedLvals::new(tcx, mir, &env), - |bd, p| &bd.move_data().move_paths[p]); + do_dataflow(tcx, mir, id, &[], &dead_unwinds, + MaybeInitializedLvals::new(tcx, mir, &env), + |bd, p| DebugFormatted::new(&bd.move_data().move_paths[p])); for (bb, bb_data) in mir.basic_blocks().iter_enumerated() { let location = match bb_data.terminator().kind { TerminatorKind::Drop { ref location, unwind: Some(_), .. } | diff --git a/src/librustc_mir/transform/generator.rs b/src/librustc_mir/transform/generator.rs index aaa28634eb82c..455a07c04cfc0 100644 --- a/src/librustc_mir/transform/generator.rs +++ b/src/librustc_mir/transform/generator.rs @@ -78,7 +78,7 @@ use std::mem; use transform::{MirPass, MirSource}; use transform::simplify; use transform::no_landing_pads::no_landing_pads; -use dataflow::{self, MaybeStorageLive, state_for_location}; +use dataflow::{do_dataflow, DebugFormatted, MaybeStorageLive, state_for_location}; pub struct StateTransform; @@ -341,8 +341,8 @@ fn locals_live_across_suspend_points<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, let node_id = tcx.hir.as_local_node_id(source.def_id).unwrap(); let analysis = MaybeStorageLive::new(mir); let storage_live = - dataflow::do_dataflow(tcx, mir, node_id, &[], &dead_unwinds, analysis, - |bd, p| &bd.mir().local_decls[p]); + do_dataflow(tcx, mir, node_id, &[], &dead_unwinds, analysis, + |bd, p| DebugFormatted::new(&bd.mir().local_decls[p])); let mut ignored = StorageIgnored(IdxSetBuf::new_filled(mir.local_decls.len())); ignored.visit_mir(mir); diff --git a/src/librustc_mir/transform/rustc_peek.rs b/src/librustc_mir/transform/rustc_peek.rs index 08508143976e6..6b8e2b073ccd3 100644 --- a/src/librustc_mir/transform/rustc_peek.rs +++ b/src/librustc_mir/transform/rustc_peek.rs @@ -18,7 +18,7 @@ use rustc_data_structures::indexed_set::IdxSetBuf; use rustc_data_structures::indexed_vec::Idx; use transform::{MirPass, MirSource}; -use dataflow::do_dataflow; +use dataflow::{do_dataflow, DebugFormatted}; use dataflow::MoveDataParamEnv; use dataflow::BitDenotation; use dataflow::DataflowResults; @@ -51,15 +51,15 @@ impl MirPass for SanityCheck { let flow_inits = do_dataflow(tcx, mir, id, &attributes, &dead_unwinds, MaybeInitializedLvals::new(tcx, mir, &mdpe), - |bd, i| &bd.move_data().move_paths[i]); + |bd, i| DebugFormatted::new(&bd.move_data().move_paths[i])); let flow_uninits = do_dataflow(tcx, mir, id, &attributes, &dead_unwinds, MaybeUninitializedLvals::new(tcx, mir, &mdpe), - |bd, i| &bd.move_data().move_paths[i]); + |bd, i| DebugFormatted::new(&bd.move_data().move_paths[i])); let flow_def_inits = do_dataflow(tcx, mir, id, &attributes, &dead_unwinds, DefinitelyInitializedLvals::new(tcx, mir, &mdpe), - |bd, i| &bd.move_data().move_paths[i]); + |bd, i| DebugFormatted::new(&bd.move_data().move_paths[i])); if has_rustc_mir_with(&attributes, "rustc_peek_maybe_init").is_some() { sanity_check_via_rustc_peek(tcx, mir, id, &attributes, &flow_inits); diff --git a/src/test/compile-fail/borrowck/two-phase-activation-sharing-interference.rs b/src/test/compile-fail/borrowck/two-phase-activation-sharing-interference.rs new file mode 100644 index 0000000000000..b6f5e17f1f609 --- /dev/null +++ b/src/test/compile-fail/borrowck/two-phase-activation-sharing-interference.rs @@ -0,0 +1,62 @@ +// Copyright 2017 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +// revisions: lxl nll +//[lxl]compile-flags: -Z borrowck=mir -Z two-phase-borrows +//[nll]compile-flags: -Z borrowck=mir -Z two-phase-borrows -Z nll + +// This is an important corner case pointed out by Niko: one is +// allowed to initiate a shared borrow during a reservation, but it +// *must end* before the activation occurs. +// +// FIXME: for clarity, diagnostics for these cases might be better off +// if they specifically said "cannot activate mutable borrow of `x`" + +#![allow(dead_code)] + +fn read(_: &i32) { } + +fn ok() { + let mut x = 3; + let y = &mut x; + { let z = &x; read(z); } + *y += 1; +} + +fn not_ok() { + let mut x = 3; + let y = &mut x; + let z = &x; + *y += 1; + //[lxl]~^ ERROR cannot borrow `x` as mutable because it is also borrowed as immutable + //[nll]~^^ ERROR cannot borrow `x` as mutable because it is also borrowed as immutable + read(z); +} + +fn should_be_ok_with_nll() { + let mut x = 3; + let y = &mut x; + let z = &x; + read(z); + *y += 1; + //[lxl]~^ ERROR cannot borrow `x` as mutable because it is also borrowed as immutable + // (okay with nll today) +} + +fn should_also_eventually_be_ok_with_nll() { + let mut x = 3; + let y = &mut x; + let _z = &x; + *y += 1; + //[lxl]~^ ERROR cannot borrow `x` as mutable because it is also borrowed as immutable + //[nll]~^^ ERROR cannot borrow `x` as mutable because it is also borrowed as immutable +} + +fn main() { } diff --git a/src/test/compile-fail/borrowck/two-phase-allow-access-during-reservation.rs b/src/test/compile-fail/borrowck/two-phase-allow-access-during-reservation.rs new file mode 100644 index 0000000000000..7695bd3e4652c --- /dev/null +++ b/src/test/compile-fail/borrowck/two-phase-allow-access-during-reservation.rs @@ -0,0 +1,37 @@ +// Copyright 2017 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +// revisions: lxl nll +//[lxl]compile-flags: -Z borrowck=mir -Z two-phase-borrows +//[nll]compile-flags: -Z borrowck=mir -Z two-phase-borrows -Z nll + +// This is the second counter-example from Niko's blog post +// smallcultfollowing.com/babysteps/blog/2017/03/01/nested-method-calls-via-two-phase-borrowing/ +// +// It is "artificial". It is meant to illustrate directly that we +// should allow an aliasing access during reservation, but *not* while +// the mutable borrow is active. + +fn main() { + /*0*/ let mut i = 0; + + /*1*/ let p = &mut i; // (reservation of `i` starts here) + + /*2*/ let j = i; // OK: `i` is only reserved here + + /*3*/ *p += 1; // (mutable borrow of `i` starts here, since `p` is used) + + /*4*/ let k = i; //[lxl]~ ERROR cannot use `i` because it was mutably borrowed [E0503] + //[nll]~^ ERROR cannot use `i` because it was mutably borrowed [E0503] + + /*5*/ *p += 1; + + let _ = (j, k, p); +} diff --git a/src/test/compile-fail/borrowck/two-phase-cannot-nest-mut-self-calls.rs b/src/test/compile-fail/borrowck/two-phase-cannot-nest-mut-self-calls.rs new file mode 100644 index 0000000000000..01b04708599c0 --- /dev/null +++ b/src/test/compile-fail/borrowck/two-phase-cannot-nest-mut-self-calls.rs @@ -0,0 +1,34 @@ +// Copyright 2017 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +// revisions: lxl nll +//[lxl]compile-flags: -Z borrowck=mir -Z two-phase-borrows +//[nll]compile-flags: -Z borrowck=mir -Z two-phase-borrows -Z nll + +// This is the third counter-example from Niko's blog post +// smallcultfollowing.com/babysteps/blog/2017/03/01/nested-method-calls-via-two-phase-borrowing/ +// +// It shows that not all nested method calls on `self` are magically +// allowed by this change. In particular, a nested `&mut` borrow is +// still disallowed. + +fn main() { + + + let mut vec = vec![0, 1]; + vec.get({ + + vec.push(2); + //[lxl]~^ ERROR cannot borrow `vec` as mutable because it is also borrowed as immutable + //[nll]~^^ ERROR cannot borrow `vec` as mutable because it is also borrowed as immutable + + 0 + }); +} diff --git a/src/test/compile-fail/borrowck/two-phase-reservation-sharing-interference-2.rs b/src/test/compile-fail/borrowck/two-phase-reservation-sharing-interference-2.rs new file mode 100644 index 0000000000000..fc9100c8a9a86 --- /dev/null +++ b/src/test/compile-fail/borrowck/two-phase-reservation-sharing-interference-2.rs @@ -0,0 +1,37 @@ +// Copyright 2017 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +// revisions: lxl nll +//[lxl]compile-flags: -Z borrowck=mir -Z two-phase-borrows +//[nll]compile-flags: -Z borrowck=mir -Z two-phase-borrows -Z nll + +// This is similar to two-phase-reservation-sharing-interference.rs +// in that it shows a reservation that overlaps with a shared borrow. +// +// Currently, this test fails with lexical lifetimes, but succeeds +// with non-lexical lifetimes. (The reason is because the activation +// of the mutable borrow ends up overlapping with a lexically-scoped +// shared borrow; but a non-lexical shared borrow can end before the +// activation occurs.) +// +// So this test is just making a note of the current behavior. + +#![feature(rustc_attrs)] + +#[rustc_error] +fn main() { //[nll]~ ERROR compilation successful + let mut v = vec![0, 1, 2]; + let shared = &v; + + v.push(shared.len()); + //[lxl]~^ ERROR cannot borrow `v` as mutable because it is also borrowed as immutable [E0502] + + assert_eq!(v, [0, 1, 2, 3]); +} diff --git a/src/test/compile-fail/borrowck/two-phase-reservation-sharing-interference.rs b/src/test/compile-fail/borrowck/two-phase-reservation-sharing-interference.rs new file mode 100644 index 0000000000000..cc85315263a4f --- /dev/null +++ b/src/test/compile-fail/borrowck/two-phase-reservation-sharing-interference.rs @@ -0,0 +1,46 @@ +// Copyright 2017 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +// revisions: lxl nll +//[lxl]compile-flags: -Z borrowck=mir -Z two-phase-borrows +//[nll]compile-flags: -Z borrowck=mir -Z two-phase-borrows -Z nll + +// This is a corner case that the current implementation is (probably) +// treating more conservatively than is necessary. But it also does +// not seem like a terribly important use case to cover. +// +// So this test is just making a note of the current behavior, with +// the caveat that in the future, the rules may be loosened, at which +// point this test might be thrown out. + +fn main() { + let mut vec = vec![0, 1]; + let delay: &mut Vec<_>; + { + let shared = &vec; + + // we reserve here, which could (on its own) be compatible + // with the shared borrow. But in the current implementation, + // its an error. + delay = &mut vec; + //[lxl]~^ ERROR cannot borrow `vec` as mutable because it is also borrowed as immutable + //[nll]~^^ ERROR cannot borrow `vec` as mutable because it is also borrowed as immutable + + shared[0]; + } + + // the &mut-borrow only becomes active way down here. + // + // (At least in theory; part of the reason this test fails is that + // the constructed MIR throws in extra &mut reborrows which + // flummoxes our attmpt to delay the activation point here.) + delay.push(2); +} + diff --git a/src/test/compile-fail/borrowck/two-phase-sneaky.rs b/src/test/compile-fail/borrowck/two-phase-sneaky.rs new file mode 100644 index 0000000000000..32747407c67f0 --- /dev/null +++ b/src/test/compile-fail/borrowck/two-phase-sneaky.rs @@ -0,0 +1,30 @@ +// Copyright 2017 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , 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 = vec![format!("Hello, ")]; + v[0].push_str({ + + v.push(format!("foo")); + //[lxl]~^ ERROR cannot borrow `v` as mutable more than once at a time [E0499] + //[nll]~^^ ERROR cannot borrow `v` as mutable more than once at a time [E0499] + + "World!" + }); +} diff --git a/src/test/run-pass/borrowck/two-phase-baseline.rs b/src/test/run-pass/borrowck/two-phase-baseline.rs new file mode 100644 index 0000000000000..6623444926398 --- /dev/null +++ b/src/test/run-pass/borrowck/two-phase-baseline.rs @@ -0,0 +1,21 @@ +// Copyright 2017 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +// revisions: lxl nll +//[lxl]compile-flags: -Z borrowck=mir -Z two-phase-borrows +//[nll]compile-flags: -Z borrowck=mir -Z two-phase-borrows -Z nll + +// This is the "goto example" for why we want two phase borrows. + +fn main() { + let mut v = vec![0, 1, 2]; + v.push(v.len()); + assert_eq!(v, [0, 1, 2, 3]); +} diff --git a/src/test/run-pass/borrowck/two-phase-control-flow-split-before-activation.rs b/src/test/run-pass/borrowck/two-phase-control-flow-split-before-activation.rs new file mode 100644 index 0000000000000..a891e6072a7a6 --- /dev/null +++ b/src/test/run-pass/borrowck/two-phase-control-flow-split-before-activation.rs @@ -0,0 +1,27 @@ +// Copyright 2017 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , 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) { }