Enum SolidityStmt 

pub enum SolidityStmt {
    VarDecl {
        ty: SolidityType,
        location: Option<String>,
        name: String,
        init: Option<SolidityExpr>,
    },
    Assign(SolidityExpr, SolidityExpr),
    CompoundAssign(String, SolidityExpr, SolidityExpr),
    ExprStmt(SolidityExpr),
    Return(Option<SolidityExpr>),
    If(SolidityExpr, Vec<SolidityStmt>, Vec<SolidityStmt>),
    While(SolidityExpr, Vec<SolidityStmt>),
    For(Option<Box<SolidityStmt>>, Option<SolidityExpr>, Option<Box<SolidityStmt>>, Vec<SolidityStmt>),
    DoWhile(Vec<SolidityStmt>, SolidityExpr),
    Emit(String, Vec<SolidityExpr>),
    Revert(String, Vec<SolidityExpr>),
    Require(SolidityExpr, Option<String>),
    Assert(SolidityExpr),
    Break,
    Continue,
    Unchecked(Vec<SolidityStmt>),
    Assembly(String),
    MultiAssign(Vec<SolidityExpr>, SolidityExpr),
    Block(Vec<SolidityStmt>),
}

Solidity statement AST node.

Variants

VarDecl

Variable declaration: T loc name = expr;

Fields

ty: SolidityType

location: Option<String>

name: String

init: Option<SolidityExpr>

Assign(SolidityExpr, SolidityExpr)

Assignment: lhs = rhs;

CompoundAssign(String, SolidityExpr, SolidityExpr)

Compound assignment: lhs += rhs;

ExprStmt(SolidityExpr)

Expression statement: f();

Return(Option<SolidityExpr>)

return expr;

If(SolidityExpr, Vec<SolidityStmt>, Vec<SolidityStmt>)

if (cond) { then } else { else_ }

While(SolidityExpr, Vec<SolidityStmt>)

while (cond) { body }

For(Option<Box<SolidityStmt>>, Option<SolidityExpr>, Option<Box<SolidityStmt>>, Vec<SolidityStmt>)

for (init; cond; update) { body }

DoWhile(Vec<SolidityStmt>, SolidityExpr)

do { body } while (cond);

Emit(String, Vec<SolidityExpr>)

emit EventName(args...);

Revert(String, Vec<SolidityExpr>)

revert ErrorName(args...);

Require(SolidityExpr, Option<String>)

require(cond, msg);

Assert(SolidityExpr)

assert(cond);

Break

break;

Continue

continue;

Unchecked(Vec<SolidityStmt>)

unchecked { stmts }

Assembly(String)

assembly { body }

MultiAssign(Vec<SolidityExpr>, SolidityExpr)

Multi-return: (a, b) = f();

Block(Vec<SolidityStmt>)

Block of statements { ... }

Trait Implementations

impl Clone for SolidityStmt

fn clone(&self) -> SolidityStmt

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SolidityStmt

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

Formats the value using the given formatter.