Function dispatch_call

compiler/src/main/abi_bridge.rs:42–69

(recv_h: u32, name: &str, args: &[Val])

}

fn dispatch_call(recv_h: u32, name: &str, args: &[Val]) -> Result<Val, VmErr> {
    with_recv("edge_op call: invalid receiver handle", recv_h, |vm, recv| {
        // `__call__` means "invoke `recv` as a callable", letting plugins forward arbitrary Python hooks (lambdas, builtins, classes) through `Handle::call("__call__", args)`. Pushes args + callee then drives `exec_call` so every callable kind (`Extern`, `NativeFn`, `Func`, `BoundMethod`, `Class`, ...) routes through the same dispatch path the VM uses normally. Empty caller-slots are fine because lambdas/hooks that escape a plugin call cannot reference caller-frame locals, they can still capture their own defining scope through the regular Func captures vector.
        if name == "__call__" {
            // Stack layout for `Call`: callee at the bottom, then positional args (top is the rightmost). `parse_call_args` pops args first, then `exec_call` pops the callee.
            let stack_before = vm.stack.len();
            vm.stack.push(recv);
            for a in args { vm.stack.push(*a); }
            let operand = args.len() as u16; // (num_kw<<8)|num_pos; no kwargs from FFI hooks.
            let chunk: &crate::modules::parser::SSAChunk = unsafe { &*(vm.chunk as *const _) };
            let mut empty_slots: [Val; 0] = [];
            vm.exec_call(operand, chunk, &mut empty_slots)?;
            if vm.stack.len() != stack_before + 1 {
                return Err(VmErr::Runtime("edge_op call(__call__): callable left no result"));
            }
            return vm.stack.pop().ok_or(VmErr::Runtime("edge_op call(__call__): stack drained"));
        }
        let ty = vm.type_name(recv);
        let mid = lookup_method(ty, name).ok_or_else(|| VmErr::Attribute(s!("'", str ty, "' object has no method '", str name, "'")))?;
        let stack_before = vm.stack.len();
        dispatch_method(vm, mid, recv, args, &[])?;
        if vm.stack.len() != stack_before + 1 {
            return Err(VmErr::Runtime("edge_op call: method left no result"));
        }
        // The length check above guarantees a value is present; `ok_or` keeps the FFI boundary panic-free if a future change drops the invariant.
        vm.stack.pop().ok_or(VmErr::Runtime("edge_op call: stack drained mid-dispatch"))
    })
}

/* GetAttr: module/instance attr, or bind builtin method as BoundMethod. */
fn dispatch_get_attr(recv_h: u32, name: &str) -> Result<Val, VmErr> {