Enum StmtKind 

pub enum StmtKind {
    Let {
        mutable: bool,
        pattern: Pattern,
        type_ann: Option<TypeAnn>,
        value: Expr,
    },
    ExprStmt {
        expr: Expr,
        has_semi: bool,
    },
    FnDecl {
        name: String,
        params: Vec<Param>,
        body: Vec<Stmt>,
    },
    For {
        pattern: Pattern,
        iter: Expr,
        body: Vec<Stmt>,
    },
    While {
        cond: Expr,
        body: Vec<Stmt>,
    },
    WhileLet {
        pattern: Pattern,
        expr: Expr,
        body: Vec<Stmt>,
    },
    Loop {
        body: Vec<Stmt>,
    },
    Break {
        value: Option<Expr>,
    },
    Continue,
    Use {
        path: Vec<String>,
        imports: UseImports,
    },
    Return {
        value: Option<Expr>,
    },
    Assign {
        target: AssignTarget,
        op: AssignOp,
        value: Expr,
    },
}

Variants

Let

let [mut] pattern [: type] = expr;

Fields

mutable: bool

pattern: Pattern

type_ann: Option<TypeAnn>

value: Expr

ExprStmt

Expression statement (with trailing semicolon = discards value)

Fields

expr: Expr

has_semi: bool

FnDecl

fn name(params) { body }

Fields

name: String

params: Vec<Param>

body: Vec<Stmt>

For

for pattern in expr { body }

Fields

pattern: Pattern

iter: Expr

body: Vec<Stmt>

While

while cond { body }

Fields

cond: Expr

body: Vec<Stmt>

WhileLet

while let pattern = expr { body }

Fields

pattern: Pattern

expr: Expr

body: Vec<Stmt>

Loop

loop { body }

Fields

body: Vec<Stmt>

Break

break [expr];

Fields

value: Option<Expr>

Continue

continue;

Use

use module::{name1, name2} or use module::*

Fields

path: Vec<String>

imports: UseImports

Return

return [expr];

Fields

value: Option<Expr>

Assign

Assignment: lhs = rhs; or lhs += rhs;

Fields

target: AssignTarget

op: AssignOp

value: Expr

Trait Implementations

impl Clone for StmtKind

fn clone(&self) -> StmtKind

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for StmtKind

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

Formats the value using the given formatter.