Struct Vm 

pub struct Vm<'p> { /* private fields */ }

Implementations

impl<'p> Vm<'p>

pub fn new(program: &'p CompiledProgram) -> Self

pub fn install_warm_bytecode(&mut self, fi: usize, fnbc: &FnBytecode) -> bool

Install a re-optimized body as function fi’s warm tier (HOTSWAP §7 / P11): append it to warm_code after program.code, rebasing its 0-relative jumps into that unified pc space, and point warm_entry[fi] at it. Subsequent calls to fi run this body. The body shares the program’s constant pool (a FnBytecode preserves constant indices), so only jumps are relocated.

pub fn with_native_tier(self, tier: &'p dyn NativeTier) -> Self

Install a native tier: hot functions in the integer subset run as JIT-compiled machine code, guarded per call (non-Int args deopt to the bytecode path).

pub fn install_aot_native(&mut self, fi: usize, nf: Box<dyn NativeFn>)

Pre-install an AOT-native function for fi (HOTSWAP §Axis-3): the VM dispatches to it via the existing NativeSlot::Ready path from the first call (it is not Untried, so it skips the hotness threshold and the forge compile). Requires a native tier to be installed (the dispatch is gated on self.tier); on desktop the forge tier is always present alongside. Absent ⇒ the function stays on VM+JIT — the AOT artifact is strictly optional, no gap at the seam.

pub fn with_bg_native_tier(self, tier: &'static dyn NativeTier) -> Self

Install the process tier AND a background compiler (HOTSWAP §6): hot functions are compiled on a worker thread instead of stalling the interpreter. The tier must be &'static (the process-installed forge backend) so it can cross to the worker — &'static dyn NativeTier is Send because NativeTier: Sync. The interpreter still runs the chains and is the sole FnTable writer; the worker only compiles. Falls back to Vm::with_native_tier (synchronous) for a borrowed &'p tier, which cannot be shared with a thread.

pub fn drain_pending_compiles(&mut self)

Block until every outstanding background compile has come back and been published — the determinism hook the differential tests use so the native tier engages predictably regardless of thread scheduling. No-op without a background compiler.

pub fn with_program_args(self, args: Vec<String>) -> Self

Supply the program arguments read by the args() system native. The vector is the full argv (index 0 is the program name), matching the compiled binary’s env::args().

pub fn with_policy_ctx( self, registry: &'p PolicyRegistry, interner: &'p Interner, ) -> Self

Provide the policy registry (and the interner its symbols live in) for Check statements.

pub fn lines(&self) -> &[String]

The output lines, one per Show.

pub fn output(&self) -> String

The output as one string (one trailing newline per Show).

pub fn into_lines(self) -> Vec<String>

Consume the VM, returning its output lines.

pub fn run(&mut self) -> Result<(), String>

Run the whole program to completion (the non-concurrent entry). A concurrent program never reaches here — it is driven through Vm::run_until_block by the scheduler.