src/librustc_mir/borrow_check/mod.rs

   1 // Copyright 2017 The Rust Project Developers. See the COPYRIGHT
   2 // file at the top-level directory of this distribution and at
   3 // http://rust-lang.org/COPYRIGHT.
   4 //
   5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   8 // option. This file may not be copied, modified, or distributed
   9 // except according to those terms.
  10
  11 //! This query borrow-checks the MIR to (further) ensure it is not broken.
  12
  13 use borrow_check::nll::region_infer::RegionInferenceContext;
  14 use rustc::hir;
  15 use rustc::hir::def_id::DefId;
  16 use rustc::hir::map::definitions::DefPathData;
  17 use rustc::infer::InferCtxt;
  18 use rustc::lint::builtin::UNUSED_MUT;
  19 use rustc::mir::{AggregateKind, BasicBlock, BorrowCheckResult, BorrowKind};
  20 use rustc::mir::{ClearCrossCrate, Local, Location, Mir, Mutability, Operand, Place};
  21 use rustc::mir::{Field, Projection, ProjectionElem, Rvalue, Statement, StatementKind};
  22 use rustc::mir::{Terminator, TerminatorKind};
  23 use rustc::ty::query::Providers;
  24 use rustc::ty::{self, ParamEnv, TyCtxt};
  25
  26 use rustc_data_structures::graph::dominators::Dominators;
  27 use rustc_data_structures::fx::FxHashSet;
  28 use rustc_data_structures::indexed_set::IdxSetBuf;
  29 use rustc_data_structures::indexed_vec::Idx;
  30 use rustc_data_structures::small_vec::SmallVec;
  31
  32 use std::rc::Rc;
  33
  34 use syntax_pos::Span;
  35
  36 use dataflow::indexes::BorrowIndex;
  37 use dataflow::move_paths::{HasMoveData, LookupResult, MoveData, MoveError, MovePathIndex};
  38 use dataflow::Borrows;
  39 use dataflow::DataflowResultsConsumer;
  40 use dataflow::FlowAtLocation;
  41 use dataflow::MoveDataParamEnv;
  42 use dataflow::{do_dataflow, DebugFormatted};
  43 use dataflow::{EverInitializedPlaces, MovingOutStatements};
  44 use dataflow::{MaybeInitializedPlaces, MaybeUninitializedPlaces};
  45 use util::borrowck_errors::{BorrowckErrors, Origin};
  46
  47 use self::borrow_set::{BorrowData, BorrowSet};
  48 use self::flows::Flows;
  49 use self::location::LocationTable;
  50 use self::prefixes::PrefixSet;
  51 use self::MutateMode::{JustWrite, WriteAndRead};
  52 use self::mutability_errors::AccessKind;
  53
  54 use self::path_utils::*;
  55
  56 crate mod borrow_set;
  57 mod error_reporting;
  58 mod flows;
  59 mod location;
  60 mod move_errors;
  61 mod mutability_errors;
  62 mod path_utils;
  63 crate mod place_ext;
  64 mod places_conflict;
  65 mod prefixes;
  66 mod used_muts;
  67
  68 pub(crate) mod nll;
  69
  70 pub fn provide(providers: &mut Providers) {
  71     *providers = Providers {
  72         mir_borrowck,
  73         ..*providers
  74     };
  75 }
  76
  77 fn mir_borrowck<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) -> BorrowCheckResult<'tcx> {
  78     let input_mir = tcx.mir_validated(def_id);
  79     debug!("run query mir_borrowck: {}", tcx.item_path_str(def_id));
  80
  81     let mut return_early;
  82
  83     // Return early if we are not supposed to use MIR borrow checker for this function.
  84     return_early = !tcx.has_attr(def_id, "rustc_mir") && !tcx.use_mir_borrowck();
  85
  86     if tcx.is_struct_constructor(def_id) {
  87         // We are not borrow checking the automatically generated struct constructors
  88         // because we want to accept structs such as this (taken from the `linked-hash-map`
  89         // crate):
  90         // ```rust
  91         // struct Qey<Q: ?Sized>(Q);
  92         // ```
  93         // MIR of this struct constructor looks something like this:
  94         // ```rust
  95         // fn Qey(_1: Q) -> Qey<Q>{
  96         //     let mut _0: Qey<Q>;                  // return place
  97         //
  98         //     bb0: {
  99         //         (_0.0: Q) = move _1;             // bb0[0]: scope 0 at src/main.rs:1:1: 1:26
 100         //         return;                          // bb0[1]: scope 0 at src/main.rs:1:1: 1:26
 101         //     }
 102         // }
 103         // ```
 104         // The problem here is that `(_0.0: Q) = move _1;` is valid only if `Q` is
 105         // of statically known size, which is not known to be true because of the
 106         // `Q: ?Sized` constraint. However, it is true because the constructor can be
 107         // called only when `Q` is of statically known size.
 108         return_early = true;
 109     }
 110
 111     if return_early {
 112         return BorrowCheckResult {
 113             closure_requirements: None,
 114             used_mut_upvars: SmallVec::new(),
 115         };
 116     }
 117
 118     let opt_closure_req = tcx.infer_ctxt().enter(|infcx| {
 119         let input_mir: &Mir = &input_mir.borrow();
 120         do_mir_borrowck(&infcx, input_mir, def_id)
 121     });
 122     debug!("mir_borrowck done");
 123
 124     opt_closure_req
 125 }
 126
 127 fn do_mir_borrowck<'a, 'gcx, 'tcx>(
 128     infcx: &InferCtxt<'a, 'gcx, 'tcx>,
 129     input_mir: &Mir<'gcx>,
 130     def_id: DefId,
 131 ) -> BorrowCheckResult<'gcx> {
 132     debug!("do_mir_borrowck(def_id = {:?})", def_id);
 133
 134     let tcx = infcx.tcx;
 135     let attributes = tcx.get_attrs(def_id);
 136     let param_env = tcx.param_env(def_id);
 137     let id = tcx
 138         .hir
 139         .as_local_node_id(def_id)
 140         .expect("do_mir_borrowck: non-local DefId");
 141
 142     // Replace all regions with fresh inference variables. This
 143     // requires first making our own copy of the MIR. This copy will
 144     // be modified (in place) to contain non-lexical lifetimes. It
 145     // will have a lifetime tied to the inference context.
 146     let mut mir: Mir<'tcx> = input_mir.clone();
 147     let free_regions = nll::replace_regions_in_mir(infcx, def_id, param_env, &mut mir);
 148     let mir = &mir; // no further changes
 149     let location_table = &LocationTable::new(mir);
 150
 151     let (move_data, move_errors): (MoveData<'tcx>, Option<Vec<MoveError<'tcx>>>) =
 152         match MoveData::gather_moves(mir, tcx) {
 153             Ok(move_data) => (move_data, None),
 154             Err((move_data, move_errors)) => (move_data, Some(move_errors)),
 155         };
 156
 157     let mdpe = MoveDataParamEnv {
 158         move_data: move_data,
 159         param_env: param_env,
 160     };
 161     let body_id = match tcx.def_key(def_id).disambiguated_data.data {
 162         DefPathData::StructCtor | DefPathData::EnumVariant(_) => None,
 163         _ => Some(tcx.hir.body_owned_by(id)),
 164     };
 165
 166     let dead_unwinds = IdxSetBuf::new_empty(mir.basic_blocks().len());
 167     let mut flow_inits = FlowAtLocation::new(do_dataflow(
 168         tcx,
 169         mir,
 170         id,
 171         &attributes,
 172         &dead_unwinds,
 173         MaybeInitializedPlaces::new(tcx, mir, &mdpe),
 174         |bd, i| DebugFormatted::new(&bd.move_data().move_paths[i]),
 175     ));
 176     let flow_uninits = FlowAtLocation::new(do_dataflow(
 177         tcx,
 178         mir,
 179         id,
 180         &attributes,
 181         &dead_unwinds,
 182         MaybeUninitializedPlaces::new(tcx, mir, &mdpe),
 183         |bd, i| DebugFormatted::new(&bd.move_data().move_paths[i]),
 184     ));
 185     let flow_move_outs = FlowAtLocation::new(do_dataflow(
 186         tcx,
 187         mir,
 188         id,
 189         &attributes,
 190         &dead_unwinds,
 191         MovingOutStatements::new(tcx, mir, &mdpe),
 192         |bd, i| DebugFormatted::new(&bd.move_data().moves[i]),
 193     ));
 194     let flow_ever_inits = FlowAtLocation::new(do_dataflow(
 195         tcx,
 196         mir,
 197         id,
 198         &attributes,
 199         &dead_unwinds,
 200         EverInitializedPlaces::new(tcx, mir, &mdpe),
 201         |bd, i| DebugFormatted::new(&bd.move_data().inits[i]),
 202     ));
 203
 204     let borrow_set = Rc::new(BorrowSet::build(tcx, mir));
 205
 206     // If we are in non-lexical mode, compute the non-lexical lifetimes.
 207     let (regioncx, polonius_output, opt_closure_req) = nll::compute_regions(
 208         infcx,
 209         def_id,
 210         free_regions,
 211         mir,
 212         location_table,
 213         param_env,
 214         &mut flow_inits,
 215         &mdpe.move_data,
 216         &borrow_set,
 217     );
 218     let regioncx = Rc::new(regioncx);
 219     let flow_inits = flow_inits; // remove mut
 220
 221     let flow_borrows = FlowAtLocation::new(do_dataflow(
 222         tcx,
 223         mir,
 224         id,
 225         &attributes,
 226         &dead_unwinds,
 227         Borrows::new(tcx, mir, regioncx.clone(), def_id, body_id, &borrow_set),
 228         |rs, i| DebugFormatted::new(&rs.location(i)),
 229     ));
 230
 231     let movable_generator = match tcx.hir.get(id) {
 232         hir::map::Node::NodeExpr(&hir::Expr {
 233             node: hir::ExprKind::Closure(.., Some(hir::GeneratorMovability::Static)),
 234             ..
 235         }) => false,
 236         _ => true,
 237     };
 238
 239     let dominators = mir.dominators();
 240
 241     let mut mbcx = MirBorrowckCtxt {
 242         tcx: tcx,
 243         mir: mir,
 244         mir_def_id: def_id,
 245         move_data: &mdpe.move_data,
 246         param_env: param_env,
 247         location_table,
 248         movable_generator,
 249         locals_are_invalidated_at_exit: match tcx.hir.body_owner_kind(id) {
 250             hir::BodyOwnerKind::Const | hir::BodyOwnerKind::Static(_) => false,
 251             hir::BodyOwnerKind::Fn => true,
 252         },
 253         access_place_error_reported: FxHashSet(),
 254         reservation_error_reported: FxHashSet(),
 255         moved_error_reported: FxHashSet(),
 256         nonlexical_regioncx: regioncx,
 257         used_mut: FxHashSet(),
 258         used_mut_upvars: SmallVec::new(),
 259         borrow_set,
 260         dominators,
 261     };
 262
 263     let mut state = Flows::new(
 264         flow_borrows,
 265         flow_inits,
 266         flow_uninits,
 267         flow_move_outs,
 268         flow_ever_inits,
 269         polonius_output,
 270     );
 271
 272     if let Some(errors) = move_errors {
 273         mbcx.report_move_errors(errors);
 274     }
 275     mbcx.analyze_results(&mut state); // entry point for DataflowResultsConsumer
 276
 277     // For each non-user used mutable variable, check if it's been assigned from
 278     // a user-declared local. If so, then put that local into the used_mut set.
 279     // Note that this set is expected to be small - only upvars from closures
 280     // would have a chance of erroneously adding non-user-defined mutable vars
 281     // to the set.
 282     let temporary_used_locals: FxHashSet<Local> = mbcx
 283         .used_mut
 284         .iter()
 285         .filter(|&local| !mbcx.mir.local_decls[*local].is_user_variable.is_some())
 286         .cloned()
 287         .collect();
 288     mbcx.gather_used_muts(temporary_used_locals);
 289
 290     debug!("mbcx.used_mut: {:?}", mbcx.used_mut);
 291
 292     for local in mbcx
 293         .mir
 294         .mut_vars_and_args_iter()
 295         .filter(|local| !mbcx.used_mut.contains(local))
 296     {
 297         if let ClearCrossCrate::Set(ref vsi) = mbcx.mir.source_scope_local_data {
 298             let local_decl = &mbcx.mir.local_decls[local];
 299
 300             // Skip implicit `self` argument for closures
 301             if local.index() == 1 && tcx.is_closure(mbcx.mir_def_id) {
 302                 continue;
 303             }
 304
 305             // Skip over locals that begin with an underscore or have no name
 306             match local_decl.name {
 307                 Some(name) => if name.as_str().starts_with("_") {
 308                     continue;
 309                 },
 310                 None => continue,
 311             }
 312
 313             let span = local_decl.source_info.span;
 314             let mut_span = tcx.sess.codemap().span_until_non_whitespace(span);
 315
 316             tcx.struct_span_lint_node(
 317                 UNUSED_MUT,
 318                 vsi[local_decl.source_info.scope].lint_root,
 319                 span,
 320                 "variable does not need to be mutable",
 321             ).span_suggestion_short(mut_span, "remove this `mut`", "".to_owned())
 322                 .emit();
 323         }
 324     }
 325
 326     let result = BorrowCheckResult {
 327         closure_requirements: opt_closure_req,
 328         used_mut_upvars: mbcx.used_mut_upvars,
 329     };
 330
 331     debug!("do_mir_borrowck: result = {:#?}", result);
 332
 333     result
 334 }
 335
 336 #[allow(dead_code)]
 337 pub struct MirBorrowckCtxt<'cx, 'gcx: 'tcx, 'tcx: 'cx> {
 338     tcx: TyCtxt<'cx, 'gcx, 'tcx>,
 339     mir: &'cx Mir<'tcx>,
 340     mir_def_id: DefId,
 341     move_data: &'cx MoveData<'tcx>,
 342
 343     /// Map from MIR `Location` to `LocationIndex`; created
 344     /// when MIR borrowck begins.
 345     location_table: &'cx LocationTable,
 346
 347     param_env: ParamEnv<'gcx>,
 348     movable_generator: bool,
 349     /// This keeps track of whether local variables are free-ed when the function
 350     /// exits even without a `StorageDead`, which appears to be the case for
 351     /// constants.
 352     ///
 353     /// I'm not sure this is the right approach - @eddyb could you try and
 354     /// figure this out?
 355     locals_are_invalidated_at_exit: bool,
 356     /// This field keeps track of when borrow errors are reported in the access_place function
 357     /// so that there is no duplicate reporting. This field cannot also be used for the conflicting
 358     /// borrow errors that is handled by the `reservation_error_reported` field as the inclusion
 359     /// of the `Span` type (while required to mute some errors) stops the muting of the reservation
 360     /// errors.
 361     access_place_error_reported: FxHashSet<(Place<'tcx>, Span)>,
 362     /// This field keeps track of when borrow conflict errors are reported
 363     /// for reservations, so that we don't report seemingly duplicate
 364     /// errors for corresponding activations
 365     ///
 366     /// FIXME: Ideally this would be a set of BorrowIndex, not Places,
 367     /// but it is currently inconvenient to track down the BorrowIndex
 368     /// at the time we detect and report a reservation error.
 369     reservation_error_reported: FxHashSet<Place<'tcx>>,
 370     /// This field keeps track of errors reported in the checking of moved variables,
 371     /// so that we don't report report seemingly duplicate errors.
 372     moved_error_reported: FxHashSet<Place<'tcx>>,
 373     /// This field keeps track of all the local variables that are declared mut and are mutated.
 374     /// Used for the warning issued by an unused mutable local variable.
 375     used_mut: FxHashSet<Local>,
 376     /// If the function we're checking is a closure, then we'll need to report back the list of
 377     /// mutable upvars that have been used. This field keeps track of them.
 378     used_mut_upvars: SmallVec<[Field; 8]>,
 379     /// Non-lexical region inference context, if NLL is enabled.  This
 380     /// contains the results from region inference and lets us e.g.
 381     /// find out which CFG points are contained in each borrow region.
 382     nonlexical_regioncx: Rc<RegionInferenceContext<'tcx>>,
 383
 384     /// The set of borrows extracted from the MIR
 385     borrow_set: Rc<BorrowSet<'tcx>>,
 386
 387     /// Dominators for MIR
 388     dominators: Dominators<BasicBlock>,
 389 }
 390
 391 // Check that:
 392 // 1. assignments are always made to mutable locations (FIXME: does that still really go here?)
 393 // 2. loans made in overlapping scopes do not conflict
 394 // 3. assignments do not affect things loaned out as immutable
 395 // 4. moves do not affect things loaned out in any way
 396 impl<'cx, 'gcx, 'tcx> DataflowResultsConsumer<'cx, 'tcx> for MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
 397     type FlowState = Flows<'cx, 'gcx, 'tcx>;
 398
 399     fn mir(&self) -> &'cx Mir<'tcx> {
 400         self.mir
 401     }
 402
 403     fn visit_block_entry(&mut self, bb: BasicBlock, flow_state: &Self::FlowState) {
 404         debug!("MirBorrowckCtxt::process_block({:?}): {}", bb, flow_state);
 405     }
 406
 407     fn visit_statement_entry(
 408         &mut self,
 409         location: Location,
 410         stmt: &Statement<'tcx>,
 411         flow_state: &Self::FlowState,
 412     ) {
 413         debug!(
 414             "MirBorrowckCtxt::process_statement({:?}, {:?}): {}",
 415             location, stmt, flow_state
 416         );
 417         let span = stmt.source_info.span;
 418
 419         self.check_activations(location, span, flow_state);
 420
 421         match stmt.kind {
 422             StatementKind::Assign(ref lhs, ref rhs) => {
 423                 self.consume_rvalue(
 424                     ContextKind::AssignRhs.new(location),
 425                     (rhs, span),
 426                     location,
 427                     flow_state,
 428                 );
 429
 430                 self.mutate_place(
 431                     ContextKind::AssignLhs.new(location),
 432                     (lhs, span),
 433                     Shallow(None),
 434                     JustWrite,
 435                     flow_state,
 436                 );
 437             }
 438             StatementKind::ReadForMatch(ref place) => {
 439                 self.access_place(
 440                     ContextKind::ReadForMatch.new(location),
 441                     (place, span),
 442                     (Deep, Read(ReadKind::Borrow(BorrowKind::Shared))),
 443                     LocalMutationIsAllowed::No,
 444                     flow_state,
 445                 );
 446             }
 447             StatementKind::SetDiscriminant {
 448                 ref place,
 449                 variant_index: _,
 450             } => {
 451                 self.mutate_place(
 452                     ContextKind::SetDiscrim.new(location),
 453                     (place, span),
 454                     Shallow(Some(ArtificialField::Discriminant)),
 455                     JustWrite,
 456                     flow_state,
 457                 );
 458             }
 459             StatementKind::InlineAsm {
 460                 ref asm,
 461                 ref outputs,
 462                 ref inputs,
 463             } => {
 464                 let context = ContextKind::InlineAsm.new(location);
 465                 for (o, output) in asm.outputs.iter().zip(outputs) {
 466                     if o.is_indirect {
 467                         // FIXME(eddyb) indirect inline asm outputs should
 468                         // be encoeded through MIR place derefs instead.
 469                         self.access_place(
 470                             context,
 471                             (output, span),
 472                             (Deep, Read(ReadKind::Copy)),
 473                             LocalMutationIsAllowed::No,
 474                             flow_state,
 475                         );
 476                         self.check_if_path_or_subpath_is_moved(
 477                             context,
 478                             InitializationRequiringAction::Use,
 479                             (output, span),
 480                             flow_state,
 481                         );
 482                     } else {
 483                         self.mutate_place(
 484                             context,
 485                             (output, span),
 486                             if o.is_rw { Deep } else { Shallow(None) },
 487                             if o.is_rw { WriteAndRead } else { JustWrite },
 488                             flow_state,
 489                         );
 490                     }
 491                 }
 492                 for input in inputs {
 493                     self.consume_operand(context, (input, span), flow_state);
 494                 }
 495             }
 496             StatementKind::EndRegion(ref _rgn) => {
 497                 // ignored when consuming results (update to
 498                 // flow_state already handled).
 499             }
 500             StatementKind::Nop
 501             | StatementKind::UserAssertTy(..)
 502             | StatementKind::Validate(..)
 503             | StatementKind::StorageLive(..) => {
 504                 // `Nop`, `UserAssertTy`, `Validate`, and `StorageLive` are irrelevant
 505                 // to borrow check.
 506             }
 507             StatementKind::StorageDead(local) => {
 508                 self.access_place(
 509                     ContextKind::StorageDead.new(location),
 510                     (&Place::Local(local), span),
 511                     (Shallow(None), Write(WriteKind::StorageDeadOrDrop)),
 512                     LocalMutationIsAllowed::Yes,
 513                     flow_state,
 514                 );
 515             }
 516         }
 517     }
 518
 519     fn visit_terminator_entry(
 520         &mut self,
 521         location: Location,
 522         term: &Terminator<'tcx>,
 523         flow_state: &Self::FlowState,
 524     ) {
 525         let loc = location;
 526         debug!(
 527             "MirBorrowckCtxt::process_terminator({:?}, {:?}): {}",
 528             location, term, flow_state
 529         );
 530         let span = term.source_info.span;
 531
 532         self.check_activations(location, span, flow_state);
 533
 534         match term.kind {
 535             TerminatorKind::SwitchInt {
 536                 ref discr,
 537                 switch_ty: _,
 538                 values: _,
 539                 targets: _,
 540             } => {
 541                 self.consume_operand(ContextKind::SwitchInt.new(loc), (discr, span), flow_state);
 542             }
 543             TerminatorKind::Drop {
 544                 location: ref drop_place,
 545                 target: _,
 546                 unwind: _,
 547             } => {
 548                 let gcx = self.tcx.global_tcx();
 549
 550                 // Compute the type with accurate region information.
 551                 let drop_place_ty = drop_place.ty(self.mir, self.tcx);
 552
 553                 // Erase the regions.
 554                 let drop_place_ty = self.tcx.erase_regions(&drop_place_ty).to_ty(self.tcx);
 555
 556                 // "Lift" into the gcx -- once regions are erased, this type should be in the
 557                 // global arenas; this "lift" operation basically just asserts that is true, but
 558                 // that is useful later.
 559                 let drop_place_ty = gcx.lift(&drop_place_ty).unwrap();
 560
 561                 self.visit_terminator_drop(loc, term, flow_state, drop_place, drop_place_ty, span);
 562             }
 563             TerminatorKind::DropAndReplace {
 564                 location: ref drop_place,
 565                 value: ref new_value,
 566                 target: _,
 567                 unwind: _,
 568             } => {
 569                 self.mutate_place(
 570                     ContextKind::DropAndReplace.new(loc),
 571                     (drop_place, span),
 572                     Deep,
 573                     JustWrite,
 574                     flow_state,
 575                 );
 576                 self.consume_operand(
 577                     ContextKind::DropAndReplace.new(loc),
 578                     (new_value, span),
 579                     flow_state,
 580                 );
 581             }
 582             TerminatorKind::Call {
 583                 ref func,
 584                 ref args,
 585                 ref destination,
 586                 cleanup: _,
 587             } => {
 588                 self.consume_operand(ContextKind::CallOperator.new(loc), (func, span), flow_state);
 589                 for arg in args {
 590                     self.consume_operand(
 591                         ContextKind::CallOperand.new(loc),
 592                         (arg, span),
 593                         flow_state,
 594                     );
 595                 }
 596                 if let Some((ref dest, _ /*bb*/)) = *destination {
 597                     self.mutate_place(
 598                         ContextKind::CallDest.new(loc),
 599                         (dest, span),
 600                         Deep,
 601                         JustWrite,
 602                         flow_state,
 603                     );
 604                 }
 605             }
 606             TerminatorKind::Assert {
 607                 ref cond,
 608                 expected: _,
 609                 ref msg,
 610                 target: _,
 611                 cleanup: _,
 612             } => {
 613                 self.consume_operand(ContextKind::Assert.new(loc), (cond, span), flow_state);
 614                 use rustc::mir::interpret::EvalErrorKind::BoundsCheck;
 615                 if let BoundsCheck { ref len, ref index } = *msg {
 616                     self.consume_operand(ContextKind::Assert.new(loc), (len, span), flow_state);
 617                     self.consume_operand(ContextKind::Assert.new(loc), (index, span), flow_state);
 618                 }
 619             }
 620
 621             TerminatorKind::Yield {
 622                 ref value,
 623                 resume: _,
 624                 drop: _,
 625             } => {
 626                 self.consume_operand(ContextKind::Yield.new(loc), (value, span), flow_state);
 627
 628                 if self.movable_generator {
 629                     // Look for any active borrows to locals
 630                     let borrow_set = self.borrow_set.clone();
 631                     flow_state.with_outgoing_borrows(|borrows| {
 632                         for i in borrows {
 633                             let borrow = &borrow_set[i];
 634                             self.check_for_local_borrow(borrow, span);
 635                         }
 636                     });
 637                 }
 638             }
 639
 640             TerminatorKind::Resume | TerminatorKind::Return | TerminatorKind::GeneratorDrop => {
 641                 // Returning from the function implicitly kills storage for all locals and statics.
 642                 // Often, the storage will already have been killed by an explicit
 643                 // StorageDead, but we don't always emit those (notably on unwind paths),
 644                 // so this "extra check" serves as a kind of backup.
 645                 let borrow_set = self.borrow_set.clone();
 646                 flow_state.with_outgoing_borrows(|borrows| {
 647                     for i in borrows {
 648                         let borrow = &borrow_set[i];
 649                         let context = ContextKind::StorageDead.new(loc);
 650                         self.check_for_invalidation_at_exit(context, borrow, span);
 651                     }
 652                 });
 653             }
 654             TerminatorKind::Goto { target: _ }
 655             | TerminatorKind::Abort
 656             | TerminatorKind::Unreachable
 657             | TerminatorKind::FalseEdges {
 658                 real_target: _,
 659                 imaginary_targets: _,
 660             }
 661             | TerminatorKind::FalseUnwind {
 662                 real_target: _,
 663                 unwind: _,
 664             } => {
 665                 // no data used, thus irrelevant to borrowck
 666             }
 667         }
 668     }
 669 }
 670
 671 #[derive(Copy, Clone, PartialEq, Eq, Debug)]
 672 enum MutateMode {
 673     JustWrite,
 674     WriteAndRead,
 675 }
 676
 677 use self::ReadOrWrite::{Activation, Read, Reservation, Write};
 678 use self::ShallowOrDeep::{Deep, Shallow};
 679
 680 #[derive(Copy, Clone, PartialEq, Eq, Debug)]
 681 enum ArtificialField {
 682     Discriminant,
 683     ArrayLength,
 684 }
 685
 686 #[derive(Copy, Clone, PartialEq, Eq, Debug)]
 687 enum ShallowOrDeep {
 688     /// From the RFC: "A *shallow* access means that the immediate
 689     /// fields reached at P are accessed, but references or pointers
 690     /// found within are not dereferenced. Right now, the only access
 691     /// that is shallow is an assignment like `x = ...;`, which would
 692     /// be a *shallow write* of `x`."
 693     Shallow(Option<ArtificialField>),
 694
 695     /// From the RFC: "A *deep* access means that all data reachable
 696     /// through the given place may be invalidated or accesses by
 697     /// this action."
 698     Deep,
 699 }
 700
 701 /// Kind of access to a value: read or write
 702 /// (For informational purposes only)
 703 #[derive(Copy, Clone, PartialEq, Eq, Debug)]
 704 enum ReadOrWrite {
 705     /// From the RFC: "A *read* means that the existing data may be
 706     /// read, but will not be changed."
 707     Read(ReadKind),
 708
 709     /// From the RFC: "A *write* means that the data may be mutated to
 710     /// new values or otherwise invalidated (for example, it could be
 711     /// de-initialized, as in a move operation).
 712     Write(WriteKind),
 713
 714     /// For two-phase borrows, we distinguish a reservation (which is treated
 715     /// like a Read) from an activation (which is treated like a write), and
 716     /// each of those is furthermore distinguished from Reads/Writes above.
 717     Reservation(WriteKind),
 718     Activation(WriteKind, BorrowIndex),
 719 }
 720
 721 /// Kind of read access to a value
 722 /// (For informational purposes only)
 723 #[derive(Copy, Clone, PartialEq, Eq, Debug)]
 724 enum ReadKind {
 725     Borrow(BorrowKind),
 726     Copy,
 727 }
 728
 729 /// Kind of write access to a value
 730 /// (For informational purposes only)
 731 #[derive(Copy, Clone, PartialEq, Eq, Debug)]
 732 enum WriteKind {
 733     StorageDeadOrDrop,
 734     MutableBorrow(BorrowKind),
 735     Mutate,
 736     Move,
 737 }
 738
 739 /// When checking permissions for a place access, this flag is used to indicate that an immutable
 740 /// local place can be mutated.
 741 ///
 742 /// FIXME: @nikomatsakis suggested that this flag could be removed with the following modifications:
 743 /// - Merge `check_access_permissions()` and `check_if_reassignment_to_immutable_state()`
 744 /// - Split `is_mutable()` into `is_assignable()` (can be directly assigned) and
 745 ///   `is_declared_mutable()`
 746 /// - Take flow state into consideration in `is_assignable()` for local variables
 747 #[derive(Copy, Clone, PartialEq, Eq, Debug)]
 748 enum LocalMutationIsAllowed {
 749     Yes,
 750     /// We want use of immutable upvars to cause a "write to immutable upvar"
 751     /// error, not an "reassignment" error.
 752     ExceptUpvars,
 753     No,
 754 }
 755
 756 struct AccessErrorsReported {
 757     mutability_error: bool,
 758     #[allow(dead_code)]
 759     conflict_error: bool,
 760 }
 761
 762 #[derive(Copy, Clone)]
 763 enum InitializationRequiringAction {
 764     Update,
 765     Borrow,
 766     Use,
 767     Assignment,
 768 }
 769
 770 struct RootPlace<'d, 'tcx: 'd> {
 771     place: &'d Place<'tcx>,
 772     is_local_mutation_allowed: LocalMutationIsAllowed,
 773 }
 774
 775 impl InitializationRequiringAction {
 776     fn as_noun(self) -> &'static str {
 777         match self {
 778             InitializationRequiringAction::Update => "update",
 779             InitializationRequiringAction::Borrow => "borrow",
 780             InitializationRequiringAction::Use => "use",
 781             InitializationRequiringAction::Assignment => "assign",
 782         }
 783     }
 784
 785     fn as_verb_in_past_tense(self) -> &'static str {
 786         match self {
 787             InitializationRequiringAction::Update => "updated",
 788             InitializationRequiringAction::Borrow => "borrowed",
 789             InitializationRequiringAction::Use => "used",
 790             InitializationRequiringAction::Assignment => "assigned",
 791         }
 792     }
 793 }
 794
 795 impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
 796     /// Invokes `access_place` as appropriate for dropping the value
 797     /// at `drop_place`. Note that the *actual* `Drop` in the MIR is
 798     /// always for a variable (e.g., `Drop(x)`) -- but we recursively
 799     /// break this variable down into subpaths (e.g., `Drop(x.foo)`)
 800     /// to indicate more precisely which fields might actually be
 801     /// accessed by a destructor.
 802     fn visit_terminator_drop(
 803         &mut self,
 804         loc: Location,
 805         term: &Terminator<'tcx>,
 806         flow_state: &Flows<'cx, 'gcx, 'tcx>,
 807         drop_place: &Place<'tcx>,
 808         erased_drop_place_ty: ty::Ty<'gcx>,
 809         span: Span,
 810     ) {
 811         let gcx = self.tcx.global_tcx();
 812         let drop_field = |mir: &mut MirBorrowckCtxt<'cx, 'gcx, 'tcx>,
 813                           (index, field): (usize, ty::Ty<'gcx>)| {
 814             let field_ty = gcx.normalize_erasing_regions(mir.param_env, field);
 815             let place = drop_place.clone().field(Field::new(index), field_ty);
 816
 817             mir.visit_terminator_drop(loc, term, flow_state, &place, field_ty, span);
 818         };
 819
 820         match erased_drop_place_ty.sty {
 821             // When a struct is being dropped, we need to check
 822             // whether it has a destructor, if it does, then we can
 823             // call it, if it does not then we need to check the
 824             // individual fields instead. This way if `foo` has a
 825             // destructor but `bar` does not, we will only check for
 826             // borrows of `x.foo` and not `x.bar`. See #47703.
 827             ty::TyAdt(def, substs) if def.is_struct() && !def.has_dtor(self.tcx) => {
 828                 def.all_fields()
 829                     .map(|field| field.ty(gcx, substs))
 830                     .enumerate()
 831                     .for_each(|field| drop_field(self, field));
 832             }
 833             // Same as above, but for tuples.
 834             ty::TyTuple(tys) => {
 835                 tys.iter()
 836                     .cloned()
 837                     .enumerate()
 838                     .for_each(|field| drop_field(self, field));
 839             }
 840             // Closures also have disjoint fields, but they are only
 841             // directly accessed in the body of the closure.
 842             ty::TyClosure(def, substs)
 843                 if *drop_place == Place::Local(Local::new(1))
 844                     && !self.mir.upvar_decls.is_empty() =>
 845             {
 846                 substs
 847                     .upvar_tys(def, self.tcx)
 848                     .enumerate()
 849                     .for_each(|field| drop_field(self, field));
 850             }
 851             // Generators also have disjoint fields, but they are only
 852             // directly accessed in the body of the generator.
 853             ty::TyGenerator(def, substs, _)
 854                 if *drop_place == Place::Local(Local::new(1))
 855                     && !self.mir.upvar_decls.is_empty() =>
 856             {
 857                 substs
 858                     .upvar_tys(def, self.tcx)
 859                     .enumerate()
 860                     .for_each(|field| drop_field(self, field));
 861             }
 862             _ => {
 863                 // We have now refined the type of the value being
 864                 // dropped (potentially) to just the type of a
 865                 // subfield; so check whether that field's type still
 866                 // "needs drop". If so, we assume that the destructor
 867                 // may access any data it likes (i.e., a Deep Write).
 868                 if erased_drop_place_ty.needs_drop(gcx, self.param_env) {
 869                     self.access_place(
 870                         ContextKind::Drop.new(loc),
 871                         (drop_place, span),
 872                         (Deep, Write(WriteKind::StorageDeadOrDrop)),
 873                         LocalMutationIsAllowed::Yes,
 874                         flow_state,
 875                     );
 876                 }
 877             }
 878         }
 879     }
 880
 881     /// Checks an access to the given place to see if it is allowed. Examines the set of borrows
 882     /// that are in scope, as well as which paths have been initialized, to ensure that (a) the
 883     /// place is initialized and (b) it is not borrowed in some way that would prevent this
 884     /// access.
 885     ///
 886     /// Returns true if an error is reported, false otherwise.
 887     fn access_place(
 888         &mut self,
 889         context: Context,
 890         place_span: (&Place<'tcx>, Span),
 891         kind: (ShallowOrDeep, ReadOrWrite),
 892         is_local_mutation_allowed: LocalMutationIsAllowed,
 893         flow_state: &Flows<'cx, 'gcx, 'tcx>,
 894     ) -> AccessErrorsReported {
 895         let (sd, rw) = kind;
 896
 897         if let Activation(_, borrow_index) = rw {
 898             if self.reservation_error_reported.contains(&place_span.0) {
 899                 debug!(
 900                     "skipping access_place for activation of invalid reservation \
 901                      place: {:?} borrow_index: {:?}",
 902                     place_span.0, borrow_index
 903                 );
 904                 return AccessErrorsReported {
 905                     mutability_error: false,
 906                     conflict_error: true,
 907                 };
 908             }
 909         }
 910
 911         if self
 912             .access_place_error_reported
 913             .contains(&(place_span.0.clone(), place_span.1))
 914         {
 915             debug!(
 916                 "access_place: suppressing error place_span=`{:?}` kind=`{:?}`",
 917                 place_span, kind
 918             );
 919             return AccessErrorsReported {
 920                 mutability_error: false,
 921                 conflict_error: true,
 922             };
 923         }
 924
 925         let mutability_error =
 926             self.check_access_permissions(
 927                 place_span,
 928                 rw,
 929                 is_local_mutation_allowed,
 930                 flow_state,
 931                 context.loc,
 932             );
 933         let conflict_error =
 934             self.check_access_for_conflict(context, place_span, sd, rw, flow_state);
 935
 936         if conflict_error || mutability_error {
 937             debug!(
 938                 "access_place: logging error place_span=`{:?}` kind=`{:?}`",
 939                 place_span, kind
 940             );
 941             self.access_place_error_reported
 942                 .insert((place_span.0.clone(), place_span.1));
 943         }
 944
 945         AccessErrorsReported {
 946             mutability_error,
 947             conflict_error,
 948         }
 949     }
 950
 951     fn check_access_for_conflict(
 952         &mut self,
 953         context: Context,
 954         place_span: (&Place<'tcx>, Span),
 955         sd: ShallowOrDeep,
 956         rw: ReadOrWrite,
 957         flow_state: &Flows<'cx, 'gcx, 'tcx>,
 958     ) -> bool {
 959         debug!(
 960             "check_access_for_conflict(context={:?}, place_span={:?}, sd={:?}, rw={:?})",
 961             context, place_span, sd, rw,
 962         );
 963
 964         let mut error_reported = false;
 965         let tcx = self.tcx;
 966         let mir = self.mir;
 967         let location = self.location_table.start_index(context.loc);
 968         let borrow_set = self.borrow_set.clone();
 969         each_borrow_involving_path(
 970             self,
 971             tcx,
 972             mir,
 973             context,
 974             (sd, place_span.0),
 975             &borrow_set,
 976             flow_state.borrows_in_scope(location),
 977             |this, borrow_index, borrow| match (rw, borrow.kind) {
 978                 // Obviously an activation is compatible with its own
 979                 // reservation (or even prior activating uses of same
 980                 // borrow); so don't check if they interfere.
 981                 //
 982                 // NOTE: *reservations* do conflict with themselves;
 983                 // thus aren't injecting unsoundenss w/ this check.)
 984                 (Activation(_, activating), _) if activating == borrow_index => {
 985                     debug!(
 986                         "check_access_for_conflict place_span: {:?} sd: {:?} rw: {:?} \
 987                          skipping {:?} b/c activation of same borrow_index",
 988                         place_span,
 989                         sd,
 990                         rw,
 991                         (borrow_index, borrow),
 992                     );
 993                     Control::Continue
 994                 }
 995
 996                 (Read(_), BorrowKind::Shared) | (Reservation(..), BorrowKind::Shared) => {
 997                     Control::Continue
 998                 }
 999
1000                 (Read(kind), BorrowKind::Unique) | (Read(kind), BorrowKind::Mut { .. }) => {
1001                     // Reading from mere reservations of mutable-borrows is OK.
1002                     if !is_active(&this.dominators, borrow, context.loc) {
1003                         assert!(allow_two_phase_borrow(&this.tcx, borrow.kind));
1004                         return Control::Continue;
1005                     }
1006
1007                     match kind {
1008                         ReadKind::Copy => {
1009                             error_reported = true;
1010                             this.report_use_while_mutably_borrowed(context, place_span, borrow)
1011                         }
1012                         ReadKind::Borrow(bk) => {
1013                             error_reported = true;
1014                             this.report_conflicting_borrow(context, place_span, bk, &borrow)
1015                         }
1016                     }
1017                     Control::Break
1018                 }
1019
1020                 (Reservation(kind), BorrowKind::Unique)
1021                 | (Reservation(kind), BorrowKind::Mut { .. })
1022                 | (Activation(kind, _), _)
1023                 | (Write(kind), _) => {
1024                     match rw {
1025                         Reservation(_) => {
1026                             debug!(
1027                                 "recording invalid reservation of \
1028                                  place: {:?}",
1029                                 place_span.0
1030                             );
1031                             this.reservation_error_reported.insert(place_span.0.clone());
1032                         }
1033                         Activation(_, activating) => {
1034                             debug!(
1035                                 "observing check_place for activation of \
1036                                  borrow_index: {:?}",
1037                                 activating
1038                             );
1039                         }
1040                         Read(..) | Write(..) => {}
1041                     }
1042
1043                     match kind {
1044                         WriteKind::MutableBorrow(bk) => {
1045                             error_reported = true;
1046                             this.report_conflicting_borrow(context, place_span, bk, &borrow)
1047                         }
1048                         WriteKind::StorageDeadOrDrop => {
1049                             error_reported = true;
1050                             this.report_borrowed_value_does_not_live_long_enough(
1051                                 context,
1052                                 borrow,
1053                                 place_span,
1054                                 Some(kind),
1055                             );
1056                         }
1057                         WriteKind::Mutate => {
1058                             error_reported = true;
1059                             this.report_illegal_mutation_of_borrowed(context, place_span, borrow)
1060                         }
1061                         WriteKind::Move => {
1062                             error_reported = true;
1063                             this.report_move_out_while_borrowed(context, place_span, &borrow)
1064                         }
1065                     }
1066                     Control::Break
1067                 }
1068             },
1069         );
1070
1071         error_reported
1072     }
1073
1074     fn mutate_place(
1075         &mut self,
1076         context: Context,
1077         place_span: (&Place<'tcx>, Span),
1078         kind: ShallowOrDeep,
1079         mode: MutateMode,
1080         flow_state: &Flows<'cx, 'gcx, 'tcx>,
1081     ) {
1082         // Write of P[i] or *P, or WriteAndRead of any P, requires P init'd.
1083         match mode {
1084             MutateMode::WriteAndRead => {
1085                 self.check_if_path_or_subpath_is_moved(
1086                     context,
1087                     InitializationRequiringAction::Update,
1088                     place_span,
1089                     flow_state,
1090                 );
1091             }
1092             MutateMode::JustWrite => {
1093                 self.check_if_assigned_path_is_moved(context, place_span, flow_state);
1094             }
1095         }
1096
1097         let errors_reported = self.access_place(
1098             context,
1099             place_span,
1100             (kind, Write(WriteKind::Mutate)),
1101             // We want immutable upvars to cause an "assignment to immutable var"
1102             // error, not an "reassignment of immutable var" error, because the
1103             // latter can't find a good previous assignment span.
1104             //
1105             // There's probably a better way to do this.
1106             LocalMutationIsAllowed::ExceptUpvars,
1107             flow_state,
1108         );
1109
1110         if !errors_reported.mutability_error {
1111             // check for reassignments to immutable local variables
1112             self.check_if_reassignment_to_immutable_state(context, place_span, flow_state);
1113         }
1114     }
1115
1116     fn consume_rvalue(
1117         &mut self,
1118         context: Context,
1119         (rvalue, span): (&Rvalue<'tcx>, Span),
1120         _location: Location,
1121         flow_state: &Flows<'cx, 'gcx, 'tcx>,
1122     ) {
1123         match *rvalue {
1124             Rvalue::Ref(_ /*rgn*/, bk, ref place) => {
1125                 let access_kind = match bk {
1126                     BorrowKind::Shared => (Deep, Read(ReadKind::Borrow(bk))),
1127                     BorrowKind::Unique | BorrowKind::Mut { .. } => {
1128                         let wk = WriteKind::MutableBorrow(bk);
1129                         if allow_two_phase_borrow(&self.tcx, bk) {
1130                             (Deep, Reservation(wk))
1131                         } else {
1132                             (Deep, Write(wk))
1133                         }
1134                     }
1135                 };
1136
1137                 self.access_place(
1138                     context,
1139                     (place, span),
1140                     access_kind,
1141                     LocalMutationIsAllowed::No,
1142                     flow_state,
1143                 );
1144
1145                 self.check_if_path_or_subpath_is_moved(
1146                     context,
1147                     InitializationRequiringAction::Borrow,
1148                     (place, span),
1149                     flow_state,
1150                 );
1151             }
1152
1153             Rvalue::Use(ref operand)
1154             | Rvalue::Repeat(ref operand, _)
1155             | Rvalue::UnaryOp(_ /*un_op*/, ref operand)
1156             | Rvalue::Cast(_ /*cast_kind*/, ref operand, _ /*ty*/) => {
1157                 self.consume_operand(context, (operand, span), flow_state)
1158             }
1159
1160             Rvalue::Len(ref place) | Rvalue::Discriminant(ref place) => {
1161                 let af = match *rvalue {
1162                     Rvalue::Len(..) => ArtificialField::ArrayLength,
1163                     Rvalue::Discriminant(..) => ArtificialField::Discriminant,
1164                     _ => unreachable!(),
1165                 };
1166                 self.access_place(
1167                     context,
1168                     (place, span),
1169                     (Shallow(Some(af)), Read(ReadKind::Copy)),
1170                     LocalMutationIsAllowed::No,
1171                     flow_state,
1172                 );
1173                 self.check_if_path_or_subpath_is_moved(
1174                     context,
1175                     InitializationRequiringAction::Use,
1176                     (place, span),
1177                     flow_state,
1178                 );
1179             }
1180
1181             Rvalue::BinaryOp(_bin_op, ref operand1, ref operand2)
1182             | Rvalue::CheckedBinaryOp(_bin_op, ref operand1, ref operand2) => {
1183                 self.consume_operand(context, (operand1, span), flow_state);
1184                 self.consume_operand(context, (operand2, span), flow_state);
1185             }
1186
1187             Rvalue::NullaryOp(_op, _ty) => {
1188                 // nullary ops take no dynamic input; no borrowck effect.
1189                 //
1190                 // FIXME: is above actually true? Do we want to track
1191                 // the fact that uninitialized data can be created via
1192                 // `NullOp::Box`?
1193             }
1194
1195             Rvalue::Aggregate(ref aggregate_kind, ref operands) => {
1196                 // We need to report back the list of mutable upvars that were
1197                 // moved into the closure and subsequently used by the closure,
1198                 // in order to populate our used_mut set.
1199                 match **aggregate_kind {
1200                     AggregateKind::Closure(def_id, _)
1201                     | AggregateKind::Generator(def_id, _, _) => {
1202                         let BorrowCheckResult {
1203                             used_mut_upvars, ..
1204                         } = self.tcx.mir_borrowck(def_id);
1205                         debug!("{:?} used_mut_upvars={:?}", def_id, used_mut_upvars);
1206                         for field in used_mut_upvars {
1207                             // This relies on the current way that by-value
1208                             // captures of a closure are copied/moved directly
1209                             // when generating MIR.
1210                             match operands[field.index()] {
1211                                 Operand::Move(Place::Local(local))
1212                                 | Operand::Copy(Place::Local(local)) => {
1213                                     self.used_mut.insert(local);
1214                                 }
1215                                 Operand::Move(ref place @ Place::Projection(_))
1216                                 | Operand::Copy(ref place @ Place::Projection(_)) => {
1217                                     if let Some(field) = place.is_upvar_field_projection(
1218                                             self.mir, &self.tcx) {
1219                                         self.used_mut_upvars.push(field);
1220                                     }
1221                                 }
1222                                 Operand::Move(Place::Static(..))
1223                                 | Operand::Copy(Place::Static(..))
1224                                 | Operand::Move(Place::Promoted(..))
1225                                 | Operand::Copy(Place::Promoted(..))
1226                                 | Operand::Constant(..) => {}
1227                             }
1228                         }
1229                     }
1230                     AggregateKind::Adt(..)
1231                     | AggregateKind::Array(..)
1232                     | AggregateKind::Tuple { .. } => (),
1233                 }
1234
1235                 for operand in operands {
1236                     self.consume_operand(context, (operand, span), flow_state);
1237                 }
1238             }
1239         }
1240     }
1241
1242     fn consume_operand(
1243         &mut self,
1244         context: Context,
1245         (operand, span): (&Operand<'tcx>, Span),
1246         flow_state: &Flows<'cx, 'gcx, 'tcx>,
1247     ) {
1248         match *operand {
1249             Operand::Copy(ref place) => {
1250                 // copy of place: check if this is "copy of frozen path"
1251                 // (FIXME: see check_loans.rs)
1252                 self.access_place(
1253                     context,
1254                     (place, span),
1255                     (Deep, Read(ReadKind::Copy)),
1256                     LocalMutationIsAllowed::No,
1257                     flow_state,
1258                 );
1259
1260                 // Finally, check if path was already moved.
1261                 self.check_if_path_or_subpath_is_moved(
1262                     context,
1263                     InitializationRequiringAction::Use,
1264                     (place, span),
1265                     flow_state,
1266                 );
1267             }
1268             Operand::Move(ref place) => {
1269                 // move of place: check if this is move of already borrowed path
1270                 self.access_place(
1271                     context,
1272                     (place, span),
1273                     (Deep, Write(WriteKind::Move)),
1274                     LocalMutationIsAllowed::Yes,
1275                     flow_state,
1276                 );
1277
1278                 // Finally, check if path was already moved.
1279                 self.check_if_path_or_subpath_is_moved(
1280                     context,
1281                     InitializationRequiringAction::Use,
1282                     (place, span),
1283                     flow_state,
1284                 );
1285             }
1286             Operand::Constant(_) => {}
1287         }
1288     }
1289
1290     /// Returns whether a borrow of this place is invalidated when the function
1291     /// exits
1292     fn check_for_invalidation_at_exit(
1293         &mut self,
1294         context: Context,
1295         borrow: &BorrowData<'tcx>,
1296         span: Span,
1297     ) {
1298         debug!("check_for_invalidation_at_exit({:?})", borrow);
1299         let place = &borrow.borrowed_place;
1300         let root_place = self.prefixes(place, PrefixSet::All).last().unwrap();
1301
1302         // FIXME(nll-rfc#40): do more precise destructor tracking here. For now
1303         // we just know that all locals are dropped at function exit (otherwise
1304         // we'll have a memory leak) and assume that all statics have a destructor.
1305         //
1306         // FIXME: allow thread-locals to borrow other thread locals?
1307         let (might_be_alive, will_be_dropped) = match root_place {
1308             Place::Promoted(_) => (true, false),
1309             Place::Static(statik) => {
1310                 // Thread-locals might be dropped after the function exits, but
1311                 // "true" statics will never be.
1312                 let is_thread_local = self
1313                     .tcx
1314                     .get_attrs(statik.def_id)
1315                     .iter()
1316                     .any(|attr| attr.check_name("thread_local"));
1317
1318                 (true, is_thread_local)
1319             }
1320             Place::Local(_) => {
1321                 // Locals are always dropped at function exit, and if they
1322                 // have a destructor it would've been called already.
1323                 (false, self.locals_are_invalidated_at_exit)
1324             }
1325             Place::Projection(..) => {
1326                 bug!("root of {:?} is a projection ({:?})?", place, root_place)
1327             }
1328         };
1329
1330         if !will_be_dropped {
1331             debug!(
1332                 "place_is_invalidated_at_exit({:?}) - won't be dropped",
1333                 place
1334             );
1335             return;
1336         }
1337
1338         // FIXME: replace this with a proper borrow_conflicts_with_place when
1339         // that is merged.
1340         let sd = if might_be_alive { Deep } else { Shallow(None) };
1341
1342         if places_conflict::places_conflict(self.tcx, self.mir, place, root_place, sd) {
1343             debug!("check_for_invalidation_at_exit({:?}): INVALID", place);
1344             // FIXME: should be talking about the region lifetime instead
1345             // of just a span here.
1346             let span = self.tcx.sess.codemap().end_point(span);
1347             self.report_borrowed_value_does_not_live_long_enough(
1348                 context,
1349                 borrow,
1350                 (place, span),
1351                 None,
1352             )
1353         }
1354     }
1355
1356     /// Reports an error if this is a borrow of local data.
1357     /// This is called for all Yield statements on movable generators
1358     fn check_for_local_borrow(&mut self, borrow: &BorrowData<'tcx>, yield_span: Span) {
1359         debug!("check_for_local_borrow({:?})", borrow);
1360
1361         if borrow_of_local_data(&borrow.borrowed_place) {
1362             self.tcx
1363                 .cannot_borrow_across_generator_yield(
1364                     self.retrieve_borrow_span(borrow),
1365                     yield_span,
1366                     Origin::Mir,
1367                 )
1368                 .emit();
1369         }
1370     }
1371
1372     fn check_activations(
1373         &mut self,
1374         location: Location,
1375         span: Span,
1376         flow_state: &Flows<'cx, 'gcx, 'tcx>,
1377     ) {
1378         if !self.tcx.two_phase_borrows() {
1379             return;
1380         }
1381
1382         // Two-phase borrow support: For each activation that is newly
1383         // generated at this statement, check if it interferes with
1384         // another borrow.
1385         let borrow_set = self.borrow_set.clone();
1386         for &borrow_index in borrow_set.activations_at_location(location) {
1387             let borrow = &borrow_set[borrow_index];
1388
1389             // only mutable borrows should be 2-phase
1390             assert!(match borrow.kind {
1391                 BorrowKind::Shared => false,
1392                 BorrowKind::Unique | BorrowKind::Mut { .. } => true,
1393             });
1394
1395             self.access_place(
1396                 ContextKind::Activation.new(location),
1397                 (&borrow.borrowed_place, span),
1398                 (
1399                     Deep,
1400                     Activation(WriteKind::MutableBorrow(borrow.kind), borrow_index),
1401                 ),
1402                 LocalMutationIsAllowed::No,
1403                 flow_state,
1404             );
1405             // We do not need to call `check_if_path_or_subpath_is_moved`
1406             // again, as we already called it when we made the
1407             // initial reservation.
1408         }
1409     }
1410 }
1411
1412 impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
1413     fn check_if_reassignment_to_immutable_state(
1414         &mut self,
1415         context: Context,
1416         (place, span): (&Place<'tcx>, Span),
1417         flow_state: &Flows<'cx, 'gcx, 'tcx>,
1418     ) {
1419         debug!("check_if_reassignment_to_immutable_state({:?})", place);
1420         // determine if this path has a non-mut owner (and thus needs checking).
1421         let err_place = match self.is_mutable(place, LocalMutationIsAllowed::No) {
1422             Ok(..) => return,
1423             Err(place) => place,
1424         };
1425         debug!(
1426             "check_if_reassignment_to_immutable_state({:?}) - is an imm local",
1427             place
1428         );
1429
1430         for i in flow_state.ever_inits.iter_incoming() {
1431             let init = self.move_data.inits[i];
1432             let init_place = &self.move_data.move_paths[init.path].place;
1433             if places_conflict::places_conflict(self.tcx, self.mir, &init_place, place, Deep) {
1434                 self.report_illegal_reassignment(context, (place, span), init.span, err_place);
1435                 break;
1436             }
1437         }
1438     }
1439
1440     fn check_if_full_path_is_moved(
1441         &mut self,
1442         context: Context,
1443         desired_action: InitializationRequiringAction,
1444         place_span: (&Place<'tcx>, Span),
1445         flow_state: &Flows<'cx, 'gcx, 'tcx>,
1446     ) {
1447         // FIXME: analogous code in check_loans first maps `place` to
1448         // its base_path ... but is that what we want here?
1449         let place = self.base_path(place_span.0);
1450
1451         let maybe_uninits = &flow_state.uninits;
1452         let curr_move_outs = &flow_state.move_outs;
1453
1454         // Bad scenarios:
1455         //
1456         // 1. Move of `a.b.c`, use of `a.b.c`
1457         // 2. Move of `a.b.c`, use of `a.b.c.d` (without first reinitializing `a.b.c.d`)
1458         // 3. Uninitialized `(a.b.c: &_)`, use of `*a.b.c`; note that with
1459         //    partial initialization support, one might have `a.x`
1460         //    initialized but not `a.b`.
1461         //
1462         // OK scenarios:
1463         //
1464         // 4. Move of `a.b.c`, use of `a.b.d`
1465         // 5. Uninitialized `a.x`, initialized `a.b`, use of `a.b`
1466         // 6. Copied `(a.b: &_)`, use of `*(a.b).c`; note that `a.b`
1467         //    must have been initialized for the use to be sound.
1468         // 7. Move of `a.b.c` then reinit of `a.b.c.d`, use of `a.b.c.d`
1469
1470         // The dataflow tracks shallow prefixes distinctly (that is,
1471         // field-accesses on P distinctly from P itself), in order to
1472         // track substructure initialization separately from the whole
1473         // structure.
1474         //
1475         // E.g., when looking at (*a.b.c).d, if the closest prefix for
1476         // which we have a MovePath is `a.b`, then that means that the
1477         // initialization state of `a.b` is all we need to inspect to
1478         // know if `a.b.c` is valid (and from that we infer that the
1479         // dereference and `.d` access is also valid, since we assume
1480         // `a.b.c` is assigned a reference to a initialized and
1481         // well-formed record structure.)
1482
1483         // Therefore, if we seek out the *closest* prefix for which we
1484         // have a MovePath, that should capture the initialization
1485         // state for the place scenario.
1486         //
1487         // This code covers scenarios 1, 2, and 3.
1488
1489         debug!("check_if_full_path_is_moved place: {:?}", place);
1490         match self.move_path_closest_to(place) {
1491             Ok(mpi) => {
1492                 if maybe_uninits.contains(&mpi) {
1493                     self.report_use_of_moved_or_uninitialized(
1494                         context,
1495                         desired_action,
1496                         place_span,
1497                         mpi,
1498                         curr_move_outs,
1499                     );
1500                     return; // don't bother finding other problems.
1501                 }
1502             }
1503             Err(NoMovePathFound::ReachedStatic) => {
1504                 // Okay: we do not build MoveData for static variables
1505             } // Only query longest prefix with a MovePath, not further
1506               // ancestors; dataflow recurs on children when parents
1507               // move (to support partial (re)inits).
1508               //
1509               // (I.e. querying parents breaks scenario 7; but may want
1510               // to do such a query based on partial-init feature-gate.)
1511         }
1512     }
1513
1514     fn check_if_path_or_subpath_is_moved(
1515         &mut self,
1516         context: Context,
1517         desired_action: InitializationRequiringAction,
1518         place_span: (&Place<'tcx>, Span),
1519         flow_state: &Flows<'cx, 'gcx, 'tcx>,
1520     ) {
1521         // FIXME: analogous code in check_loans first maps `place` to
1522         // its base_path ... but is that what we want here?
1523         let place = self.base_path(place_span.0);
1524
1525         let maybe_uninits = &flow_state.uninits;
1526         let curr_move_outs = &flow_state.move_outs;
1527
1528         // Bad scenarios:
1529         //
1530         // 1. Move of `a.b.c`, use of `a` or `a.b`
1531         //    partial initialization support, one might have `a.x`
1532         //    initialized but not `a.b`.
1533         // 2. All bad scenarios from `check_if_full_path_is_moved`
1534         //
1535         // OK scenarios:
1536         //
1537         // 3. Move of `a.b.c`, use of `a.b.d`
1538         // 4. Uninitialized `a.x`, initialized `a.b`, use of `a.b`
1539         // 5. Copied `(a.b: &_)`, use of `*(a.b).c`; note that `a.b`
1540         //    must have been initialized for the use to be sound.
1541         // 6. Move of `a.b.c` then reinit of `a.b.c.d`, use of `a.b.c.d`
1542
1543         self.check_if_full_path_is_moved(context, desired_action, place_span, flow_state);
1544
1545         // A move of any shallow suffix of `place` also interferes
1546         // with an attempt to use `place`. This is scenario 3 above.
1547         //
1548         // (Distinct from handling of scenarios 1+2+4 above because
1549         // `place` does not interfere with suffixes of its prefixes,
1550         // e.g. `a.b.c` does not interfere with `a.b.d`)
1551         //
1552         // This code covers scenario 1.
1553
1554         debug!("check_if_path_or_subpath_is_moved place: {:?}", place);
1555         if let Some(mpi) = self.move_path_for_place(place) {
1556             if let Some(child_mpi) = maybe_uninits.has_any_child_of(mpi) {
1557                 self.report_use_of_moved_or_uninitialized(
1558                     context,
1559                     desired_action,
1560                     place_span,
1561                     child_mpi,
1562                     curr_move_outs,
1563                 );
1564                 return; // don't bother finding other problems.
1565             }
1566         }
1567     }
1568
1569     /// Currently MoveData does not store entries for all places in
1570     /// the input MIR. For example it will currently filter out
1571     /// places that are Copy; thus we do not track places of shared
1572     /// reference type. This routine will walk up a place along its
1573     /// prefixes, searching for a foundational place that *is*
1574     /// tracked in the MoveData.
1575     ///
1576     /// An Err result includes a tag indicated why the search failed.
1577     /// Currently this can only occur if the place is built off of a
1578     /// static variable, as we do not track those in the MoveData.
1579     fn move_path_closest_to(
1580         &mut self,
1581         place: &Place<'tcx>,
1582     ) -> Result<MovePathIndex, NoMovePathFound> {
1583         let mut last_prefix = place;
1584         for prefix in self.prefixes(place, PrefixSet::All) {
1585             if let Some(mpi) = self.move_path_for_place(prefix) {
1586                 return Ok(mpi);
1587             }
1588             last_prefix = prefix;
1589         }
1590         match *last_prefix {
1591             Place::Local(_) => panic!("should have move path for every Local"),
1592             Place::Projection(_) => panic!("PrefixSet::All meant don't stop for Projection"),
1593             Place::Promoted(_) |
1594             Place::Static(_) => return Err(NoMovePathFound::ReachedStatic),
1595         }
1596     }
1597
1598     fn move_path_for_place(&mut self, place: &Place<'tcx>) -> Option<MovePathIndex> {
1599         // If returns None, then there is no move path corresponding
1600         // to a direct owner of `place` (which means there is nothing
1601         // that borrowck tracks for its analysis).
1602
1603         match self.move_data.rev_lookup.find(place) {
1604             LookupResult::Parent(_) => None,
1605             LookupResult::Exact(mpi) => Some(mpi),
1606         }
1607     }
1608
1609     fn check_if_assigned_path_is_moved(
1610         &mut self,
1611         context: Context,
1612         (place, span): (&Place<'tcx>, Span),
1613         flow_state: &Flows<'cx, 'gcx, 'tcx>,
1614     ) {
1615         debug!("check_if_assigned_path_is_moved place: {:?}", place);
1616         // recur down place; dispatch to external checks when necessary
1617         let mut place = place;
1618         loop {
1619             match *place {
1620                 Place::Promoted(_) |
1621                 Place::Local(_) | Place::Static(_) => {
1622                     // assigning to `x` does not require `x` be initialized.
1623                     break;
1624                 }
1625                 Place::Projection(ref proj) => {
1626                     let Projection { ref base, ref elem } = **proj;
1627                     match *elem {
1628                         ProjectionElem::Index(_/*operand*/) |
1629                         ProjectionElem::ConstantIndex { .. } |
1630                         // assigning to P[i] requires P to be valid.
1631                         ProjectionElem::Downcast(_/*adt_def*/, _/*variant_idx*/) =>
1632                         // assigning to (P->variant) is okay if assigning to `P` is okay
1633                         //
1634                         // FIXME: is this true even if P is a adt with a dtor?
1635                         { }
1636
1637                         // assigning to (*P) requires P to be initialized
1638                         ProjectionElem::Deref => {
1639                             self.check_if_full_path_is_moved(
1640                                 context, InitializationRequiringAction::Use,
1641                                 (base, span), flow_state);
1642                             // (base initialized; no need to
1643                             // recur further)
1644                             break;
1645                         }
1646
1647                         ProjectionElem::Subslice { .. } => {
1648                             panic!("we don't allow assignments to subslices, context: {:?}",
1649                                    context);
1650                         }
1651
1652                         ProjectionElem::Field(..) => {
1653                             // if type of `P` has a dtor, then
1654                             // assigning to `P.f` requires `P` itself
1655                             // be already initialized
1656                             let tcx = self.tcx;
1657                             match base.ty(self.mir, tcx).to_ty(tcx).sty {
1658                                 ty::TyAdt(def, _) if def.has_dtor(tcx) => {
1659
1660                                     // FIXME: analogous code in
1661                                     // check_loans.rs first maps
1662                                     // `base` to its base_path.
1663
1664                                     self.check_if_path_or_subpath_is_moved(
1665                                         context, InitializationRequiringAction::Assignment,
1666                                         (base, span), flow_state);
1667
1668                                     // (base initialized; no need to
1669                                     // recur further)
1670                                     break;
1671                                 }
1672                                 _ => {}
1673                             }
1674                         }
1675                     }
1676
1677                     place = base;
1678                     continue;
1679                 }
1680             }
1681         }
1682     }
1683
1684
1685     /// Check the permissions for the given place and read or write kind
1686     ///
1687     /// Returns true if an error is reported, false otherwise.
1688     fn check_access_permissions(
1689         &mut self,
1690         (place, span): (&Place<'tcx>, Span),
1691         kind: ReadOrWrite,
1692         is_local_mutation_allowed: LocalMutationIsAllowed,
1693         flow_state: &Flows<'cx, 'gcx, 'tcx>,
1694         location: Location,
1695     ) -> bool {
1696         debug!(
1697             "check_access_permissions({:?}, {:?}, {:?})",
1698             place, kind, is_local_mutation_allowed
1699         );
1700
1701         let error_access;
1702         let the_place_err;
1703
1704         match kind {
1705             Reservation(WriteKind::MutableBorrow(borrow_kind @ BorrowKind::Unique))
1706             | Reservation(WriteKind::MutableBorrow(borrow_kind @ BorrowKind::Mut { .. }))
1707             | Write(WriteKind::MutableBorrow(borrow_kind @ BorrowKind::Unique))
1708             | Write(WriteKind::MutableBorrow(borrow_kind @ BorrowKind::Mut { .. })) => {
1709                 let is_local_mutation_allowed = match borrow_kind {
1710                     BorrowKind::Unique => LocalMutationIsAllowed::Yes,
1711                     BorrowKind::Mut { .. } => is_local_mutation_allowed,
1712                     BorrowKind::Shared => unreachable!(),
1713                 };
1714                 match self.is_mutable(place, is_local_mutation_allowed) {
1715                     Ok(root_place) => {
1716                         self.add_used_mut(root_place, flow_state);
1717                         return false;
1718                     }
1719                     Err(place_err) => {
1720                         error_access = AccessKind::MutableBorrow;
1721                         the_place_err = place_err;
1722                     }
1723                 }
1724             }
1725             Reservation(WriteKind::Mutate) | Write(WriteKind::Mutate) => {
1726                 match self.is_mutable(place, is_local_mutation_allowed) {
1727                     Ok(root_place) => {
1728                         self.add_used_mut(root_place, flow_state);
1729                         return false;
1730                     }
1731                     Err(place_err) => {
1732                         error_access = AccessKind::Mutate;
1733                         the_place_err = place_err;
1734                     }
1735                 }
1736             }
1737
1738             Reservation(WriteKind::Move)
1739             | Write(WriteKind::Move)
1740             | Reservation(WriteKind::StorageDeadOrDrop)
1741             | Reservation(WriteKind::MutableBorrow(BorrowKind::Shared))
1742             | Write(WriteKind::StorageDeadOrDrop)
1743             | Write(WriteKind::MutableBorrow(BorrowKind::Shared)) => {
1744                 if let Err(_place_err) = self.is_mutable(place, is_local_mutation_allowed) {
1745                     self.tcx.sess.delay_span_bug(
1746                         span,
1747                         &format!(
1748                             "Accessing `{:?}` with the kind `{:?}` shouldn't be possible",
1749                             place, kind
1750                         ),
1751                     );
1752                 }
1753                 return false;
1754             }
1755             Activation(..) => {
1756                 // permission checks are done at Reservation point.
1757                 return false;
1758             }
1759             Read(ReadKind::Borrow(BorrowKind::Unique))
1760             | Read(ReadKind::Borrow(BorrowKind::Mut { .. }))
1761             | Read(ReadKind::Borrow(BorrowKind::Shared))
1762             | Read(ReadKind::Copy) => {
1763                 // Access authorized
1764                 return false;
1765             }
1766         }
1767
1768         // at this point, we have set up the error reporting state.
1769         self.report_mutability_error(
1770             place,
1771             span,
1772             the_place_err,
1773             error_access,
1774             location,
1775         );
1776         return true;
1777     }
1778
1779     /// Adds the place into the used mutable variables set
1780     fn add_used_mut<'d>(
1781         &mut self,
1782         root_place: RootPlace<'d, 'tcx>,
1783         flow_state: &Flows<'cx, 'gcx, 'tcx>,
1784     ) {
1785         match root_place {
1786             RootPlace {
1787                 place: Place::Local(local),
1788                 is_local_mutation_allowed,
1789             } => {
1790                 if is_local_mutation_allowed != LocalMutationIsAllowed::Yes {
1791                     // If the local may be initialized, and it is now currently being
1792                     // mutated, then it is justified to be annotated with the `mut`
1793                     // keyword, since the mutation may be a possible reassignment.
1794                     let mpi = self.move_data.rev_lookup.find_local(*local);
1795                     let ii = &self.move_data.init_path_map[mpi];
1796                     for index in ii {
1797                         if flow_state.ever_inits.contains(index) {
1798                             self.used_mut.insert(*local);
1799                             break;
1800                         }
1801                     }
1802                 }
1803             }
1804             RootPlace {
1805                 place: _,
1806                 is_local_mutation_allowed: LocalMutationIsAllowed::Yes,
1807             } => {}
1808             RootPlace {
1809                 place: place @ Place::Projection(_),
1810                 is_local_mutation_allowed: _,
1811             } => {
1812                 if let Some(field) = place.is_upvar_field_projection(self.mir, &self.tcx) {
1813                     self.used_mut_upvars.push(field);
1814                 }
1815             }
1816             RootPlace {
1817                 place: Place::Promoted(..),
1818                 is_local_mutation_allowed: _,
1819             } => {}
1820             RootPlace {
1821                 place: Place::Static(..),
1822                 is_local_mutation_allowed: _,
1823             } => {}
1824         }
1825     }
1826
1827     /// Whether this value be written or borrowed mutably.
1828     /// Returns the root place if the place passed in is a projection.
1829     fn is_mutable<'d>(
1830         &self,
1831         place: &'d Place<'tcx>,
1832         is_local_mutation_allowed: LocalMutationIsAllowed,
1833     ) -> Result<RootPlace<'d, 'tcx>, &'d Place<'tcx>> {
1834         match *place {
1835             Place::Local(local) => {
1836                 let local = &self.mir.local_decls[local];
1837                 match local.mutability {
1838                     Mutability::Not => match is_local_mutation_allowed {
1839                         LocalMutationIsAllowed::Yes => Ok(RootPlace {
1840                             place,
1841                             is_local_mutation_allowed: LocalMutationIsAllowed::Yes,
1842                         }),
1843                         LocalMutationIsAllowed::ExceptUpvars => Ok(RootPlace {
1844                             place,
1845                             is_local_mutation_allowed: LocalMutationIsAllowed::ExceptUpvars,
1846                         }),
1847                         LocalMutationIsAllowed::No => Err(place),
1848                     },
1849                     Mutability::Mut => Ok(RootPlace {
1850                         place,
1851                         is_local_mutation_allowed,
1852                     }),
1853                 }
1854             }
1855             // promoteds may never be mutated
1856             Place::Promoted(_) => Err(place),
1857             Place::Static(ref static_) => {
1858                 if self.tcx.is_static(static_.def_id) != Some(hir::Mutability::MutMutable) {
1859                     Err(place)
1860                 } else {
1861                     Ok(RootPlace {
1862                         place,
1863                         is_local_mutation_allowed,
1864                     })
1865                 }
1866             }
1867             Place::Projection(ref proj) => {
1868                 match proj.elem {
1869                     ProjectionElem::Deref => {
1870                         let base_ty = proj.base.ty(self.mir, self.tcx).to_ty(self.tcx);
1871
1872                         // Check the kind of deref to decide
1873                         match base_ty.sty {
1874                             ty::TyRef(_, _, mutbl) => {
1875                                 match mutbl {
1876                                     // Shared borrowed data is never mutable
1877                                     hir::MutImmutable => Err(place),
1878                                     // Mutably borrowed data is mutable, but only if we have a
1879                                     // unique path to the `&mut`
1880                                     hir::MutMutable => {
1881                                         let mode = match place.is_upvar_field_projection(
1882                                             self.mir, &self.tcx)
1883                                         {
1884                                             Some(field)
1885                                                 if {
1886                                                     self.mir.upvar_decls[field.index()].by_ref
1887                                                 } =>
1888                                             {
1889                                                 is_local_mutation_allowed
1890                                             }
1891                                             _ => LocalMutationIsAllowed::Yes,
1892                                         };
1893
1894                                         self.is_mutable(&proj.base, mode)
1895                                     }
1896                                 }
1897                             }
1898                             ty::TyRawPtr(tnm) => {
1899                                 match tnm.mutbl {
1900                                     // `*const` raw pointers are not mutable
1901                                     hir::MutImmutable => return Err(place),
1902                                     // `*mut` raw pointers are always mutable, regardless of
1903                                     // context. The users have to check by themselves.
1904                                     hir::MutMutable => {
1905                                         return Ok(RootPlace {
1906                                             place,
1907                                             is_local_mutation_allowed,
1908                                         });
1909                                     }
1910                                 }
1911                             }
1912                             // `Box<T>` owns its content, so mutable if its location is mutable
1913                             _ if base_ty.is_box() => {
1914                                 self.is_mutable(&proj.base, is_local_mutation_allowed)
1915                             }
1916                             // Deref should only be for reference, pointers or boxes
1917                             _ => bug!("Deref of unexpected type: {:?}", base_ty),
1918                         }
1919                     }
1920                     // All other projections are owned by their base path, so mutable if
1921                     // base path is mutable
1922                     ProjectionElem::Field(..)
1923                     | ProjectionElem::Index(..)
1924                     | ProjectionElem::ConstantIndex { .. }
1925                     | ProjectionElem::Subslice { .. }
1926                     | ProjectionElem::Downcast(..) => {
1927                         let upvar_field_projection = place.is_upvar_field_projection(
1928                             self.mir, &self.tcx);
1929                         if let Some(field) = upvar_field_projection {
1930                             let decl = &self.mir.upvar_decls[field.index()];
1931                             debug!(
1932                                 "decl.mutability={:?} local_mutation_is_allowed={:?} place={:?}",
1933                                 decl, is_local_mutation_allowed, place
1934                             );
1935                             match (decl.mutability, is_local_mutation_allowed) {
1936                                 (Mutability::Not, LocalMutationIsAllowed::No)
1937                                 | (Mutability::Not, LocalMutationIsAllowed::ExceptUpvars) => {
1938                                     Err(place)
1939                                 }
1940                                 (Mutability::Not, LocalMutationIsAllowed::Yes)
1941                                 | (Mutability::Mut, _) => {
1942                                     // Subtle: this is an upvar
1943                                     // reference, so it looks like
1944                                     // `self.foo` -- we want to double
1945                                     // check that the context `*self`
1946                                     // is mutable (i.e., this is not a
1947                                     // `Fn` closure).  But if that
1948                                     // check succeeds, we want to
1949                                     // *blame* the mutability on
1950                                     // `place` (that is,
1951                                     // `self.foo`). This is used to
1952                                     // propagate the info about
1953                                     // whether mutability declarations
1954                                     // are used outwards, so that we register
1955                                     // the outer variable as mutable. Otherwise a
1956                                     // test like this fails to record the `mut`
1957                                     // as needed:
1958                                     //
1959                                     // ```
1960                                     // fn foo<F: FnOnce()>(_f: F) { }
1961                                     // fn main() {
1962                                     //     let var = Vec::new();
1963                                     //     foo(move || {
1964                                     //         var.push(1);
1965                                     //     });
1966                                     // }
1967                                     // ```
1968                                     let _ = self.is_mutable(&proj.base, is_local_mutation_allowed)?;
1969                                     Ok(RootPlace {
1970                                         place,
1971                                         is_local_mutation_allowed,
1972                                     })
1973                                 }
1974                             }
1975                         } else {
1976                             self.is_mutable(&proj.base, is_local_mutation_allowed)
1977                         }
1978                     }
1979                 }
1980             }
1981         }
1982     }
1983 }
1984
1985 #[derive(Copy, Clone, PartialEq, Eq, Debug)]
1986 enum NoMovePathFound {
1987     ReachedStatic,
1988 }
1989
1990 /// The degree of overlap between 2 places for borrow-checking.
1991 enum Overlap {
1992     /// The places might partially overlap - in this case, we give
1993     /// up and say that they might conflict. This occurs when
1994     /// different fields of a union are borrowed. For example,
1995     /// if `u` is a union, we have no way of telling how disjoint
1996     /// `u.a.x` and `a.b.y` are.
1997     Arbitrary,
1998     /// The places have the same type, and are either completely disjoint
1999     /// or equal - i.e. they can't "partially" overlap as can occur with
2000     /// unions. This is the "base case" on which we recur for extensions
2001     /// of the place.
2002     EqualOrDisjoint,
2003     /// The places are disjoint, so we know all extensions of them
2004     /// will also be disjoint.
2005     Disjoint,
2006 }
2007
2008 impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
2009     // FIXME (#16118): function intended to allow the borrow checker
2010     // to be less precise in its handling of Box while still allowing
2011     // moves out of a Box. They should be removed when/if we stop
2012     // treating Box specially (e.g. when/if DerefMove is added...)
2013
2014     fn base_path<'d>(&self, place: &'d Place<'tcx>) -> &'d Place<'tcx> {
2015         //! Returns the base of the leftmost (deepest) dereference of an
2016         //! Box in `place`. If there is no dereference of an Box
2017         //! in `place`, then it just returns `place` itself.
2018
2019         let mut cursor = place;
2020         let mut deepest = place;
2021         loop {
2022             let proj = match *cursor {
2023                 Place::Promoted(_) |
2024                 Place::Local(..) | Place::Static(..) => return deepest,
2025                 Place::Projection(ref proj) => proj,
2026             };
2027             if proj.elem == ProjectionElem::Deref
2028                 && place.ty(self.mir, self.tcx).to_ty(self.tcx).is_box()
2029             {
2030                 deepest = &proj.base;
2031             }
2032             cursor = &proj.base;
2033         }
2034     }
2035 }
2036
2037 #[derive(Copy, Clone, PartialEq, Eq, Debug)]
2038 struct Context {
2039     kind: ContextKind,
2040     loc: Location,
2041 }
2042
2043 #[derive(Copy, Clone, PartialEq, Eq, Debug)]
2044 enum ContextKind {
2045     Activation,
2046     AssignLhs,
2047     AssignRhs,
2048     SetDiscrim,
2049     InlineAsm,
2050     SwitchInt,
2051     Drop,
2052     DropAndReplace,
2053     CallOperator,
2054     CallOperand,
2055     CallDest,
2056     Assert,
2057     Yield,
2058     ReadForMatch,
2059     StorageDead,
2060 }
2061
2062 impl ContextKind {
2063     fn new(self, loc: Location) -> Context {
2064         Context {
2065             kind: self,
2066             loc: loc,
2067         }
2068     }
2069 }