Enum Stmt 

pub enum Stmt {
    Block(Vec<Stmt>),
    ExprStmt(Expr),
    LocalDef {
        var: u32,
        init: Option<Expr>,
        is_final: bool,
        force_type: bool,
    },
    Return(Option<Expr>),
    Throw(Expr),
    If {
        cond: Expr,
        then_stmt: Box<Stmt>,
        else_stmt: Option<Box<Stmt>>,
    },
    While {
        cond: Expr,
        body: Box<Stmt>,
    },
    DoWhile {
        body: Box<Stmt>,
        cond: Expr,
    },
    For {
        init: Vec<Stmt>,
        cond: Option<Expr>,
        update: Vec<Expr>,
        body: Box<Stmt>,
    },
    ForEach {
        var: u32,
        iterable: Expr,
        is_array: bool,
        body: Box<Stmt>,
    },
    Switch {
        selector: Expr,
        cases: Vec<CaseGroup>,
        default: Option<Box<Stmt>>,
        on_string: bool,
    },
    Try {
        body: Box<Stmt>,
        catches: Vec<Catch>,
        finally: Option<Box<Stmt>>,
    },
    TryWithResources {
        resources: Vec<Stmt>,
        body: Box<Stmt>,
        catches: Vec<Catch>,
        finally: Option<Box<Stmt>>,
    },
    Assert {
        cond: Expr,
        msg: Option<Expr>,
    },
    Synchronized {
        lock: Expr,
        body: Box<Stmt>,
    },
    TernaryValue {
        e: Expr,
    },
    MonitorEnter(Expr),
    MonitorExit(Expr),
    Label(u32),
    Goto(u32),
    ClassDecl {
        name: String,
        header: String,
        body: String,
    },
    Labeled {
        label: String,
        body: Box<Stmt>,
    },
    Break(Option<String>),
    Continue(Option<String>),
    Comment(String),
}

Variants

Block(Vec<Stmt>)

A plain { ... } block (or statement sequence during construction).

ExprStmt(Expr)

Expression statement (the expression must have side effects).

LocalDef

Local variable declaration: [final] T name [= init];

Fields

var: u32

init: Option<Expr>

is_final: bool

force_type: bool

Force declaration with explicit type even when inferrable.

Return(Option<Expr>)

Throw(Expr)

If

Fields

cond: Expr

then_stmt: Box<Stmt>

else_stmt: Option<Box<Stmt>>

While

while (cond) body; cond may be true for infinite loops.

Fields

cond: Expr

body: Box<Stmt>

DoWhile

Fields

body: Box<Stmt>

cond: Expr

For

Classic for (init; cond; update) body.

Fields

init: Vec<Stmt>

cond: Option<Expr>

update: Vec<Expr>

body: Box<Stmt>

ForEach

Enhanced for: for (T v : iterable) body.

Fields

var: u32

iterable: Expr

is_array: bool

true if iterating an array (index-based lowering).

body: Box<Stmt>

Switch

Fields

selector: Expr

cases: Vec<CaseGroup>

default: Option<Box<Stmt>>

on_string: bool

true if this was a string switch (selector hashed).

Try

Fields

body: Box<Stmt>

catches: Vec<Catch>

finally: Option<Box<Stmt>>

TryWithResources

try (resources) body — restored try-with-resources.

Fields

resources: Vec<Stmt>

Resource declarations (LocalDef statements).

body: Box<Stmt>

catches: Vec<Catch>

finally: Option<Box<Stmt>>

Assert

assert cond [: msg]; restored from the $assertionsDisabled idiom.

Fields

cond: Expr

msg: Option<Expr>

Synchronized

synchronized (lock) body

Fields

lock: Expr

body: Box<Stmt>

TernaryValue

A folded value-diamond: this “statement” represents a value left on the operand stack (consumed by the merge block). Removed after the merge statements are woven.

Fields

e: Expr

MonitorEnter(Expr)

Raw monitorenter (before synchronized reconstruction).

MonitorExit(Expr)

Raw monitorexit.

Label(u32)

Fallback: label (for unstructured control flow / jsr-ret leftovers).

Goto(u32)

Fallback: goto a label.

ClassDecl

Local class declaration rendered inline in a method body. header is e.g. Local implements Runnable.

Fields

name: String

header: String

body: String

Labeled

label: statement

Fields

label: String

body: Box<Stmt>

Break(Option<String>)

break; / break label;

Continue(Option<String>)

continue; / continue label;

Comment(String)

A raw line we could not decompile (error resilience).

Implementations

impl Stmt

pub fn is_empty_block(&self) -> bool

pub fn as_block(self) -> Stmt

Wrap in a block if not already one.

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Stmt