clean up old place in place_ext

Author: csmoe

src/librustc_mir/borrow_check/borrow_set.rs

@@ -212,7 +212,8 @@ impl<'a, 'gcx, 'tcx> Visitor<'tcx> for GatherBorrows<'a, 'gcx, 'tcx> {
 
             self.insert_as_pending_if_two_phase(location, &assigned_place, kind, idx);
 
-            if let Some(local) = borrowed_place.root_local() {
+            let neo_place = self.tcx.as_new_place(borrowed_place);
+            if let mir::PlaceBase::Local(local) = neo_place.base {
                 self.local_map.entry(local).or_default().insert(idx);
             }
         }

src/librustc_mir/borrow_check/place_ext.rs

@@ -1,6 +1,7 @@
 use rustc::hir;
 use rustc::mir::ProjectionElem;
-use rustc::mir::{Local, Mir, Place, Mutability};
+use rustc::mir::{Mir, Place, PlaceBase, Mutability};
+use rustc::mir::tcx::PlaceTy;
 use rustc::ty::{self, TyCtxt};
 use borrow_check::borrow_set::LocalsStateAtExit;
 
@@ -16,10 +17,6 @@ crate trait PlaceExt<'tcx> {
         mir: &Mir<'tcx>,
         locals_state_at_exit: &LocalsStateAtExit,
         ) -> bool;
-
-    /// If this is a place like `x.f.g`, returns the local
-    /// `x`. Returns `None` if this is based in a static.
-    fn root_local(&self) -> Option<Local>;
 }
 
 impl<'tcx> PlaceExt<'tcx> for Place<'tcx> {
@@ -29,9 +26,8 @@ impl<'tcx> PlaceExt<'tcx> for Place<'tcx> {
         mir: &Mir<'tcx>,
         locals_state_at_exit: &LocalsStateAtExit,
     ) -> bool {
-        match self {
-            Place::Promoted(_) => false,
-
+        let neo_place = tcx.as_new_place(self);
+        let mut is_unsafe_place = match &neo_place.base {
             // If a local variable is immutable, then we only need to track borrows to guard
             // against two kinds of errors:
             // * The variable being dropped while still borrowed (e.g., because the fn returns
@@ -40,7 +36,7 @@ impl<'tcx> PlaceExt<'tcx> for Place<'tcx> {
             //
             // In particular, the variable cannot be mutated -- the "access checks" will fail --
             // so we don't have to worry about mutation while borrowed.
-            Place::Local(index) => {
+            PlaceBase::Local(index) => {
                 match locals_state_at_exit {
                     LocalsStateAtExit::AllAreInvalidated => false,
                     LocalsStateAtExit::SomeAreInvalidated { has_storage_dead_or_moved } => {
@@ -50,48 +46,33 @@ impl<'tcx> PlaceExt<'tcx> for Place<'tcx> {
                         ignore
                     }
                 }
-            }
-            Place::Static(static_) => {
+            },
+            PlaceBase::Promoted(_) => false,
+            PlaceBase::Static(static_) => {
                 tcx.is_static(static_.def_id) == Some(hir::Mutability::MutMutable)
             }
-            Place::Projection(proj) => match proj.elem {
-                ProjectionElem::Field(..)
-                | ProjectionElem::Downcast(..)
-                | ProjectionElem::Subslice { .. }
-                | ProjectionElem::ConstantIndex { .. }
-                | ProjectionElem::Index(_) => proj.base.ignore_borrow(
-                    tcx, mir, locals_state_at_exit),
+        };
 
-                ProjectionElem::Deref => {
-                    let ty = proj.base.ty(mir, tcx).to_ty(tcx);
-                    match ty.sty {
-                        // For both derefs of raw pointers and `&T`
-                        // references, the original path is `Copy` and
-                        // therefore not significant.  In particular,
-                        // there is nothing the user can do to the
-                        // original path that would invalidate the
-                        // newly created reference -- and if there
-                        // were, then the user could have copied the
-                        // original path into a new variable and
-                        // borrowed *that* one, leaving the original
-                        // path unborrowed.
-                        ty::RawPtr(..) | ty::Ref(_, _, hir::MutImmutable) => true,
-                        _ => proj.base.ignore_borrow(tcx, mir, locals_state_at_exit),
-                    }
+        let mut base_ty = neo_place.base.ty(mir);
+        for elem in neo_place.elems.iter() {
+            if let ProjectionElem::Deref = elem {
+                if let ty::RawPtr(..) | ty::Ref(_, _, hir::MutImmutable) = base_ty.sty {
+                    // For both derefs of raw pointers and `&T`
+                    // references, the original path is `Copy` and
+                    // therefore not significant.  In particular,
+                    // there is nothing the user can do to the
+                    // original path that would invalidate the
+                    // newly created reference -- and if there
+                    // were, then the user could have copied the
+                    // original path into a new variable and
+                    // borrowed *that* one, leaving the original
+                    // path unborrowed.
+                    is_unsafe_place = true;
                 }
-            },
-        }
-    }
-
-    fn root_local(&self) -> Option<Local> {
-        let mut p = self;
-        loop {
-            match p {
-                Place::Projection(pi) => p = &pi.base,
-                Place::Promoted(_) |
-                Place::Static(_) => return None,
-                Place::Local(l) => return Some(*l),
             }
+            base_ty = PlaceTy::from(base_ty).projection_ty(tcx, elem).to_ty(tcx);
         }
+
+        is_unsafe_place
     }
 }