Enum rhai::Stmt

#[non_exhaustive]
pub enum Stmt {
    Noop(Position),
    If(Box<(Expr, StmtBlock, StmtBlock)>, Position),
    Switch(Box<(Expr, SwitchCasesCollection)>, Position),
    While(Box<(Expr, StmtBlock)>, Position),
    Do(Box<(Expr, StmtBlock)>, ASTFlags, Position),
    For(Box<(Ident, Ident, Expr, StmtBlock)>, Position),
    Var(Box<(Ident, Expr, Option<NonZeroUsize>)>, ASTFlags, Position),
    Assignment(Box<(OpAssignment, BinaryExpr)>),
    FnCall(Box<FnCallExpr>, Position),
    Block(Box<StmtBlock>),
    TryCatch(Box<TryCatchBlock>, Position),
    Expr(Box<Expr>),
    BreakLoop(ASTFlags, Position),
    Return(Option<Box<Expr>>, ASTFlags, Position),
    Import(Box<(Expr, Ident)>, Position),
    Export(Box<(Ident, Ident)>, Position),
    Share(ImmutableString, Position),
}

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

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Noop(Position)

No-op.

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

if expr { stmt } else { stmt }

Switch(Box<(Expr, SwitchCasesCollection)>, Position)

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

Data Structure

0. Hash table for (condition, block)
1. Default block
2. List of ranges: (start, end, inclusive, condition, statement)

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

while expr { stmt } | loop { stmt }

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

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

do { stmt } while|until expr

Flags

• NONE = while
• NEGATED = until

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

for ( id , counter ) in expr { stmt }

Var(Box<(Ident, Expr, Option<NonZeroUsize>)>, ASTFlags, Position)

[export] let|const id = expr

Flags

• EXPORTED = export
• CONSTANT = const

Assignment(Box<(OpAssignment, BinaryExpr)>)

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<StmtBlock>)

{ stmt; … }

TryCatch(Box<TryCatchBlock>, Position)

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

Expr(Box<Expr>)

expression

BreakLoop(ASTFlags, Position)

continue/break

Flags

• NONE = continue
• BREAK = break

Return(Option<Box<Expr>>, ASTFlags, Position)

return/throw

Flags

• NONE = return
• BREAK = throw

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

import expr as alias

Not available under no_module.

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

export var as alias

Not available under no_module.

Share(ImmutableString, Position)

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 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_block_dependent(&self) -> bool

Does this statement’s behavior depend on its containing block?

A statement that depends on its containing block behaves differently when promoted to an upper block.

Currently only variable definitions (i.e. let and const), import/export statements, and eval calls (which may in turn define variables) fall under this category.

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, other than pure expressions.

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 Extend<Stmt> for StmtBlock

fn extend<T: IntoIterator<Item = Stmt>>(&mut self, iter: T)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

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

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

Converts to this type from the input type.

impl<T: IntoIterator<Item = Stmt>> From<(T, Position, Position)> for Stmt

fn from(value: (T, Position, Position)) -> Self

Converts to this type from the input type.

impl<T: IntoIterator<Item = Stmt>> From<(T, Span)> for Stmt

fn from(value: (T, Span)) -> Self

Converts to this type from the input type.

impl From<Stmt> for StmtBlock

fn from(stmt: Stmt) -> Self

Converts to this type from the input type.

impl From<StmtBlock> for Stmt

fn from(block: StmtBlock) -> Self

Converts to this type from the input type.

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.