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),
    Crate(Crate),
}

Variants

Item(P<Item>)

Tuple Fields

0: P<Item>

TraitItem(P<AssocItem>)

Tuple Fields

0: P<AssocItem>

ImplItem(P<AssocItem>)

Tuple Fields

0: P<AssocItem>

ForeignItem(P<ForeignItem>)

Tuple Fields

0: P<ForeignItem>

Stmt(P<Stmt>)

Tuple Fields

0: P<Stmt>

Expr(P<Expr>)

Tuple Fields

0: P<Expr>

Arm(Arm)

Tuple Fields

0: Arm

ExprField(ExprField)

Tuple Fields

0: ExprField

PatField(PatField)

Tuple Fields

0: PatField

GenericParam(GenericParam)

Tuple Fields

0: GenericParam

Param(Param)

Tuple Fields

0: Param

FieldDef(FieldDef)

Tuple Fields

0: FieldDef

Variant(Variant)

Tuple Fields

0: Variant

Crate(Crate)

Tuple Fields

0: Crate

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

pub fn expect_crate(self) -> Crate

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
• Crate: 64 bytes