Struct rustc_hir::hir::GenericArgs

pub struct GenericArgs<'hir> {
    pub args: &'hir [GenericArg<'hir>],
    pub bindings: &'hir [TypeBinding<'hir>],
    pub parenthesized: bool,
    pub span_ext: Span,
}

Fields

args: &'hir [GenericArg<'hir>]

The generic arguments for this path segment.

bindings: &'hir [TypeBinding<'hir>]

Bindings (equality constraints) on associated types, if present. E.g., Foo<A = Bar>.

parenthesized: bool

Were arguments written in parenthesized form Fn(T) -> U? This is required mostly for pretty-printing and diagnostics, but also for changing lifetime elision rules to be “function-like”.

span_ext: Span

The span encompassing arguments and the surrounding brackets <> or () Foo<A, B, AssocTy = D> Fn(T, U, V) -> W ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^ Note that this may be:

• empty, if there are no generic brackets (but there may be hidden lifetimes)
• dummy, if this was generated while desugaring

Implementations

impl<'hir> GenericArgs<'hir>

pub const fn none() -> Self

pub fn inputs(&self) -> &[Ty<'hir>]

pub fn has_type_params(&self) -> bool

pub fn has_err(&self) -> bool

pub fn num_type_params(&self) -> usize

pub fn num_lifetime_params(&self) -> usize

pub fn has_lifetime_params(&self) -> bool

pub fn num_generic_params(&self) -> usize

pub fn span(&self) -> Option<Span>

The span encompassing the text inside the surrounding brackets. It will also include bindings if they aren’t in the form -> Ret Returns None if the span is empty (e.g. no brackets) or dummy

pub fn span_ext(&self) -> Option<Span>

Returns span encompassing arguments and their surrounding <> or ()

pub fn is_empty(&self) -> bool

Trait Implementations

impl<'tcx> ArenaAllocatable<'tcx, IsNotCopy> for GenericArgs<'tcx>

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

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

impl<'hir> Debug for GenericArgs<'hir>

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

Formats the value using the given formatter.

impl<'hir, __CTX> HashStable<__CTX> for GenericArgs<'hir>where
    __CTX: HashStableContext,

fn hash_stable(&self, __hcx: &mut __CTX, __hasher: &mut StableHasher)

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