Enum rustc_ast::ast::ItemKind

pub enum ItemKind {
    ExternCrate(Option<Symbol>),
    Use(UseTree),
    Static(P<Ty>, Mutability, Option<P<Expr>>),
    Const(Defaultness, P<Ty>, Option<P<Expr>>),
    Fn(Box<Fn>),
    Mod(Unsafe, ModKind),
    ForeignMod(ForeignMod),
    GlobalAsm(Box<InlineAsm>),
    TyAlias(Box<TyAlias>),
    Enum(EnumDef, Generics),
    Struct(VariantData, Generics),
    Union(VariantData, Generics),
    Trait(Box<Trait>),
    TraitAlias(Generics, GenericBounds),
    Impl(Box<Impl>),
    MacCall(MacCall),
    MacroDef(MacroDef),
}

Variants

ExternCrate(Option<Symbol>)

Tuple Fields

0: Option<Symbol>

An extern crate item, with the optional original crate name if the crate was renamed.

E.g., extern crate foo or extern crate foo_bar as foo.

Use(UseTree)

Tuple Fields

0: UseTree

A use declaration item (use).

E.g., use foo;, use foo::bar; or use foo::bar as FooBar;.

Static(P<Ty>, Mutability, Option<P<Expr>>)

Tuple Fields

0: P<Ty>

1: Mutability

2: Option<P<Expr>>

A static item (static).

E.g., static FOO: i32 = 42; or static FOO: &'static str = "bar";.

Const(Defaultness, P<Ty>, Option<P<Expr>>)

Tuple Fields

0: Defaultness

1: P<Ty>

2: Option<P<Expr>>

A constant item (const).

E.g., const FOO: i32 = 42;.

Fn(Box<Fn>)

Tuple Fields

0: Box<Fn>

A function declaration (fn).

E.g., fn foo(bar: usize) -> usize { .. }.

Mod(Unsafe, ModKind)

Tuple Fields

0: Unsafe

1: ModKind

A module declaration (mod).

E.g., mod foo; or mod foo { .. }. unsafe keyword on modules is accepted syntactically for macro DSLs, but not semantically by Rust.

ForeignMod(ForeignMod)

Tuple Fields

0: ForeignMod

An external module (extern).

E.g., extern {} or extern "C" {}.

GlobalAsm(Box<InlineAsm>)

Tuple Fields

0: Box<InlineAsm>

Module-level inline assembly (from global_asm!()).

TyAlias(Box<TyAlias>)

Tuple Fields

0: Box<TyAlias>

A type alias (type).

E.g., type Foo = Bar<u8>;.

Enum(EnumDef, Generics)

Tuple Fields

0: EnumDef

1: Generics

An enum definition (enum).

E.g., enum Foo<A, B> { C<A>, D<B> }.

Struct(VariantData, Generics)

Tuple Fields

0: VariantData

1: Generics

A struct definition (struct).

E.g., struct Foo<A> { x: A }.

Union(VariantData, Generics)

Tuple Fields

0: VariantData

1: Generics

A union definition (union).

E.g., union Foo<A, B> { x: A, y: B }.

Trait(Box<Trait>)

Tuple Fields

0: Box<Trait>

A trait declaration (trait).

E.g., trait Foo { .. }, trait Foo<T> { .. } or auto trait Foo {}.

TraitAlias(Generics, GenericBounds)

Tuple Fields

0: Generics

1: GenericBounds

Trait alias

E.g., trait Foo = Bar + Quux;.

Impl(Box<Impl>)

Tuple Fields

0: Box<Impl>

An implementation.

E.g., impl<A> Foo<A> { .. } or impl<A> Trait for Foo<A> { .. }.

MacCall(MacCall)

Tuple Fields

0: MacCall

A macro invocation.

E.g., foo!(..).

MacroDef(MacroDef)

Tuple Fields

0: MacroDef

A macro definition.

Implementations

impl ItemKind

pub fn article(&self) -> &str

pub fn descr(&self) -> &str

pub fn generics(&self) -> Option<&Generics>

Trait Implementations

impl Clone for ItemKind

fn clone(&self) -> ItemKind

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ItemKind

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

Formats the value using the given formatter.

impl<__D: Decoder> Decodable<__D> for ItemKind

fn decode(__decoder: &mut __D) -> Result<Self, <__D as Decoder>::Error>

impl<__E: Encoder> Encodable<__E> for ItemKind

fn encode(&self, __encoder: &mut __E) -> Result<(), <__E as Encoder>::Error>

impl From<AssocItemKind> for ItemKind

fn from(assoc_item_kind: AssocItemKind) -> ItemKind

Performs the conversion.

impl From<ForeignItemKind> for ItemKind

fn from(foreign_item_kind: ForeignItemKind) -> ItemKind

Performs the conversion.

impl TryFrom<ItemKind> for AssocItemKind

type Error = ItemKind

The type returned in the event of a conversion error.

fn try_from(item_kind: ItemKind) -> Result<AssocItemKind, ItemKind>

Performs the conversion.

impl TryFrom<ItemKind> for ForeignItemKind

type Error = ItemKind

The type returned in the event of a conversion error.

fn try_from(item_kind: ItemKind) -> Result<ForeignItemKind, ItemKind>

Performs the conversion.

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

Size for each variant:

• ExternCrate: 7 bytes
• Use: 87 bytes
• Static: 23 bytes
• Const: 31 bytes
• Fn: 15 bytes
• Mod: 55 bytes
• ForeignMod: 71 bytes
• GlobalAsm: 15 bytes
• TyAlias: 15 bytes
• Enum: 103 bytes
• Struct: 111 bytes
• Union: 111 bytes
• Trait: 15 bytes
• TraitAlias: 103 bytes
• Impl: 15 bytes
• MacCall: 71 bytes
• MacroDef: 23 bytes