Method exec_inst

compiler/src/modules/vm/dispatch.rs:95–131

(&mut self, inst: InstanceCache, chunk: &SSAChunk, slots: &mut [Val])

    /* Instance-dunder fast path. Guards the receiver's class identity, invokes the pre-resolved method bypassing `resolve_attr_silent`, and treats `NotImplemented` as a deopt so reflected dispatch can take over via the slow path. Restores the stack on miss so the slow handler reads its operands unchanged. */
    #[inline]
    fn exec_inst(&mut self, inst: InstanceCache, chunk: &SSAChunk, slots: &mut [Val]) -> Result<FastOutcome, VmErr> {
        let arity = inst.arity as usize;
        let len = self.stack.len();
        if len < arity { return Ok(FastOutcome::TypeMiss); }

        let recv_idx = len - arity;
        let recv = self.stack[recv_idx];
        if !recv.is_heap() { return Ok(FastOutcome::TypeMiss); }
        let class_val = match self.heap.get(recv) {
            HeapObj::Instance(c, _) => *c,
            _ => return Ok(FastOutcome::TypeMiss),
        };
        if class_val.as_heap() != inst.class { return Ok(FastOutcome::TypeMiss); }

        if self.depth >= self.max_calls { return Err(cold_depth()); }

        // Snapshot the operand window before mutating; reused to roll back on deopt.
        let mut operands: Vec<Val> = Vec::with_capacity(arity);
        operands.extend_from_slice(&self.stack[recv_idx..len]);
        self.stack.truncate(recv_idx);

        // SAFETY: `method_bits` was recorded from a live `Val` and `Class` references are immutable, so the function still lives on the heap.
        let method = unsafe { Val::from_raw(inst.method_bits) };
        self.pending.method_binding = Some((class_val, recv));
        self.push(method);
        for &v in &operands { self.push(v); }
        self.exec_call(arity as u16, chunk, slots)?;

        let result = self.pop()?;
        if self.heap.is_not_implemented(result) {
            // Deopt: restore the original stack window so the slow handler sees its operands.
            for &v in &operands { self.push(v); }
            return Ok(FastOutcome::TypeMiss);
        }
        self.push(result);
        Ok(FastOutcome::Done)
    }

    /* Post-success recording for the instance-dunder IC; ignored when the receiver isn't an instance or the method isn't on its class. */
    #[inline]