Enum Statement 

pub enum Statement {
    Expression(Expression),
    Assignment {
        name: String,
        value: Expression,
    },
    GlobalAssignment {
        name: String,
        value: Expression,
    },
    InstanceAssignment {
        name: String,
        value: Expression,
    },
    ClassAssignment {
        name: String,
        value: Expression,
    },
    If {
        condition: Expression,
        then_branch: Vec<Statement>,
        else_branch: Vec<Statement>,
    },
    While {
        condition: Expression,
        body: Vec<Statement>,
    },
    Until {
        condition: Expression,
        body: Vec<Statement>,
    },
    Case {
        value: Expression,
        when_clauses: Vec<(Expression, Vec<Statement>)>,
        else_clause: Vec<Statement>,
    },
    For {
        variable: String,
        iterator: Expression,
        body: Vec<Statement>,
    },
    Break,
    Next,
    Redo,
    Return(Option<Expression>),
    MethodDefinition {
        name: String,
        parameters: Vec<String>,
        body: Vec<Statement>,
    },
    ClassDefinition {
        name: String,
        superclass: Option<String>,
        body: Vec<Statement>,
    },
    ModuleDefinition {
        name: String,
        body: Vec<Statement>,
    },
    Require(Expression),
    Load(Expression),
}

Statement types in the IR

Variants

Expression(Expression)

Expression statement

Assignment

Variable assignment

Fields

name: String

Variable name

value: Expression

Assignment value

GlobalAssignment

Global variable assignment

Fields

name: String

Global variable name

value: Expression

Assignment value

InstanceAssignment

Instance variable assignment

Fields

name: String

Instance variable name

value: Expression

Assignment value

ClassAssignment

Class variable assignment

Fields

name: String

Class variable name

value: Expression

Assignment value

If

If statement

Fields

condition: Expression

Condition expression

then_branch: Vec<Statement>

Then branch statements

else_branch: Vec<Statement>

Else branch statements

While

While loop

Fields

condition: Expression

Loop condition

body: Vec<Statement>

Loop body statements

Until

Until loop

Fields

condition: Expression

Loop condition

body: Vec<Statement>

Loop body statements

Case

Case statement

Fields

value: Expression

Value to match

when_clauses: Vec<(Expression, Vec<Statement>)>

When clauses (condition, body)

else_clause: Vec<Statement>

Else clause statements

For

For loop

Fields

variable: String

Loop variable

iterator: Expression

Iterator expression

body: Vec<Statement>

Loop body statements

Break

Break statement

Next

Next statement

Redo

Redo statement

Return(Option<Expression>)

Return statement

MethodDefinition

Method definition

Fields

name: String

Method name

parameters: Vec<String>

Method parameters

body: Vec<Statement>

Method body statements

ClassDefinition

Class definition

Fields

name: String

Class name

superclass: Option<String>

Superclass name

body: Vec<Statement>

Class body statements

ModuleDefinition

Module definition

Fields

name: String

Module name

body: Vec<Statement>

Module body statements

Require(Expression)

Require statement

Load(Expression)

Load statement

Trait Implementations

impl Clone for Statement

fn clone(&self) -> Statement

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Statement

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Statement

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Statement

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Statement