Enum Item

pub enum Item {
    Contract(ItemContract),
    Enum(ItemEnum),
    Error(ItemError),
    Event(ItemEvent),
    Function(ItemFunction),
    Import(ImportDirective),
    Pragma(PragmaDirective),
    Struct(ItemStruct),
    Udt(ItemUdt),
    Using(UsingDirective),
    Variable(VariableDefinition),
}

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

Variants

Contract(ItemContract)

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

Enum(ItemEnum)

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

Error(ItemError)

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

Event(ItemEvent)

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

Function(ItemFunction)

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

Import(ImportDirective)

An import directive: import "foo.sol";

Pragma(PragmaDirective)

A pragma directive: pragma solidity ^0.8.0;

Struct(ItemStruct)

A struct definition: struct Foo { uint256 bar; }

Udt(ItemUdt)

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

Using(UsingDirective)

A using directive: using { A, B.mul as * } for uint256 global;

Variable(VariableDefinition)

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

Implementations

impl Item

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

pub fn attrs(&self) -> Option<&Vec<Attribute>>

pub fn attrs_mut(&mut self) -> Option<&mut Vec<Attribute>>

Trait Implementations

impl Clone for Item

fn clone(&self) -> Item

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Item

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

Formats the value using the given formatter.

impl Display for Item

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

Formats the value using the given formatter.

impl Parse for Item

fn parse(input: ParseStream<'_>) -> Result<Self>

impl Spanned for Item

fn span(&self) -> Span

Returns a Span covering the complete contents of this syntax tree node, or Span::call_site() if this node is empty.

fn set_span(&mut self, span: Span)

Sets the span of this syntax tree node if it is not empty.

fn with_span(self, span: Span) -> Self

where Self: Sized,

Sets the span of this owned syntax tree node if it is not empty.

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

Size for each variant:

• Contract: 112 bytes
• Enum: 76 bytes
• Error: 88 bytes
• Event: 100 bytes
• Function: 160 bytes
• Import: 96 bytes
• Pragma: 64 bytes
• Struct: 76 bytes
• Udt: 168 bytes
• Using: 176 bytes
• Variable: 284 bytes