Enum Expr

pub enum Expr {
    Error(Box<[Span]>, ErrorEmitted),
    Path(PathExpr),
    Literal(Literal),
    AbiCast {
        abi_token: AbiToken,
        args: Parens<AbiCastArgs>,
    },
    Struct {
        path: PathExpr,
        fields: Braces<Punctuated<ExprStructField, CommaToken>>,
    },
    Tuple(Parens<ExprTupleDescriptor>),
    Parens(Parens<Box<Expr>>),
    Block(Braces<CodeBlockContents>),
    Array(SquareBrackets<ExprArrayDescriptor>),
    Asm(AsmBlock),
    Return {
        return_token: ReturnToken,
        expr_opt: Option<Box<Expr>>,
    },
    If(IfExpr),
    Match {
        match_token: MatchToken,
        value: Box<Expr>,
        branches: Braces<Vec<MatchBranch>>,
    },
    While {
        while_token: WhileToken,
        condition: Box<Expr>,
        block: Braces<CodeBlockContents>,
    },
    For {
        for_token: ForToken,
        in_token: InToken,
        value_pattern: Pattern,
        iterator: Box<Expr>,
        block: Braces<CodeBlockContents>,
    },
    FuncApp {
        func: Box<Expr>,
        args: Parens<Punctuated<Expr, CommaToken>>,
    },
    Index {
        target: Box<Expr>,
        arg: SquareBrackets<Box<Expr>>,
    },
    MethodCall {
        target: Box<Expr>,
        dot_token: DotToken,
        path_seg: PathExprSegment,
        contract_args_opt: Option<Braces<Punctuated<ExprStructField, CommaToken>>>,
        args: Parens<Punctuated<Expr, CommaToken>>,
    },
    FieldProjection {
        target: Box<Expr>,
        dot_token: DotToken,
        name: Ident,
    },
    TupleFieldProjection {
        target: Box<Expr>,
        dot_token: DotToken,
        field: BigUint,
        field_span: Span,
    },
    Ref {
        ampersand_token: AmpersandToken,
        mut_token: Option<MutToken>,
        expr: Box<Expr>,
    },
    Deref {
        star_token: StarToken,
        expr: Box<Expr>,
    },
    Not {
        bang_token: BangToken,
        expr: Box<Expr>,
    },
    Mul {
        lhs: Box<Expr>,
        star_token: StarToken,
        rhs: Box<Expr>,
    },
    Div {
        lhs: Box<Expr>,
        forward_slash_token: ForwardSlashToken,
        rhs: Box<Expr>,
    },
    Pow {
        lhs: Box<Expr>,
        double_star_token: DoubleStarToken,
        rhs: Box<Expr>,
    },
    Modulo {
        lhs: Box<Expr>,
        percent_token: PercentToken,
        rhs: Box<Expr>,
    },
    Add {
        lhs: Box<Expr>,
        add_token: AddToken,
        rhs: Box<Expr>,
    },
    Sub {
        lhs: Box<Expr>,
        sub_token: SubToken,
        rhs: Box<Expr>,
    },
    Shl {
        lhs: Box<Expr>,
        shl_token: ShlToken,
        rhs: Box<Expr>,
    },
    Shr {
        lhs: Box<Expr>,
        shr_token: ShrToken,
        rhs: Box<Expr>,
    },
    BitAnd {
        lhs: Box<Expr>,
        ampersand_token: AmpersandToken,
        rhs: Box<Expr>,
    },
    BitXor {
        lhs: Box<Expr>,
        caret_token: CaretToken,
        rhs: Box<Expr>,
    },
    BitOr {
        lhs: Box<Expr>,
        pipe_token: PipeToken,
        rhs: Box<Expr>,
    },
    Equal {
        lhs: Box<Expr>,
        double_eq_token: DoubleEqToken,
        rhs: Box<Expr>,
    },
    NotEqual {
        lhs: Box<Expr>,
        bang_eq_token: BangEqToken,
        rhs: Box<Expr>,
    },
    LessThan {
        lhs: Box<Expr>,
        less_than_token: LessThanToken,
        rhs: Box<Expr>,
    },
    GreaterThan {
        lhs: Box<Expr>,
        greater_than_token: GreaterThanToken,
        rhs: Box<Expr>,
    },
    LessThanEq {
        lhs: Box<Expr>,
        less_than_eq_token: LessThanEqToken,
        rhs: Box<Expr>,
    },
    GreaterThanEq {
        lhs: Box<Expr>,
        greater_than_eq_token: GreaterThanEqToken,
        rhs: Box<Expr>,
    },
    LogicalAnd {
        lhs: Box<Expr>,
        double_ampersand_token: DoubleAmpersandToken,
        rhs: Box<Expr>,
    },
    LogicalOr {
        lhs: Box<Expr>,
        double_pipe_token: DoublePipeToken,
        rhs: Box<Expr>,
    },
    Reassignment {
        assignable: Assignable,
        reassignment_op: ReassignmentOp,
        expr: Box<Expr>,
    },
    Break {
        break_token: BreakToken,
    },
    Continue {
        continue_token: ContinueToken,
    },
}

Variants

Error(Box<[Span]>, ErrorEmitted)

A malformed expression.

Used for parser recovery when we cannot form a more specific node.

Path(PathExpr)

Literal(Literal)

AbiCast

Fields

abi_token: AbiToken

args: Parens<AbiCastArgs>

Struct

Fields

path: PathExpr

fields: Braces<Punctuated<ExprStructField, CommaToken>>

Tuple(Parens<ExprTupleDescriptor>)

Parens(Parens<Box<Expr>>)

Block(Braces<CodeBlockContents>)

Array(SquareBrackets<ExprArrayDescriptor>)

Asm(AsmBlock)

Return

Fields

return_token: ReturnToken

expr_opt: Option<Box<Expr>>

If(IfExpr)

Match

Fields

match_token: MatchToken

value: Box<Expr>

branches: Braces<Vec<MatchBranch>>

While

Fields

while_token: WhileToken

condition: Box<Expr>

block: Braces<CodeBlockContents>

For

Fields

for_token: ForToken

in_token: InToken

value_pattern: Pattern

iterator: Box<Expr>

block: Braces<CodeBlockContents>

FuncApp

Fields

func: Box<Expr>

args: Parens<Punctuated<Expr, CommaToken>>

Index

Fields

target: Box<Expr>

arg: SquareBrackets<Box<Expr>>

MethodCall

Fields

target: Box<Expr>

dot_token: DotToken

path_seg: PathExprSegment

contract_args_opt: Option<Braces<Punctuated<ExprStructField, CommaToken>>>

args: Parens<Punctuated<Expr, CommaToken>>

FieldProjection

Fields

target: Box<Expr>

dot_token: DotToken

name: Ident

TupleFieldProjection

Fields

target: Box<Expr>

dot_token: DotToken

field: BigUint

field_span: Span

Ref

Fields

ampersand_token: AmpersandToken

mut_token: Option<MutToken>

expr: Box<Expr>

Deref

Fields

star_token: StarToken

expr: Box<Expr>

Not

Fields

bang_token: BangToken

expr: Box<Expr>

Mul

Fields

lhs: Box<Expr>

star_token: StarToken

rhs: Box<Expr>

Div

Fields

lhs: Box<Expr>

forward_slash_token: ForwardSlashToken

rhs: Box<Expr>

Pow

Fields

lhs: Box<Expr>

double_star_token: DoubleStarToken

rhs: Box<Expr>

Modulo

Fields

lhs: Box<Expr>

percent_token: PercentToken

rhs: Box<Expr>

Add

Fields

lhs: Box<Expr>

add_token: AddToken

rhs: Box<Expr>

Sub

Fields

lhs: Box<Expr>

sub_token: SubToken

rhs: Box<Expr>

Shl

Fields

lhs: Box<Expr>

shl_token: ShlToken

rhs: Box<Expr>

Shr

Fields

lhs: Box<Expr>

shr_token: ShrToken

rhs: Box<Expr>

BitAnd

Fields

lhs: Box<Expr>

ampersand_token: AmpersandToken

rhs: Box<Expr>

BitXor

Fields

lhs: Box<Expr>

caret_token: CaretToken

rhs: Box<Expr>

BitOr

Fields

lhs: Box<Expr>

pipe_token: PipeToken

rhs: Box<Expr>

Equal

Fields

lhs: Box<Expr>

double_eq_token: DoubleEqToken

rhs: Box<Expr>

NotEqual

Fields

lhs: Box<Expr>

bang_eq_token: BangEqToken

rhs: Box<Expr>

LessThan

Fields

lhs: Box<Expr>

less_than_token: LessThanToken

rhs: Box<Expr>

GreaterThan

Fields

lhs: Box<Expr>

greater_than_token: GreaterThanToken

rhs: Box<Expr>

LessThanEq

Fields

lhs: Box<Expr>

less_than_eq_token: LessThanEqToken

rhs: Box<Expr>

GreaterThanEq

Fields

lhs: Box<Expr>

greater_than_eq_token: GreaterThanEqToken

rhs: Box<Expr>

LogicalAnd

Fields

lhs: Box<Expr>

double_ampersand_token: DoubleAmpersandToken

rhs: Box<Expr>

LogicalOr

Fields

lhs: Box<Expr>

double_pipe_token: DoublePipeToken

rhs: Box<Expr>

Reassignment

Fields

assignable: Assignable

reassignment_op: ReassignmentOp

expr: Box<Expr>

Break

Fields

break_token: BreakToken

Continue

Fields

continue_token: ContinueToken

Implementations

impl Expr

pub fn try_into_assignable(self) -> Result<Assignable, Expr>

Returns the resulting Assignable if the self is a valid Assignable, or an error containing the Expr which causes the self to be an invalid Assignable.

In case of an error, the returned Expr can be self or any subexpression of self that is not allowed in assignment targets.

pub fn is_control_flow(&self) -> bool

pub fn friendly_name(&self) -> &'static str

Friendly Expr name string used for error reporting,

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 Serialize for Expr

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Spanned for Expr

fn span(&self) -> Span