Enum Type

pub enum Type {
    Address(Span, Option<payable>),
    Bool(Span),
    String(Span),
    Bytes(Span),
    FixedBytes(Span, NonZeroU16),
    Int(Span, Option<NonZeroU16>),
    Uint(Span, Option<NonZeroU16>),
    Array(TypeArray),
    Tuple(TypeTuple),
    Function(TypeFunction),
    Mapping(TypeMapping),
    Custom(SolPath),
}

A type name.

Solidity reference: https://docs.soliditylang.org/en/latest/grammar.html#a4.SolidityParser.typeName

Variants

Address(Span, Option<payable>)

address $(payable)?

Bool(Span)

bool

String(Span)

string

Bytes(Span)

bytes

FixedBytes(Span, NonZeroU16)

bytes<size>

Int(Span, Option<NonZeroU16>)

int[size]

Uint(Span, Option<NonZeroU16>)

uint[size]

Array(TypeArray)

$ty[$($size)?]

Tuple(TypeTuple)

$(tuple)? ( $($types,)* )

Function(TypeFunction)

function($($arguments),*) $($attributes)* $(returns ($($returns),+))?

Mapping(TypeMapping)

mapping($key $($key_name)? => $value $($value_name)?)

Custom(SolPath)

A custom type.

Implementations

impl Type

pub fn custom(ident: Ident) -> Self

pub fn peek(lookahead: &Lookahead1<'_>) -> bool

pub fn parse_ident(ident: Ident) -> Self

Parses an identifier as an elementary type name.

Note that you will have to check for the existence of a payable keyword separately.

pub fn try_parse_ident(ident: Ident) -> Result<Self>

pub fn parse_payable(self, input: ParseStream<'_>) -> Self

Parses the payable keyword from the input stream if this type is an address.

pub fn is_one_word( &self, custom_is_value_type: impl Fn(&SolPath) -> bool, ) -> bool

👎Deprecated: use is_value_type instead

Returns whether this type is ABI-encoded as a single EVM word (32 bytes).

This is the same as is_value_type.

pub fn is_abi_dynamic(&self) -> bool

Returns whether this type is dynamic according to ABI rules.

Note that this does not account for custom types, such as UDVTs.

pub fn is_value_type( &self, custom_is_value_type: impl Fn(&SolPath) -> bool, ) -> bool

Returns whether this type is a value type.

These types’ variables are always passed by value.

custom_is_value_type accounts for custom value types.

See the Solidity docs for more information.

pub fn is_value_type_simple(&self) -> bool

Returns whether this type is a simple value type.

See is_value_type for more information.

pub const fn is_array(&self) -> bool

pub const fn is_tuple(&self) -> bool

pub const fn is_custom(&self) -> bool

pub fn has_custom(&self) -> bool

Recurses into this type and returns whether it contains a custom type.

pub fn has_custom_simple(&self) -> bool

Same as has_custom, but Function returns false rather than recursing into its arguments and return types.

pub fn peel_arrays(&self) -> &Self

Returns the inner type.

pub fn abi_name(&self) -> String

Returns the Solidity ABI name for this type. This is tuple for custom types, otherwise the same as Display.

pub fn abi_name_raw(&self, s: &mut String)

Returns the Solidity ABI name for this type. This is tuple for custom types, otherwise the same as Display.

pub fn visit(&self, f: impl FnMut(&Self))

Available on crate feature visit only.

Traverses this type while calling f.

pub fn visit_mut(&mut self, f: impl FnMut(&mut Self))

Available on crate feature visit-mut only.

Traverses this type while calling f.

Trait Implementations

impl Clone for Type

fn clone(&self) -> Type

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Type

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

Formats the value using the given formatter.

impl Display for Type

Canonical type name formatting, used in selector preimages.

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

Formats the value using the given formatter.

impl FromIterator<Type> for TypeTuple

fn from_iter<T: IntoIterator<Item = Type>>(iter: T) -> Self

Creates a value from an iterator.

impl Hash for Type

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Parse for Type

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

impl PartialEq for Type

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Spanned for Type

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, new_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.

impl Eq for Type

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

Size for each variant:

• Address: 32 bytes
• Bool: 20 bytes
• String: 20 bytes
• Bytes: 20 bytes
• FixedBytes: 24 bytes
• Int: 24 bytes
• Uint: 24 bytes
• Array: 40 bytes
• Tuple: 64 bytes
• Function: 136 bytes
• Mapping: 136 bytes
• Custom: 40 bytes