Struct BytecodeProgram 

pub struct BytecodeProgram {

    pub instructions: Vec<Instruction>,
    pub constants: Vec<Constant>,
    pub strings: Vec<String>,
    pub functions: Vec<Function>,
    pub debug_info: DebugInfo,
    pub data_schema: Option<DataFrameSchema>,
    pub module_binding_names: Vec<String>,
    pub top_level_locals_count: u16,
    pub top_level_local_storage_hints: Vec<StorageHint>,
    pub module_binding_storage_hints: Vec<StorageHint>,
    pub function_local_storage_hints: Vec<Vec<StorageHint>>,
    pub top_level_frame: Option<FrameDescriptor>,
    pub type_schema_registry: TypeSchemaRegistry,
    pub compiled_annotations: HashMap<String, CompiledAnnotation>,
    pub trait_method_symbols: HashMap<String, String>,
    pub expanded_function_defs: HashMap<String, FunctionDef>,
    pub string_index: HashMap<String, u32>,
    pub foreign_functions: Vec<ForeignFunctionEntry>,
    pub native_struct_layouts: Vec<NativeStructLayoutEntry>,
    pub content_addressed: Option<Program>,
    pub function_blob_hashes: Vec<Option<FunctionHash>>,
}

A compiled bytecode program

Fields

instructions: Vec<Instruction>

The bytecode instructions

constants: Vec<Constant>

Constant pool for literals

strings: Vec<String>

String pool for identifiers and properties

functions: Vec<Function>

Function table

debug_info: DebugInfo

Debug information (always present, used for error messages)

data_schema: Option<DataFrameSchema>

DataFrame schema for column name resolution (required for data access)

module_binding_names: Vec<String>

ModuleBinding variable names (index -> name mapping for REPL persistence)

top_level_locals_count: u16

Number of locals used by top-level code. The executor advances sp past this many slots before execution so that expression evaluation doesn’t overlap with local storage.

top_level_local_storage_hints: Vec<StorageHint>

Storage hints for top-level locals (index -> hint). Used by JIT lowering to preserve native width integer codegen.

module_binding_storage_hints: Vec<StorageHint>

Storage hints for module bindings (index -> hint).

function_local_storage_hints: Vec<Vec<StorageHint>>

Per-function local storage hints. function_local_storage_hints[f][local] is the hint for local slot in function f.

top_level_frame: Option<FrameDescriptor>

Typed frame layout for top-level locals.

When present, supersedes top_level_local_storage_hints for the JIT and VM. None means fall back to the legacy hints vec.

type_schema_registry: TypeSchemaRegistry

Type schema registry for TypedObject field resolution Used to convert TypedObject back to Object when needed

compiled_annotations: HashMap<String, CompiledAnnotation>

Compiled annotation definitions Maps annotation name to its compiled handlers

trait_method_symbols: HashMap<String, String>

Trait method dispatch registry: (trait, type, impl selector, method) -> compiled function symbol name.

This is populated by impl-block compilation and used by runtime dispatch (e.g. print() -> Display::display) without relying on symbol naming heuristics.

expanded_function_defs: HashMap<String, FunctionDef>

Final function definitions after comptime mutation/specialization.

This is a compile-time inspection artifact for tooling (e.g. shape --expand) and is not serialized into cached bytecode.

string_index: HashMap<String, u32>

Reverse index for O(1) string dedup during compilation. Maps string content → index in self.strings. Not serialized — rebuilt lazily on first intern_string call after deserialization.

foreign_functions: Vec<ForeignFunctionEntry>

Foreign function metadata table. Populated by the compiler when fn python ... blocks are compiled. Linked to language runtimes before execution.

native_struct_layouts: Vec<NativeStructLayoutEntry>

Native type C layout metadata table.

content_addressed: Option<Program>

Content-addressed program built alongside the flat bytecode.

When present, this contains per-function FunctionBlobs with content hashes. It is produced by the compiler as a dual-output alongside the traditional flat instruction array.

function_blob_hashes: Vec<Option<FunctionHash>>

Content hash for each function in functions, indexed by function ID.

This provides stable function identity without relying on function names. None entries indicate missing content-addressed metadata.

Implementations

impl BytecodeProgram

pub fn new() -> Self

Create a new empty program

pub fn add_constant(&mut self, constant: Constant) -> u16

Add a constant to the pool and return its index

pub fn add_string(&mut self, string: String) -> u16

Add a string to the pool and return its index. Uses the HashMap index for O(1) dedup.

pub fn intern_string(&mut self, s: &str) -> StringId

Intern a string and return a StringId for use in Operand::Name / Operand::MethodCall. Uses the HashMap index for O(1) dedup.

pub fn ensure_string_index(&mut self)

Ensure the string_index HashMap is populated. After deserialization, string_index is empty — rebuild it from the strings Vec.

pub fn resolve_string(&self, id: StringId) -> &str

Resolve a StringId back to a &str.

Panics if the id is out of bounds (indicates a compiler bug).

pub fn emit(&mut self, instruction: Instruction) -> usize

Add an instruction to the program

pub fn current_offset(&self) -> usize

Get the current instruction pointer

pub fn register_trait_method_symbol( &mut self, trait_name: &str, type_name: &str, impl_name: Option<&str>, method_name: &str, function_name: &str, )

Register a trait-method dispatch symbol.

pub fn lookup_trait_method_symbol( &self, trait_name: &str, type_name: &str, impl_name: Option<&str>, method_name: &str, ) -> Option<&str>

Resolve a trait-method dispatch symbol name.

pub fn named_trait_impls_for_method( &self, trait_name: &str, type_name: &str, method_name: &str, ) -> Vec<String>

List named impl selectors for a trait method on a specific type.

Excludes the default selector (__default__) and returns stable sorted names.

pub fn find_default_trait_impl_for_type_method( &self, type_name: &str, method_name: &str, ) -> Option<&str>

Find the default trait impl function for a given type and method (any trait).

Searches trait_method_symbols for any entry whose type and method match, preferring the default selector (__default__). Returns the compiled function symbol name if found.

This is used by method call dispatch to detect when a trait impl method exists for the receiver type, so that builtin functions with the same name don’t shadow it.

Trait Implementations

impl Clone for BytecodeProgram

fn clone(&self) -> BytecodeProgram

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BytecodeProgram

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

Formats the value using the given formatter.

impl Default for BytecodeProgram

fn default() -> BytecodeProgram

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for BytecodeProgram

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for BytecodeProgram

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

where __S: Serializer,

Serialize this value into the given Serde serializer.