Struct rustc_pattern_analysis::IndexVec

source ·
#[repr(transparent)]
pub struct IndexVec<I, T>
where I: Idx,
{ pub raw: Vec<T>, _marker: PhantomData<fn(_: &I)>, }
Expand description

An owned contiguous collection of Ts, indexed by I rather than by usize.

§Why use this instead of a Vec?

An IndexVec allows element access only via a specific associated index type, meaning that trying to use the wrong index type (possibly accessing an invalid element) will fail at compile time.

It also documents what the index is indexing: in a HashMap<usize, Something> it’s not immediately clear what the usize means, while a HashMap<FieldIdx, Something> makes it obvious.

use rustc_index::{Idx, IndexVec};

fn f<I1: Idx, I2: Idx>(vec1: IndexVec<I1, u8>, idx1: I1, idx2: I2) {
  &vec1[idx1]; // Ok
  &vec1[idx2]; // Compile error!
}

While it’s possible to use u32 or usize directly for I, you almost certainly want to use a newtype_index!-generated type instead.

This allows to index the IndexVec with the new index type.

Fields§

§raw: Vec<T>§_marker: PhantomData<fn(_: &I)>

Implementations§

source§

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

source

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

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

source

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

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

source

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

source

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.

source

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.

source

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.)

source

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

source

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

source

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

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

source

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

source

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

source

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

source

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

source

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

source

pub fn shrink_to_fit(&mut self)

source

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

source

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.

source

pub fn resize(&mut self, new_len: usize, value: T)
where T: Clone,

source

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

source

pub fn append(&mut self, other: &mut IndexVec<I, T>)

source§

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

IndexVec is often used as a map, so it provides some map-like APIs.

source

pub fn insert(&mut self, index: I, value: T) -> Option<T>

source

pub fn get_or_insert_with( &mut self, index: I, value: impl FnOnce() -> T, ) -> &mut T

source

pub fn remove(&mut self, index: I) -> Option<T>

source

pub fn contains(&self, index: I) -> bool

Methods from Deref<Target = IndexSlice<I, T>>§

source

pub fn len(&self) -> usize

source

pub fn is_empty(&self) -> bool

source

pub fn next_index(&self) -> I

Gives the next index that will be assigned when push is called.

Manual bounds checks can be done using idx < slice.next_index() (as opposed to idx.index() < slice.len()).

source

pub fn iter(&self) -> Iter<'_, T>

source

pub fn iter_enumerated(&self) -> impl DoubleEndedIterator + ExactSizeIterator

source

pub fn indices( &self, ) -> impl DoubleEndedIterator + ExactSizeIterator + Clone + 'static

source

pub fn iter_mut(&mut self) -> IterMut<'_, T>

source

pub fn iter_enumerated_mut( &mut self, ) -> impl DoubleEndedIterator + ExactSizeIterator

source

pub fn last_index(&self) -> Option<I>

source

pub fn swap(&mut self, a: I, b: I)

source

pub fn get(&self, index: I) -> Option<&T>

source

pub fn get_mut(&mut self, index: I) -> Option<&mut T>

source

pub fn pick2_mut(&mut self, a: I, b: I) -> (&mut T, &mut T)

Returns mutable references to two distinct elements, a and b.

Panics if a == b.

source

pub fn pick3_mut(&mut self, a: I, b: I, c: I) -> (&mut T, &mut T, &mut T)

Returns mutable references to three distinct elements.

Panics if the elements are not distinct.

source

pub fn invert_bijective_mapping(&self) -> IndexVec<J, I>

Invert a bijective mapping, i.e. invert(map)[y] = x if map[x] = y, assuming the values in self are a permutation of 0..self.len().

This is used to go between memory_index (source field order to memory order) and inverse_memory_index (memory order to source field order). See also FieldsShape::Arbitrary::memory_index for more details.

Trait Implementations§

source§

impl<'tcx> ArenaAllocatable<'tcx> for IndexVec<Promoted, Body<'tcx>>

source§

fn allocate_on<'a>( self, arena: &'a Arena<'tcx>, ) -> &'a mut IndexVec<Promoted, Body<'tcx>>

source§

fn allocate_from_iter<'a>( arena: &'a Arena<'tcx>, iter: impl IntoIterator<Item = IndexVec<Promoted, Body<'tcx>>>, ) -> &'a mut [IndexVec<Promoted, Body<'tcx>>]

source§

impl<I, T> Borrow<IndexSlice<I, T>> for IndexVec<I, T>
where I: Idx,

source§

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

Immutably borrows from an owned value. Read more
source§

impl<I, T> BorrowMut<IndexSlice<I, T>> for IndexVec<I, T>
where I: Idx,

source§

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

Mutably borrows from an owned value. Read more
source§

impl<I, T> Clone for IndexVec<I, T>
where I: Clone + Idx, T: Clone,

source§

fn clone(&self) -> IndexVec<I, T>

Returns a copy of the value. Read more
1.0.0 · source§

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

Performs copy-assignment from source. Read more
source§

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

source§

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter. Read more
source§

impl<'a, 'tcx> Decodable<CacheDecoder<'a, 'tcx>> for &'tcx IndexVec<Promoted, Body<'tcx>>

source§

fn decode( d: &mut CacheDecoder<'a, 'tcx>, ) -> &'tcx IndexVec<Promoted, Body<'tcx>>

source§

impl<D, I, T> Decodable<D> for IndexVec<I, T>
where D: Decoder, I: Idx, T: Decodable<D>,

source§

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

source§

fn default() -> IndexVec<I, T>

Returns the “default value” for a type. Read more
source§

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

source§

type Target = IndexSlice<I, T>

The resulting type after dereferencing.
source§

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

Dereferences the value.
source§

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

source§

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

Mutably dereferences the value.
source§

impl<S, I, T> Encodable<S> for IndexVec<I, T>
where S: Encoder, I: Idx, T: Encodable<S>,

source§

fn encode(&self, s: &mut S)

source§

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

source§

fn extend<J>(&mut self, iter: J)
where J: IntoIterator<Item = T>,

Extends a collection with the contents of an iterator. Read more
source§

fn extend_one(&mut self, item: T)

🔬This is a nightly-only experimental API. (extend_one)
Extends a collection with exactly one element.
source§

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)
Reserves capacity in a collection for the given number of additional elements. Read more
source§

impl<I, T, const N: usize> From<[T; N]> for IndexVec<I, T>
where I: Idx,

source§

fn from(array: [T; N]) -> IndexVec<I, T>

Converts to this type from the input type.
source§

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

source§

fn from_iter<J>(iter: J) -> IndexVec<I, T>
where J: IntoIterator<Item = T>,

Creates a value from an iterator. Read more
source§

impl<'tcx> HasLocalDecls<'tcx> for IndexVec<Local, LocalDecl<'tcx>>

source§

impl<I, T> Hash for IndexVec<I, T>
where I: Hash + Idx, T: Hash,

source§

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

Feeds this value into the given Hasher. Read more
1.3.0 · source§

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

Feeds a slice of this type into the given Hasher. Read more
source§

impl<I, T, CTX> HashStable<CTX> for IndexVec<I, T>
where I: Idx, T: HashStable<CTX>,

source§

fn hash_stable(&self, ctx: &mut CTX, hasher: &mut StableHasher<SipHasher128>)

source§

impl<'a, I, T> IntoIterator for &'a IndexVec<I, T>
where I: Idx,

source§

type Item = &'a T

The type of the elements being iterated over.
source§

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?
source§

fn into_iter(self) -> Iter<'a, T>

Creates an iterator from a value. Read more
source§

impl<'a, I, T> IntoIterator for &'a mut IndexVec<I, T>
where I: Idx,

source§

type Item = &'a mut T

The type of the elements being iterated over.
source§

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?
source§

fn into_iter(self) -> IterMut<'a, T>

Creates an iterator from a value. Read more
source§

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

source§

type Item = T

The type of the elements being iterated over.
source§

type IntoIter = IntoIter<T>

Which kind of iterator are we turning this into?
source§

fn into_iter(self) -> IntoIter<T>

Creates an iterator from a value. Read more
source§

impl<I, T> ParameterizedOverTcx for IndexVec<I, T>
where I: Idx + 'static, T: ParameterizedOverTcx,

source§

type Value<'tcx> = IndexVec<I, <T as ParameterizedOverTcx>::Value<'tcx>>

source§

impl<I, T> PartialEq for IndexVec<I, T>
where I: PartialEq + Idx, T: PartialEq,

source§

fn eq(&self, other: &IndexVec<I, T>) -> bool

Tests for self and other values to be equal, and is used by ==.
1.0.0 · source§

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
source§

impl<'tcx, D> RefDecodable<'tcx, D> for IndexVec<Promoted, Body<'tcx>>
where D: TyDecoder<I = TyCtxt<'tcx>>,

source§

fn decode(decoder: &mut D) -> &'tcx IndexVec<Promoted, Body<'tcx>>

source§

impl<I, T, Ix> TypeFoldable<I> for IndexVec<Ix, T>
where I: Interner, T: TypeFoldable<I>, Ix: Idx,

source§

fn try_fold_with<F>( self, folder: &mut F, ) -> Result<IndexVec<Ix, T>, <F as FallibleTypeFolder<I>>::Error>
where F: FallibleTypeFolder<I>,

The entry point for folding. To fold a value t with a folder f call: t.try_fold_with(f). Read more
source§

fn fold_with<F>(self, folder: &mut F) -> Self
where F: TypeFolder<I>,

A convenient alternative to try_fold_with for use with infallible folders. Do not override this method, to ensure coherence with try_fold_with.
source§

impl<I, T, Ix> TypeVisitable<I> for IndexVec<Ix, T>
where I: Interner, T: TypeVisitable<I>, Ix: Idx,

source§

fn visit_with<V>(&self, visitor: &mut V) -> <V as TypeVisitor<I>>::Result
where V: TypeVisitor<I>,

The entry point for visiting. To visit a value t with a visitor v call: t.visit_with(v). Read more
source§

impl<I, T> Eq for IndexVec<I, T>
where I: Eq + Idx, T: Eq,

source§

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

source§

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

Auto Trait Implementations§

§

impl<I, T> Freeze for IndexVec<I, T>

§

impl<I, T> RefUnwindSafe for IndexVec<I, T>
where T: RefUnwindSafe,

§

impl<I, T> Sync for IndexVec<I, T>
where T: Sync,

§

impl<I, T> Unpin for IndexVec<I, T>
where T: Unpin,

§

impl<I, T> UnwindSafe for IndexVec<I, T>
where T: UnwindSafe,

Blanket Implementations§

source§

impl<T> Aligned for T

source§

const ALIGN: Alignment = _

Alignment of Self.
source§

impl<T> Any for T
where T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> AnyEq for T
where T: Any + PartialEq,

source§

fn equals(&self, other: &(dyn Any + 'static)) -> bool

source§

fn as_any(&self) -> &(dyn Any + 'static)

source§

impl<T> Borrow<T> for T
where T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> CloneToUninit for T
where T: Clone,

source§

unsafe fn clone_to_uninit(&self, dst: *mut T)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dst. Read more
source§

impl<T, R> CollectAndApply<T, R> for T

source§

fn collect_and_apply<I, F>(iter: I, f: F) -> R
where I: Iterator<Item = T>, F: FnOnce(&[T]) -> R,

Equivalent to f(&iter.collect::<Vec<_>>()).

source§

type Output = R

source§

impl<Tcx, T> DepNodeParams<Tcx> for T
where Tcx: DepContext, T: for<'a> HashStable<StableHashingContext<'a>> + Debug,

source§

default fn fingerprint_style() -> FingerprintStyle

source§

default fn to_fingerprint(&self, tcx: Tcx) -> Fingerprint

This method turns the parameters of a DepNodeConstructor into an opaque Fingerprint to be used in DepNode. Not all DepNodeParams support being turned into a Fingerprint (they don’t need to if the corresponding DepNode is anonymous).
source§

default fn to_debug_str(&self, _: Tcx) -> String

source§

default fn recover(_: Tcx, _: &DepNode) -> Option<T>

This method tries to recover the query key from the given DepNode, something which is needed when forcing DepNodes during red-green evaluation. The query system will only call this method if fingerprint_style() is not FingerprintStyle::Opaque. It is always valid to return None here, in which case incremental compilation will treat the query as having changed instead of forcing it.
source§

impl<Q, K> Equivalent<K> for Q
where Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,

source§

fn equivalent(&self, key: &K) -> bool

Checks if this value is equivalent to the given key. Read more
source§

impl<Q, K> Equivalent<K> for Q
where Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,

source§

fn equivalent(&self, key: &K) -> bool

Checks if this value is equivalent to the given key. Read more
source§

impl<Q, K> Equivalent<K> for Q
where Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,

source§

fn equivalent(&self, key: &K) -> bool

Compare self to key and return true if they are equal.
source§

impl<T> Filterable for T

source§

fn filterable( self, filter_name: &'static str, ) -> RequestFilterDataProvider<T, fn(_: DataRequest<'_>) -> bool>

Creates a filterable data provider with the given name for debugging. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T> Instrument for T

source§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more
source§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more
source§

impl<T, U> Into<U> for T
where U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<T> IntoEither for T

source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
source§

impl<P> IntoQueryParam<P> for P

source§

impl<'tcx, T> IsSuggestable<'tcx> for T
where T: TypeVisitable<TyCtxt<'tcx>> + TypeFoldable<TyCtxt<'tcx>>,

source§

fn is_suggestable(self, tcx: TyCtxt<'tcx>, infer_suggestable: bool) -> bool

Whether this makes sense to suggest in a diagnostic. Read more
source§

fn make_suggestable( self, tcx: TyCtxt<'tcx>, infer_suggestable: bool, placeholder: Option<Ty<'tcx>>, ) -> Option<T>

source§

impl<T> MaybeResult<T> for T

source§

type Error = !

source§

fn from(_: Result<T, <T as MaybeResult<T>>::Error>) -> T

source§

fn to_result(self) -> Result<T, <T as MaybeResult<T>>::Error>

source§

impl<T> Same for T

source§

type Output = T

Should always be Self
source§

impl<T> ToOwned for T
where T: Clone,

source§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

source§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
source§

impl<I, T> TypeVisitableExt<I> for T
where I: Interner, T: TypeVisitable<I>,

source§

fn has_type_flags(&self, flags: TypeFlags) -> bool

source§

fn has_vars_bound_at_or_above(&self, binder: DebruijnIndex) -> bool

Returns true if self has any late-bound regions that are either bound by binder or bound by some binder outside of binder. If binder is ty::INNERMOST, this indicates whether there are any late-bound regions that appear free.
source§

fn error_reported(&self) -> Result<(), <I as Interner>::ErrorGuaranteed>

source§

fn has_vars_bound_above(&self, binder: DebruijnIndex) -> bool

Returns true if this type has any regions that escape binder (and hence are not bound by it).
source§

fn has_escaping_bound_vars(&self) -> bool

Return true if this type has regions that are not a part of the type. For example, for<'a> fn(&'a i32) return false, while fn(&'a i32) would return true. The latter can occur when traversing through the former. Read more
source§

fn has_aliases(&self) -> bool

source§

fn has_opaque_types(&self) -> bool

source§

fn has_coroutines(&self) -> bool

source§

fn references_error(&self) -> bool

source§

fn has_non_region_param(&self) -> bool

source§

fn has_infer_regions(&self) -> bool

source§

fn has_infer_types(&self) -> bool

source§

fn has_non_region_infer(&self) -> bool

source§

fn has_infer(&self) -> bool

source§

fn has_placeholders(&self) -> bool

source§

fn has_non_region_placeholders(&self) -> bool

source§

fn has_param(&self) -> bool

source§

fn has_free_regions(&self) -> bool

“Free” regions in this context means that it has any region that is not (a) erased or (b) late-bound.
source§

fn has_erased_regions(&self) -> bool

source§

fn has_erasable_regions(&self) -> bool

True if there are any un-erased free regions.
source§

fn is_global(&self) -> bool

Indicates whether this value references only ‘global’ generic parameters that are the same regardless of what fn we are in. This is used for caching.
source§

fn has_bound_regions(&self) -> bool

True if there are any late-bound regions
source§

fn has_non_region_bound_vars(&self) -> bool

True if there are any late-bound non-region variables
source§

fn has_bound_vars(&self) -> bool

True if there are any bound variables
source§

fn still_further_specializable(&self) -> bool

Indicates whether this value still has parameters/placeholders/inference variables which could be replaced later, in a way that would change the results of impl specialization.
source§

impl<I, T, U> Upcast<I, U> for T
where U: UpcastFrom<I, T>,

source§

fn upcast(self, interner: I) -> U

source§

impl<I, T> UpcastFrom<I, T> for T

source§

fn upcast_from(from: T, _tcx: I) -> T

source§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

source§

fn vzip(self) -> V

source§

impl<Tcx, T> Value<Tcx> for T
where Tcx: DepContext,

source§

default fn from_cycle_error( tcx: Tcx, cycle_error: &CycleError, _guar: ErrorGuaranteed, ) -> T

source§

impl<T> WithSubscriber for T

source§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more
source§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a WithDispatch wrapper. Read more
source§

impl<'a, T> Captures<'a> for T
where T: ?Sized,

source§

impl<'a, T> Captures<'a> for T
where T: ?Sized,

source§

impl<T> ErasedDestructor for T
where T: 'static,

source§

impl<T> MaybeSendSync for T

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