Enum resast::spanned::stmt::Stmt

pub enum Stmt<'a> {
    Expr {
        expr: Expr<'a>,
        semi_colon: Option<Slice<'a>>,
    },
    Block(BlockStmt<'a>),
    Empty(Slice<'a>),
    Debugger {
        keyword: Slice<'a>,
        semi_colon: Option<Slice<'a>>,
    },
    With(WithStmt<'a>),
    Return {
        keyword: Slice<'a>,
        value: Option<Expr<'a>>,
        semi_colon: Option<Slice<'a>>,
    },
    Labeled(LabeledStmt<'a>),
    Break {
        keyword: Slice<'a>,
        label: Option<Ident<'a>>,
        semi_colon: Option<Slice<'a>>,
    },
    Continue {
        keyword: Slice<'a>,
        label: Option<Ident<'a>>,
        semi_colon: Option<Slice<'a>>,
    },
    If(IfStmt<'a>),
    Switch(SwitchStmt<'a>),
    Throw {
        keyword: Slice<'a>,
        expr: Expr<'a>,
        semi_colon: Option<Slice<'a>>,
    },
    Try(TryStmt<'a>),
    While(WhileStmt<'a>),
    DoWhile(DoWhileStmt<'a>),
    For(ForStmt<'a>),
    ForIn(ForInStmt<'a>),
    ForOf(ForOfStmt<'a>),
    Var {
        decls: VarDecls<'a>,
        semi_colon: Option<Slice<'a>>,
    },
}

A slightly more granular part of an es program than ProgramPart

Variants

Expr

Fields

expr: Expr<'a>

semi_colon: Option<Slice<'a>>

Any expression

Block(BlockStmt<'a>)

A collection of program parts wrapped in curly braces

Empty(Slice<'a>)

A single semi-colon

Debugger

Fields

keyword: Slice<'a>

semi_colon: Option<Slice<'a>>

The contextual keyword debugger

With(WithStmt<'a>)

A with statement, this puts one object at the top of the identifier search tree.

note: this cannot be used in a strict context

function random() {
    return 0;
}
let rand;
with (Math) {
    rand = floor(random() * 100) + 1;
}
//rand !== 0

Return

Fields

keyword: Slice<'a>

value: Option<Expr<'a>>

semi_colon: Option<Slice<'a>>

A return statement

function thing() {
    return 'stuff';
}
function stuff() {
    return;
}

Labeled(LabeledStmt<'a>)

A labeled statement

label: {
    break label;
}

Break

Fields

keyword: Slice<'a>

label: Option<Ident<'a>>

semi_colon: Option<Slice<'a>>

A break statement

label: {
    break label;
}
while (true) {
    break;
}

Continue

Fields

keyword: Slice<'a>

label: Option<Ident<'a>>

semi_colon: Option<Slice<'a>>

A short circuit continuation of a loop

label: while (true) {
    if (Math.floor(Math.random() * 100) > 50) {
        continue;
    } else {
        console.log('too low')
    }
}

If(IfStmt<'a>)

An if statement

if (1 < 2) {
    console.log('Always true');
} else {
    console.log('Never true');
}

Switch(SwitchStmt<'a>)

A switch statement

switch (Math.floor(Math.random()) * 10) {
    case 1:

    break;
    case 2:
    case 3:
    case 4:
        return false;
    default:
        return true;
}

Throw

Fields

keyword: Slice<'a>

expr: Expr<'a>

semi_colon: Option<Slice<'a>>

A statement that throws an error

function error() {
    throw 'hahahaha';
}

function newError() {
    throw new Error('hohoho');
}

Try(TryStmt<'a>)

A try/catch block

try {

} catch (e) {

} finally {

}

While(WhileStmt<'a>)

A while loop

while (false) {

}
var i = 0;
while (i < 100) {
    if (Math.floor(Math.random() * 100) > 50) {
        i--;
    } else {
        i += 5;
    }
}

DoWhile(DoWhileStmt<'a>)

A while loop that executes its body first

do {
    console.log('at least once')
} while (Math.floor(Math.random() * 100) < 75)

For(ForStmt<'a>)

A “c-style” for loop

for (var i = 0; i < 100; i++) console.log(i);
for (;;) {
    console.log('forever!');
}

ForIn(ForInStmt<'a>)

A for in statement, this kind of for statement will extract each key from an indexable thing

for (var i in [2,3,4,5,6]) {
    console.log(i);
}
//prints 0, 1, 2, 3, 4
for (var k in {a: 'b', c: 'd'}) {
    console.log(k);
}
//prints a, b

ForOf(ForOfStmt<'a>)

A for of statement, this kind of for statement will extract the value from a generator or iterator

for (var k of [2, 3, 4, 5, 6]) {
    console.log(k);
}
//prints 2, 3, 4, 5, 6

Var

Fields

decls: VarDecls<'a>

semi_colon: Option<Slice<'a>>

A var statement

var x;
var x, y = 'huh?';

Trait Implementations

impl<'a> Clone for Stmt<'a>

fn clone(&self) -> Stmt<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Stmt<'a>

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

Formats the value using the given formatter.

impl<'a> From<Stmt<'a>> for Stmt<'a>

fn from(other: Stmt<'a>) -> Self

Converts to this type from the input type.

impl<'a> Node for Stmt<'a>

fn loc(&self) -> SourceLocation

impl<'a> PartialEq<Stmt<'a>> for Stmt<'a>

fn eq(&self, other: &Stmt<'a>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> StructuralPartialEq for Stmt<'a>