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<FnKind>),
    Mod(Unsafe, ModKind),
    ForeignMod(ForeignMod),
    GlobalAsm(InlineAsm),
    TyAlias(Box<TyAliasKind>),
    Enum(EnumDef, Generics),
    Struct(VariantData, Generics),
    Union(VariantData, Generics),
    Trait(Box<TraitKind>),
    TraitAlias(Generics, GenericBounds),
    Impl(Box<ImplKind>),
    MacCall(MacCall),
    MacroDef(MacroDef),
}

Variants

ExternCrate(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.

Tuple Fields of ExternCrate

0: Option<Symbol>

Use(UseTree)

A use declaration item (use).

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

Tuple Fields of Use

0: UseTree

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

A static item (static).

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

Tuple Fields of Static

0: P<Ty>1: Mutability2: Option<P<Expr>>

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

A constant item (const).

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

Tuple Fields of Const

0: Defaultness1: P<Ty>2: Option<P<Expr>>

Fn(Box<FnKind>)

A function declaration (fn).

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

Tuple Fields of Fn

0: Box<FnKind>

Mod(Unsafe, 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.

Tuple Fields of Mod

0: Unsafe1: ModKind

ForeignMod(ForeignMod)

An external module (extern).

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

Tuple Fields of ForeignMod

0: ForeignMod

GlobalAsm(InlineAsm)

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

Tuple Fields of GlobalAsm

0: InlineAsm

TyAlias(Box<TyAliasKind>)

A type alias (type).

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

Tuple Fields of TyAlias

0: Box<TyAliasKind>

Enum(EnumDef, Generics)

An enum definition (enum).

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

Tuple Fields of Enum

0: EnumDef1: Generics

Struct(VariantData, Generics)

A struct definition (struct).

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

Tuple Fields of Struct

0: VariantData1: Generics

Union(VariantData, Generics)

A union definition (union).

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

Tuple Fields of Union

0: VariantData1: Generics

Trait(Box<TraitKind>)

A trait declaration (trait).

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

Tuple Fields of Trait

0: Box<TraitKind>

TraitAlias(Generics, GenericBounds)

Trait alias

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

Tuple Fields of TraitAlias

0: Generics1: GenericBounds

Impl(Box<ImplKind>)

An implementation.

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

Tuple Fields of Impl

0: Box<ImplKind>

MacCall(MacCall)

A macro invocation.

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

Tuple Fields of MacCall

0: MacCall

MacroDef(MacroDef)

A macro definition.

Tuple Fields of MacroDef

0: MacroDef

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: 111 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