Method exec_call

compiler/src/modules/vm/handlers/function.rs:184–279

`Call` orchestrator. Only user `Func` callees build a fresh `fn_slots` and run the body inline; every other callee kind short-circuits in `try_dispatch_non_func_callable`. */

(&mut self, operand: u16, chunk: &SSAChunk, slots: &mut [Val])

    /* `Call` orchestrator. Only user `Func` callees build a fresh `fn_slots` and run the body inline; every other callee kind short-circuits in `try_dispatch_non_func_callable`. */
    pub(crate) fn exec_call(&mut self, operand: u16, chunk: &SSAChunk, slots: &mut [Val]) -> Result<(), VmErr> {
        let (positional, kw_flat, _num_pos, num_kw) = self.parse_call_args(operand)?;

        if self.depth >= self.max_calls { return Err(cold_depth()); }
        // Charge each call so wide recursion is op-budget bounded.
        self.charge_step()?;

        let callee = self.pop()?;
        if !callee.is_heap() { return Err(cold_type("object is not callable")); }

        if self.try_dispatch_non_func_callable(callee, &positional, &kw_flat, num_kw, chunk, slots)? {
            return Ok(());
        }

        // Snapshot defaults/captures once, both are tiny (<10), and cloning beats the 3+ heap re-reads later phases would do. Back-prop still uses `get_mut` since it writes.
        let (fi, defaults, captures) = match self.heap.get(callee) {
            HeapObj::Func(i, d, c) => (*i, d.clone(), c.clone()),
            _ => return Err(cold_type("object is not callable")),
        };

        // Pure-call memoisation. Disabled under impure outer frames (stale-view risk) or kwargs (cache key only spans positionals).
        let outer_impure = self.observed_impure.last().copied().unwrap_or(false);
        if num_kw == 0 && !outer_impure
            && let Some(cached) = self.templates.lookup(fi, &positional, &self.heap) {
                self.push(cached);
                return Ok(());
        }

        self.depth += 1;
        let (_params, body, _, _) = self.functions[fi];
        let mut fn_slots = self.slot_templates[fi].clone();

        self.bind_function_args(fi, &defaults, &captures, &positional, &kw_flat, &mut fn_slots)?;

        if self.needs_caller_slots[fi] {
            self.apply_caller_slot_propagation(fi, &captures, chunk, slots, &mut fn_slots);
        }

        self.bind_self_reference(fi, callee, &mut fn_slots);

        // Generator/coroutine: return a suspended Coroutine instead of running. Both flags are O(1).
        let is_async_fn = self.is_async.get(fi).copied().unwrap_or(false);
        if is_async_fn || body.is_generator {
            let coro = self.heap.alloc(HeapObj::Coroutine(0, fn_slots, Vec::new(), BodyRef::Fn(fi), Vec::new(), Vec::new(), Vec::new()))?;
            self.push(coro);
            self.depth -= 1;
            return Ok(());
        }

        // Snapshot caller-visible depths so we can split the helper's stack/iter/exception contributions out if it suspends mid-body via a yielding builtin.
        let stack_base = self.stack.len();
        let iter_base = self.iter_stack.len();
        let exc_base = self.exception_stack.len();
        let yields_before = self.yields.len();
        let (callee_impure, exec_result) = self.run_body_with_frame(fi, body, chunk, &mut fn_slots, slots);
        self.depth -= 1;

        self.back_propagate_nonlocals(fi, body, callee, chunk, slots, &fn_slots);