Enum Stmt 

pub enum Stmt {
    Expr(Expr),
    Let {
        name: String,
        init: Option<Expr>,
        mutable: bool,
        type_annotation: Option<String>,
        span: Option<Span>,
    },
    Block(Vec<Stmt>),
    If {
        test: Expr,
        consequent: Box<Stmt>,
        alternate: Option<Box<Stmt>>,
        span: Option<Span>,
    },
    While {
        test: Expr,
        body: Box<Stmt>,
        span: Option<Span>,
    },
    For {
        init: Option<Box<Stmt>>,
        test: Option<Expr>,
        update: Option<Expr>,
        body: Box<Stmt>,
        span: Option<Span>,
    },
    ForIn {
        variable: String,
        iterable: Expr,
        body: Box<Stmt>,
        span: Option<Span>,
    },
    Return(Option<Expr>),
    Break,
    Continue,
    TryCatch {
        body: Box<Stmt>,
        catch_param: Option<String>,
        catch_body: Option<Box<Stmt>>,
        finally_body: Option<Box<Stmt>>,
        span: Option<Span>,
    },
    Function(Function),
    Import {
        source: String,
        names: Vec<ImportName>,
        span: Option<Span>,
    },
    Export {
        names: Vec<ExportName>,
        source: Option<String>,
        span: Option<Span>,
    },
    Class {
        name: String,
        extends: Option<String>,
        methods: Vec<Method>,
        span: Option<Span>,
    },
    Destructure {
        pat: Pat,
        value: Expr,
        mutable: bool,
        span: Option<Span>,
    },
    Comment {
        text: String,
        block: bool,
        span: Option<Span>,
    },
}

A statement (doesn’t produce a value directly).

Variants

Expr(Expr)

Expression statement: expr;.

Let

Variable declaration: let name = init or const name = init.

Fields

name: String

init: Option<Expr>

mutable: bool

type_annotation: Option<String>

Optional type annotation (e.g. string for let x: string = ...).

span: Option<Span>

Source location (populated by readers; ignored by writers).

Block(Vec<Stmt>)

Block: { stmts... }.

If

If statement: if (test) consequent else alternate.

Fields

test: Expr

consequent: Box<Stmt>

alternate: Option<Box<Stmt>>

span: Option<Span>

Source location (populated by readers; ignored by writers).

While

While loop: while (test) body.

Fields

test: Expr

body: Box<Stmt>

span: Option<Span>

Source location (populated by readers; ignored by writers).

For

For loop: for (init; test; update) body.

Fields

init: Option<Box<Stmt>>

test: Option<Expr>

update: Option<Expr>

body: Box<Stmt>

span: Option<Span>

Source location (populated by readers; ignored by writers).

ForIn

For-in/for-of loop: for (variable in/of iterable) body.

Fields

variable: String

iterable: Expr

body: Box<Stmt>

span: Option<Span>

Source location (populated by readers; ignored by writers).

Return(Option<Expr>)

Return statement: return expr.

Break

Break statement.

Continue

Continue statement.

TryCatch

Try/catch/finally statement.

Fields

body: Box<Stmt>

catch_param: Option<String>

catch_body: Option<Box<Stmt>>

finally_body: Option<Box<Stmt>>

span: Option<Span>

Source location (populated by readers; ignored by writers).

Function(Function)

Function declaration.

Import

Import statement: import { X, Y } from 'source' or import * as ns from 'source'.

names is empty for side-effect-only imports: import './side-effect'.

Fields

source: String

The module specifier string (e.g. "./module", "react").

names: Vec<ImportName>

Named/namespace/default specifiers. Empty means side-effect import.

span: Option<Span>

Source location (populated by readers; ignored by writers).

Export

Export statement: export { X, Y } or re-export: export { X } from 'source'.

Fields

names: Vec<ExportName>

Names being exported.

source: Option<String>

Source module for re-exports (e.g. "./other" in export { X } from './other').

span: Option<Span>

Source location (populated by readers; ignored by writers).

Class

Class definition: class Foo extends Bar { method() { ... } }.

Fields

name: String

Class name.

extends: Option<String>

Superclass name (e.g. "Bar" in class Foo extends Bar).

methods: Vec<Method>

Methods (including constructor).

span: Option<Span>

Source location (populated by readers; ignored by writers).

Destructure

Destructuring declaration: const { a, b: c } = obj or const [x, y] = arr.

The pattern captures the full structural binding; the mutable flag distinguishes let from const. Writers emit the appropriate destructuring syntax for the target language (TypeScript/JavaScript: const { a } = obj; Python: a, b = obj).

Fields

pat: Pat

The binding pattern.

value: Expr

The right-hand side expression.

mutable: bool

true for let (mutable), false for const.

span: Option<Span>

Source location (populated by readers; ignored by writers).

Comment

Comment (line or block). Used to preserve documentation comments during translation.

text is the raw comment text including delimiters (e.g. // foo, /* bar */, /** JSDoc */, -- Lua, --[[ block ]]). Writers emit the text verbatim so the correct delimiter style for the target language must be supplied by the writer.

For cross-language translation, use Stmt::comment_line(text) / Stmt::comment_block(text) which store only the content; writers format it according to the target language.

Fields

text: String

Comment content (without delimiters).

block: bool

Whether this was originally a block comment (/* */, --[[ ]]).

span: Option<Span>

Source location.

Implementations

impl Stmt

pub fn expr(e: Expr) -> Self

pub fn let_decl(name: impl Into<String>, init: Option<Expr>) -> Self

pub fn const_decl(name: impl Into<String>, init: Expr) -> Self

pub fn block(stmts: Vec<Stmt>) -> Self

pub fn if_stmt(test: Expr, consequent: Stmt, alternate: Option<Stmt>) -> Self

pub fn while_loop(test: Expr, body: Stmt) -> Self

pub fn for_loop( init: Option<Stmt>, test: Option<Expr>, update: Option<Expr>, body: Stmt, ) -> Self

pub fn for_in(variable: impl Into<String>, iterable: Expr, body: Stmt) -> Self

pub fn return_stmt(expr: Option<Expr>) -> Self

pub fn break_stmt() -> Self

pub fn continue_stmt() -> Self

pub fn try_catch( body: Stmt, catch_param: Option<String>, catch_body: Option<Stmt>, finally_body: Option<Stmt>, ) -> Self

pub fn function(f: Function) -> Self

pub fn import(source: impl Into<String>, names: Vec<ImportName>) -> Self

Create an import statement.

pub fn export(names: Vec<ExportName>, source: Option<String>) -> Self

Create an export statement.

pub fn class( name: impl Into<String>, extends: Option<String>, methods: Vec<Method>, ) -> Self

Create a class definition.

pub fn destructure(pat: Pat, value: Expr, mutable: bool) -> Self

Create a destructuring declaration.

pub fn comment_line(text: impl Into<String>) -> Self

Create a line comment from raw content (without // or -- delimiter).

pub fn comment_block(text: impl Into<String>) -> Self

Create a block comment from raw content (without /* */ or --[[ ]] delimiters).

pub fn with_span(self, span: Span) -> Self

Attach a source location span to this 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 Debug for Stmt

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Stmt

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

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

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructureEq for Stmt

fn structure_eq(&self, other: &Self) -> bool

Compare two values for structural equality.

impl StructuralPartialEq for Stmt