Enum syn_solidity::Expr

pub enum Expr {
    Array(ExprArray),
    Binary(ExprBinary),
    Call(ExprCall),
    CallOptions(ExprCallOptions),
    Delete(ExprDelete),
    Ident(SolIdent),
    Index(ExprIndex),
    Lit(Lit),
    LitDenominated(LitDenominated),
    Member(ExprMember),
    New(ExprNew),
    Payable(ExprPayable),
    Postfix(ExprPostfix),
    Ternary(ExprTernary),
    Tuple(ExprTuple),
    Type(Type),
    TypeCall(ExprTypeCall),
    Unary(ExprUnary),
}

An expression.

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

Variants

Array(ExprArray)

An array literal expression: [a, b, c, d].

Binary(ExprBinary)

A binary operation: a + b, a += b.

Call(ExprCall)

A function call expression: foo(42) or foo({ bar: 42 }).

CallOptions(ExprCallOptions)

Function call options: foo.bar{ value: 1, gas: 2 }.

Delete(ExprDelete)

A unary delete expression: delete vector.

Ident(SolIdent)

An identifier: foo.

Index(ExprIndex)

A square bracketed indexing expression: vector[2].

Lit(Lit)

A literal: hex"1234".

LitDenominated(LitDenominated)

A number literal with a sub-denomination: 1 ether.

Member(ExprMember)

Access of a named member: obj.k.

New(ExprNew)

A new expression: new Contract.

Payable(ExprPayable)

A payable expression: payable(address(0x...)).

Postfix(ExprPostfix)

A postfix unary expression: foo++.

Ternary(ExprTernary)

A ternary (AKA conditional) expression: foo ? bar : baz.

Tuple(ExprTuple)

A tuple expression: (a, b, c, d).

Type(Type)

A type name.

Cannot be Custom, as custom identifiers are parsed as Ident instead.

TypeCall(ExprTypeCall)

A type() expression: type(uint256)

Unary(ExprUnary)

A unary operation: !x, -x.

Trait Implementations

impl Clone for Expr

fn clone(&self) -> Expr

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Expr

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

Formats the value using the given formatter.

impl Parse for Expr

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

impl Spanned for Expr

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.