Enum ItemKind 

pub enum ItemKind<'ast> {
    Pragma(PragmaDirective<'ast>),
    Import(ImportDirective<'ast>),
    Using(UsingDirective<'ast>),
    Contract(ItemContract<'ast>),
    Function(ItemFunction<'ast>),
    Variable(VariableDefinition<'ast>),
    Struct(ItemStruct<'ast>),
    Enum(ItemEnum<'ast>),
    Udvt(ItemUdvt<'ast>),
    Error(ItemError<'ast>),
    Event(ItemEvent<'ast>),
}

An AST item. A more expanded version of a Solidity source unit.

Variants

Pragma(PragmaDirective<'ast>)

A pragma directive: pragma solidity ^0.8.0;

Import(ImportDirective<'ast>)

An import directive: import "foo.sol";

Using(UsingDirective<'ast>)

A using directive: using { A, B.add as + } for uint256 global;

Contract(ItemContract<'ast>)

A contract, abstract contract, interface, or library definition: contract Foo is Bar, Baz { ... }

Function(ItemFunction<'ast>)

A function, constructor, fallback, receive, or modifier definition: function helloWorld() external pure returns(string memory);

Variable(VariableDefinition<'ast>)

A state variable or constant definition: uint256 constant FOO = 42;

Struct(ItemStruct<'ast>)

A struct definition: struct Foo { uint256 bar; }

Enum(ItemEnum<'ast>)

An enum definition: enum Foo { A, B, C }

Udvt(ItemUdvt<'ast>)

A user-defined value type definition: type Foo is uint256;

Error(ItemError<'ast>)

An error definition: error Foo(uint256 a, uint256 b);

Event(ItemEvent<'ast>)

An event definition: event Transfer(address indexed from, address indexed to, uint256 value);

Implementations

impl ItemKind<'_>

pub fn name(&self) -> Option<Ident>

Returns the name of the item, if any.

pub fn description(&self) -> &'static str

Returns the description of the item.

pub fn is_allowed_in_contract(&self) -> bool

Returns true if the item is allowed inside of contracts.

Trait Implementations

impl Debug for ItemKind<'_>

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

Formats the value using the given formatter.