Enum Stmt 

pub enum Stmt {
    Error,
    Empty,
    Expr(ExprId),
    Decl(DeclId),
    Compound(StmtList),
    If {
        cond: ExprId,
        then: StmtId,
        otherwise: Option<StmtId>,
    },
    Switch {
        scrutinee: ExprId,
        body: StmtId,
    },
    While {
        cond: ExprId,
        body: StmtId,
    },
    DoWhile {
        body: StmtId,
        cond: ExprId,
    },
    For {
        init: ForInit,
        cond: Option<ExprId>,
        step: Option<ExprId>,
        body: StmtId,
    },
    Goto(Symbol),
    GotoExpr(ExprId),
    Continue,
    Break,
    Return(Option<ExprId>),
    Label {
        name: Symbol,
        body: Option<StmtId>,
        attrs: AttrList,
    },
    Case {
        lo: ExprId,
        hi: Option<ExprId>,
        body: Option<StmtId>,
    },
    Default {
        body: Option<StmtId>,
    },
    LocalLabels(SymbolList),
    Asm(AsmId),
}

One statement node.

Twenty bytes, set by Stmt::For, which is the only variant with four operands and which gets away with it because ForInit has spare tag values for the statement’s own tag to live in. Splitting the loop’s clauses into a side table would buy four bytes a statement and cost an indirection on the most common loop in C, so they stay inline.

Variants

Error

A parse that did not work out. Poisoned, as Expr::Error is.

Empty

;.

Expr(ExprId)

An expression evaluated for its effect.

Decl(DeclId)

A declaration at block scope, with all of its declarators.

Compound(StmtList)

{ ... }, which is also a scope.

If

if (cond) then else otherwise.

Fields

cond: ExprId

The controlling expression.

then: StmtId

The statement taken when it is nonzero.

otherwise: Option<StmtId>

The else branch, if there was one.

Switch

switch (scrutinee) body.

Fields

scrutinee: ExprId

The controlling expression.

body: StmtId

The body, whose cases are found by walking it.

While

while (cond) body.

Fields

cond: ExprId

The controlling expression, tested before each iteration.

body: StmtId

The body.

DoWhile

do body while (cond);.

Fields

body: StmtId

The body, which runs at least once.

cond: ExprId

The controlling expression, tested after each iteration.

For

for (init; cond; step) body.

Fields

init: ForInit

The first clause, which may declare something and so may open a scope.

cond: Option<ExprId>

The controlling expression, absent when the clause was left empty, which means the loop runs forever.

step: Option<ExprId>

The third clause, evaluated after each iteration.

body: StmtId

The body.

Goto(Symbol)

goto name;.

GotoExpr(ExprId)

goto *expr;, GNU’s computed goto, which Postgres and the kernel both use.

Continue

continue;.

Break

break;.

Return(Option<ExprId>)

return expr;, or return;.

Label

name: body.

Fields

name: Symbol

The label, which lives in a namespace of its own and is scoped to the function.

body: Option<StmtId>

The statement it labels, absent when the label is the last thing in a block, which C23 allows and which everybody wrote as name: ; before it.

attrs: AttrList

Attributes on the label, such as [[gnu::hot]].

Case

case lo: body, or GNU’s case lo ... hi: body.

Fields

lo: ExprId

The value, or the first value of a range.

hi: Option<ExprId>

The last value of a GNU case range, which is included.

body: Option<StmtId>

The statement it labels, absent for the same reason as on a label.

Default

default: body.

Fields

body: Option<StmtId>

The statement it labels.

LocalLabels(SymbolList)

__label__ a, b;, GNU’s block-local labels, which a macro needs so that two expansions in one function do not collide.

Asm(AsmId)

An asm statement.

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 Copy for Stmt

impl Debug for Stmt

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

Formats the value using the given formatter.

impl Eq for Stmt

impl PartialEq for Stmt

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Stmt