[−][src]Struct rustc_middle::ty::list::List

#[repr(C)]pub struct List<T> {
    len: usize,
    data: [T; 0],
    opaque: OpaqueListContents,
}

A wrapper for slices with the additional invariant that the slice is interned and no other slice with the same contents can exist in the same context. This means we can use pointer for both equality comparisons and hashing.

Unlike slices, The types contained in List are expected to be Copy and iterating over a List returns T instead of a reference.

Note: Slice was already taken by the Ty.

Fields

len: usizedata: [T; 0]opaque: OpaqueListContents

Implementations

`impl<'a, 'tcx> List<GenericArg<'tcx>>`[src]

`pub fn as_closure(&'a self) -> ClosureSubsts<'a>`[src]

Interpret these substitutions as the substitutions of a closure type. Closure substitutions have a particular structure controlled by the compiler that encodes information like the signature and closure kind; see ty::ClosureSubsts struct for more comments.

`pub fn as_generator(&'tcx self) -> GeneratorSubsts<'tcx>`[src]

Interpret these substitutions as the substitutions of a generator type. Closure substitutions have a particular structure controlled by the compiler that encodes information like the signature and generator kind; see ty::GeneratorSubsts struct for more comments.

`pub fn identity_for_item(tcx: TyCtxt<'tcx>, def_id: DefId) -> SubstsRef<'tcx>`[src]

Creates a InternalSubsts that maps each generic parameter to itself.

`pub fn for_item<F>( tcx: TyCtxt<'tcx>, def_id: DefId, mk_kind: F ) -> SubstsRef<'tcx> where F: FnMut(&GenericParamDef, &[GenericArg<'tcx>]) -> GenericArg<'tcx>,` [src]

Creates a InternalSubsts for generic parameter definitions, by calling closures to obtain each kind. The closures get to observe the InternalSubsts as they're being built, which can be used to correctly substitute defaults of generic parameters.

`pub fn extend_to<F>( &self, tcx: TyCtxt<'tcx>, def_id: DefId, mk_kind: F ) -> SubstsRef<'tcx> where F: FnMut(&GenericParamDef, &[GenericArg<'tcx>]) -> GenericArg<'tcx>,` [src]

`fn fill_item<F>( substs: &mut SmallVec<[GenericArg<'tcx>; 8]>, tcx: TyCtxt<'tcx>, defs: &Generics, mk_kind: &mut F ) where F: FnMut(&GenericParamDef, &[GenericArg<'tcx>]) -> GenericArg<'tcx>,` [src]

`fn fill_single<F>( substs: &mut SmallVec<[GenericArg<'tcx>; 8]>, defs: &Generics, mk_kind: &mut F ) where F: FnMut(&GenericParamDef, &[GenericArg<'tcx>]) -> GenericArg<'tcx>,` [src]

`pub fn is_noop(&self) -> bool`[src]

`pub fn types(&'a self) -> impl DoubleEndedIterator<Item = Ty<'tcx>> + 'a`[src]

`pub fn regions(&'a self) -> impl DoubleEndedIterator<Item = Region<'tcx>> + 'a`[src]

`pub fn consts( &'a self ) -> impl DoubleEndedIterator<Item = &'tcx Const<'tcx>> + 'a`[src]

`pub fn non_erasable_generics( &'a self ) -> impl DoubleEndedIterator<Item = GenericArgKind<'tcx>> + 'a`[src]

`pub fn type_at(&self, i: usize) -> Ty<'tcx>`[src]

`pub fn region_at(&self, i: usize) -> Region<'tcx>`[src]

`pub fn const_at(&self, i: usize) -> &'tcx Const<'tcx>`[src]

`pub fn type_for_def(&self, def: &GenericParamDef) -> GenericArg<'tcx>`[src]

`pub fn rebase_onto( &self, tcx: TyCtxt<'tcx>, source_ancestor: DefId, target_substs: SubstsRef<'tcx> ) -> SubstsRef<'tcx>`[src]

Transform from substitutions for a child of source_ancestor (e.g., a trait or impl) to substitutions for the same child in a different item, with target_substs as the base for the target impl/trait, with the source child-specific parameters (e.g., method parameters) on top of that base.

For example given:

trait X<S> { fn f<T>(); }
impl<U> X<U> for U { fn f<V>() {} }

If self is [Self, S, T]: the identity substs of f in the trait.
If source_ancestor is the def_id of the trait.
If target_substs is [U], the substs for the impl.
Then we will return [U, T], the subst for f in the impl that are needed for it to match the trait.

`pub fn truncate_to( &self, tcx: TyCtxt<'tcx>, generics: &Generics ) -> SubstsRef<'tcx>`[src]

`impl<T: Copy> List<T>`[src]

`pub(super) fn from_arena<'tcx>( arena: &'tcx Arena<'tcx>, slice: &[T] ) -> &'tcx List<T>`[src]

`pub fn iter(&self) -> <&List<T> as IntoIterator>::IntoIter`[src]

`impl<T> List<T>`[src]

`pub fn empty<'a>() -> &'a List<T>`[src]

`impl<'tcx> List<ExistentialPredicate<'tcx>>`[src]

`pub fn principal(&self) -> Option<ExistentialTraitRef<'tcx>>`[src]

Returns the "principal DefId" of this set of existential predicates.

A Rust trait object type consists (in addition to a lifetime bound) of a set of trait bounds, which are separated into any number of auto-trait bounds, and at most one non-auto-trait bound. The non-auto-trait bound is called the "principal" of the trait object.

Only the principal can have methods or type parameters (because auto traits can have neither of them). This is important, because it means the auto traits can be treated as an unordered set (methods would force an order for the vtable, while relating traits with type parameters without knowing the order to relate them in is a rather non-trivial task).

For example, in the trait object dyn fmt::Debug + Sync, the principal bound is Some(fmt::Debug), while the auto-trait bounds are the set {Sync}.

It is also possible to have a "trivial" trait object that consists only of auto traits, with no principal - for example, dyn Send + Sync. In that case, the set of auto-trait bounds is {Send, Sync}, while there is no principal. These trait objects have a "trivial" vtable consisting of just the size, alignment, and destructor.