Struct Bytecode 

pub struct Bytecode {
    pub instructions: Instructions,
    pub constants: Vec<Value>,
    pub source_map: SourceMap,
    pub type_registry: Vec<TypeDef>,
}

Compiled bytecode output containing instructions and constants.

This represents the complete compiled program ready for execution by the virtual machine. The Bytecode struct is the interface between the compiler (which produces it) and the VM (which executes it).

Architecture

The bytecode uses a two-part structure:

1. Instruction Stream (instructions): A linear sequence of bytecode instructions that the VM executes. Each instruction consists of an opcode byte optionally followed by operand bytes.

2. Constant Pool (constants): An array of runtime values referenced by OpConstant instructions. The constant pool allows large or frequently-used values to be stored once and referenced by a compact 2-byte index.

Constant Pool Design

Constants are stored separately from instructions for several reasons:

• Space efficiency: A large integer like 999_999_999_999 is stored once in the constant pool, not embedded in every instruction that uses it.

• Fixed instruction size: OpConstant instructions are always 3 bytes (1 opcode + 2 index bytes), regardless of the size of the referenced value.

• Type flexibility: The constant pool can hold any Value type (integers, booleans, strings, arrays, functions) while the bytecode remains uniform.

Example

For the expression 1 + 2:

// Constant pool stores the actual values:
let constants = vec![
    Value::Integer(Integer::I64(1)),  // constants[0]
    Value::Integer(Integer::I64(2)),  // constants[1]
];

// Instructions reference constants by index:
let mut instructions = Instructions::new();
instructions.extend(&Instructions::from(encode(Opcode::Constant, &[0])));  // Push constants[0]
instructions.extend(&Instructions::from(encode(Opcode::Constant, &[1])));  // Push constants[1]
instructions.extend(&Instructions::from(encode(Opcode::Add, &[])));        // Add them
instructions.extend(&Instructions::from(encode(Opcode::Pop, &[])));        // Pop result

let bytecode = Bytecode { instructions, constants, source_map: Default::default(), type_registry: vec![] };

When executed by the VM:

1. OpConstant 0 pushes Value::I64(1) onto the stack
2. OpConstant 1 pushes Value::I64(2) onto the stack
3. OpAdd pops both values, adds them, and pushes Value::I64(3)
4. OpPop removes the result from the stack

Fields

instructions: Instructions

The sequence of bytecode instructions to execute.

Each instruction consists of an opcode byte optionally followed by operand bytes. Instructions are executed sequentially by the VM.

constants: Vec<Value>

The constant pool containing runtime values.

This array holds all constant values referenced by OpConstant instructions. The index into this array is encoded as a 2-byte operand (allowing up to 65,535 distinct constants).

source_map: SourceMap

Maps instruction byte offsets to source spans for error reporting.

type_registry: Vec<TypeDef>

Type definitions for user-defined structs and enums.

Registered at compile time and read by the VM for field access, struct construction, and pattern matching operations.

Implementations

impl Bytecode

pub fn serialize(&self) -> Result<Vec<u8>, SerializationError>

Serializes this bytecode to a binary representation.

The output can be written to a .mtc file and later restored with deserialize. The format consists of an 8-byte header (magic + version) followed by a postcard-encoded payload.

Errors

Returns an error if the constant pool contains value types that cannot be represented in the binary format (e.g., Builtin function pointers or tree-walking Function objects).

pub fn deserialize(bytes: &[u8]) -> Result<Self, SerializationError>

Deserializes bytecode from a binary representation produced by serialize.

Errors

Returns an error if the data is malformed, exceeds resource limits, or contains an unsupported format version.

Trait Implementations

impl Clone for Bytecode

fn clone(&self) -> Bytecode

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Bytecode

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Bytecode

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Bytecode

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Bytecode