Struct CompiledProgram 

pub struct CompiledProgram {
    pub constants: Vec<Constant>,
    pub code: Vec<Op>,
    pub register_count: usize,
    pub functions: Vec<CompiledFunction>,
    pub fn_index: HashMap<Symbol, u16>,
    pub globals: Vec<String>,
    pub named_regs: Vec<bool>,
    pub loop_locals: HashMap<usize, Vec<bool>>,
    pub reg_names: Vec<(u16, String)>,
    pub struct_types: Vec<StructTypeDef>,
    pub enum_types: Vec<EnumTypeDef>,
    pub global_types: Vec<Option<BoundaryType>>,
}

A compiled program: the constant pool, the linear bytecode (Main first, then every function body), the size of Main’s register frame, and the function table (indexed by FuncIdx, with a name → index map for call resolution).

Fields

constants: Vec<Constant>

code: Vec<Op>

register_count: usize

functions: Vec<CompiledFunction>

fn_index: HashMap<Symbol, u16>

globals: Vec<String>

Names of the promoted globals (Main top-level bindings referenced from function/closure bodies), for “Undefined variable” errors.

named_regs: Vec<bool>

Which Main-frame registers carry a user-visible NAME (Let targets, loop variables). Everything else is a statement-local scratch — dead at every statement boundary by the allocator’s recycling discipline — so the region JIT neither writes it back nor preserves its pre-state.

loop_locals: HashMap<usize, Vec<bool>>

loop_locals[head] = the registers bound INSIDE the loop whose region head (back-edge target) is the absolute pc head — names lexically dead the moment that loop exits. The region JIT subtracts these from the write-back set, so copy-prop/CSE/fusion can treat them as true scratch. Keyed by absolute pc (one code array); valued by the head’s OWNING frame’s register indices (Main or the enclosing function).

reg_names: Vec<(u16, String)>

DEBUG-ONLY: Main-frame register index → source variable name, populated only by the debugger’s compile path (crate::vm::Compiler::compile_for_debug). Empty on every production build, so the runtime pays nothing; it just lets the Studio debug drawer show x instead of R0.

struct_types: Vec<StructTypeDef>

The program’s struct type definitions (name → field layout), resolved at compile time. The bytecode’s static type registry — the dynamically-typed tree-walker/VM never needed it, but a statically-typed consumer (the AOT backend) addresses a struct’s fields through it.

enum_types: Vec<EnumTypeDef>

The program’s enum type definitions (name → per-variant payload layout), resolved at compile time — the sum-type companion to struct_types. Lets the AOT backend type a When V (binds) payload extraction on an enum whose construction isn’t in scope (an enum PARAMETER).

global_types: Vec<Option<BoundaryType>>

Each promoted GLOBAL’s resolved composite type (by global index; None for scalar / self-describing / unmodeled). Lets the AOT type a closure that CAPTURES a composite global with the value’s shape — the capture analog of a parameter’s declared type.

Trait Implementations

impl Clone for CompiledProgram

fn clone(&self) -> CompiledProgram

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CompiledProgram

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

Formats the value using the given formatter.

impl Default for CompiledProgram

fn default() -> CompiledProgram

Returns the “default value” for a type.