take mir::PlaceElem by value

Author: lcnr

src/librustc_codegen_ssa/mir/analyze.rs

@@ -104,7 +104,7 @@ impl<Bx: BuilderMethods<'a, 'tcx>> LocalAnalyzer<'mir, 'a, 'tcx, Bx> {
     ) {
         let cx = self.fx.cx;
 
-        if let [proj_base @ .., elem] = place_ref.projection {
+        if let &[ref proj_base @ .., elem] = place_ref.projection {
             let mut base_context = if context.is_mutating_use() {
                 PlaceContext::MutatingUse(MutatingUseContext::Projection)
             } else {
@@ -186,7 +186,7 @@ impl<Bx: BuilderMethods<'a, 'tcx>> LocalAnalyzer<'mir, 'a, 'tcx, Bx> {
             // now that we have moved to the "slice of projections" representation.
             if let mir::ProjectionElem::Index(local) = elem {
                 self.visit_local(
-                    local,
+                    &local,
                     PlaceContext::NonMutatingUse(NonMutatingUseContext::Copy),
                     location,
                 );

src/librustc_codegen_ssa/mir/place.rs

@@ -429,7 +429,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                 self.codegen_consume(bx, mir::PlaceRef { local, projection: proj_base })
                     .deref(bx.cx())
             }
-            mir::PlaceRef { local, projection: [proj_base @ .., elem] } => {
+            mir::PlaceRef { local, projection: &[ref proj_base @ .., elem] } => {
                 // FIXME turn this recursion into iteration
                 let cg_base =
                     self.codegen_place(bx, mir::PlaceRef { local, projection: proj_base });
@@ -440,7 +440,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                         cg_base.project_field(bx, field.index())
                     }
                     mir::ProjectionElem::Index(index) => {
-                        let index = &mir::Operand::Copy(mir::Place::from(*index));
+                        let index = &mir::Operand::Copy(mir::Place::from(index));
                         let index = self.codegen_operand(bx, index);
                         let llindex = index.immediate();
                         cg_base.project_index(bx, llindex)
@@ -450,22 +450,22 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                         from_end: false,
                         min_length: _,
                     } => {
-                        let lloffset = bx.cx().const_usize(*offset as u64);
+                        let lloffset = bx.cx().const_usize(offset as u64);
                         cg_base.project_index(bx, lloffset)
                     }
                     mir::ProjectionElem::ConstantIndex {
                         offset,
                         from_end: true,
                         min_length: _,
                     } => {
-                        let lloffset = bx.cx().const_usize(*offset as u64);
+                        let lloffset = bx.cx().const_usize(offset as u64);
                         let lllen = cg_base.len(bx.cx());
                         let llindex = bx.sub(lllen, lloffset);
                         cg_base.project_index(bx, llindex)
                     }
                     mir::ProjectionElem::Subslice { from, to, from_end } => {
                         let mut subslice =
-                            cg_base.project_index(bx, bx.cx().const_usize(*from as u64));
+                            cg_base.project_index(bx, bx.cx().const_usize(from as u64));
                         let projected_ty =
                             PlaceTy::from_ty(cg_base.layout.ty).projection_ty(tcx, elem).ty;
                         subslice.layout = bx.cx().layout_of(self.monomorphize(&projected_ty));
@@ -474,7 +474,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                             assert!(from_end, "slice subslices should be `from_end`");
                             subslice.llextra = Some(bx.sub(
                                 cg_base.llextra.unwrap(),
-                                bx.cx().const_usize((*from as u64) + (*to as u64)),
+                                bx.cx().const_usize((from as u64) + (to as u64)),
                             ));
                         }
 
@@ -487,7 +487,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
 
                         subslice
                     }
-                    mir::ProjectionElem::Downcast(_, v) => cg_base.project_downcast(bx, *v),
+                    mir::ProjectionElem::Downcast(_, v) => cg_base.project_downcast(bx, v),
                 }
             }
         };

src/librustc_middle/mir/tcx.rs

@@ -56,8 +56,8 @@ impl<'tcx> PlaceTy<'tcx> {
     /// Convenience wrapper around `projection_ty_core` for
     /// `PlaceElem`, where we can just use the `Ty` that is already
     /// stored inline on field projection elems.
-    pub fn projection_ty(self, tcx: TyCtxt<'tcx>, elem: &PlaceElem<'tcx>) -> PlaceTy<'tcx> {
-        self.projection_ty_core(tcx, ty::ParamEnv::empty(), elem, |_, _, ty| ty)
+    pub fn projection_ty(self, tcx: TyCtxt<'tcx>, elem: PlaceElem<'tcx>) -> PlaceTy<'tcx> {
+        self.projection_ty_core(tcx, ty::ParamEnv::empty(), &elem, |_, _, ty| ty)
     }
 
     /// `place_ty.projection_ty_core(tcx, elem, |...| { ... })`
@@ -124,7 +124,7 @@ impl<'tcx> Place<'tcx> {
     {
         projection
             .iter()
-            .fold(PlaceTy::from_ty(local_decls.local_decls()[local].ty), |place_ty, elem| {
+            .fold(PlaceTy::from_ty(local_decls.local_decls()[local].ty), |place_ty, &elem| {
                 place_ty.projection_ty(tcx, elem)
             })
     }

src/librustc_middle/mir/visit.rs

@@ -903,7 +903,7 @@ macro_rules! visit_place_fns {
             let mut projection = Cow::Borrowed(projection);
 
             for i in 0..projection.len() {
-                if let Some(elem) = projection.get(i) {
+                if let Some(&elem) = projection.get(i) {
                     if let Some(elem) = self.process_projection_elem(elem, location) {
                         // This converts the borrowed projection into `Cow::Owned(_)` and returns a
                         // clone of the projection so we can mutate and reintern later.
@@ -921,19 +921,19 @@ macro_rules! visit_place_fns {
 
         fn process_projection_elem(
             &mut self,
-            elem: &PlaceElem<'tcx>,
+            elem: PlaceElem<'tcx>,
             location: Location,
         ) -> Option<PlaceElem<'tcx>> {
             match elem {
                 PlaceElem::Index(local) => {
-                    let mut new_local = *local;
+                    let mut new_local = local;
                     self.visit_local(
                         &mut new_local,
                         PlaceContext::NonMutatingUse(NonMutatingUseContext::Copy),
                         location,
                     );
 
-                    if new_local == *local { None } else { Some(PlaceElem::Index(new_local)) }
+                    if new_local == local { None } else { Some(PlaceElem::Index(new_local)) }
                 }
                 PlaceElem::Deref
                 | PlaceElem::Field(..)
@@ -959,7 +959,7 @@ macro_rules! visit_place_fns {
             &mut self,
             local: Local,
             proj_base: &[PlaceElem<'tcx>],
-            elem: &PlaceElem<'tcx>,
+            elem: PlaceElem<'tcx>,
             context: PlaceContext,
             location: Location,
         ) {
@@ -990,7 +990,7 @@ macro_rules! visit_place_fns {
             location: Location,
         ) {
             let mut cursor = projection;
-            while let [proj_base @ .., elem] = cursor {
+            while let &[ref proj_base @ .., elem] = cursor {
                 cursor = proj_base;
                 self.visit_projection_elem(local, cursor, elem, context, location);
             }
@@ -1000,7 +1000,7 @@ macro_rules! visit_place_fns {
             &mut self,
             _local: Local,
             _proj_base: &[PlaceElem<'tcx>],
-            elem: &PlaceElem<'tcx>,
+            elem: PlaceElem<'tcx>,
             _context: PlaceContext,
             location: Location,
         ) {
@@ -1010,7 +1010,7 @@ macro_rules! visit_place_fns {
                 }
                 ProjectionElem::Index(local) => {
                     self.visit_local(
-                        local,
+                        &local,
                         PlaceContext::NonMutatingUse(NonMutatingUseContext::Copy),
                         location,
                     );

src/librustc_mir/borrow_check/places_conflict.rs

@@ -138,7 +138,7 @@ fn place_components_conflict<'tcx>(
     }
 
     // loop invariant: borrow_c is always either equal to access_c or disjoint from it.
-    for (i, (borrow_c, access_c)) in
+    for (i, (borrow_c, &access_c)) in
         borrow_place.projection.iter().zip(access_place.projection.iter()).enumerate()
     {
         debug!("borrow_conflicts_with_place: borrow_c = {:?}", borrow_c);
@@ -163,8 +163,8 @@ fn place_components_conflict<'tcx>(
             body,
             borrow_local,
             borrow_proj_base,
-            &borrow_c,
-            &access_c,
+            borrow_c,
+            access_c,
             bias,
         ) {
             Overlap::Arbitrary => {
@@ -313,8 +313,8 @@ fn place_projection_conflict<'tcx>(
     body: &Body<'tcx>,
     pi1_local: Local,
     pi1_proj_base: &[PlaceElem<'tcx>],
-    pi1_elem: &PlaceElem<'tcx>,
-    pi2_elem: &PlaceElem<'tcx>,
+    pi1_elem: PlaceElem<'tcx>,
+    pi2_elem: PlaceElem<'tcx>,
     bias: PlaceConflictBias,
 ) -> Overlap {
     match (pi1_elem, pi2_elem) {
@@ -420,24 +420,24 @@ fn place_projection_conflict<'tcx>(
             }
         }
         (
-            &ProjectionElem::ConstantIndex {
+            ProjectionElem::ConstantIndex {
                 offset: offset_from_begin,
                 min_length: min_length1,
                 from_end: false,
             },
-            &ProjectionElem::ConstantIndex {
+            ProjectionElem::ConstantIndex {
                 offset: offset_from_end,
                 min_length: min_length2,
                 from_end: true,
             },
         )
         | (
-            &ProjectionElem::ConstantIndex {
+            ProjectionElem::ConstantIndex {
                 offset: offset_from_end,
                 min_length: min_length1,
                 from_end: true,
             },
-            &ProjectionElem::ConstantIndex {
+            ProjectionElem::ConstantIndex {
                 offset: offset_from_begin,
                 min_length: min_length2,
                 from_end: false,

src/librustc_mir/borrow_check/renumber.rs

@@ -66,14 +66,14 @@ impl<'a, 'tcx> MutVisitor<'tcx> for NLLVisitor<'a, 'tcx> {
 
     fn process_projection_elem(
         &mut self,
-        elem: &PlaceElem<'tcx>,
+        elem: PlaceElem<'tcx>,
         _: Location,
     ) -> Option<PlaceElem<'tcx>> {
         if let PlaceElem::Field(field, ty) = elem {
-            let new_ty = self.renumber_regions(ty);
+            let new_ty = self.renumber_regions(&ty);
 
-            if new_ty != *ty {
-                return Some(PlaceElem::Field(*field, new_ty));
+            if new_ty != ty {
+                return Some(PlaceElem::Field(field, new_ty));
             }
         }
 

src/librustc_mir/borrow_check/type_check/mod.rs

@@ -497,7 +497,7 @@ impl<'a, 'b, 'tcx> TypeVerifier<'a, 'b, 'tcx> {
                     return PlaceTy::from_ty(self.tcx().types.err);
                 }
             }
-            place_ty = self.sanitize_projection(place_ty, &elem, place, location)
+            place_ty = self.sanitize_projection(place_ty, elem, place, location)
         }
 
         if let PlaceContext::NonMutatingUse(NonMutatingUseContext::Copy) = context {
@@ -611,14 +611,14 @@ impl<'a, 'b, 'tcx> TypeVerifier<'a, 'b, 'tcx> {
     fn sanitize_projection(
         &mut self,
         base: PlaceTy<'tcx>,
-        pi: &PlaceElem<'tcx>,
+        pi: PlaceElem<'tcx>,
         place: &Place<'tcx>,
         location: Location,
     ) -> PlaceTy<'tcx> {
         debug!("sanitize_projection: {:?} {:?} {:?}", base, pi, place);
         let tcx = self.tcx();
         let base_ty = base.ty;
-        match *pi {
+        match pi {
             ProjectionElem::Deref => {
                 let deref_ty = base_ty.builtin_deref(true);
                 PlaceTy::from_ty(deref_ty.map(|t| t.ty).unwrap_or_else(|| {

src/librustc_mir/dataflow/drop_flag_effects.rs

@@ -12,12 +12,12 @@ pub fn move_path_children_matching<'tcx, F>(
     mut cond: F,
 ) -> Option<MovePathIndex>
 where
-    F: FnMut(&mir::PlaceElem<'tcx>) -> bool,
+    F: FnMut(mir::PlaceElem<'tcx>) -> bool,
 {
     let mut next_child = move_data.move_paths[path].first_child;
     while let Some(child_index) = next_child {
         let move_path_children = &move_data.move_paths[child_index];
-        if let Some(elem) = move_path_children.place.projection.last() {
+        if let Some(&elem) = move_path_children.place.projection.last() {
             if cond(elem) {
                 return Some(child_index);
             }

src/librustc_mir/dataflow/move_paths/builder.rs

@@ -158,7 +158,7 @@ impl<'b, 'a, 'tcx> Gatherer<'b, 'a, 'tcx> {
             };
 
             if union_path.is_none() {
-                base = self.add_move_path(base, &elem, |tcx| Place {
+                base = self.add_move_path(base, elem, |tcx| Place {
                     local: place.local,
                     projection: tcx.intern_place_elems(&place.projection[..i + 1]),
                 });
@@ -176,7 +176,7 @@ impl<'b, 'a, 'tcx> Gatherer<'b, 'a, 'tcx> {
     fn add_move_path(
         &mut self,
         base: MovePathIndex,
-        elem: &PlaceElem<'tcx>,
+        elem: PlaceElem<'tcx>,
         mk_place: impl FnOnce(TyCtxt<'tcx>) -> Place<'tcx>,
     ) -> MovePathIndex {
         let MoveDataBuilder {
@@ -485,7 +485,7 @@ impl<'b, 'a, 'tcx> Gatherer<'b, 'a, 'tcx> {
                 let elem =
                     ProjectionElem::ConstantIndex { offset, min_length: len, from_end: false };
                 let path =
-                    self.add_move_path(base_path, &elem, |tcx| tcx.mk_place_elem(base_place, elem));
+                    self.add_move_path(base_path, elem, |tcx| tcx.mk_place_elem(base_place, elem));
                 self.record_move(place, path);
             }
         } else {

src/librustc_mir/interpret/operand.rs

@@ -400,10 +400,10 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
     pub fn operand_projection(
         &self,
         base: OpTy<'tcx, M::PointerTag>,
-        proj_elem: &mir::PlaceElem<'tcx>,
+        proj_elem: mir::PlaceElem<'tcx>,
     ) -> InterpResult<'tcx, OpTy<'tcx, M::PointerTag>> {
         use rustc_middle::mir::ProjectionElem::*;
-        Ok(match *proj_elem {
+        Ok(match proj_elem {
             Field(field, _) => self.operand_field(base, field.index())?,
             Downcast(_, variant) => self.operand_downcast(base, variant)?,
             Deref => self.deref_operand(base)?.into(),
@@ -466,7 +466,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
         let op = place
             .projection
             .iter()
-            .try_fold(base_op, |op, elem| self.operand_projection(op, &elem))?;
+            .try_fold(base_op, |op, elem| self.operand_projection(op, elem))?;
 
         trace!("eval_place_to_op: got {:?}", *op);
         Ok(op)