src/librustc_borrowck/borrowck/check_loans.rs

   1 // Copyright 2012-2013 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 // ----------------------------------------------------------------------
  12 // Checking loans
  13 //
  14 // Phase 2 of check: we walk down the tree and check that:
  15 // 1. assignments are always made to mutable locations;
  16 // 2. loans made in overlapping scopes do not conflict
  17 // 3. assignments do not affect things loaned out as immutable
  18 // 4. moves do not affect things loaned out in any way
  19 use self::UseError::*;
  20
  21 use borrowck::*;
  22 use borrowck::InteriorKind::{InteriorElement, InteriorField};
  23 use rustc::middle::expr_use_visitor as euv;
  24 use rustc::middle::expr_use_visitor::MutateMode;
  25 use rustc::middle::mem_categorization as mc;
  26 use rustc::middle::mem_categorization::Categorization;
  27 use rustc::middle::region;
  28 use rustc::ty::{self, TyCtxt};
  29 use syntax::ast;
  30 use syntax_pos::Span;
  31 use rustc::hir;
  32
  33 use std::rc::Rc;
  34
  35 // FIXME (#16118): These functions are intended to allow the borrow checker to
  36 // be less precise in its handling of Box while still allowing moves out of a
  37 // Box. They should be removed when Unique is removed from LoanPath.
  38
  39 fn owned_ptr_base_path<'a, 'tcx>(loan_path: &'a LoanPath<'tcx>) -> &'a LoanPath<'tcx> {
  40     //! Returns the base of the leftmost dereference of an Unique in
  41     //! `loan_path`. If there is no dereference of an Unique in `loan_path`,
  42     //! then it just returns `loan_path` itself.
  43
  44     return match helper(loan_path) {
  45         Some(new_loan_path) => new_loan_path,
  46         None => loan_path.clone()
  47     };
  48
  49     fn helper<'a, 'tcx>(loan_path: &'a LoanPath<'tcx>) -> Option<&'a LoanPath<'tcx>> {
  50         match loan_path.kind {
  51             LpVar(_) | LpUpvar(_) => None,
  52             LpExtend(ref lp_base, _, LpDeref(mc::Unique)) => {
  53                 match helper(&lp_base) {
  54                     v @ Some(_) => v,
  55                     None => Some(&lp_base)
  56                 }
  57             }
  58             LpDowncast(ref lp_base, _) |
  59             LpExtend(ref lp_base, ..) => helper(&lp_base)
  60         }
  61     }
  62 }
  63
  64 fn owned_ptr_base_path_rc<'tcx>(loan_path: &Rc<LoanPath<'tcx>>) -> Rc<LoanPath<'tcx>> {
  65     //! The equivalent of `owned_ptr_base_path` for an &Rc<LoanPath> rather than
  66     //! a &LoanPath.
  67
  68     return match helper(loan_path) {
  69         Some(new_loan_path) => new_loan_path,
  70         None => loan_path.clone()
  71     };
  72
  73     fn helper<'tcx>(loan_path: &Rc<LoanPath<'tcx>>) -> Option<Rc<LoanPath<'tcx>>> {
  74         match loan_path.kind {
  75             LpVar(_) | LpUpvar(_) => None,
  76             LpExtend(ref lp_base, _, LpDeref(mc::Unique)) => {
  77                 match helper(lp_base) {
  78                     v @ Some(_) => v,
  79                     None => Some(lp_base.clone())
  80                 }
  81             }
  82             LpDowncast(ref lp_base, _) |
  83             LpExtend(ref lp_base, ..) => helper(lp_base)
  84         }
  85     }
  86 }
  87
  88 struct CheckLoanCtxt<'a, 'tcx: 'a> {
  89     bccx: &'a BorrowckCtxt<'a, 'tcx>,
  90     dfcx_loans: &'a LoanDataFlow<'a, 'tcx>,
  91     move_data: &'a move_data::FlowedMoveData<'a, 'tcx>,
  92     all_loans: &'a [Loan<'tcx>],
  93     param_env: ty::ParamEnv<'tcx>,
  94 }
  95
  96 impl<'a, 'tcx> euv::Delegate<'tcx> for CheckLoanCtxt<'a, 'tcx> {
  97     fn consume(&mut self,
  98                consume_id: ast::NodeId,
  99                consume_span: Span,
 100                cmt: mc::cmt<'tcx>,
 101                mode: euv::ConsumeMode) {
 102         debug!("consume(consume_id={}, cmt={:?}, mode={:?})",
 103                consume_id, cmt, mode);
 104
 105         self.consume_common(consume_id, consume_span, cmt, mode);
 106     }
 107
 108     fn matched_pat(&mut self,
 109                    _matched_pat: &hir::Pat,
 110                    _cmt: mc::cmt,
 111                    _mode: euv::MatchMode) { }
 112
 113     fn consume_pat(&mut self,
 114                    consume_pat: &hir::Pat,
 115                    cmt: mc::cmt<'tcx>,
 116                    mode: euv::ConsumeMode) {
 117         debug!("consume_pat(consume_pat={:?}, cmt={:?}, mode={:?})",
 118                consume_pat,
 119                cmt,
 120                mode);
 121
 122         self.consume_common(consume_pat.id, consume_pat.span, cmt, mode);
 123     }
 124
 125     fn borrow(&mut self,
 126               borrow_id: ast::NodeId,
 127               borrow_span: Span,
 128               cmt: mc::cmt<'tcx>,
 129               loan_region: ty::Region<'tcx>,
 130               bk: ty::BorrowKind,
 131               loan_cause: euv::LoanCause)
 132     {
 133         debug!("borrow(borrow_id={}, cmt={:?}, loan_region={:?}, \
 134                bk={:?}, loan_cause={:?})",
 135                borrow_id, cmt, loan_region,
 136                bk, loan_cause);
 137
 138         if let Some(lp) = opt_loan_path(&cmt) {
 139             let moved_value_use_kind = match loan_cause {
 140                 euv::ClosureCapture(_) => MovedInCapture,
 141                 _ => MovedInUse,
 142             };
 143             self.check_if_path_is_moved(borrow_id, borrow_span, moved_value_use_kind, &lp);
 144         }
 145
 146         self.check_for_conflicting_loans(borrow_id);
 147     }
 148
 149     fn mutate(&mut self,
 150               assignment_id: ast::NodeId,
 151               assignment_span: Span,
 152               assignee_cmt: mc::cmt<'tcx>,
 153               mode: euv::MutateMode)
 154     {
 155         debug!("mutate(assignment_id={}, assignee_cmt={:?})",
 156                assignment_id, assignee_cmt);
 157
 158         if let Some(lp) = opt_loan_path(&assignee_cmt) {
 159             match mode {
 160                 MutateMode::Init | MutateMode::JustWrite => {
 161                     // In a case like `path = 1`, then path does not
 162                     // have to be *FULLY* initialized, but we still
 163                     // must be careful lest it contains derefs of
 164                     // pointers.
 165                     self.check_if_assigned_path_is_moved(assignee_cmt.id,
 166                                                          assignment_span,
 167                                                          MovedInUse,
 168                                                          &lp);
 169                 }
 170                 MutateMode::WriteAndRead => {
 171                     // In a case like `path += 1`, then path must be
 172                     // fully initialized, since we will read it before
 173                     // we write it.
 174                     self.check_if_path_is_moved(assignee_cmt.id,
 175                                                 assignment_span,
 176                                                 MovedInUse,
 177                                                 &lp);
 178                 }
 179             }
 180         }
 181         self.check_assignment(assignment_id, assignment_span, assignee_cmt);
 182     }
 183
 184     fn decl_without_init(&mut self, _id: ast::NodeId, _span: Span) { }
 185 }
 186
 187 pub fn check_loans<'a, 'b, 'c, 'tcx>(bccx: &BorrowckCtxt<'a, 'tcx>,
 188                                      dfcx_loans: &LoanDataFlow<'b, 'tcx>,
 189                                      move_data: &move_data::FlowedMoveData<'c, 'tcx>,
 190                                      all_loans: &[Loan<'tcx>],
 191                                      body: &hir::Body) {
 192     debug!("check_loans(body id={})", body.value.id);
 193
 194     let def_id = bccx.tcx.hir.body_owner_def_id(body.id());
 195     let infcx = bccx.tcx.borrowck_fake_infer_ctxt(body.id());
 196     let param_env = bccx.tcx.param_env(def_id);
 197     let mut clcx = CheckLoanCtxt {
 198         bccx: bccx,
 199         dfcx_loans: dfcx_loans,
 200         move_data: move_data,
 201         all_loans: all_loans,
 202         param_env,
 203     };
 204     euv::ExprUseVisitor::new(&mut clcx, &bccx.region_maps, &infcx, param_env).consume_body(body);
 205 }
 206
 207 #[derive(PartialEq)]
 208 enum UseError<'tcx> {
 209     UseOk,
 210     UseWhileBorrowed(/*loan*/Rc<LoanPath<'tcx>>, /*loan*/Span)
 211 }
 212
 213 fn compatible_borrow_kinds(borrow_kind1: ty::BorrowKind,
 214                            borrow_kind2: ty::BorrowKind)
 215                            -> bool {
 216     borrow_kind1 == ty::ImmBorrow && borrow_kind2 == ty::ImmBorrow
 217 }
 218
 219 impl<'a, 'tcx> CheckLoanCtxt<'a, 'tcx> {
 220     pub fn tcx(&self) -> TyCtxt<'a, 'tcx, 'tcx> { self.bccx.tcx }
 221
 222     pub fn each_issued_loan<F>(&self, node: ast::NodeId, mut op: F) -> bool where
 223         F: FnMut(&Loan<'tcx>) -> bool,
 224     {
 225         //! Iterates over each loan that has been issued
 226         //! on entrance to `node`, regardless of whether it is
 227         //! actually *in scope* at that point.  Sometimes loans
 228         //! are issued for future scopes and thus they may have been
 229         //! *issued* but not yet be in effect.
 230
 231         self.dfcx_loans.each_bit_on_entry(node, |loan_index| {
 232             let loan = &self.all_loans[loan_index];
 233             op(loan)
 234         })
 235     }
 236
 237     pub fn each_in_scope_loan<F>(&self, scope: region::CodeExtent, mut op: F) -> bool where
 238         F: FnMut(&Loan<'tcx>) -> bool,
 239     {
 240         //! Like `each_issued_loan()`, but only considers loans that are
 241         //! currently in scope.
 242
 243         self.each_issued_loan(scope.node_id(), |loan| {
 244             if self.bccx.region_maps.is_subscope_of(scope, loan.kill_scope) {
 245                 op(loan)
 246             } else {
 247                 true
 248             }
 249         })
 250     }
 251
 252     fn each_in_scope_loan_affecting_path<F>(&self,
 253                                             scope: region::CodeExtent,
 254                                             loan_path: &LoanPath<'tcx>,
 255                                             mut op: F)
 256                                             -> bool where
 257         F: FnMut(&Loan<'tcx>) -> bool,
 258     {
 259         //! Iterates through all of the in-scope loans affecting `loan_path`,
 260         //! calling `op`, and ceasing iteration if `false` is returned.
 261
 262         // First, we check for a loan restricting the path P being used. This
 263         // accounts for borrows of P but also borrows of subpaths, like P.a.b.
 264         // Consider the following example:
 265         //
 266         //     let x = &mut a.b.c; // Restricts a, a.b, and a.b.c
 267         //     let y = a;          // Conflicts with restriction
 268
 269         let loan_path = owned_ptr_base_path(loan_path);
 270         let cont = self.each_in_scope_loan(scope, |loan| {
 271             let mut ret = true;
 272             for restr_path in &loan.restricted_paths {
 273                 if **restr_path == *loan_path {
 274                     if !op(loan) {
 275                         ret = false;
 276                         break;
 277                     }
 278                 }
 279             }
 280             ret
 281         });
 282
 283         if !cont {
 284             return false;
 285         }
 286
 287         // Next, we must check for *loans* (not restrictions) on the path P or
 288         // any base path. This rejects examples like the following:
 289         //
 290         //     let x = &mut a.b;
 291         //     let y = a.b.c;
 292         //
 293         // Limiting this search to *loans* and not *restrictions* means that
 294         // examples like the following continue to work:
 295         //
 296         //     let x = &mut a.b;
 297         //     let y = a.c;
 298
 299         let mut loan_path = loan_path;
 300         loop {
 301             match loan_path.kind {
 302                 LpVar(_) | LpUpvar(_) => {
 303                     break;
 304                 }
 305                 LpDowncast(ref lp_base, _) |
 306                 LpExtend(ref lp_base, ..) => {
 307                     loan_path = &lp_base;
 308                 }
 309             }
 310
 311             let cont = self.each_in_scope_loan(scope, |loan| {
 312                 if *loan.loan_path == *loan_path {
 313                     op(loan)
 314                 } else {
 315                     true
 316                 }
 317             });
 318
 319             if !cont {
 320                 return false;
 321             }
 322         }
 323
 324         return true;
 325     }
 326
 327     pub fn loans_generated_by(&self, node: ast::NodeId) -> Vec<usize> {
 328         //! Returns a vector of the loans that are generated as
 329         //! we enter `node`.
 330
 331         let mut result = Vec::new();
 332         self.dfcx_loans.each_gen_bit(node, |loan_index| {
 333             result.push(loan_index);
 334             true
 335         });
 336         return result;
 337     }
 338
 339     pub fn check_for_conflicting_loans(&self, node: ast::NodeId) {
 340         //! Checks to see whether any of the loans that are issued
 341         //! on entrance to `node` conflict with loans that have already been
 342         //! issued when we enter `node` (for example, we do not
 343         //! permit two `&mut` borrows of the same variable).
 344         //!
 345         //! (Note that some loans can be *issued* without necessarily
 346         //! taking effect yet.)
 347
 348         debug!("check_for_conflicting_loans(node={:?})", node);
 349
 350         let new_loan_indices = self.loans_generated_by(node);
 351         debug!("new_loan_indices = {:?}", new_loan_indices);
 352
 353         for &new_loan_index in &new_loan_indices {
 354             self.each_issued_loan(node, |issued_loan| {
 355                 let new_loan = &self.all_loans[new_loan_index];
 356                 // Only report an error for the first issued loan that conflicts
 357                 // to avoid O(n^2) errors.
 358                 self.report_error_if_loans_conflict(issued_loan, new_loan)
 359             });
 360         }
 361
 362         for (i, &x) in new_loan_indices.iter().enumerate() {
 363             let old_loan = &self.all_loans[x];
 364             for &y in &new_loan_indices[(i+1) ..] {
 365                 let new_loan = &self.all_loans[y];
 366                 self.report_error_if_loans_conflict(old_loan, new_loan);
 367             }
 368         }
 369     }
 370
 371     pub fn report_error_if_loans_conflict(&self,
 372                                           old_loan: &Loan<'tcx>,
 373                                           new_loan: &Loan<'tcx>)
 374                                           -> bool {
 375         //! Checks whether `old_loan` and `new_loan` can safely be issued
 376         //! simultaneously.
 377
 378         debug!("report_error_if_loans_conflict(old_loan={:?}, new_loan={:?})",
 379                old_loan,
 380                new_loan);
 381
 382         // Should only be called for loans that are in scope at the same time.
 383         assert!(self.bccx.region_maps.scopes_intersect(old_loan.kill_scope,
 384                                                        new_loan.kill_scope));
 385
 386         self.report_error_if_loan_conflicts_with_restriction(
 387             old_loan, new_loan, old_loan, new_loan) &&
 388         self.report_error_if_loan_conflicts_with_restriction(
 389             new_loan, old_loan, old_loan, new_loan)
 390     }
 391
 392     pub fn report_error_if_loan_conflicts_with_restriction(&self,
 393                                                            loan1: &Loan<'tcx>,
 394                                                            loan2: &Loan<'tcx>,
 395                                                            old_loan: &Loan<'tcx>,
 396                                                            new_loan: &Loan<'tcx>)
 397                                                            -> bool {
 398         //! Checks whether the restrictions introduced by `loan1` would
 399         //! prohibit `loan2`. Returns false if an error is reported.
 400
 401         debug!("report_error_if_loan_conflicts_with_restriction(\
 402                 loan1={:?}, loan2={:?})",
 403                loan1,
 404                loan2);
 405
 406         if compatible_borrow_kinds(loan1.kind, loan2.kind) {
 407             return true;
 408         }
 409
 410         let loan2_base_path = owned_ptr_base_path_rc(&loan2.loan_path);
 411         for restr_path in &loan1.restricted_paths {
 412             if *restr_path != loan2_base_path { continue; }
 413
 414             // If new_loan is something like `x.a`, and old_loan is something like `x.b`, we would
 415             // normally generate a rather confusing message (in this case, for multiple mutable
 416             // borrows):
 417             //
 418             //     error: cannot borrow `x.b` as mutable more than once at a time
 419             //     note: previous borrow of `x.a` occurs here; the mutable borrow prevents
 420             //     subsequent moves, borrows, or modification of `x.a` until the borrow ends
 421             //
 422             // What we want to do instead is get the 'common ancestor' of the two borrow paths and
 423             // use that for most of the message instead, giving is something like this:
 424             //
 425             //     error: cannot borrow `x` as mutable more than once at a time
 426             //     note: previous borrow of `x` occurs here (through borrowing `x.a`); the mutable
 427             //     borrow prevents subsequent moves, borrows, or modification of `x` until the
 428             //     borrow ends
 429
 430             let common = new_loan.loan_path.common(&old_loan.loan_path);
 431             let (nl, ol, new_loan_msg, old_loan_msg) = {
 432                 if new_loan.loan_path.has_fork(&old_loan.loan_path) && common.is_some() {
 433                     let nl = self.bccx.loan_path_to_string(&common.unwrap());
 434                     let ol = nl.clone();
 435                     let new_loan_msg = format!(" (via `{}`)",
 436                                                self.bccx.loan_path_to_string(
 437                                                    &new_loan.loan_path));
 438                     let old_loan_msg = format!(" (via `{}`)",
 439                                                self.bccx.loan_path_to_string(
 440                                                    &old_loan.loan_path));
 441                     (nl, ol, new_loan_msg, old_loan_msg)
 442                 } else {
 443                     (self.bccx.loan_path_to_string(&new_loan.loan_path),
 444                      self.bccx.loan_path_to_string(&old_loan.loan_path),
 445                      String::new(),
 446                      String::new())
 447                 }
 448             };
 449
 450             let ol_pronoun = if new_loan.loan_path == old_loan.loan_path {
 451                 "it".to_string()
 452             } else {
 453                 format!("`{}`", ol)
 454             };
 455
 456             // We want to assemble all the relevant locations for the error.
 457             //
 458             // 1. Where did the new loan occur.
 459             //    - if due to closure creation, where was the variable used in closure?
 460             // 2. Where did old loan occur.
 461             // 3. Where does old loan expire.
 462
 463             let previous_end_span =
 464                 self.tcx().hir.span(old_loan.kill_scope.node_id()).end_point();
 465
 466             let mut err = match (new_loan.kind, old_loan.kind) {
 467                 (ty::MutBorrow, ty::MutBorrow) => {
 468                     let mut err = struct_span_err!(self.bccx, new_loan.span, E0499,
 469                                                   "cannot borrow `{}`{} as mutable \
 470                                                   more than once at a time",
 471                                                   nl, new_loan_msg);
 472                     err.span_label(
 473                             old_loan.span,
 474                             format!("first mutable borrow occurs here{}", old_loan_msg));
 475                     err.span_label(
 476                             new_loan.span,
 477                             format!("second mutable borrow occurs here{}", new_loan_msg));
 478                     err.span_label(
 479                             previous_end_span,
 480                             "first borrow ends here");
 481                     err
 482                 }
 483
 484                 (ty::UniqueImmBorrow, ty::UniqueImmBorrow) => {
 485                     let mut err = struct_span_err!(self.bccx, new_loan.span, E0524,
 486                                      "two closures require unique access to `{}` \
 487                                       at the same time",
 488                                      nl);
 489                     err.span_label(
 490                             old_loan.span,
 491                             "first closure is constructed here");
 492                     err.span_label(
 493                             new_loan.span,
 494                             "second closure is constructed here");
 495                     err.span_label(
 496                             previous_end_span,
 497                             "borrow from first closure ends here");
 498                     err
 499                 }
 500
 501                 (ty::UniqueImmBorrow, _) => {
 502                     let mut err = struct_span_err!(self.bccx, new_loan.span, E0500,
 503                                                    "closure requires unique access to `{}` \
 504                                                    but {} is already borrowed{}",
 505                                                    nl, ol_pronoun, old_loan_msg);
 506                     err.span_label(
 507                             new_loan.span,
 508                             format!("closure construction occurs here{}", new_loan_msg));
 509                     err.span_label(
 510                             old_loan.span,
 511                             format!("borrow occurs here{}", old_loan_msg));
 512                     err.span_label(
 513                             previous_end_span,
 514                             "borrow ends here");
 515                     err
 516                 }
 517
 518                 (_, ty::UniqueImmBorrow) => {
 519                     let mut err = struct_span_err!(self.bccx, new_loan.span, E0501,
 520                                                    "cannot borrow `{}`{} as {} because \
 521                                                    previous closure requires unique access",
 522                                                    nl, new_loan_msg, new_loan.kind.to_user_str());
 523                     err.span_label(
 524                             new_loan.span,
 525                             format!("borrow occurs here{}", new_loan_msg));
 526                     err.span_label(
 527                             old_loan.span,
 528                             format!("closure construction occurs here{}", old_loan_msg));
 529                     err.span_label(
 530                             previous_end_span,
 531                             "borrow from closure ends here");
 532                     err
 533                 }
 534
 535                 (..) => {
 536                     let mut err = struct_span_err!(self.bccx, new_loan.span, E0502,
 537                                                    "cannot borrow `{}`{} as {} because \
 538                                                    {} is also borrowed as {}{}",
 539                                                    nl,
 540                                                    new_loan_msg,
 541                                                    new_loan.kind.to_user_str(),
 542                                                    ol_pronoun,
 543                                                    old_loan.kind.to_user_str(),
 544                                                    old_loan_msg);
 545                     err.span_label(
 546                             new_loan.span,
 547                             format!("{} borrow occurs here{}",
 548                                      new_loan.kind.to_user_str(),
 549                                      new_loan_msg));
 550                     err.span_label(
 551                             old_loan.span,
 552                             format!("{} borrow occurs here{}",
 553                                      old_loan.kind.to_user_str(),
 554                                      old_loan_msg));
 555                     err.span_label(
 556                             previous_end_span,
 557                             format!("{} borrow ends here",
 558                                      old_loan.kind.to_user_str()));
 559                     err
 560                 }
 561             };
 562
 563             match new_loan.cause {
 564                 euv::ClosureCapture(span) => {
 565                     err.span_label(
 566                         span,
 567                         format!("borrow occurs due to use of `{}` in closure", nl));
 568                 }
 569                 _ => { }
 570             }
 571
 572             match old_loan.cause {
 573                 euv::ClosureCapture(span) => {
 574                     err.span_label(
 575                         span,
 576                         format!("previous borrow occurs due to use of `{}` in closure",
 577                                  ol));
 578                 }
 579                 _ => { }
 580             }
 581
 582             err.emit();
 583             return false;
 584         }
 585
 586         true
 587     }
 588
 589     fn consume_common(&self,
 590                       id: ast::NodeId,
 591                       span: Span,
 592                       cmt: mc::cmt<'tcx>,
 593                       mode: euv::ConsumeMode) {
 594         if let Some(lp) = opt_loan_path(&cmt) {
 595             let moved_value_use_kind = match mode {
 596                 euv::Copy => {
 597                     self.check_for_copy_of_frozen_path(id, span, &lp);
 598                     MovedInUse
 599                 }
 600                 euv::Move(_) => {
 601                     match self.move_data.kind_of_move_of_path(id, &lp) {
 602                         None => {
 603                             // Sometimes moves don't have a move kind;
 604                             // this either means that the original move
 605                             // was from something illegal to move,
 606                             // or was moved from referent of an unsafe
 607                             // pointer or something like that.
 608                             MovedInUse
 609                         }
 610                         Some(move_kind) => {
 611                             self.check_for_move_of_borrowed_path(id, span,
 612                                                                  &lp, move_kind);
 613                             if move_kind == move_data::Captured {
 614                                 MovedInCapture
 615                             } else {
 616                                 MovedInUse
 617                             }
 618                         }
 619                     }
 620                 }
 621             };
 622
 623             self.check_if_path_is_moved(id, span, moved_value_use_kind, &lp);
 624         }
 625     }
 626
 627     fn check_for_copy_of_frozen_path(&self,
 628                                      id: ast::NodeId,
 629                                      span: Span,
 630                                      copy_path: &LoanPath<'tcx>) {
 631         match self.analyze_restrictions_on_use(id, copy_path, ty::ImmBorrow) {
 632             UseOk => { }
 633             UseWhileBorrowed(loan_path, loan_span) => {
 634                 struct_span_err!(self.bccx, span, E0503,
 635                                  "cannot use `{}` because it was mutably borrowed",
 636                                  &self.bccx.loan_path_to_string(copy_path))
 637                     .span_label(loan_span,
 638                                format!("borrow of `{}` occurs here",
 639                                        &self.bccx.loan_path_to_string(&loan_path))
 640                                )
 641                     .span_label(span,
 642                                format!("use of borrowed `{}`",
 643                                         &self.bccx.loan_path_to_string(&loan_path)))
 644                     .emit();
 645             }
 646         }
 647     }
 648
 649     fn check_for_move_of_borrowed_path(&self,
 650                                        id: ast::NodeId,
 651                                        span: Span,
 652                                        move_path: &LoanPath<'tcx>,
 653                                        move_kind: move_data::MoveKind) {
 654         // We want to detect if there are any loans at all, so we search for
 655         // any loans incompatible with MutBorrrow, since all other kinds of
 656         // loans are incompatible with that.
 657         match self.analyze_restrictions_on_use(id, move_path, ty::MutBorrow) {
 658             UseOk => { }
 659             UseWhileBorrowed(loan_path, loan_span) => {
 660                 let mut err = match move_kind {
 661                     move_data::Captured => {
 662                         let mut err = struct_span_err!(self.bccx, span, E0504,
 663                                          "cannot move `{}` into closure because it is borrowed",
 664                                          &self.bccx.loan_path_to_string(move_path));
 665                         err.span_label(
 666                             loan_span,
 667                             format!("borrow of `{}` occurs here",
 668                                     &self.bccx.loan_path_to_string(&loan_path))
 669                             );
 670                         err.span_label(
 671                             span,
 672                             "move into closure occurs here"
 673                             );
 674                         err
 675                     }
 676                     move_data::Declared |
 677                     move_data::MoveExpr |
 678                     move_data::MovePat => {
 679                         let mut err = struct_span_err!(self.bccx, span, E0505,
 680                                          "cannot move out of `{}` because it is borrowed",
 681                                          &self.bccx.loan_path_to_string(move_path));
 682                         err.span_label(
 683                             loan_span,
 684                             format!("borrow of `{}` occurs here",
 685                                     &self.bccx.loan_path_to_string(&loan_path))
 686                             );
 687                         err.span_label(
 688                             span,
 689                             format!("move out of `{}` occurs here",
 690                                 &self.bccx.loan_path_to_string(move_path))
 691                             );
 692                         err
 693                     }
 694                 };
 695
 696                 err.emit();
 697             }
 698         }
 699     }
 700
 701     pub fn analyze_restrictions_on_use(&self,
 702                                        expr_id: ast::NodeId,
 703                                        use_path: &LoanPath<'tcx>,
 704                                        borrow_kind: ty::BorrowKind)
 705                                        -> UseError<'tcx> {
 706         debug!("analyze_restrictions_on_use(expr_id={}, use_path={:?})",
 707                self.tcx().hir.node_to_string(expr_id),
 708                use_path);
 709
 710         let mut ret = UseOk;
 711
 712         self.each_in_scope_loan_affecting_path(
 713             region::CodeExtent::Misc(expr_id), use_path, |loan| {
 714             if !compatible_borrow_kinds(loan.kind, borrow_kind) {
 715                 ret = UseWhileBorrowed(loan.loan_path.clone(), loan.span);
 716                 false
 717             } else {
 718                 true
 719             }
 720         });
 721
 722         return ret;
 723     }
 724
 725     /// Reports an error if `expr` (which should be a path)
 726     /// is using a moved/uninitialized value
 727     fn check_if_path_is_moved(&self,
 728                               id: ast::NodeId,
 729                               span: Span,
 730                               use_kind: MovedValueUseKind,
 731                               lp: &Rc<LoanPath<'tcx>>) {
 732         debug!("check_if_path_is_moved(id={}, use_kind={:?}, lp={:?})",
 733                id, use_kind, lp);
 734
 735         // FIXME (22079): if you find yourself tempted to cut and paste
 736         // the body below and then specializing the error reporting,
 737         // consider refactoring this instead!
 738
 739         let base_lp = owned_ptr_base_path_rc(lp);
 740         self.move_data.each_move_of(id, &base_lp, |the_move, moved_lp| {
 741             self.bccx.report_use_of_moved_value(
 742                 span,
 743                 use_kind,
 744                 &lp,
 745                 the_move,
 746                 moved_lp,
 747                 self.param_env);
 748             false
 749         });
 750     }
 751
 752     /// Reports an error if assigning to `lp` will use a
 753     /// moved/uninitialized value. Mainly this is concerned with
 754     /// detecting derefs of uninitialized pointers.
 755     ///
 756     /// For example:
 757     ///
 758     /// ```ignore
 759     /// let a: i32;
 760     /// a = 10; // ok, even though a is uninitialized
 761     ///
 762     /// struct Point { x: u32, y: u32 }
 763     /// let p: Point;
 764     /// p.x = 22; // ok, even though `p` is uninitialized
 765     ///
 766     /// let p: Box<Point>;
 767     /// (*p).x = 22; // not ok, p is uninitialized, can't deref
 768     /// ```
 769     fn check_if_assigned_path_is_moved(&self,
 770                                        id: ast::NodeId,
 771                                        span: Span,
 772                                        use_kind: MovedValueUseKind,
 773                                        lp: &Rc<LoanPath<'tcx>>)
 774     {
 775         match lp.kind {
 776             LpVar(_) | LpUpvar(_) => {
 777                 // assigning to `x` does not require that `x` is initialized
 778             }
 779             LpDowncast(ref lp_base, _) => {
 780                 // assigning to `(P->Variant).f` is ok if assigning to `P` is ok
 781                 self.check_if_assigned_path_is_moved(id, span,
 782                                                      use_kind, lp_base);
 783             }
 784             LpExtend(ref lp_base, _, LpInterior(_, InteriorField(_))) => {
 785                 match lp_base.to_type().sty {
 786                     ty::TyAdt(def, _) if def.has_dtor(self.tcx()) => {
 787                         // In the case where the owner implements drop, then
 788                         // the path must be initialized to prevent a case of
 789                         // partial reinitialization
 790                         //
 791                         // FIXME (22079): could refactor via hypothetical
 792                         // generalized check_if_path_is_moved
 793                         let loan_path = owned_ptr_base_path_rc(lp_base);
 794                         self.move_data.each_move_of(id, &loan_path, |_, _| {
 795                             self.bccx
 796                                 .report_partial_reinitialization_of_uninitialized_structure(
 797                                     span,
 798                                     &loan_path);
 799                             false
 800                         });
 801                         return;
 802                     },
 803                     _ => {},
 804                 }
 805
 806                 // assigning to `P.f` is ok if assigning to `P` is ok
 807                 self.check_if_assigned_path_is_moved(id, span,
 808                                                      use_kind, lp_base);
 809             }
 810             LpExtend(ref lp_base, _, LpInterior(_, InteriorElement)) |
 811             LpExtend(ref lp_base, _, LpDeref(_)) => {
 812                 // assigning to `P[i]` requires `P` is initialized
 813                 // assigning to `(*P)` requires `P` is initialized
 814                 self.check_if_path_is_moved(id, span, use_kind, lp_base);
 815             }
 816         }
 817     }
 818
 819     fn check_assignment(&self,
 820                         assignment_id: ast::NodeId,
 821                         assignment_span: Span,
 822                         assignee_cmt: mc::cmt<'tcx>) {
 823         debug!("check_assignment(assignee_cmt={:?})", assignee_cmt);
 824
 825         // Check that we don't invalidate any outstanding loans
 826         if let Some(loan_path) = opt_loan_path(&assignee_cmt) {
 827             let scope = region::CodeExtent::Misc(assignment_id);
 828             self.each_in_scope_loan_affecting_path(scope, &loan_path, |loan| {
 829                 self.report_illegal_mutation(assignment_span, &loan_path, loan);
 830                 false
 831             });
 832         }
 833
 834         // Check for reassignments to (immutable) local variables. This
 835         // needs to be done here instead of in check_loans because we
 836         // depend on move data.
 837         if let Categorization::Local(local_id) = assignee_cmt.cat {
 838             let lp = opt_loan_path(&assignee_cmt).unwrap();
 839             self.move_data.each_assignment_of(assignment_id, &lp, |assign| {
 840                 if assignee_cmt.mutbl.is_mutable() {
 841                     self.tcx().used_mut_nodes.borrow_mut().insert(local_id);
 842                 } else {
 843                     self.bccx.report_reassigned_immutable_variable(
 844                         assignment_span,
 845                         &lp,
 846                         assign);
 847                 }
 848                 false
 849             });
 850             return
 851         }
 852     }
 853
 854     pub fn report_illegal_mutation(&self,
 855                                    span: Span,
 856                                    loan_path: &LoanPath<'tcx>,
 857                                    loan: &Loan) {
 858         struct_span_err!(self.bccx, span, E0506,
 859                          "cannot assign to `{}` because it is borrowed",
 860                          self.bccx.loan_path_to_string(loan_path))
 861             .span_label(loan.span,
 862                        format!("borrow of `{}` occurs here",
 863                                self.bccx.loan_path_to_string(loan_path)))
 864             .span_label(span,
 865                        format!("assignment to borrowed `{}` occurs here",
 866                                self.bccx.loan_path_to_string(loan_path)))
 867             .emit();
 868     }
 869 }