Enum StatementKind 

pub enum StatementKind {
    Block {
        body: Vec<Statement>,
    },
    Empty,
    Debugger,
    Expression {
        expression: Expression,
    },
    If {
        test: Expression,
        consequent: Box<Statement>,
        alternate: Option<Box<Statement>>,
    },
    Switch {
        discriminant: Expression,
        cases: Vec<SwitchCase>,
    },
    For {
        init: Option<ForInit>,
        test: Option<Expression>,
        update: Option<Expression>,
        body: Box<Statement>,
    },
    ForIn {
        left: ForLeft,
        right: Expression,
        body: Box<Statement>,
    },
    ForOf {
        left: ForLeft,
        right: Expression,
        body: Box<Statement>,
        is_await: bool,
    },
    While {
        test: Expression,
        body: Box<Statement>,
    },
    DoWhile {
        body: Box<Statement>,
        test: Expression,
    },
    Return {
        argument: Option<Expression>,
    },
    Throw {
        argument: Expression,
    },
    Try {
        block: Vec<Statement>,
        handler: Option<CatchClause>,
        finalizer: Option<Vec<Statement>>,
    },
    Break {
        label: Option<Identifier>,
    },
    Continue {
        label: Option<Identifier>,
    },
    Labeled {
        label: Identifier,
        body: Box<Statement>,
    },
    VariableDeclaration(VariableDeclaration),
    FunctionDeclaration(Function),
    ClassDeclaration(Class),
}

The shape of an ECMAScript statement.

Variants

Block

A block: { ... }.

Fields

body: Vec<Statement>

Statements inside the block.

Empty

An empty statement (;).

Debugger

debugger;

Expression

An expression evaluated as a statement.

Fields

expression: Expression

The expression.

If

if (test) consequent else? alternate.

Fields

test: Expression

The test expression.

consequent: Box<Statement>

The body run when test is truthy.

alternate: Option<Box<Statement>>

The optional else branch.

Switch

switch (discriminant) { cases }.

Fields

discriminant: Expression

The discriminant expression.

cases: Vec<SwitchCase>

The cases.

For

for (init; test; update) body.

Fields

init: Option<ForInit>

Optional initialiser (declaration or expression).

test: Option<Expression>

Optional loop-continuation test.

update: Option<Expression>

Optional update expression evaluated after each iteration.

body: Box<Statement>

The loop body.

ForIn

for (left in right) body.

Fields

left: ForLeft

The iteration target (declaration or assignment-target pattern).

right: Expression

The object whose enumerable properties are iterated.

body: Box<Statement>

The loop body.

ForOf

for (left of right) body, possibly for await.

Fields

left: ForLeft

The iteration target.

right: Expression

The iterable expression.

body: Box<Statement>

The loop body.

is_await: bool

True for for await (...) of.

While

while (test) body.

Fields

test: Expression

The test expression.

body: Box<Statement>

The loop body.

DoWhile

do body while (test);.

Fields

body: Box<Statement>

The loop body.

test: Expression

The test expression checked after each iteration.

Return

return argument?;

Fields

argument: Option<Expression>

Optional return value.

Throw

throw argument;

Fields

argument: Expression

The value to throw.

Try

try { ... } catch (e) { ... } finally { ... }.

Fields

block: Vec<Statement>

The protected block.

handler: Option<CatchClause>

Optional catch clause.

finalizer: Option<Vec<Statement>>

Optional finally block.

Break

break label?;

Fields

label: Option<Identifier>

Optional label to break out of.

Continue

continue label?;

Fields

label: Option<Identifier>

Optional label to continue.

Labeled

label: body – attach a label to a loop or block.

Fields

label: Identifier

The label name.

body: Box<Statement>

The labelled statement.

VariableDeclaration(VariableDeclaration)

A variable declaration treated as a statement.

FunctionDeclaration(Function)

A function declaration.

ClassDeclaration(Class)

A class declaration.

Trait Implementations

impl Clone for StatementKind

fn clone(&self) -> StatementKind

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for StatementKind

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

Formats the value using the given formatter.

impl Display for StatementKind

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

Formats the value using the given formatter.

impl Eq for StatementKind

impl PartialEq for StatementKind

fn eq(&self, other: &StatementKind) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for StatementKind