Enum StdItem 

enum StdItem {
    ArrayAsSlice,
    ArrayAsMutSlice,
    ArrayRepeat,
    ArrayIndex,
    ArrayIndexMut,
    SliceIndexImpl,
    SliceIndexMutImpl,
    SliceIndex,
    SliceIndexMut,
    RangeIndex,
    RangeIndexMut,
}

We do the following.

If p is a projection (for instance: var, *var, var.f, etc.), we detect:

• whether it operates on a slice or an array (we keep track of the types)
• whether the access might mutate the value or not (it is the case if it is in a move, &mut or at the lhs of an assignment), and do the following transformations

  // If array and mutable access:
  ... p[i] ...
     ~~>
  tmp0 = &mut p
  tmp1 = <[_; _] as IndexMut<_>>::index_mut(move tmp0, i)
  ... *tmp1 ...

  // If array and non-mutable access:
  ... p[i] ...
     ~~>
  tmp0 := & p
  tmp1 := <[_; _] as Index<_>>::index(move tmp0, i)
  ... *tmp1 ...

  // Omitting the slice cases, which are similar

For instance, it leads to the following transformations:

  // x : [u32; N]
  y : u32 = copy x[i]
     ~~>
  tmp0 : & [u32; N] := &x
  tmp1 : &u32 = <[_; _] as Index<_>>::index(move tmp0, i)
  y : u32 = copy (*tmp1)

  // x : &[T; N]
  y : &T = & (*x)[i]
     ~~>
  tmp0 : & [T; N] := & (*x)
  tmp1 : &T = <[_; _] as Index<_>>::index(move tmp0, i)
  y : &T = & (*tmp1)

  // x : [u32; N]
  y = &mut x[i]
     ~~>
  tmp0 : &mut [u32; N] := &mut x
  tmp1 : &mut u32 := <[_; _] as IndexMut<_>>::index_mut(move tmp0, i)
  y = &mut (*tmp)

  // When using an index on the lhs:
  // y : [T; N]
  y[i] = x
     ~~>
  tmp0 : &mut [T; N] := &mut y;
  tmp1 : &mut T = <[_; _] as IndexMut<_>>::index_mut(move tmp0, i)
  *tmp1 = x

Variants

ArrayAsSlice

ArrayAsMutSlice

ArrayRepeat

ArrayIndex

ArrayIndexMut

SliceIndexImpl

SliceIndexMutImpl

SliceIndex

SliceIndexMut

RangeIndex

RangeIndexMut

Trait Implementations

impl Clone for StdItem

fn clone(&self) -> StdItem

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for StdItem

impl Eq for StdItem

impl Hash for StdItem

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for StdItem

fn eq(&self, other: &StdItem) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for StdItem