Enum StatementKind 

pub enum StatementKind {
    VariableDeclaration {
        name: String,
        type_annotation: TypeAnnotation,
        value: ExprId,
    },
    ResolvedVariableDeclaration {
        name: String,
        slot: usize,
        type_annotation: TypeAnnotation,
        value: ExprId,
    },
    ConstantDeclaration {
        name: String,
        type_annotation: TypeAnnotation,
        value: ExprId,
    },
    ResolvedConstantDeclaration {
        name: String,
        slot: usize,
        type_annotation: TypeAnnotation,
        value: ExprId,
    },
    Array {
        name: String,
        type_annotation: TypeAnnotation,
        value: Vec<ExprId>,
    },
    ConstantArray {
        name: String,
        type_annotation: TypeAnnotation,
        value: Vec<ExprId>,
    },
    ResolvedArray {
        name: String,
        slot: usize,
        type_annotation: TypeAnnotation,
        value: ExprId,
    },
    ResolvedConstantArray {
        name: String,
        slot: usize,
        type_annotation: TypeAnnotation,
        value: ExprId,
    },
    Map {
        name: String,
        type_annotation: TypeAnnotation,
        entries: Vec<(ExprId, ExprId)>,
    },
    ConstantMap {
        name: String,
        type_annotation: TypeAnnotation,
        entries: Vec<(ExprId, ExprId)>,
    },
    ResolvedMap {
        name: String,
        slot: usize,
        type_annotation: TypeAnnotation,
        value: ExprId,
    },
    ResolvedConstantMap {
        name: String,
        slot: usize,
        type_annotation: TypeAnnotation,
        value: ExprId,
    },
    Set {
        name: String,
        type_annotation: TypeAnnotation,
        items: Vec<ExprId>,
    },
    ConstantSet {
        name: String,
        type_annotation: TypeAnnotation,
        items: Vec<ExprId>,
    },
    ResolvedSet {
        name: String,
        slot: usize,
        type_annotation: TypeAnnotation,
        value: ExprId,
    },
    ResolvedConstantSet {
        name: String,
        slot: usize,
        type_annotation: TypeAnnotation,
        value: ExprId,
    },
    Expression(ExprId),
    While {
        condition: ExprId,
        body: Vec<Statement>,
    },
    For {
        initializer: Box<Statement>,
        condition: ExprId,
        increment: ExprId,
        body: Vec<Statement>,
    },
    ResolvedFor {
        initializer: Box<Statement>,
        condition: ExprId,
        increment: ExprId,
        body: Vec<Statement>,
    },
    ForRange {
        variable: String,
        range: Box<Statement>,
        body: Vec<Statement>,
    },
    ResolvedForRange {
        slot: usize,
        variable: String,
        range: Box<Statement>,
        body: Vec<Statement>,
    },
    ForEach {
        variable: String,
        iterable: ExprId,
        body: Vec<Statement>,
    },
    ResolvedForEach {
        slot: usize,
        variable: String,
        iterable: ExprId,
        body: Vec<Statement>,
    },
    Range(Vec<i64>),
    ConditionalBranch {
        condition: Option<ExprId>,
        body: Vec<Statement>,
        needs_scope: bool,
    },
    Conditional {
        if_branch: Box<Statement>,
        else_branch: Option<Box<Statement>>,
    },
    FunctionDeclaration {
        name: String,
        params: Vec<Param>,
        return_type: TypeAnnotation,
        body: Vec<Statement>,
        attribute: Option<FunctionAttribute>,
    },
    ResolvedFunctionDeclaration {
        name: String,
        slot: usize,
        params: Vec<Param>,
        return_type: TypeAnnotation,
        body: Vec<Statement>,
        attribute: Option<FunctionAttribute>,
    },
    Return(Option<ExprId>),
    Break,
    Continue,
    Import {
        names: Vec<String>,
        path: Vec<String>,
    },
    ImportFile {
        path: Vec<String>,
    },
    ResolvedImportFile {
        path: Vec<String>,
        body: Vec<Statement>,
    },
    ImportFileNamed {
        path: Vec<String>,
        names: Vec<String>,
    },
    DestructureDeclaration {
        bindings: Vec<(TypeAnnotation, String)>,
        value: ExprId,
    },
    ResolvedDestructureDeclaration {
        bindings: Vec<(TypeAnnotation, String)>,
        slots: Vec<usize>,
        value: ExprId,
    },
    Match {
        value: ExprId,
        arms: Vec<(MatchPattern, Vec<Statement>)>,
    },
    RecordDeclaration {
        name: String,
        fields: Vec<(String, TypeAnnotation)>,
    },
    TagDeclaration {
        name: String,
        variants: Vec<String>,
    },
}

Variants

VariableDeclaration

A mutable variable declaration: dec T name = value.

Fields

name: String

type_annotation: TypeAnnotation

value: ExprId

ResolvedVariableDeclaration

Resolver-annotated mutable variable declaration. slot is the index in the current environment frame.

Fields

name: String

slot: usize

type_annotation: TypeAnnotation

value: ExprId

ConstantDeclaration

An immutable constant declaration: const T NAME = value.

Fields

name: String

type_annotation: TypeAnnotation

value: ExprId

ResolvedConstantDeclaration

Resolver-annotated constant declaration.

Fields

name: String

slot: usize

type_annotation: TypeAnnotation

value: ExprId

Array

A mutable array declaration with an inline literal: dec array[T] name = [items].

Fields

name: String

type_annotation: TypeAnnotation

value: Vec<ExprId>

ConstantArray

An immutable array declaration with an inline literal: const array[T] NAME = [items].

Fields

name: String

type_annotation: TypeAnnotation

value: Vec<ExprId>

ResolvedArray

Resolver-annotated mutable array declaration. value is the initialiser expression (may be an ExpressionKind::ArrayLiteral).

Fields

name: String

slot: usize

type_annotation: TypeAnnotation

value: ExprId

ResolvedConstantArray

Resolver-annotated constant array declaration.

Fields

name: String

slot: usize

type_annotation: TypeAnnotation

value: ExprId

Map

Fields

name: String

type_annotation: TypeAnnotation

entries: Vec<(ExprId, ExprId)>

ConstantMap

Fields

name: String

type_annotation: TypeAnnotation

entries: Vec<(ExprId, ExprId)>

ResolvedMap

Fields

name: String

slot: usize

type_annotation: TypeAnnotation

value: ExprId

ResolvedConstantMap

Fields

name: String

slot: usize

type_annotation: TypeAnnotation

value: ExprId

Set

Fields

name: String

type_annotation: TypeAnnotation

items: Vec<ExprId>

ConstantSet

Fields

name: String

type_annotation: TypeAnnotation

items: Vec<ExprId>

ResolvedSet

Fields

name: String

slot: usize

type_annotation: TypeAnnotation

value: ExprId

ResolvedConstantSet

Fields

name: String

slot: usize

type_annotation: TypeAnnotation

value: ExprId

Expression(ExprId)

A bare expression used as a statement (e.g. a function call whose return value is discarded, or a newline placeholder).

While

A while condition { body } loop.

Fields

condition: ExprId

body: Vec<Statement>

For

A C-style for [init, cond, incr] { body } loop.

Fields

initializer: Box<Statement>

condition: ExprId

increment: ExprId

body: Vec<Statement>

ResolvedFor

Resolver-annotated C-style for loop.

Fields

initializer: Box<Statement>

condition: ExprId

increment: ExprId

body: Vec<Statement>

ForRange

A range-based for x in N..M { body } loop. The range is pre-evaluated at parse time into a [Range] statement.

Fields

variable: String

range: Box<Statement>

body: Vec<Statement>

ResolvedForRange

Resolver-annotated range-based for loop. slot is the loop variable’s environment index.

Fields

slot: usize

variable: String

range: Box<Statement>

body: Vec<Statement>

ForEach

A foreach for item in iterable { body } loop over an array expression.

Fields

variable: String

iterable: ExprId

body: Vec<Statement>

ResolvedForEach

Resolver-annotated foreach loop.

Fields

slot: usize

variable: String

iterable: ExprId

body: Vec<Statement>

Range(Vec<i64>)

A pre-evaluated integer range produced by the parser for for x in N..M.

ConditionalBranch

A single branch of a conditional: either if condition { body } (condition is Some) or else { body } (condition is None).

Fields

condition: Option<ExprId>

body: Vec<Statement>

needs_scope: bool

Precomputed by the resolver true if body declares any local variable/constant and therefore needs its own scope frame

Conditional

A full if / else-if / else chain.

Fields

if_branch: Box<Statement>

else_branch: Option<Box<Statement>>

FunctionDeclaration

A named function declaration.

Fields

name: String

params: Vec<Param>

return_type: TypeAnnotation

body: Vec<Statement>

attribute: Option<FunctionAttribute>

true when the function is marked with !#[entry].

ResolvedFunctionDeclaration

Resolver-annotated function declaration. slot is the function’s index in the current environment frame.

Fields

name: String

slot: usize

params: Vec<Param>

return_type: TypeAnnotation

body: Vec<Statement>

attribute: Option<FunctionAttribute>

Return(Option<ExprId>)

A return expr or bare return statement.

Break

Breaks out of the nearest enclosing loop.

Continue

Skips to the next iteration of the nearest enclosing loop.

Import

A stdlib import: get std::ns::fn or get fn from std::ns.

Fields

names: Vec<String>

names of the imported functions

path: Vec<String>

module path (e.g. ["std", "math"])

ImportFile

A file module import: get mymodule or get mymodule::sub.

Fields

path: Vec<String>

ResolvedImportFile

A resolved file import - the imported file’s statements are inlined here.

Fields

path: Vec<String>

body: Vec<Statement>

ImportFileNamed

A named file import: get fn, fn from mymodule::sub.

Fields

path: Vec<String>

names: Vec<String>

DestructureDeclaration

Fields

bindings: Vec<(TypeAnnotation, String)>

value: ExprId

ResolvedDestructureDeclaration

Fields

bindings: Vec<(TypeAnnotation, String)>

slots: Vec<usize>

value: ExprId

Match

Fields

value: ExprId

arms: Vec<(MatchPattern, Vec<Statement>)>

RecordDeclaration

A record (struct) type declaration: record Name { int a, string b }.

Fields

name: String

fields: Vec<(String, TypeAnnotation)>

TagDeclaration

A tag (enum) type declaration: tag Name { VariantA, VariantB }.

Fields

name: String

variants: Vec<String>

Trait Implementations

impl Clone for StatementKind

fn clone(&self) -> StatementKind

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for StatementKind

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

Formats the value using the given formatter.

impl PartialEq for StatementKind

fn eq(&self, other: &StatementKind) -> 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 StatementKind