Type Alias CanonicalUserTypeAnnotations

Help

pub type CanonicalUserTypeAnnotations<'tcx> = IndexVec<UserTypeAnnotationIndex, CanonicalUserTypeAnnotation<'tcx>>;

Expand description

Mapping of type annotation indices to canonical user type annotations.

Aliased Type§

struct CanonicalUserTypeAnnotations<'tcx> {
    pub raw: Vec<CanonicalUserTypeAnnotation<'tcx>>,
    /* private fields */
}

Fields§

§raw: Vec<CanonicalUserTypeAnnotation<'tcx>>

Layout§

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 24 bytes

Implementations

§

impl<I, T> IndexVec<I, T>
where I: Idx,

pub const fn new() -> IndexVec<I, T>

Constructs a new, empty IndexVec<I, T>.

pub const fn from_raw(raw: Vec<T>) -> IndexVec<I, T>

Constructs a new IndexVec<I, T> from a Vec<T>.

pub fn with_capacity(capacity: usize) -> IndexVec<I, T>

pub fn from_elem<S>(elem: T, universe: &IndexSlice<I, S>) -> IndexVec<I, T>
where T: Clone,

Creates a new vector with a copy of elem for each index in universe.

Thus IndexVec::from_elem(elem, &universe) is equivalent to IndexVec::<I, _>::from_elem_n(elem, universe.len()). That can help type inference as it ensures that the resulting vector uses the same index type as universe, rather than something potentially surprising.

For example, if you want to store data for each local in a MIR body, using let mut uses = IndexVec::from_elem(vec![], &body.local_decls); ensures that uses is an IndexVec<Local, _>, and thus can give better error messages later if one accidentally mismatches indices.

pub fn from_elem_n(elem: T, n: usize) -> IndexVec<I, T>
where T: Clone,

Creates a new IndexVec with n copies of the elem.

pub fn from_fn_n(func: impl FnMut(I) -> T, n: usize) -> IndexVec<I, T>

Create an IndexVec with n elements, where the value of each element is the result of func(i). (The underlying vector will be allocated only once, with a capacity of at least n.)

pub fn as_slice(&self) -> &IndexSlice<I, T>

pub fn as_mut_slice(&mut self) -> &mut IndexSlice<I, T>

pub fn push(&mut self, d: T) -> I

Pushes an element to the array returning the index where it was pushed to.

pub fn pop(&mut self) -> Option<T>

pub fn into_iter(self) -> IntoIter<T>

pub fn into_iter_enumerated( self, ) -> impl DoubleEndedIterator + ExactSizeIterator

pub fn drain<R>(&mut self, range: R) -> impl Iterator<Item = T>
where R: RangeBounds<usize>,

pub fn drain_enumerated<R>(&mut self, range: R) -> impl Iterator<Item = (I, T)>
where R: RangeBounds<usize>,

pub fn shrink_to_fit(&mut self)

pub fn truncate(&mut self, a: usize)

pub fn ensure_contains_elem( &mut self, elem: I, fill_value: impl FnMut() -> T, ) -> &mut T

Grows the index vector so that it contains an entry for elem; if that is already true, then has no effect. Otherwise, inserts new values as needed by invoking fill_value.

Returns a reference to the elem entry.