Enum ExpressionKind 

pub enum ExpressionKind {
    Null,
    Integer(i64),
    Byte(u8),
    Binary {
        left: ExprId,
        operator: TokenType,
        right: ExprId,
    },
    Unary {
        operator: TokenType,
        operand: ExprId,
    },
    Grouping(ExprId),
    String(String),
    Bool(bool),
    Float(f64),
    Character(char),
    Identifier(String),
    ResolvedIdentifier {
        name: String,
        depth: usize,
        slot: usize,
    },
    ArrayLiteral(Vec<ExprId>),
    MapLiteral(Vec<(ExprId, ExprId)>),
    SetLiteral(Vec<ExprId>),
    Assign {
        name: String,
        value: ExprId,
    },
    ResolvedAssign {
        name: String,
        depth: usize,
        slot: usize,
        value: ExprId,
    },
    Call {
        path: Vec<String>,
        args: Vec<ExprId>,
    },
    MethodCall {
        caller: ExprId,
        method: Vec<String>,
        args: Vec<ExprId>,
    },
    Index {
        target: ExprId,
        index: ExprId,
    },
    IndexAssign {
        target: ExprId,
        index: ExprId,
        value: ExprId,
    },
    Lambda {
        params: Vec<Param>,
        return_type: Option<TypeAnnotation>,
        body: Vec<Statement>,
    },
    ResolvedLambda {
        params: Vec<Param>,
        return_type: Option<TypeAnnotation>,
        body: Vec<Statement>,
        capture_depth: usize,
    },
    CallExpr {
        callee: ExprId,
        args: Vec<ExprId>,
    },
    Cast {
        value: ExprId,
        target_type: TypeAnnotation,
    },
    TupleLiteral(Vec<ExprId>),
    ErrorLiteral(ExprId),
    OkLiteral(ExprId),
    ErrLiteral(ExprId),
    Propagate(ExprId),
    StructLiteral {
        name: String,
        fields: Vec<(String, ExprId)>,
    },
    FieldAccess {
        target: ExprId,
        field: String,
    },
    FieldAssign {
        target: ExprId,
        field: String,
        value: ExprId,
    },
    EnumVariant {
        enum_name: String,
        variant: String,
    },
}

Variants

Null

The null literal.

Integer(i64)

A 64-bit signed integer literal.

Byte(u8)

A byte literal (u8).

Binary

A binary operation: left operator right.

Fields

left: ExprId

operator: TokenType

right: ExprId

Unary

A unary prefix operation: operator operand.

Fields

operator: TokenType

operand: ExprId

Grouping(ExprId)

A parenthesised expression (expr) - preserves grouping in the AST.

String(String)

A string literal.

Bool(bool)

A boolean literal.

Float(f64)

A 64-bit float literal.

Character(char)

A character literal.

Identifier(String)

An unresolved variable or function reference by name. Replaced by [ResolvedIdentifier] after the resolver pass.

ResolvedIdentifier

A lexically-resolved variable reference. depth is the number of scopes to walk up; slot is the index within that scope.

Fields

name: String

depth: usize

slot: usize

ArrayLiteral(Vec<ExprId>)

An array literal [a, b, c].

MapLiteral(Vec<(ExprId, ExprId)>)

SetLiteral(Vec<ExprId>)

Assign

An unresolved variable assignment name = value. Replaced by [ResolvedAssign] after the resolver pass.

Fields

name: String

value: ExprId

ResolvedAssign

A lexically-resolved variable assignment.

Fields

name: String

depth: usize

slot: usize

value: ExprId

Call

A function call via a module path: std::io::println(args) or f(args).

Fields

path: Vec<String>

args: Vec<ExprId>

MethodCall

A method call chain: expr.method(args).

Fields

caller: ExprId

method: Vec<String>

args: Vec<ExprId>

Index

An index access: target[index].

Fields

target: ExprId

index: ExprId

IndexAssign

An index assignment: target[index] = value.

Fields

target: ExprId

index: ExprId

value: ExprId

Lambda

An unresolved anonymous function (lambda) expression. Replaced by [ResolvedLambda] after the resolver pass.

Fields

params: Vec<Param>

return_type: Option<TypeAnnotation>

body: Vec<Statement>

ResolvedLambda

A lexically-resolved lambda. capture_depth is the scope depth at the point of definition, used to correctly capture the enclosing environment.

Fields

params: Vec<Param>

return_type: Option<TypeAnnotation>

body: Vec<Statement>

capture_depth: usize

CallExpr

A call on an arbitrary callee expression, e.g. fns[0](args) or an immediately-invoked lambda.

Fields

callee: ExprId

args: Vec<ExprId>

Cast

A type cast expression value as type. Used for non-literal casts; literal casts are constant-folded in the parser.

Fields

value: ExprId

target_type: TypeAnnotation

TupleLiteral(Vec<ExprId>)

ErrorLiteral(ExprId)

OkLiteral(ExprId)

ErrLiteral(ExprId)

Propagate(ExprId)

StructLiteral

A record (struct) literal: Name { field: value, ... }.

Fields

name: String

fields: Vec<(String, ExprId)>

FieldAccess

A field access: target.field.

Fields

target: ExprId

field: String

FieldAssign

A field assignment: target.field = value.

Fields

target: ExprId

field: String

value: ExprId

EnumVariant

A tag (enum) variant reference: EnumName.Variant.

Fields

enum_name: String

variant: String

Trait Implementations

impl Clone for ExpressionKind

fn clone(&self) -> ExpressionKind

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ExpressionKind

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

Formats the value using the given formatter.

impl PartialEq for ExpressionKind

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