Struct GenericArgs

pub struct GenericArgs<'hir> {
    pub args: &'hir [GenericArg<'hir>],
    pub constraints: &'hir [AssocItemConstraint<'hir>],
    pub parenthesized: GenericArgsParentheses,
    pub span_ext: Span,
}

The generic arguments and associated item constraints of a path segment.

Fields

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

The generic arguments for this path segment.

constraints: &'hir [AssocItemConstraint<'hir>]

The associated item constraints for this path segment.

parenthesized: GenericArgsParentheses

Whether the arguments were written in parenthesized form (e.g., 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 the arguments, constraints and the surrounding brackets (<> or ()).

For example:

      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 during desugaring

Implementations

impl<'hir> GenericArgs<'hir>

pub const fn none() -> Self

pub fn paren_sugar_inputs_output(&self) -> Option<(&[Ty<'hir>], &Ty<'hir>)>

Obtain the list of input types and the output type if the generic arguments are parenthesized.

Returns the Ty0, Ty1, ... and the RetTy in Trait(Ty0, Ty1, ...) -> RetTy. Panics if the parenthesized arguments have an incorrect form (this shouldn’t happen).

pub fn paren_sugar_output(&self) -> Option<&Ty<'hir>>

Obtain the output type if the generic arguments are parenthesized.

Returns the RetTy in Trait(Ty0, Ty1, ...) -> RetTy. Panics if the parenthesized arguments have an incorrect form (this shouldn’t happen).

fn paren_sugar_output_inner(&self) -> &Ty<'hir>

pub fn has_err(&self) -> Option<ErrorGuaranteed>

pub fn num_lifetime_params(&self) -> usize

pub fn has_lifetime_params(&self) -> bool

pub fn num_generic_params(&self) -> usize

This function returns the number of type and const generic params. It should only be used for diagnostics.

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

The span encompassing the arguments and constraints¹ inside the surrounding brackets.

Returns None if the span is empty (i.e., no brackets) or dummy.

---

1. Unless of the form -> Ty (see GenericArgsParentheses). ↩

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

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

pub fn is_empty(&self) -> bool

Trait Implementations

impl<'hir> Clone for GenericArgs<'hir>

fn clone(&self) -> GenericArgs<'hir>

Returns a copy of the value.

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

Performs copy-assignment from source.

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)

impl<'hir> Copy for GenericArgs<'hir>

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