Enum Statement 

pub enum Statement {
    Expression(Expression),
    Let {
        name: String,
        binding: Binding,
        declared_type: Option<Type>,
        value: Expression,
        line: u32,
    },
    Assign(Expression, Expression),
    Return(Option<Expression>),
    Label {
        name: String,
        parameters: Vec<Parameter>,
        initial_arguments: Vec<Expression>,
    },
    Jump {
        label: String,
        arguments: Vec<Expression>,
    },
    While {
        condition: Expression,
        body: Block,
    },
    Defer(Box<Self>),
}

A statement (no value produced).

Variants

Expression(Expression)

Expression evaluated for side effects.

Let

Variable binding (let/ref/var).

Fields

name: String

Variable name.

binding: Binding

Binding kind (value, ref, mutable ref).

declared_type: Option<Type>

Optional explicit type annotation.

value: Expression

Initializer expression.

line: u32

Source line number (0 if unavailable).

Assign(Expression, Expression)

Assignment (target := value).

Return(Option<Expression>)

Early return with optional value.

Label

Label definition for structured jumps.

Fields

name: String

Label name.

parameters: Vec<Parameter>

Parameters bound on each jump.

initial_arguments: Vec<Expression>

Initial argument values.

Jump

Jump to a label with arguments.

Fields

label: String

Target label name.

arguments: Vec<Expression>

Arguments passed to the label.

While

While loop.

Fields

condition: Expression

Loop condition.

body: Block

Loop body.

Defer(Box<Self>)

Deferred statement executed on scope exit.

Trait Implementations

impl Clone for Statement

fn clone(&self) -> Statement

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Statement

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

Formats the value using the given formatter.