simplify more, ret_deref -> has_deref

compiler/rustc_codegen_ssa/src/mir/place.rs

@@ -435,13 +435,12 @@ pub fn codegen_place(
             LocalRef::Place(place) => place,
             LocalRef::UnsizedPlace(place) => bx.load_operand(place).deref(cx),
             LocalRef::Operand(..) => {
-                if place_ref.ret_deref().is_some() {
+                if place_ref.has_deref() {
                     base = 1;
                     let cg_base = self.codegen_consume(
                         bx,
                         mir::PlaceRef { projection: &place_ref.projection[..0], ..place_ref },
                     );
-
                     cg_base.deref(bx.cx())
                 } else {
                     bug!("using operand local {:?} as place", place_ref);

compiler/rustc_middle/src/mir/mod.rs

@@ -1463,11 +1463,11 @@ pub fn is_indirect(&self) -> bool {
 
     /// If MirPhase >= Derefered and if projection contains Deref,
     /// It's guaranteed to be in the first place
-    pub fn ret_deref(&self) -> Option<PlaceElem<'tcx>> {
+    pub fn has_deref(&self) -> bool {
         if !self.projection.is_empty() && self.projection[0] == PlaceElem::Deref {
-            return Some(self.projection[0]);
+            true
         } else {
-            None
+            false
         }
     }
 
@@ -1545,11 +1545,11 @@ pub fn local_or_deref_local(&self) -> Option<Local> {
 
     /// If MirPhase >= Derefered and if projection contains Deref,
     /// It's guaranteed to be in the first place
-    pub fn ret_deref(&self) -> Option<PlaceElem<'tcx>> {
+    pub fn has_deref(&self) -> bool {
         if !self.projection.is_empty() && self.projection[0] == PlaceElem::Deref {
-            return Some(self.projection[0]);
+            true
         } else {
-            None
+            false
         }
     }
 

compiler/rustc_mir_transform/src/add_retag.rs

@@ -15,7 +15,7 @@
 /// (Concurrent accesses by other threads are no problem as these are anyway non-atomic
 /// copies.  Data races are UB.)
 fn is_stable(place: PlaceRef<'_>) -> bool {
-    if place.ret_deref().is_some() {
+    if place.has_deref() {
         // Which place this evaluates to can change with any memory write,
         // so cannot assume deref to be stable.
         return false;
@@ -83,8 +83,7 @@ fn run_pass(&self, tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
         let place_base_raw = |place: &Place<'tcx>| {
             // If this is a `Deref`, get the type of what we are deref'ing.
             if place.ret_deref().is_some() {
-                let base_proj = &place.projection[..0];
+                let ty = place.ty(local_decls, tcx).ty;
-                let ty = Place::ty_from(place.local, base_proj, &*local_decls, tcx).ty;
                 ty.is_unsafe_ptr()
             } else {
                 // Not a deref, and thus not raw.