Struct TypeSpecifier 

pub struct TypeSpecifier<'a> {
    pub span: &'a str,
    pub stem: TypeStem<'a>,
    pub sizes: Vec<Option<NonZeroUsize>>,
}

Represents a type-name. Consists of an identifier and optional array sizes.

A type specifier has a stem, which is TypeStem representing either a RootType or a TupleSpecifier, and a list of array sizes. The array sizes are in innermost-to-outermost order. An empty array size vec indicates that the specified type is not an array

Type specifier examples:

• uint256
• uint256[2]
• uint256[2][]
• (uint256,uint256)
• (uint256,uint256)[2]
• MyStruct
• MyStruct[2]

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

Compatibility with JSON ABI

This type supports the internalType semantics for JSON-ABI compatibility.

Examples of valid JSON ABI internal types:

• contract MyContract
• struct MyStruct
• enum MyEnum
• struct MyContract.MyStruct\[333\]
• enum MyContract.MyEnum[][][][][][]
• MyValueType

Examples

let spec = TypeSpecifier::parse("uint256[2][]")?;
assert_eq!(spec.span(), "uint256[2][]");
assert_eq!(spec.stem.span(), "uint256");
// The sizes are in innermost-to-outermost order.
assert_eq!(spec.sizes.as_slice(), &[NonZeroUsize::new(2), None]);

Fields

span: &'a str

The full span of the specifier.

stem: TypeStem<'a>

The type stem, which is either a root type or a tuple type.

sizes: Vec<Option<NonZeroUsize>>

Array sizes, in innermost-to-outermost order. If the size is None, then the array is dynamic. If the size is Some, then the array is fixed-size. If the vec is empty, then the type is not an array.

Implementations

impl<'a> TypeSpecifier<'a>

pub fn parse(s: &'a str) -> Result<Self>

Parse a type specifier from a string.

pub fn parse_eip712(s: &'a str) -> Result<Self>

Available on crate feature eip712 only.

Parse a type specifier from a string with support for : in identifiers.

Extends the standard type parsing.

pub const fn span(&self) -> &'a str

Returns the type stem as a string.

pub const fn stem(&self) -> &TypeStem<'_>

Returns the type stem.

pub fn try_basic_solidity(&self) -> Result<()>

Returns true if the type is a basic Solidity type.

pub fn is_array(&self) -> bool

Returns true if this type is an array.

Trait Implementations

impl AsRef<str> for TypeSpecifier<'_>

fn as_ref(&self) -> &str

Converts this type into a shared reference of the (usually inferred) input type.

impl<'a> Clone for TypeSpecifier<'a>

fn clone(&self) -> TypeSpecifier<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for TypeSpecifier<'a>

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

Formats the value using the given formatter.

impl<'a> PartialEq for TypeSpecifier<'a>

fn eq(&self, other: &TypeSpecifier<'a>) -> 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<'a> TryFrom<&'a str> for TypeSpecifier<'a>

type Error = Error

The type returned in the event of a conversion error.

fn try_from(s: &'a str) -> Result<Self>

Performs the conversion.

impl<'a> Eq for TypeSpecifier<'a>

impl<'a> StructuralPartialEq for TypeSpecifier<'a>

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