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 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 copy 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>