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) -> Result<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 parse_payable(self, input: ParseStream<'_>) -> Result<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