Enum ExprKind 

pub enum ExprKind<'ast> {
    Array(BoxSlice<'ast, Box<'ast, Expr<'ast>>>),
    Assign(Box<'ast, Expr<'ast>>, Option<BinOp>, Box<'ast, Expr<'ast>>),
    Binary(Box<'ast, Expr<'ast>>, BinOp, Box<'ast, Expr<'ast>>),
    Call(Box<'ast, Expr<'ast>>, CallArgs<'ast>),
    CallOptions(Box<'ast, Expr<'ast>>, NamedArgList<'ast>),
    Delete(Box<'ast, Expr<'ast>>),
    Ident(Ident),
    Index(Box<'ast, Expr<'ast>>, IndexKind<'ast>),
    Lit(Box<'ast, Lit<'ast>>, Option<SubDenomination>),
    Member(Box<'ast, Expr<'ast>>, Ident),
    New(Type<'ast>),
    Payable(CallArgs<'ast>),
    Ternary(Box<'ast, Expr<'ast>>, Box<'ast, Expr<'ast>>, Box<'ast, Expr<'ast>>),
    Tuple(BoxSlice<'ast, SpannedOption<Box<'ast, Expr<'ast>>>>),
    TypeCall(Type<'ast>),
    Type(Type<'ast>),
    Unary(UnOp, Box<'ast, Expr<'ast>>),
}

A kind of expression.

Variants

Array(BoxSlice<'ast, Box<'ast, Expr<'ast>>>)

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

Assign(Box<'ast, Expr<'ast>>, Option<BinOp>, Box<'ast, Expr<'ast>>)

An assignment: a = b, a += b.

Binary(Box<'ast, Expr<'ast>>, BinOp, Box<'ast, Expr<'ast>>)

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

Call(Box<'ast, Expr<'ast>>, CallArgs<'ast>)

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

CallOptions(Box<'ast, Expr<'ast>>, NamedArgList<'ast>)

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

Delete(Box<'ast, Expr<'ast>>)

A unary delete expression: delete vector.

Ident(Ident)

An identifier: foo.

Index(Box<'ast, Expr<'ast>>, IndexKind<'ast>)

A square bracketed indexing expression: vector[index], slice[l:r].

Lit(Box<'ast, Lit<'ast>>, Option<SubDenomination>)

A literal: hex"1234", 5.6 ether.

Note that the SubDenomination is only present for numeric literals, and it’s already applied to Lit’s value. It is only present for error reporting/formatting purposes.

Member(Box<'ast, Expr<'ast>>, Ident)

Access of a named member: obj.k.

New(Type<'ast>)

A new expression: new Contract.

Payable(CallArgs<'ast>)

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

Ternary(Box<'ast, Expr<'ast>>, Box<'ast, Expr<'ast>>, Box<'ast, Expr<'ast>>)

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

Tuple(BoxSlice<'ast, SpannedOption<Box<'ast, Expr<'ast>>>>)

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

TypeCall(Type<'ast>)

A type() expression: type(uint256).

Type(Type<'ast>)

An elementary type name: uint256.

Unary(UnOp, Box<'ast, Expr<'ast>>)

A unary operation: !x, -x, x++.

Trait Implementations

impl<'ast> Debug for ExprKind<'ast>

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

Formats the value using the given formatter.

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

Size for each variant:

• Array: 15 bytes
• Assign: 31 bytes
• Binary: 31 bytes
• Call: 39 bytes
• CallOptions: 23 bytes
• Delete: 15 bytes
• Ident: 15 bytes
• Index: 39 bytes
• Lit: 15 bytes
• Member: 23 bytes
• New: 31 bytes
• Payable: 31 bytes
• Ternary: 31 bytes
• Tuple: 15 bytes
• TypeCall: 31 bytes
• Type: 31 bytes
• Unary: 23 bytes