Enum quad_compat_rhai::Stmt

pub enum Stmt {
    Noop(Position),
    If(Expr, Box<(StmtBlock, StmtBlock)>, Position),
    Switch(Expr, Box<(BTreeMap<u64, Box<(Option<Expr>, StmtBlock)>>, StmtBlock, StaticVec<(INT, INT, bool, Option<Expr>, StmtBlock)>)>, Position),
    While(Expr, Box<StmtBlock>, Position),
    Do(Box<StmtBlock>, Expr, OptionFlags, Position),
    For(Expr, Box<(Ident, Option<Ident>, StmtBlock)>, Position),
    Var(Expr, Box<Ident>, OptionFlags, Position),
    Assignment(Box<(Expr, Option<OpAssignment<'static>>, Expr)>, Position),
    FnCall(Box<FnCallExpr>, Position),
    Block(Box<[Stmt]>, Position),
    TryCatch(Box<(StmtBlock, Option<Ident>, StmtBlock)>, Position),
    Expr(Expr),
    BreakLoop(OptionFlags, Position),
    Return(OptionFlags, Option<Expr>, Position),
    Import(Expr, Option<Box<Ident>>, Position),
    Export(Box<[(Ident, Ident)]>, Position),
    Share(Identifier),
}

(internals) A statement. Exported under the internals feature only.

Variants

Noop(Position)

Tuple Fields

0: Position

No-op.

If(Expr, Box<(StmtBlock, StmtBlock)>, Position)

Tuple Fields

0: Expr

1: Box<(StmtBlock, StmtBlock)>

2: Position

if expr { stmt } else { stmt }

Switch(Expr, Box<(BTreeMap<u64, Box<(Option<Expr>, StmtBlock)>>, StmtBlock, StaticVec<(INT, INT, bool, Option<Expr>, StmtBlock)>)>, Position)

Tuple Fields

0: Expr

1: Box<(BTreeMap<u64, Box<(Option<Expr>, StmtBlock)>>, StmtBlock, StaticVec<(INT, INT, bool, Option<Expr>, StmtBlock)>)>

2: Position

switch expr if condition { literal or _ => stmt , … }

While(Expr, Box<StmtBlock>, Position)

Tuple Fields

0: Expr

1: Box<StmtBlock>

2: Position

while expr { stmt } | loop { stmt }

If the guard expression is UNIT, then it is a loop statement.

Do(Box<StmtBlock>, Expr, OptionFlags, Position)

Tuple Fields

0: Box<StmtBlock>

1: Expr

2: OptionFlags

3: Position

do { stmt } while|until expr

Option Flags

• AST_OPTION_NONE = while
• AST_OPTION_NEGATED = until

For(Expr, Box<(Ident, Option<Ident>, StmtBlock)>, Position)

Tuple Fields

0: Expr

1: Box<(Ident, Option<Ident>, StmtBlock)>

2: Position

for ( id , counter ) in expr { stmt }

Var(Expr, Box<Ident>, OptionFlags, Position)

Tuple Fields

0: Expr

1: Box<Ident>

2: OptionFlags

3: Position

[export] let|const id = expr

Option Flags

• AST_OPTION_PUBLIC = export
• AST_OPTION_CONSTANT = const

Assignment(Box<(Expr, Option<OpAssignment<'static>>, Expr)>, Position)

Tuple Fields

0: Box<(Expr, Option<OpAssignment<'static>>, Expr)>

1: Position

expr op= expr

FnCall(Box<FnCallExpr>, Position)

Tuple Fields

0: Box<FnCallExpr>

1: Position

func ( expr , … )

Note - this is a duplicate of Expr::FnCall to cover the very common pattern of a single function call forming one statement.

Block(Box<[Stmt]>, Position)

Tuple Fields

0: Box<[Stmt]>

1: Position

{ stmt; … }

TryCatch(Box<(StmtBlock, Option<Ident>, StmtBlock)>, Position)

Tuple Fields

0: Box<(StmtBlock, Option<Ident>, StmtBlock)>

1: Position

try { stmt; … } catch ( var ) { stmt; … }

Expr(Expr)

Tuple Fields

0: Expr

expression

BreakLoop(OptionFlags, Position)

Tuple Fields

0: OptionFlags

1: Position

continue/break

Option Flags

• AST_OPTION_NONE = continue
• AST_OPTION_BREAK_OUT = break

Return(OptionFlags, Option<Expr>, Position)

Tuple Fields

0: OptionFlags

1: Option<Expr>

2: Position

return/throw

Option Flags

• AST_OPTION_NONE = return
• AST_OPTION_BREAK_OUT = throw

Import(Expr, Option<Box<Ident>>, Position)

Tuple Fields

0: Expr

1: Option<Box<Ident>>

2: Position

import expr as var

Not available under no_module.

Export(Box<[(Ident, Ident)]>, Position)

Tuple Fields

0: Box<[(Ident, Ident)]>

1: Position

export var as var , …

Not available under no_module.

Share(Identifier)

Tuple Fields

0: Identifier

Convert a variable to shared.

Not available under no_closure.

Notes

This variant does not map to any language structure. It is currently only used only to convert a normal variable into a shared variable when the variable is captured by a closure.

Implementations

impl Stmt

pub const fn is_noop(&self) -> bool

Is this statement Noop?

pub const fn position(&self) -> Position

Get the position of this statement.

pub fn set_position(&mut self, new_pos: Position) -> &mut Self

Override the position of this statement.

pub const fn returns_value(&self) -> bool

Does this statement return a value?

pub const fn is_self_terminated(&self) -> bool

Is this statement self-terminated (i.e. no need for a semicolon terminator)?

pub fn is_pure(&self) -> bool

Is this statement pure?

A pure statement has no side effects.

pub fn is_internally_pure(&self) -> bool

Is this statement pure within the containing block?

An internally pure statement only has side effects that disappear outside the block.

Currently only variable definitions (i.e. let and const) and import/export statements are internally pure.

pub const fn is_control_flow_break(&self) -> bool

Does this statement break the current control flow through the containing block?

Currently this is only true for return, throw, break and continue.

All statements following this statement will essentially be dead code.

pub fn walk<'a>(
    &'a self,
    path: &mut Vec<ASTNode<'a>>,
    on_node: &mut impl FnMut(&[ASTNode<'_>]) -> bool
) -> bool

Recursively walk this statement. Return false from the callback to terminate the walk.

Trait Implementations

impl Clone for Stmt

fn clone(&self) -> Stmt

Returns a copy 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

Formats the value using the given formatter.

impl Default for Stmt

fn default() -> Self

Returns the “default value” for a type.

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

fn from(stmt: &'a Stmt) -> Self

Performs the conversion.

impl From<Stmt> for StmtBlock

fn from(stmt: Stmt) -> Self

Performs the conversion.

impl From<StmtBlock> for Stmt

fn from(block: StmtBlock) -> Self

Performs the conversion.

impl Hash for Stmt

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.