Struct CompiledFunction 

pub struct CompiledFunction {
    pub name: Symbol,
    pub entry_pc: usize,
    pub param_count: u16,
    pub register_count: usize,
    pub captures: Vec<(Symbol, Option<u16>)>,
    pub named_regs: Vec<bool>,
    pub param_kinds: Vec<Option<ParamKind>>,
    pub ret_kind: Option<SlotKind>,
    pub param_types: Vec<Option<BoundaryType>>,
    pub return_type: Option<BoundaryType>,
    pub mutable_param_regs: Vec<Reg>,
    pub cow_exempt_regs: Vec<Reg>,
}

A compiled user function (or closure body). All bodies share the program’s single code vector; entry_pc is where this one begins. A closure body’s frame layout is [params… , capture values… , capture-present flags…].

Fields

name: Symbol

entry_pc: usize

param_count: u16

register_count: usize

captures: Vec<(Symbol, Option<u16>)>

Capture list for a closure body (empty for plain functions), in frame order. Each entry: the captured name and, when that name is a promoted global, its global index (the live-fallback source).

named_regs: Vec<bool>

Which of THIS frame’s registers carry a user-visible name (params, captures, Let targets, loop variables) — the region JIT’s observability map for loops tiering up inside this function.

param_kinds: Vec<Option<ParamKind>>

DECLARED parameter kinds: scalars (x: Float) ride i64 slots, Seq of <scalar> pins at the boundary; None for types native code cannot represent (Map, Text, nested Seq, …). Closures (no declarations) default to all-Int — exactly the old entry-guard contract.

ret_kind: Option<SlotKind>

Declared return kind; None falls back to the adapter’s Int/Bool return inference.

param_types: Vec<Option<BoundaryType>>

Each parameter’s FULL declared type, resolved at compile time (None for a closure body — no declarations — or a type the resolver does not model). Unlike param_kinds (a scalar/list performance hint for the native tier), this carries struct/Text/etc. so a statically-typed consumer can type a f(p: Point) / f(s: Text) parameter from the bytecode alone.

return_type: Option<BoundaryType>

The function’s FULL declared RETURN type, resolved at compile time (None if undeclared or unmodeled). Carries struct/map/enum/etc. so a caller can type the inline use of a returned composite (item k of f(), Inspect f()) the same way a parameter of that type is typed.

mutable_param_regs: Vec<Reg>

Argument registers retained on return so an in-out call can copy the final values back to the caller. Includes inferred mutable-borrow slots.

cow_exempt_regs: Vec<Reg>

Registers proven to be consumed-and-returned borrows. Only these may bypass copy-on-write; an explicit mutable parameter may make local copies.

Trait Implementations

impl Clone for CompiledFunction

fn clone(&self) -> CompiledFunction

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CompiledFunction

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

Formats the value using the given formatter.