Enum SolidityExpr 

pub enum SolidityExpr {
    IntLit(i128),
    BoolLit(bool),
    StrLit(String),
    AddressLit(String),
    HexLit(String),
    Var(String),
    This,
    MsgSender,
    MsgValue,
    MsgData,
    BlockTimestamp,
    BlockNumber,
    BlockBasefee,
    TxOrigin,
    GasLeft,
    FieldAccess(Box<SolidityExpr>, String),
    Index(Box<SolidityExpr>, Box<SolidityExpr>),
    Call(Box<SolidityExpr>, Vec<SolidityExpr>),
    NamedCall(Box<SolidityExpr>, Vec<(String, SolidityExpr)>),
    Cast(SolidityType, Box<SolidityExpr>),
    AbiEncode(Vec<SolidityExpr>),
    AbiEncodePacked(Vec<SolidityExpr>),
    AbiEncodeWithSelector(Box<SolidityExpr>, Vec<SolidityExpr>),
    Keccak256(Box<SolidityExpr>),
    Sha256(Box<SolidityExpr>),
    Ecrecover(Box<SolidityExpr>, Box<SolidityExpr>, Box<SolidityExpr>, Box<SolidityExpr>),
    BinOp(String, Box<SolidityExpr>, Box<SolidityExpr>),
    UnaryOp(String, Box<SolidityExpr>),
    Ternary(Box<SolidityExpr>, Box<SolidityExpr>, Box<SolidityExpr>),
    New(SolidityType, Vec<SolidityExpr>),
    Delete(Box<SolidityExpr>),
    ArrayLit(Vec<SolidityExpr>),
    TupleLit(Vec<SolidityExpr>),
    TypeMax(SolidityType),
    TypeMin(SolidityType),
    Payable(Box<SolidityExpr>),
}

Solidity expression AST node.

Variants

IntLit(i128)

Integer literal: 42

BoolLit(bool)

Boolean literal: true / false

StrLit(String)

String literal: "hello"

AddressLit(String)

Address literal: 0x1234...

HexLit(String)

Hex literal: 0xdeadbeef

Var(String)

Variable reference: myVar

This

this

MsgSender

msg.sender

MsgValue

msg.value

MsgData

msg.data

BlockTimestamp

block.timestamp

BlockNumber

block.number

BlockBasefee

block.basefee

TxOrigin

tx.origin

GasLeft

gasleft()

FieldAccess(Box<SolidityExpr>, String)

Field access: expr.field

Index(Box<SolidityExpr>, Box<SolidityExpr>)

Index access: expr[index]

Call(Box<SolidityExpr>, Vec<SolidityExpr>)

Function call: f(args...)

NamedCall(Box<SolidityExpr>, Vec<(String, SolidityExpr)>)

Named argument call: f({name: val, ...})

Cast(SolidityType, Box<SolidityExpr>)

Type cast: uint256(expr)

AbiEncode(Vec<SolidityExpr>)

abi.encode(args...)

AbiEncodePacked(Vec<SolidityExpr>)

abi.encodePacked(args...)

AbiEncodeWithSelector(Box<SolidityExpr>, Vec<SolidityExpr>)

abi.encodeWithSelector(selector, args...)

Keccak256(Box<SolidityExpr>)

keccak256(data)

Sha256(Box<SolidityExpr>)

sha256(data)

Ecrecover(Box<SolidityExpr>, Box<SolidityExpr>, Box<SolidityExpr>, Box<SolidityExpr>)

ecrecover(hash, v, r, s)

BinOp(String, Box<SolidityExpr>, Box<SolidityExpr>)

Binary operation: a + b

UnaryOp(String, Box<SolidityExpr>)

Unary operation: !a, -a, ~a

Ternary(Box<SolidityExpr>, Box<SolidityExpr>, Box<SolidityExpr>)

Ternary: cond ? then_ : else_

New(SolidityType, Vec<SolidityExpr>)

new T(args...)

Delete(Box<SolidityExpr>)

delete expr

ArrayLit(Vec<SolidityExpr>)

Array literal: [a, b, c]

TupleLit(Vec<SolidityExpr>)

Tuple literal: (a, b, c)

TypeMax(SolidityType)

type(T).max / type(T).min

TypeMin(SolidityType)

Payable(Box<SolidityExpr>)

payable(addr)

Trait Implementations

impl Clone for SolidityExpr

fn clone(&self) -> SolidityExpr

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SolidityExpr

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

Formats the value using the given formatter.

impl Display for SolidityExpr

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

Formats the value using the given formatter.

impl PartialEq for SolidityExpr

fn eq(&self, other: &SolidityExpr) -> 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 StructuralPartialEq for SolidityExpr