) {
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 {
// 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,
);
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 });
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)
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 {
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));
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)),
));
}
subslice
}
- mir::ProjectionElem::Downcast(_, v) => cg_base.project_downcast(bx, *v),
+ mir::ProjectionElem::Downcast(_, v) => cg_base.project_downcast(bx, v),
}
}
};
/// 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, |...| { ... })`
{
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)
})
}
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.
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(..)
&mut self,
local: Local,
proj_base: &[PlaceElem<'tcx>],
- elem: &PlaceElem<'tcx>,
+ elem: PlaceElem<'tcx>,
context: PlaceContext,
location: Location,
) {
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);
}
&mut self,
_local: Local,
_proj_base: &[PlaceElem<'tcx>],
- elem: &PlaceElem<'tcx>,
+ elem: PlaceElem<'tcx>,
_context: PlaceContext,
location: Location,
) {
}
ProjectionElem::Index(local) => {
self.visit_local(
- local,
+ &local,
PlaceContext::NonMutatingUse(NonMutatingUseContext::Copy),
location,
);
}
// 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);
body,
borrow_local,
borrow_proj_base,
- &borrow_c,
- &access_c,
+ borrow_c,
+ access_c,
bias,
) {
Overlap::Arbitrary => {
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) {
}
}
(
- &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,
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));
}
}
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 {
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(|| {
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);
}
};
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]),
});
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 {
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 {
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(),
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)
pub(super) fn mplace_projection(
&self,
base: MPlaceTy<'tcx, M::PointerTag>,
- proj_elem: &mir::PlaceElem<'tcx>,
+ proj_elem: mir::PlaceElem<'tcx>,
) -> InterpResult<'tcx, MPlaceTy<'tcx, M::PointerTag>> {
use rustc_middle::mir::ProjectionElem::*;
- Ok(match *proj_elem {
+ Ok(match proj_elem {
Field(field, _) => self.mplace_field(base, field.index())?,
Downcast(_, variant) => self.mplace_downcast(base, variant)?,
Deref => self.deref_operand(base.into())?,
pub fn place_projection(
&mut self,
base: PlaceTy<'tcx, M::PointerTag>,
- proj_elem: &mir::ProjectionElem<mir::Local, Ty<'tcx>>,
+ &proj_elem: &mir::ProjectionElem<mir::Local, Ty<'tcx>>,
) -> InterpResult<'tcx, PlaceTy<'tcx, M::PointerTag>> {
use rustc_middle::mir::ProjectionElem::*;
- Ok(match *proj_elem {
+ Ok(match proj_elem {
Field(field, _) => self.place_field(base, field.index())?,
Downcast(_, variant) => self.place_downcast(base, variant)?,
Deref => self.deref_operand(self.place_to_op(base)?)?.into(),
F: FnMut(Local) -> bool,
{
let mut projection = place.projection;
- while let [ref proj_base @ .., proj_elem] = projection {
- match *proj_elem {
+ while let &[ref proj_base @ .., proj_elem] = projection {
+ match proj_elem {
ProjectionElem::Index(index) if in_local(index) => return true,
ProjectionElem::Deref
&mut self,
place_local: Local,
proj_base: &[PlaceElem<'tcx>],
- elem: &PlaceElem<'tcx>,
+ elem: PlaceElem<'tcx>,
context: PlaceContext,
location: Location,
) {
fn field_subpath(&self, path: Self::Path, field: Field) -> Option<Self::Path> {
dataflow::move_path_children_matching(self.ctxt.move_data(), path, |e| match e {
- ProjectionElem::Field(idx, _) => *idx == field,
+ ProjectionElem::Field(idx, _) => idx == field,
_ => false,
})
}
fn array_subpath(&self, path: Self::Path, index: u32, size: u32) -> Option<Self::Path> {
dataflow::move_path_children_matching(self.ctxt.move_data(), path, |e| match e {
ProjectionElem::ConstantIndex { offset, min_length, from_end } => {
- debug_assert!(size == *min_length, "min_length should be exact for arrays");
+ debug_assert!(size == min_length, "min_length should be exact for arrays");
assert!(!from_end, "from_end should not be used for array element ConstantIndex");
- *offset == index
+ offset == index
}
_ => false,
})
fn deref_subpath(&self, path: Self::Path) -> Option<Self::Path> {
dataflow::move_path_children_matching(self.ctxt.move_data(), path, |e| {
- *e == ProjectionElem::Deref
+ e == ProjectionElem::Deref
})
}
fn downcast_subpath(&self, path: Self::Path, variant: VariantIdx) -> Option<Self::Path> {
dataflow::move_path_children_matching(self.ctxt.move_data(), path, |e| match e {
- ProjectionElem::Downcast(_, idx) => *idx == variant,
+ ProjectionElem::Downcast(_, idx) => idx == variant,
_ => false,
})
}
// `let _: &'static _ = &(Cell::new(1), 2).1;`
let mut place_projection = &place.projection[..];
// FIXME(eddyb) use a forward loop instead of a reverse one.
- while let [proj_base @ .., elem] = place_projection {
+ while let &[ref proj_base @ .., elem] = place_projection {
// FIXME(eddyb) this is probably excessive, with
// the exception of `union` member accesses.
let ty =
if has_mut_interior {
let mut place_projection = place.projection;
// FIXME(eddyb) use a forward loop instead of a reverse one.
- while let [proj_base @ .., elem] = place_projection {
+ while let &[ref proj_base @ .., elem] = place_projection {
// FIXME(eddyb) this is probably excessive, with
// the exception of `union` member accesses.
let ty = Place::ty_from(place.local, proj_base, self.body, self.tcx)