Enum Statement 

pub enum Statement {
    Expression(Expression),
    VarDeclaration {
        kind: VarKind,
        decls: Vec<(Pattern, Option<Expression>)>,
    },
    Block(Vec<Statement>),
    If {
        test: Expression,
        consequent: Box<Statement>,
        alternate: Option<Box<Statement>>,
    },
    While {
        test: Expression,
        body: Box<Statement>,
    },
    DoWhile {
        body: Box<Statement>,
        test: Expression,
    },
    For {
        init: Option<Box<Statement>>,
        test: Option<Expression>,
        update: Option<Expression>,
        body: Box<Statement>,
    },
    ForIn {
        decl_kind: Option<VarKind>,
        pattern: Pattern,
        object: Expression,
        body: Box<Statement>,
        of: bool,
        is_await: bool,
    },
    FunctionDeclaration {
        name: String,
        params: Vec<Param>,
        body: Vec<Statement>,
        is_async: bool,
        is_generator: bool,
    },
    Return(Option<Expression>),
    Break(Option<String>),
    Continue(Option<String>),
    Labeled(String, Box<Statement>),
    Throw(Expression),
    Switch {
        discriminant: Expression,
        cases: Vec<SwitchCase>,
    },
    Try {
        block: Vec<Statement>,
        catch_param: Option<Pattern>,
        catch_block: Option<Vec<Statement>>,
        finally_block: Option<Vec<Statement>>,
    },
    Import {
        source: String,
        default: Option<String>,
        namespace: Option<String>,
        named: Vec<(String, String)>,
        side_effect_only: bool,
    },
    ExportNamed {
        specifiers: Vec<(String, String)>,
        source: Option<String>,
    },
    ExportDefault(Expression),
    ExportDecl {
        declaration: Box<Statement>,
        names: Vec<String>,
    },
    ExportAll {
        source: String,
    },
    Empty,
}

Variants

Expression(Expression)

VarDeclaration

Fields

kind: VarKind

decls: Vec<(Pattern, Option<Expression>)>

Block(Vec<Statement>)

If

Fields

test: Expression

consequent: Box<Statement>

alternate: Option<Box<Statement>>

While

Fields

test: Expression

body: Box<Statement>

DoWhile

Fields

body: Box<Statement>

test: Expression

For

Fields

init: Option<Box<Statement>>

test: Option<Expression>

update: Option<Expression>

body: Box<Statement>

ForIn

Fields

decl_kind: Option<VarKind>

pattern: Pattern

object: Expression

body: Box<Statement>

of: bool

is_await: bool

for await (x of iterable)。Symbol.asyncIterator があればそれを駆動し、 無ければ同期イテラブルの各要素を await するフォールバック（of の時のみ意味を持つ）。

FunctionDeclaration

Fields

name: String

params: Vec<Param>

body: Vec<Statement>

is_async: bool

is_generator: bool

Return(Option<Expression>)

Break(Option<String>)

break; / break label;。

Continue(Option<String>)

continue; / continue label;。

Labeled(String, Box<Statement>)

label: statement（ラベル付き文。主にループの break label/continue label の ターゲットとして使う）。

Throw(Expression)

Switch

Fields

discriminant: Expression

cases: Vec<SwitchCase>

Try

Fields

block: Vec<Statement>

catch_param: Option<Pattern>

catch (e)/catch ({message}) 等。分割代入パターンにも対応（ES2015）。

catch_block: Option<Vec<Statement>>

finally_block: Option<Vec<Statement>>

Import

import ... from "spec" 宣言。 例: import def, { a, b as c }, * as ns from "mod"。

Fields

source: String

モジュール指定子（指定子文字列）。

default: Option<String>

default インポートの束縛名（import def from ...）。

namespace: Option<String>

名前空間インポートの束縛名（import * as ns from ...）。

named: Vec<(String, String)>

名前付きインポート: (元の export 名, ローカル束縛名)。

side_effect_only: bool

副作用のみ import "mod"（束縛なし）。

ExportNamed

export { a, b as c } / export { x } from "mod"（再エクスポート）。

Fields

specifiers: Vec<(String, String)>

(ローカル名 or 元名, 公開する export 名)。

source: Option<String>

再エクスポート元の指定子（export { x } from "mod"）。None なら自モジュール。

ExportDefault(Expression)

export default <expr>。

ExportDecl

export var/let/const/function/class ...（宣言を実行しつつ名前を export）。 内側の宣言文と、そこから公開する名前のリストを保持する。

Fields

declaration: Box<Statement>

names: Vec<String>

ExportAll

export * from "mod"（全名前の再エクスポート）。

Fields

source: String

Empty

Trait Implementations

impl Clone for Statement

fn clone(&self) -> Statement

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Statement

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

Formats the value using the given formatter.

impl PartialEq for Statement

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl StructuralPartialEq for Statement