Enum rhai::Stmt

pub enum Stmt {
    Noop(Position),
    If(Expr, Box<(StmtBlock, StmtBlock)>, Position),
    Switch(Expr, Box<(BTreeMap<u64, Box<(Option<Expr>, StmtBlock)>>, 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),
    Continue(Position),
    Break(Position),
    Return(ReturnType, 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.

Volatile Data Structure

This type is volatile and may change.

Variants

Noop

No-op.

Tuple Fields of Noop

0: Position

If

if expr { stmt } else { stmt }

Tuple Fields of If

0: Expr1: Box<(StmtBlock, StmtBlock)>2: Position

Switch

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

Tuple Fields of Switch

0: Expr1: Box<(BTreeMap<u64, Box<(Option<Expr>, StmtBlock)>>, StmtBlock)>2: Position

While

while expr { stmt } | loop { stmt }

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

Tuple Fields of While

0: Expr1: Box<StmtBlock>2: Position

Do

do { stmt } while|until expr

Option Flags

• [AST_FLAG_NONE][AST_FLAGS::AST_FLAG_NONE] = while
• [AST_FLAG_NEGATED][AST_FLAGS::AST_FLAG_NEGATED] = until

Tuple Fields of Do

0: Box<StmtBlock>1: Expr2: OptionFlags3: Position

For

for ( id , counter ) in expr { stmt }

Tuple Fields of For

0: Expr1: Box<(Ident, Option<Ident>, StmtBlock)>2: Position

Var

[export] let|const id = expr

Option Flags

• [AST_FLAG_EXPORTED][AST_FLAGS::AST_FLAG_EXPORTED] = export
• [AST_FLAG_CONSTANT][AST_FLAGS::AST_FLAG_CONSTANT] = const

Tuple Fields of Var

0: Expr1: Box<Ident>2: OptionFlags3: Position

Assignment

expr op= expr

Tuple Fields of Assignment

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

FnCall

func ( expr , … )

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

Tuple Fields of FnCall

0: Box<FnCallExpr>1: Position

Block

{ stmt; … }

Tuple Fields of Block

0: Box<[Stmt]>1: Position

TryCatch

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

Tuple Fields of TryCatch

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

Expr

expression

Tuple Fields of Expr

0: Expr

Continue

continue

Tuple Fields of Continue

0: Position

Break

break

Tuple Fields of Break

0: Position

Return

return/throw

Tuple Fields of Return

0: ReturnType1: Option<Expr>2: Position

Import

import expr as var

Not available under no_module.

Tuple Fields of Import

0: Expr1: Option<Box<Ident>>2: Position

Export

export var as var , …

Not available under no_module.

Tuple Fields of Export

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

Share

Convert a variable to shared.

Not available under no_closure.

Tuple Fields of Share

0: Identifier

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.

Only variable declarations (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.