Enum Stmt 

pub enum Stmt {
    Let {
        is_mut: bool,
        name: String,
        ty: Option<TypeExpr>,
        init: Expr,
        span: Span,
    },
    If {
        cond: Expr,
        then_block: Block,
        else_branch: Option<ElseBranch>,
        span: Span,
    },
    While {
        cond: Expr,
        body: Block,
        span: Span,
    },
    For {
        var: String,
        iter: Expr,
        body: Block,
        span: Span,
    },
    Return {
        value: Option<Expr>,
        span: Span,
    },
    Break {
        span: Span,
    },
    Continue {
        span: Span,
    },
    Defer {
        expr: Expr,
        span: Span,
    },
    Expr {
        expr: Expr,
        span: Span,
    },
}

a statement. if/else, while, for ... in ..., return, break, continue, and defer expr are all statements – not expressions; there is no Expr::If in v1. an if chains through ElseBranch::If for else if.

Variants

Let

let name = init or let mut name = init, with an optional : ty. the initializer is required (no uninitialized bindings); the type is inferred from init when omitted.

Fields

is_mut: bool

name: String

ty: Option<TypeExpr>

init: Expr

span: Span

If

if cond { ... } with an optional else (a block, or another if for an else if chain). a statement, not an expression – there is no let x = if c { a } else { b } in v1.

Fields

cond: Expr

then_block: Block

else_branch: Option<ElseBranch>

span: Span

While

while cond { ... }.

Fields

cond: Expr

body: Block

span: Span

For

for var in iter { ... }. iter is any expression that yields an iterable; a range is just one kind of iterable. kept as a For node, not lowered to a while.

Fields

var: String

iter: Expr

body: Block

span: Span

Return

return or return expr. the value is optional – a bare return in a void function is legal.

Fields

value: Option<Expr>

span: Span

Break

break. no labels, no value in v1.

Fields

span: Span

Continue

continue. no labels, no value in v1.

Fields

span: Span

Defer

defer expr – expr runs at scope exit, LIFO with other defers in the same scope.

Fields

expr: Expr

span: Span

Expr

an expression used as a statement (expr ;). its value is discarded.

Fields

expr: Expr

span: Span

Implementations

impl Stmt

pub fn span(&self) -> Span

the source span of this statement.

every variant carries its span field; this match is exhaustive, which is the proof every statement has one. the parser builds the span from the leading keyword (or the first sub-expression) to the last token.

Trait Implementations

impl Clone for Stmt

fn clone(&self) -> Stmt

Returns a duplicate 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 PartialEq for Stmt

fn eq(&self, other: &Stmt) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for Stmt