pub enum ItemKind {
Show 17 variants
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(P<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<Fn>)
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(Box<InlineAsm>)
Module-level inline assembly (from global_asm!()
).
TyAlias(Box<TyAlias>)
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<Trait>)
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<Impl>)
An implementation.
E.g., impl<A> Foo<A> { .. }
or impl<A> Trait for Foo<A> { .. }
.
MacCall(P<MacCall>)
A macro invocation.
E.g., foo!(..)
.
MacroDef(MacroDef)
A macro definition.
Implementations
Trait Implementations
sourceimpl From<AssocItemKind> for ItemKind
impl From<AssocItemKind> for ItemKind
sourcefn from(assoc_item_kind: AssocItemKind) -> ItemKind
fn from(assoc_item_kind: AssocItemKind) -> ItemKind
sourceimpl From<ForeignItemKind> for ItemKind
impl From<ForeignItemKind> for ItemKind
sourcefn from(foreign_item_kind: ForeignItemKind) -> ItemKind
fn from(foreign_item_kind: ForeignItemKind) -> ItemKind
sourceimpl TryFrom<ItemKind> for AssocItemKind
impl TryFrom<ItemKind> for AssocItemKind
Auto Trait Implementations
impl !RefUnwindSafe for ItemKind
impl !Send for ItemKind
impl !Sync for ItemKind
impl Unpin for ItemKind
impl !UnwindSafe for ItemKind
Blanket Implementations
sourceimpl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
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 bytesUse
: 87 bytesStatic
: 23 bytesConst
: 31 bytesFn
: 15 bytesMod
: 63 bytesForeignMod
: 71 bytesGlobalAsm
: 15 bytesTyAlias
: 15 bytesEnum
: 103 bytesStruct
: 111 bytesUnion
: 111 bytesTrait
: 15 bytesTraitAlias
: 103 bytesImpl
: 15 bytesMacCall
: 15 bytesMacroDef
: 23 bytes