Enum Expr 

pub enum Expr {
    Float(f64),
    Int(i64),
    Bool(bool),
    Null,
    String(SmolStr),
    Var(SmolStr, Span),
    Array(Box<[Self]>, Box<[Span]>),
    Map(Box<[(Self, Span, Self, Span)]>, Span),
    Struct(Box<[SmolStr]>, Box<[(SmolStr, Self, Span, Span)]>, Span, Box<[TypeExpr]>, Option<Box<(StructRest, Span)>>),
    StructDeclare(SmolStr, Box<[(SmolStr, TypeExpr, Span)]>, Span, TypeParams, Box<[Option<(Self, Span)>]>),
    StructDefault(u16, Span),
    EnumDeclare(SmolStr, Box<[(SmolStr, Box<[TypeExpr]>, Span)]>, Span, TypeParams),
    NamespacedRef(Box<[SmolStr]>, Span, Box<[TypeExpr]>),
    Match(Box<Self>, Box<[(Box<[Self]>, Box<[Self]>)]>, Option<Box<[Self]>>, Span, bool),
    GetStructField(Box<Self>, SmolStr, Span, Span),
    SetStructField(Box<Self>, SmolStr, Box<Self>, Span, Span, Span),
    VarDeclare(SmolStr, Box<Self>, Option<Box<LetAnnotation>>),
    VarAssign(SmolStr, Box<Self>, Span, Span),
    Condition(Box<Self>, Box<[Self]>, Span, Span),
    InlineCondition(Box<Self>, Box<[Self]>, Span, Span),
    ElseIfBlock(Box<Self>, Box<[Self]>, Span),
    ElseBlock(Box<[Self]>),
    AnonymousFunction(Box<[SmolStr]>, Box<[Self]>, Span),
    WhileBlock(Box<Self>, Box<[Self]>, Span),
    FunctionCall(Box<[Self]>, Box<[SmolStr]>, Span, Box<[Span]>, Box<[TypeExpr]>),
    ObjFunctionCall(Box<Self>, Box<[Self]>, Box<[SmolStr]>, Span, Span, Box<[Span]>, Box<[TypeExpr]>),
    CallValue(Box<Self>, Box<[Self]>, Span, Box<[Span]>),
    FunctionDecl(SmolStr, Box<[(SmolStr, Option<TypeExpr>)]>, Rc<[Self]>, Span, ReturnAnnotation, TypeParams),
    ReturnVal(Box<Option<Self>>),
    ArrayGetIndex(Box<Self>, Box<Self>, Span),
    Propagate(Box<Self>, Span),
    Is(Box<Self>, Box<IsTarget>, Span, Span),
    Cast(Box<Self>, Box<TypeExpr>, Span, Span),
    ArrayGetSlice(Box<Self>, Box<Self>, Option<Box<Self>>, Span),
    ArrayModify(Box<Self>, Box<Self>, Box<Self>, Span, Span),
    ForLoop(SmolStr, Box<Self>, Box<[Self]>, Span),
    IntForLoop(SmolStr, Box<Self>, Box<Self>, Box<[Self]>, Span, Span),
    ImportDylib(SmolStr, Box<[(SmolStr, Box<[TypeExpr]>, TypeExpr, Span)]>, Span),
    HostBlock(SmolStr, Box<[(SmolStr, Box<[TypeExpr]>, TypeExpr, Span)]>, Span, Box<[Self]>),
    ImportFile(SmolStr, ImportBinding, bool, Span),
    Break,
    Continue,
    EvalBlock(Box<[Self]>),
    LoopBlock(Box<[Self]>),
    TryCatchBlock(Box<[Self]>, SmolStr, Box<[Self]>),
    Mul(Box<Self>, Box<Self>, Span, Span),
    Div(Box<Self>, Box<Self>, Span, Span),
    Add(Box<Self>, Box<Self>, Span, Span),
    Sub(Box<Self>, Box<Self>, Span, Span),
    Mod(Box<Self>, Box<Self>, Span, Span),
    Pow(Box<Self>, Box<Self>, Span, Span),
    BitAnd(Box<Self>, Box<Self>, Span, Span),
    BitOr(Box<Self>, Box<Self>, Span, Span),
    BitXor(Box<Self>, Box<Self>, Span, Span),
    Shl(Box<Self>, Box<Self>, Span, Span),
    Shr(Box<Self>, Box<Self>, Span, Span),
    BitNot(Box<Self>, Span, Span),
    Eq(Box<Self>, Box<Self>, Span, Span),
    NotEq(Box<Self>, Box<Self>, Span, Span),
    Sup(Box<Self>, Box<Self>, Span, Span),
    SupEq(Box<Self>, Box<Self>, Span, Span),
    Inf(Box<Self>, Box<Self>, Span, Span),
    InfEq(Box<Self>, Box<Self>, Span, Span),
    BoolAnd(Box<Self>, Box<Self>, Span, Span),
    BoolOr(Box<Self>, Box<Self>, Span, Span),
    BoolNeg(Box<Self>, Span, Span),
    Neg(Box<Self>, Span, Span),
}

Variants

Float(f64)

Int(i64)

Bool(bool)

Null

String(SmolStr)

Var(SmolStr, Span)

Array(Box<[Self]>, Box<[Span]>)

Array(contents, [entire_array, elem_spans…])

Map(Box<[(Self, Span, Self, Span)]>, Span)

Map(key-value pairs, span)

Struct(Box<[SmolStr]>, Box<[(SmolStr, Self, Span, Span)]>, Span, Box<[TypeExpr]>, Option<Box<(StructRest, Span)>>)

Struct(name, fields, span, type_args, base)

type_args holds the arguments of a generic struct literal (Cell<int>{ value: 3 }) and is empty otherwise. base is what a literal written with .. takes the fields it does not write from, ..base (Opts { cwd: "a", ..base }) or a bare .. for the struct’s default, with the span it was written at.

StructDeclare(SmolStr, Box<[(SmolStr, TypeExpr, Span)]>, Span, TypeParams, Box<[Option<(Self, Span)>]>)

StructDeclare(name, fields, span, type_params, defaults)

defaults holds the = value each field was declared with and the span it was written at, one entry per field, and is empty when no field declares one.

StructDefault(u16, Span)

StructDefault(struct_id, span)

The default value of a struct, by its id: what S::default() and a field of a struct type left to its default lower to. Built by the compiler, never by the parser.

EnumDeclare(SmolStr, Box<[(SmolStr, Box<[TypeExpr]>, Span)]>, Span, TypeParams)

EnumDeclare(name, variants: [(variant_name, payload_types, name_span)], span, type_params)

NamespacedRef(Box<[SmolStr]>, Span, Box<[TypeExpr]>)

NamespacedRef(path, span, type_args)

A bare namespaced identifier (Color::Red) with no call parentheses or struct braces. The only such form candela has is a nullary enum-variant construction; the compiler resolves it against the enum registry. type_args names the instantiation of a generic enum (Slot<int>::Empty) and is empty otherwise.

Match(Box<Self>, Box<[(Box<[Self]>, Box<[Self]>)]>, Option<Box<[Self]>>, Span, bool)

Match(scrutinee, arms: [(patterns, body)], wildcard_body, span, is_value)

The arm patterns are parsed as ordinary expressions; the compiler picks the lowering by the scrutinee’s static type. For an enum scrutinee each pattern is a variant pattern (Circle(r) binds the payload); otherwise each pattern is an equality test against the scrutinee. An arm holds one pattern per | alternative and runs when any of them matches.

is_value marks a match written where a value goes. Each of its bodies is one expression, the arm’s value, and it covers every case.

GetStructField(Box<Self>, SmolStr, Span, Span)

GetStructField(struct_expr, field, struct_span, field_span, value_span)

SetStructField(Box<Self>, SmolStr, Box<Self>, Span, Span, Span)

SetStructField(struct_expr, field, new_expr, struct_span, field_span, value_span)

VarDeclare(SmolStr, Box<Self>, Option<Box<LetAnnotation>>)

VarDeclare(name, value, annotation)

annotation is the type a let x: T = value; declares, None for a let written without one.

VarAssign(SmolStr, Box<Self>, Span, Span)

VarAssign(name, value, name_span, value_span)

Condition(Box<Self>, Box<[Self]>, Span, Span)

Condition(condition, code (contains else_if_blocks and potentially else_block), span, condition_span)

The condition carries its own span so a condition whose type is not bool is reported against the condition rather than the whole if.

InlineCondition(Box<Self>, Box<[Self]>, Span, Span)

InlineCondition - expression-form if/else, always produces a value, must have an else branch

ElseIfBlock(Box<Self>, Box<[Self]>, Span)

ElseIfBlock(condition, code, condition_span)

ElseBlock(Box<[Self]>)

AnonymousFunction(Box<[SmolStr]>, Box<[Self]>, Span)

AnonymousFunction(args, code, span)

WhileBlock(Box<Self>, Box<[Self]>, Span)

WhileBlock(condition, code, condition_span)

FunctionCall(Box<[Self]>, Box<[SmolStr]>, Span, Box<[Span]>, Box<[TypeExpr]>)

FunctionCall(args, (optional namespace + name), span, (arg_start,arg_end), type_args)

type_args holds the type arguments of a call written with them (first<int>(nums)) and is empty otherwise.

ObjFunctionCall(Box<Self>, Box<[Self]>, Box<[SmolStr]>, Span, Span, Box<[Span]>, Box<[TypeExpr]>)

ObjFunctionCall(obj, args, namespace, obj_span, fn_span, arg_markers, type_args)

type_args holds the type arguments a method call is written with (b.tagged<string>("hi")), which bind the method’s own type parameters, and is empty otherwise.

CallValue(Box<Self>, Box<[Self]>, Span, Box<[Span]>)

CallValue(callee, args, callee_span, arg_markers)

A call whose callee is an expression rather than a name: what another call handed back, an element of a list, a value read out of a map. The callee’s static Fn type names the function the same way the type of a let-bound closure does.

FunctionDecl(SmolStr, Box<[(SmolStr, Option<TypeExpr>)]>, Rc<[Self]>, Span, ReturnAnnotation, TypeParams)

FunctionDecl(name, args, code, name_span, return_type, type_params)

return_type carries the optional -> Type annotation together with the span of the annotation itself, which is what a mismatch between the declared and the returned type is reported against. type_params names the type parameters of a generic function (fn first<T>) and is empty otherwise.

ReturnVal(Box<Option<Self>>)

ArrayGetIndex(Box<Self>, Box<Self>, Span)

Propagate(Box<Self>, Span)

Propagate(operand, span)

operand?: the value inside a Some or an Ok, or an early return of the None or the Err from the function it is written in.

Is(Box<Self>, Box<IsTarget>, Span, Span)

Is(operand, target, operand_span, target_span)

operand is T tests the operand’s type and operand is Some(x) its variant; either is a bool. Where the test is known to hold (the body of an if or while it is the condition of, and the right of an && after it) a variable operand has the type tested for, and a variant test’s binders hold the payload.

Cast(Box<Self>, Box<TypeExpr>, Span, Span)

Cast(operand, type, operand_span, type_span)

operand as T: the operand, typed T, checked while the program runs where its static type does not already settle it. A value of another type raises bad_downcast.

ArrayGetSlice(Box<Self>, Box<Self>, Option<Box<Self>>, Span)

ArrayGetSlice(array, range_start, range_end, span)

range_end is None for an open-ended slice, a[i..], which runs to the end of the list or string.

ArrayModify(Box<Self>, Box<Self>, Box<Self>, Span, Span)

ForLoop(SmolStr, Box<Self>, Box<[Self]>, Span)

ForLoop(loop_var_name, loop_array+code, obj_markers)

IntForLoop(SmolStr, Box<Self>, Box<Self>, Box<[Self]>, Span, Span)

IntForLoop(loop_var_name, first_elem, final_elem, code)

ImportDylib(SmolStr, Box<[(SmolStr, Box<[TypeExpr]>, TypeExpr, Span)]>, Span)

ImportDylib(lib_path, [(fn_name, fn_args, fn_return_type, fn_name_span)], (start, end))

HostBlock(SmolStr, Box<[(SmolStr, Box<[TypeExpr]>, TypeExpr, Span)]>, Span, Box<[Self]>)

HostBlock(namespace, [(fn_name, fn_args, fn_return_type, fn_name_span)], (start, end), structs)

Declares a host namespace whose functions are backed by Rust closures registered on the embedding crate::Engine. Mirrors Self::ImportDylib but dispatches to a registered closure instead of a C symbol. structs holds the Self::StructDeclares the block declares, which a script names behind the namespace (process::StartOptions).

ImportFile(SmolStr, ImportBinding, bool, Span)

ImportFile(path, binding, is_logical, (start, end))

is_logical marks a library import (import "std/string";, an extensionless path): the resolver maps it straight to the shipped library directory and never looks source-relative. A .cdl file import (import "./local.cdl";) has is_logical false and resolves source-relative first. binding says what the import adds to the importing file’s scope; see ImportBinding.

Break

Continue

EvalBlock(Box<[Self]>)

LoopBlock(Box<[Self]>)

TryCatchBlock(Box<[Self]>, SmolStr, Box<[Self]>)

TryCatchBlock(try_code, err_var, catch_code)

Mul(Box<Self>, Box<Self>, Span, Span)

Div(Box<Self>, Box<Self>, Span, Span)

Add(Box<Self>, Box<Self>, Span, Span)

Sub(Box<Self>, Box<Self>, Span, Span)

Mod(Box<Self>, Box<Self>, Span, Span)

Pow(Box<Self>, Box<Self>, Span, Span)

BitAnd(Box<Self>, Box<Self>, Span, Span)

BitOr(Box<Self>, Box<Self>, Span, Span)

BitXor(Box<Self>, Box<Self>, Span, Span)

Shl(Box<Self>, Box<Self>, Span, Span)

Shr(Box<Self>, Box<Self>, Span, Span)

BitNot(Box<Self>, Span, Span)

Eq(Box<Self>, Box<Self>, Span, Span)

NotEq(Box<Self>, Box<Self>, Span, Span)

Sup(Box<Self>, Box<Self>, Span, Span)

SupEq(Box<Self>, Box<Self>, Span, Span)

Inf(Box<Self>, Box<Self>, Span, Span)

InfEq(Box<Self>, Box<Self>, Span, Span)

BoolAnd(Box<Self>, Box<Self>, Span, Span)

BoolOr(Box<Self>, Box<Self>, Span, Span)

BoolNeg(Box<Self>, Span, Span)

Neg(Box<Self>, Span, Span)

Implementations

impl Expr

pub fn infer_type( &self, v: &mut Vec<Variable>, ctx: Ctx, state: &mut State<'_>, ) -> DataType

Infers this expression’s static DataType without emitting code.

Panics

Panics when a call node carries an empty namespace path, which the parser never produces.

impl Expr

pub const fn is_value_only(&self) -> bool

Whether the only way to compile this form is as a value, so the register it lands in has to be read back.

Expr::compile takes a uses_id flag saying whether the caller reads the value produced, and the two answers reach different arms. A literal, a variable, an operator and a field read have a value arm and nothing else; a declaration, a loop, an assignment and a control-flow form have a statement arm and nothing else; a call has both, and its statement arm is the one that skips the result register. A form in the first group still compiles as a value when it stands alone as a statement, and the register is freed straight away.

The list is the arms of Expr::compile_with_code_context that open with debug_assert!(uses_id), and the two are kept in step by hand: an arm that gains or loses that assertion belongs here or leaves here in the same change, or a statement of that form stops on the assertion it no longer matches.

impl Expr

pub const fn is_constant_literal(&self) -> bool

pub fn compile( &self, v: &mut Vec<Variable>, ctx: Ctx, state: &mut State<'_>, output: &mut Vec<Instr>, tgt_id: Option<u16>, var_assignment: bool, uses_id: bool, ) -> Option<u16>

pub fn compile_with_code_context( &self, v: &mut Vec<Variable>, ctx: Ctx, state: &mut State<'_>, output: &mut Vec<Instr>, tgt_id: Option<u16>, var_assignment: bool, remaining_code: &[Self], uses_id: bool, ) -> Option<u16>

Trait Implementations

impl Clone for Expr

fn clone(&self) -> Expr

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Expr

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

Formats the value using the given formatter.

impl PartialEq for Expr

fn eq(&self, other: &Expr) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for Expr