Method dispatch

compiler/src/modules/vm/dispatch.rs:365–560

hot dispatcher; slices passed in to avoid re-unwrapping the cache

(&mut self, chunk: &SSAChunk, slots: &mut [Val], cache: &mut OpcodeCache, insns: &[Instruction], consts: &[Val], ip: &mut usize, exc_base: usize)

    #[inline]
    #[allow(clippy::too_many_arguments)] // hot dispatcher; slices passed in to avoid re-unwrapping the cache
    fn dispatch(&mut self, chunk: &SSAChunk, slots: &mut [Val], cache: &mut OpcodeCache, insns: &[Instruction], consts: &[Val], ip: &mut usize, exc_base: usize) -> Result<Option<Val>, VmErr> {
        let n = insns.len();
        let ins = insns[*ip];
        let rip = *ip;
        let op = ins.operand;
        *ip += 1;

        match ins.opcode {
            // Short-circuit jumps; instance `__bool__` / `__len__` may run via `truthy_op`.
            OpCode::JumpIfFalseOrPop => {
                let v = *self.stack.last().ok_or(cold_runtime("stack underflow"))?;
                if !self.truthy_op(v, chunk, slots)? { *ip = op as usize; }
                else { self.pop()?; }
            }
            OpCode::JumpIfTrueOrPop => {
                let v = *self.stack.last().ok_or(cold_runtime("stack underflow"))?;
                if self.truthy_op(v, chunk, slots)? { *ip = op as usize; }
                else { self.pop()?; }
            }

            // Hot opcodes.
            OpCode::LoadName => {
                // At module scope, module_state holds the live value so function `global` writes are visible.
                if core::ptr::eq(chunk, self.chunk)
                    && let Some(n) = chunk.names.get(op as usize)
                    && let Some(&gv) = self.module_state.get(ssa_strip(n))
                    && !gv.is_undef()
                {
                    self.push(gv);
                } else {
                    // Malformed bytecode can carry an out-of-range slot; treat it as unbound.
                    let v = slots.get(op as usize).copied().unwrap_or(Val::undef());
                    if v.is_undef() {
                        let name = chunk.names.get(op as usize).map(|n| ssa_strip(n)).unwrap_or_default();
                        return Err(VmErr::Name(name.into()));
                    }
                    self.push(v);
                }
            }
            OpCode::StoreName => {
                self.handle_store(op, slots)?;
                // Mirror entry-chunk stores into `module_state` so functions with `global X` see updates, and mirror Module values into `globals` so `import_module()` finds module aliases.
                if core::ptr::eq(chunk, self.chunk)
                    && let Some(name) = chunk.names.get(op as usize)
                {
                    let v = slots[op as usize];
                    let bare = ssa_strip(name).to_string();
                    self.module_state.insert(bare.clone(), v);
                    if v.is_heap() && matches!(self.heap.get(v), HeapObj::Module(..)) {
                        self.globals.insert(bare, v);
                    }
                }
            }
            OpCode::LoadGlobal => {
                let name = chunk.names.get(op as usize).ok_or(cold_runtime("LoadGlobal: name index out of bounds"))?;
                let v = self.module_state.get(name.as_str()).copied()
                    .or_else(|| self.globals.get(name.as_str()).copied())
                    .unwrap_or(Val::undef());