Struct GenericArgs 

pub struct GenericArgs<'tcx>(&'tcx GenericArgsUnsized<'tcx>);

List of generic arguments that are gonna be used to replace generic parameters.

Tuple Fields

0: &'tcx GenericArgsUnsized<'tcx>

Implementations

impl<'tcx> GenericArgs<'tcx>

pub fn empty() -> Self

pub fn as_ptr(&self) -> *const ()

👎Deprecated:

do not call this

Exposes the underlying pointer. Relying on this for equality won’t always be supported. Be careful.

pub fn iter(self) -> Copied<Iter<'tcx, GenericArg<'tcx>>>

pub fn get(self, idx: usize) -> Option<GenericArg<'tcx>>

pub fn first(self) -> Option<GenericArg<'tcx>>

pub fn as_slice(&self) -> &[GenericArg<'tcx>]

pub fn is_empty(&self) -> bool

pub fn len(&self) -> usize

pub fn as_tcx_slice(&self) -> &'tcx [GenericArg<'tcx>]

pub fn from_args(args: &'tcx GenericArgsUnsized<'tcx>) -> Self

pub fn into_type_list(&self, tcx: TyCtxt<'tcx>) -> &'tcx List<Ty<'tcx>>

Converts generic args to a type list.

Panics

If any of the generic arguments are not types.

pub fn as_closure(self) -> ClosureArgs<TyCtxt<'tcx>>

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

pub fn as_coroutine_closure(self) -> CoroutineClosureArgs<TyCtxt<'tcx>>

Interpret these generic args as the args of a coroutine-closure type. Coroutine-closure args have a particular structure controlled by the compiler that encodes information like the signature and closure kind; see ty::CoroutineClosureArgs struct for more comments.

pub fn as_coroutine(self) -> CoroutineArgs<TyCtxt<'tcx>>

Interpret these generic args as the args of a coroutine type. Coroutine args have a particular structure controlled by the compiler that encodes information like the signature and coroutine kind; see ty::CoroutineArgs struct for more comments.

pub fn as_inline_const(self) -> InlineConstArgs<'tcx>

Interpret these generic args as the args of an inline const. Inline const args have a particular structure controlled by the compiler that encodes information like the inferred type; see ty::InlineConstArgs struct for more comments.

pub fn identity_for_item( tcx: TyCtxt<'tcx>, def_id: impl Into<DefId>, ) -> GenericArgs<'tcx>

Creates a GenericArgs that maps each generic parameter to itself.

pub fn for_item<F>( tcx: TyCtxt<'tcx>, def_id: DefId, mk_kind: F, ) -> GenericArgs<'tcx>

where F: FnMut(&GenericParamDef, &[GenericArg<'tcx>]) -> GenericArg<'tcx>,

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

pub fn extend_to<F>( &self, tcx: TyCtxt<'tcx>, def_id: DefId, mk_kind: F, ) -> GenericArgs<'tcx>

where F: FnMut(&GenericParamDef, &[GenericArg<'tcx>]) -> GenericArg<'tcx>,

pub fn fill_item<F>( args: &mut SmallVec<[GenericArg<'tcx>; 8]>, tcx: TyCtxt<'tcx>, defs: &Generics, mk_kind: &mut F, )

where F: FnMut(&GenericParamDef, &[GenericArg<'tcx>]) -> GenericArg<'tcx>,

pub fn fill_single<F>( args: &mut SmallVec<[GenericArg<'tcx>; 8]>, defs: &Generics, mk_kind: &mut F, )

where F: FnMut(&GenericParamDef, &[GenericArg<'tcx>]) -> GenericArg<'tcx>,

pub fn extend_with_error( tcx: TyCtxt<'tcx>, def_id: DefId, original_args: &[GenericArg<'tcx>], ) -> GenericArgs<'tcx>

pub fn types(&self) -> impl DoubleEndedIterator<Item = Ty<'tcx>>

pub fn regions(&self) -> impl DoubleEndedIterator<Item = Region<'tcx>>

pub fn consts(&self) -> impl DoubleEndedIterator<Item = Const<'tcx>>

pub fn terms(&self) -> impl DoubleEndedIterator<Item = Term<'tcx>>

pub fn non_erasable_generics( &self, ) -> impl DoubleEndedIterator<Item = GenericArgKind<'tcx>>

Returns generic arguments that are not lifetimes.

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

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

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

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

pub fn rebase_onto( &self, tcx: TyCtxt<'tcx>, source_ancestor: DefId, target_args: GenericArgs<'tcx>, ) -> GenericArgs<'tcx>

Transform from generic args for a child of source_ancestor (e.g., a trait or impl) to args for the same child in a different item, with target_args 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 args of f in the trait.
• If source_ancestor is the def_id of the trait.
• If target_args is [U], the args for the impl.
• Then we will return [U, T], the arg for f in the impl that are needed for it to match the trait.

pub fn truncate_to( &self, tcx: TyCtxt<'tcx>, generics: &Generics, ) -> GenericArgs<'tcx>

Truncates this list of generic args to have at most the number of args in generics.

You might be looking for TraitRef::from_assoc.

pub fn print_as_list(&self) -> String

Trait Implementations

impl<'tcx> AsRef<[GenericArg<'tcx>]> for GenericArgs<'tcx>

fn as_ref(&self) -> &[GenericArg<'tcx>]

Converts this type into a shared reference of the (usually inferred) input type.

impl<'tcx> Clone for GenericArgs<'tcx>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'tcx> Copy for GenericArgs<'tcx>

impl<'tcx> Debug for GenericArgs<'tcx>

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

Formats the value using the given formatter.

impl<'tcx, D: TyDecoder<'tcx>> Decodable<D> for GenericArgs<'tcx>

fn decode(decoder: &mut D) -> Self

impl<'tcx> Default for GenericArgs<'tcx>

fn default() -> Self

Returns the “default value” for a type.

impl<'tcx, __E: TyEncoder<'tcx>> Encodable<__E> for GenericArgs<'tcx>

fn encode(&self, __encoder: &mut __E)

impl<'tcx> Eq for GenericArgs<'tcx>

impl Erasable for GenericArgs<'_>

type Storage = [u8; 8]

Storage type to used for erased values of this type. Should be [u8; N], where N is equal to size_of::<Self>.

impl<'tcx> GenericArgs<TyCtxt<'tcx>> for GenericArgs<'tcx>

fn rebase_onto( self, tcx: TyCtxt<'tcx>, source_ancestor: DefId, target_args: GenericArgs<'tcx>, ) -> GenericArgs<'tcx>

fn type_at(self, i: usize) -> Ty<'tcx>

fn region_at(self, i: usize) -> Region<'tcx>

fn const_at(self, i: usize) -> Const<'tcx>

fn identity_for_item(tcx: TyCtxt<'tcx>, def_id: DefId) -> GenericArgs<'tcx>

fn extend_with_error( tcx: TyCtxt<'tcx>, def_id: DefId, original_args: &[GenericArg<'tcx>], ) -> GenericArgs<'tcx>

fn split_closure_args<'a>(&'a self) -> ClosureArgsParts<'a, TyCtxt<'tcx>>

fn split_coroutine_closure_args<'a>( &'a self, ) -> CoroutineClosureArgsParts<'a, TyCtxt<'tcx>>

fn split_coroutine_args<'a>(&'a self) -> CoroutineArgsParts<'a, TyCtxt<'tcx>>

fn as_closure(self) -> ClosureArgs<I>

fn as_coroutine_closure(self) -> CoroutineClosureArgs<I>

fn as_coroutine(self) -> CoroutineArgs<I>

impl<'tcx> Hash for GenericArgs<'tcx>

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<'tcx> Index<usize> for GenericArgs<'tcx>

type Output = GenericArg<'tcx>

The returned type after indexing.

fn index(&self, index: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<'tcx> IntoIterator for GenericArgs<'tcx>

type Item = GenericArg<'tcx>

The type of the elements being iterated over.

type IntoIter = Copied<Iter<'tcx, GenericArg<'tcx>>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'tcx, '__lifted> Lift<TyCtxt<'__lifted>> for GenericArgs<'tcx>

type Lifted = GenericArgs<'__lifted>

fn lift_to_interner(self, __tcx: TyCtxt<'__lifted>) -> GenericArgs<'__lifted>

impl<'tcx> PartialEq for GenericArgs<'tcx>

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

Equality operator ==.

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

Inequality operator !=.

impl<'tcx> QueryKey for GenericArgs<'tcx>

fn default_span(&self, _: TyCtxt<'_>) -> Span

In the event that a cycle occurs, if no explicit span has been given for a query with key self, what span should we use?

type Cache<V> = DefaultCache<Self, V>

The type of in-memory cache to use for queries with this key type.

type LocalQueryKey = !

fn key_as_def_id(&self) -> Option<DefId>

If the key is a DefId or DefId–equivalent, return that DefId. Otherwise, return None.

fn as_local_key(&self) -> Option<Self::LocalQueryKey>

Given an instance of this key, what crate is it referring to? This is used to find the provider.

impl<'tcx> Relate<TyCtxt<'tcx>> for GenericArgs<'tcx>

fn relate<R: TypeRelation<TyCtxt<'tcx>>>( relation: &mut R, a: GenericArgs<'tcx>, b: GenericArgs<'tcx>, ) -> RelateResult<'tcx, GenericArgs<'tcx>>

impl<'tcx> SliceLike for GenericArgs<'tcx>

type Item = GenericArg<'tcx>

type IntoIter = Copied<Iter<'tcx, GenericArg<'tcx>>>

fn iter(self) -> Self::IntoIter

fn as_slice(&self) -> &[Self::Item]

fn get(self, idx: usize) -> Option<Self::Item>

fn len(self) -> usize

fn is_empty(self) -> bool

fn contains(self, t: &Self::Item) -> bool

where Self::Item: PartialEq,

fn to_vec(self) -> Vec<Self::Item>

fn last(self) -> Option<Self::Item>

fn split_last(&self) -> Option<(&Self::Item, &[Self::Item])>

impl<'tcx> StableHash for GenericArgs<'tcx>

fn stable_hash<__Hcx: StableHashCtxt>( &self, __hcx: &mut __Hcx, __hasher: &mut StableHasher, )

impl<'tcx> StructuralPartialEq for GenericArgs<'tcx>

impl<'tcx> TypeFoldable<TyCtxt<'tcx>> for GenericArgs<'tcx>

fn try_fold_with<F: FallibleTypeFolder<TyCtxt<'tcx>>>( self, folder: &mut F, ) -> Result<Self, F::Error>

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

fn fold_with<F: TypeFolder<TyCtxt<'tcx>>>(self, folder: &mut F) -> Self

The entry point for folding. To fold a value t with a folder f call: t.fold_with(f).

impl<'tcx> TypeVisitable<TyCtxt<'tcx>> for GenericArgs<'tcx>

fn visit_with<__V: TypeVisitor<TyCtxt<'tcx>>>( &self, __visitor: &mut __V, ) -> __V::Result

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

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: 8 bytes