Enum Stmt 

pub enum Stmt {
    VarDecl {
        name: String,
        type_qualifier: Option<TypeQualifier>,
        type_annotation: Option<String>,
        initializer: Option<Expr>,
        var_kind: VarKind,
        loc: Loc,
    },
    Assignment {
        target: Expr,
        value: Expr,
    },
    TupleAssignment {
        names: Vec<String>,
        value: Expr,
        loc: Loc,
    },
    Expression(Expr),
    If {
        condition: Expr,
        then_branch: Vec<Stmt>,
        else_if_branches: Vec<(Expr, Vec<Stmt>)>,
        else_branch: Option<Vec<Stmt>>,
    },
    For {
        var_name: String,
        from: Expr,
        to: Expr,
        step: Option<Expr>,
        body: Vec<Stmt>,
        loc: Loc,
    },
    ForIn {
        index_var: Option<String>,
        item_var: String,
        collection: Expr,
        body: Vec<Stmt>,
        loc: Loc,
    },
    While {
        condition: Expr,
        body: Vec<Stmt>,
    },
    Break {
        loc: Loc,
    },
    Continue {
        loc: Loc,
    },
    TypeDecl {
        name: String,
        fields: Vec<TypeField>,
        export: bool,
        loc: Loc,
    },
    MethodDecl {
        name: String,
        params: Vec<MethodParam>,
        body: Vec<Stmt>,
        export: bool,
        loc: Loc,
    },
    EnumDecl {
        name: String,
        fields: Vec<EnumField>,
        export: bool,
        loc: Loc,
    },
    FunctionDecl {
        name: String,
        params: Vec<FunctionParam>,
        body: Vec<Stmt>,
        export: bool,
        loc: Loc,
    },
    Export {
        item: ExportItem,
    },
    Import {
        path: String,
        alias: String,
        loc: Loc,
    },
}

Variants

VarDecl

Fields

name: String

type_qualifier: Option<TypeQualifier>

type_annotation: Option<String>

initializer: Option<Expr>

var_kind: VarKind

loc: Loc

Assignment

Fields

target: Expr

value: Expr

TupleAssignment

Fields

names: Vec<String>

value: Expr

loc: Loc

Expression(Expr)

If

Fields

condition: Expr

then_branch: Vec<Stmt>

else_if_branches: Vec<(Expr, Vec<Stmt>)>

else_branch: Option<Vec<Stmt>>

For

Fields

var_name: String

from: Expr

to: Expr

step: Option<Expr>

body: Vec<Stmt>

loc: Loc

ForIn

Fields

index_var: Option<String>

item_var: String

collection: Expr

body: Vec<Stmt>

loc: Loc

While

Fields

condition: Expr

body: Vec<Stmt>

Break

Fields

loc: Loc

Continue

Fields

loc: Loc

TypeDecl

Fields

name: String

fields: Vec<TypeField>

export: bool

loc: Loc

MethodDecl

Fields

name: String

params: Vec<MethodParam>

body: Vec<Stmt>

export: bool

loc: Loc

EnumDecl

Fields

name: String

fields: Vec<EnumField>

export: bool

loc: Loc

FunctionDecl

Fields

name: String

params: Vec<FunctionParam>

body: Vec<Stmt>

export: bool

loc: Loc

Export

Fields

item: ExportItem

Import

Fields

path: String

alias: String

loc: Loc

Trait Implementations

impl Clone for Stmt

fn clone(&self) -> Stmt

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Stmt

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Stmt

fn deserialize<__D>( __deserializer: __D, ) -> Result<Stmt, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Stmt

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for Stmt

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Stmt