IndexVec in rustc_pattern_analysis - Rust
Description: An owned contiguous collection of `T`s, indexed by `I` rather than by `usize`.

Skip to main content

## IndexVec

# Struct 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 `T`s, 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 copy_within( &mut self, src: impl IntoSliceIdx>, dest: I, )
where T: Copy, <impl IntoSliceIdx<I, [T]> as IntoSliceIdx<I, [T]>>::Output: RangeBounds<usize>,

Source

#### pub fn get<R>( &self, index: R, ) -> Option<&<<R as IntoSliceIdx<I, [T]>>::Output as SliceIndex<[T]>>::Output>
where R: IntoSliceIdx<I, [T]>,

Source

#### pub fn get_mut<R>( &mut self, index: R, ) -> Option<&mut <<R as IntoSliceIdx<I, [T]>>::Output as SliceIndex<[T]>>::Output>
where R: IntoSliceIdx<I, [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` or if some of them are out of bounds.

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 or if some of them are out of bounds.

Source

#### pub fn binary_search(&self, value: &T) -> Result<I, I>
where T: Ord,

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

## Trait Implementations§

Source§

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

Source§

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

Source§

#### fn allocate_from_iter( arena: &'tcx Arena<'tcx>, iter: impl IntoIterator<Item = IndexVec<Promoted, Body<'tcx>>>, ) -> &'tcx 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 duplicate 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>,

Available on crate feature `nightly` only.
Source§

#### fn decode(d: &mut D) -> IndexVec<I, T>

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>,

Available on crate feature `nightly` only.
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§

#### fn local_decls(&self) -> &IndexSlice<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, Hcx> HashStable<Hcx> for IndexVec<I, T>
where I: Idx, T: HashStable<Hcx>,

Source§

#### fn hash_stable(&self, hcx: &mut Hcx, 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> 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<'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) -> IndexVec<Ix, T>
where F: TypeFolder<I>,

The entry point for folding. To fold a value `t` with a folder `f` call: `t.fold_with(f)`. Read more
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> DynSend for IndexVec<I, T>
where T: DynSend,

§

### impl<I, T> DynSync for IndexVec<I, T>
where T: DynSync,

§

### 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> UnsafeUnpin for IndexVec<I, T>

§

### 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, dest: *mut u8)

🔬This is a nightly-only experimental API. (`clone_to_uninit`)
Performs copy-assignment from `self` to `dest`. 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> DepNodeKey<'tcx> for T
where T: for<'a> HashStable<StableHashingContext<'a>> + Debug,

Source§

#### default fn key_fingerprint_style() -> KeyFingerprintStyle

Source§

#### default fn to_fingerprint(&self, tcx: TyCtxt<'tcx>) -> Fingerprint

This method turns a query key into an opaque `Fingerprint` to be used in `DepNode`.
Source§

#### default fn try_recover_key(_: TyCtxt<'tcx>, _: &DepNode) -> Option<T>

This method tries to recover the query key from the given `DepNode`, something which is needed when forcing `DepNode`s 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<T> DynClone for T
where T: Clone,

Source§

#### fn __clone_box(&self, _: Private) -> *mut ()

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> 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<K> IntoQueryKey<K> for K

Source§

#### fn into_query_key(self) -> K

Argument conversion from `Self` to `K`. This should always be a very cheap conversion, e.g. `LocalDefId::to_def_id`.
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> Pointable for T

Source§

#### const ALIGN: usize

The alignment of pointer.
Source§

#### type Init = T

The type for initializers.
Source§

#### unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
Source§

#### unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
Source§

#### unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
Source§

#### unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
Source§

### impl<P, T> Receiver for P
where P: Deref<Target = T> + ?Sized, T: ?Sized,

Source§

#### type Target = T

🔬This is a nightly-only experimental API. (`arbitrary_self_types`)
The target type on which the method may be called.
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 non_region_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§

#### fn has_non_region_error(&self) -> bool

True if a type or const error is reachable
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<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<T> ErasedDestructor for T
where T: 'static,

## 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