Enum rustc_ap_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.

Use(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>>)

A static item (static).

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

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

A constant item (const).

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

Fn(Box<FnKind>)

A function declaration (fn).

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

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.

ForeignMod(ForeignMod)

An external module (extern).

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

GlobalAsm(InlineAsm)

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

TyAlias(Box<TyAliasKind>)

A type alias (type).

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

Enum(EnumDef, Generics)

An enum definition (enum).

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

Struct(VariantData, Generics)

A struct definition (struct).

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

Union(VariantData, Generics)

A union definition (union).

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

Trait(Box<TraitKind>)

A trait declaration (trait).

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

TraitAlias(Generics, GenericBounds)

Trait alias

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

Impl(Box<ImplKind>)

An implementation.

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

MacCall(MacCall)

A macro invocation.

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

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