1 use crate::borrow_check::borrow_set::LocalsStateAtExit;
3 use rustc_middle::mir::ProjectionElem;
4 use rustc_middle::mir::{Body, Mutability, Place};
5 use rustc_middle::ty::{self, TyCtxt};
7 /// Extension methods for the `Place` type.
8 crate trait PlaceExt<'tcx> {
9 /// Returns `true` if we can safely ignore borrows of this place.
10 /// This is true whenever there is no action that the user can do
11 /// to the place `self` that would invalidate the borrow. This is true
12 /// for borrows of raw pointer dereferents as well as shared references.
17 locals_state_at_exit: &LocalsStateAtExit,
21 impl<'tcx> PlaceExt<'tcx> for Place<'tcx> {
26 locals_state_at_exit: &LocalsStateAtExit,
28 // If a local variable is immutable, then we only need to track borrows to guard
29 // against two kinds of errors:
30 // * The variable being dropped while still borrowed (e.g., because the fn returns
31 // a reference to a local variable)
32 // * The variable being moved while still borrowed
34 // In particular, the variable cannot be mutated -- the "access checks" will fail --
35 // so we don't have to worry about mutation while borrowed.
36 if let LocalsStateAtExit::SomeAreInvalidated { has_storage_dead_or_moved } =
39 let ignore = !has_storage_dead_or_moved.contains(self.local)
40 && body.local_decls[self.local].mutability == Mutability::Not;
41 debug!("ignore_borrow: local {:?} => {:?}", self.local, ignore);
47 for (i, elem) in self.projection.iter().enumerate() {
48 let proj_base = &self.projection[..i];
50 if elem == ProjectionElem::Deref {
51 let ty = Place::ty_from(self.local, proj_base, body, tcx).ty;
53 ty::Ref(_, _, hir::Mutability::Not) if i == 0 => {
54 // For references to thread-local statics, we do need
55 // to track the borrow.
56 if body.local_decls[self.local].is_ref_to_thread_local() {
61 ty::RawPtr(..) | ty::Ref(_, _, hir::Mutability::Not) => {
62 // For both derefs of raw pointers and `&T`
63 // references, the original path is `Copy` and
64 // therefore not significant. In particular,
65 // there is nothing the user can do to the
66 // original path that would invalidate the
67 // newly created reference -- and if there
68 // were, then the user could have copied the
69 // original path into a new variable and
70 // borrowed *that* one, leaving the original