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, bool, Position),
    For(Expr, Box<(Ident, StmtBlock)>, Position),
    Let(Expr, Box<Ident>, bool, Position),
    Const(Expr, Box<Ident>, bool, Position),
    Assignment(Box<(Expr, Option<OpAssignment>, Expr)>, Position),
    FnCall(Box<FnCallExpr>, Position),
    Block(Box<[Stmt]>, Position),
    TryCatch(Box<(StmtBlock, Option<Ident>, StmtBlock)>, Position, Position),
    Expr(Expr),
    Continue(Position),
    Break(Position),
    Return(ReturnType, Option<Expr>, Position),
    Import(Expr, Option<Box<Ident>>, Position),
    Export(Box<[(Ident, Option<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(Position)

No-op.

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

if expr { stmt } else { stmt }

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

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

While(Expr, Box<StmtBlock>, Position)

while expr { stmt }

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

do { stmt } while|until expr

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

for id in expr { stmt }

Let(Expr, Box<Ident>, bool, Position)

[export] let id = expr

Const(Expr, Box<Ident>, bool, Position)

[export] const id = expr

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

expr op= expr

FnCall(Box<FnCallExpr>, 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)

{ stmt; … }

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

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

Expr(Expr)

expression

Continue(Position)

continue

Break(Position)

break

Return(ReturnType, Option<Expr>, Position)

return/throw

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

import expr as var

Not available under no_module.

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

export var as var , …

Not available under no_module.

Share(Identifier)

Convert a variable to shared.

Not available under no_closure.

Implementations

impl Stmt

pub fn is_noop(&self) -> bool

Is this statement Noop?

pub 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 fn returns_value(&self) -> bool

Does this statement return a value?

pub 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 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.