Enum rhai::Stmt

source ·

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

Expand description

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

Variants (Non-exhaustive)§

This enum is marked as 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<FlowControl>, Position)

if expr { stmt } else { stmt }

§

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

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

Data Structure

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

§

While(Box<FlowControl>, Position)

while expr { stmt } | loop { stmt }

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

§

Do(Box<FlowControl>, ASTFlags, Position)

do { stmt } while|until expr

Flags

NONE = while
NEGATED = until

§

For(Box<(Ident, Option<Ident>, FlowControl)>, 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 , … )

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<FlowControl>, Position)

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

§

Expr(Box<Expr>)

expression

§

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

continue/break expr

Flags

NONE = continue
BREAK = break

§

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

return/throw expr

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.

Convert a list of variables 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 normal variables into shared variables when they are captured by a closure.

Enum rhai::Stmt

Variants (Non-exhaustive)§

Noop(Position)

If(Box<FlowControl>, Position)

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

While(Box<FlowControl>, Position)

Do(Box<FlowControl>, ASTFlags, Position)

For(Box<(Ident, Option<Ident>, FlowControl)>, Position)

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

Assignment(Box<(OpAssignment, BinaryExpr)>)

FnCall(Box<FnCallExpr>, Position)

Block(Box<StmtBlock>)

TryCatch(Box<FlowControl>, Position)

Expr(Box<Expr>)

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

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

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

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

Share(Box<SmallVec<[(Ident, Option<NonZeroUsize>); 5]>>)

Implementations§

impl Stmt

pub const fn is_noop(&self) -> bool

pub const fn options(&self) -> ASTFlags

pub fn position(&self) -> Position

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

pub const fn returns_value(&self) -> bool

pub const fn is_self_terminated(&self) -> bool

pub fn is_pure(&self) -> bool

pub fn is_block_dependent(&self) -> bool

pub fn is_internally_pure(&self) -> bool

pub const fn is_control_flow_break(&self) -> bool

pub fn take(&mut self) -> Self

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

Trait Implementations§

impl Clone for Stmt

fn clone(&self) -> Stmt

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

impl Debug for Stmt

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

impl Default for Stmt

fn default() -> Self

impl Extend<Stmt> for StmtBlock

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

fn extend_one(&mut self, item: A)

fn extend_reserve(&mut self, additional: usize)

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

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

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

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

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

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

impl From<Stmt> for StmtBlock

fn from(stmt: Stmt) -> Self

impl From<StmtBlock> for Stmt

fn from(block: StmtBlock) -> Self

impl Hash for Stmt

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

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

Auto Trait Implementations§

impl !RefUnwindSafe for Stmt

impl !Send for Stmt

impl !Sync for Stmt

impl Unpin for Stmt

impl !UnwindSafe for Stmt

Blanket Implementations§

impl<T> Any for Twhere T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for Twhere T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for Twhere T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

impl<T> From<T> for T

fn from(t: T) -> T

impl<T, U> Into<U> for Twhere U: From<T>,

fn into(self) -> U

impl<T> ToOwned for Twhere T: Clone,

type Owned = T

fn to_owned(&self) -> T

fn clone_into(&self, target: &mut T)

impl<T, U> TryFrom<U> for Twhere U: Into<T>,

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