Enum rustc_expand::base::Annotatable

pub enum Annotatable {
    Item(P<Item>),
    TraitItem(P<AssocItem>),
    ImplItem(P<AssocItem>),
    ForeignItem(P<ForeignItem>),
    Stmt(P<Stmt>),
    Expr(P<Expr>),
    Arm(Arm),
    ExprField(ExprField),
    PatField(PatField),
    GenericParam(GenericParam),
    Param(Param),
    FieldDef(FieldDef),
    Variant(Variant),
}

Variants

Item(P<Item>)

Tuple Fields of Item

0: P<Item>

TraitItem(P<AssocItem>)

Tuple Fields of TraitItem

0: P<AssocItem>

ImplItem(P<AssocItem>)

Tuple Fields of ImplItem

0: P<AssocItem>

ForeignItem(P<ForeignItem>)

Tuple Fields of ForeignItem

0: P<ForeignItem>

Stmt(P<Stmt>)

Tuple Fields of Stmt

0: P<Stmt>

Expr(P<Expr>)

Tuple Fields of Expr

0: P<Expr>

Arm(Arm)

Tuple Fields of Arm

0: Arm

ExprField(ExprField)

Tuple Fields of ExprField

0: ExprField

PatField(PatField)

Tuple Fields of PatField

0: PatField

GenericParam(GenericParam)

Tuple Fields of GenericParam

0: GenericParam

Param(Param)

Tuple Fields of Param

0: Param

FieldDef(FieldDef)

Tuple Fields of FieldDef

0: FieldDef

Variant(Variant)

Tuple Fields of Variant

0: Variant

Implementations

impl Annotatable

pub fn span(&self) -> Span

pub fn visit_attrs(&mut self, f: impl FnOnce(&mut Vec<Attribute>))

pub fn visit_with<'a, V: Visitor<'a>>(&'a self, visitor: &mut V)

pub fn into_nonterminal(self) -> Nonterminal

pub(crate) fn into_tokens(self, sess: &ParseSess) -> TokenStream

pub fn expect_item(self) -> P<Item>

pub fn expect_trait_item(self) -> P<AssocItem>

pub fn expect_impl_item(self) -> P<AssocItem>

pub fn expect_foreign_item(self) -> P<ForeignItem>

pub fn expect_stmt(self) -> Stmt

pub fn expect_expr(self) -> P<Expr>

pub fn expect_arm(self) -> Arm

pub fn expect_expr_field(self) -> ExprField

pub fn expect_pat_field(self) -> PatField

pub fn expect_generic_param(self) -> GenericParam

pub fn expect_param(self) -> Param

pub fn expect_field_def(self) -> FieldDef

pub fn expect_variant(self) -> Variant

Trait Implementations

impl Clone for Annotatable

fn clone(&self) -> Annotatable

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Annotatable

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

Formats the value using the given formatter.

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

Size for each variant:

• Item: 8 bytes
• TraitItem: 8 bytes
• ImplItem: 8 bytes
• ForeignItem: 8 bytes
• Stmt: 8 bytes
• Expr: 8 bytes
• Arm: 48 bytes
• ExprField: 48 bytes
• PatField: 48 bytes
• GenericParam: 96 bytes
• Param: 40 bytes
• FieldDef: 80 bytes
• Variant: 120 bytes