Enum 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.

Implementations

impl Expr

pub fn peel_parens(&self) -> &Self

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.

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

Size for each variant:

• Array: 32 bytes
• Binary: 60 bytes
• Call: 48 bytes
• CallOptions: 36 bytes
• Delete: 20 bytes
• Ident: 24 bytes
• Index: 40 bytes
• Lit: 20 bytes
• LitDenominated: 28 bytes
• Member: 24 bytes
• New: 112 bytes
• Payable: 56 bytes
• Postfix: 36 bytes
• Ternary: 40 bytes
• Tuple: 32 bytes
• Type: 100 bytes
• TypeCall: 120 bytes
• Unary: 36 bytes