hakorune/src/backend/vm_instructions/extern_call.rs

use crate::backend::vm::ControlFlow;
use crate::backend::{VMError, VMValue, VM};
use crate::box_trait::NyashBox;
use crate::mir::ValueId;

impl VM {
    /// Execute ExternCall instruction
    pub(crate) fn execute_extern_call(
        &mut self,
        dst: Option<ValueId>,
        iface_name: &str,
        method_name: &str,
        args: &[ValueId],
    ) -> Result<ControlFlow, VMError> {
        // Core-13 pure shims: env.local.{get,set}, env.box.new
        match (iface_name, method_name) {
            ("env.local", "get") => {
                if args.len() != 1 {
                    return Err(VMError::InvalidInstruction("env.local.get arity".into()));
                }
                let ptr = args[0];
                let v = self
                    .get_value(ptr)
                    .unwrap_or(crate::backend::vm::VMValue::Void);
                if let Some(d) = dst {
                    self.set_value(d, v);
                }
                return Ok(ControlFlow::Continue);
            }
            ("env.local", "set") => {
                if args.len() != 2 {
                    return Err(VMError::InvalidInstruction("env.local.set arity".into()));
                }
                let ptr = args[0];
                let val = self.get_value(args[1])?;
                self.set_value(ptr, val);
                if let Some(d) = dst {
                    self.set_value(d, crate::backend::vm::VMValue::Void);
                }
                return Ok(ControlFlow::Continue);
            }
            ("env.box", "new") => {
                if args.is_empty() {
                    return Err(VMError::InvalidInstruction(
                        "env.box.new requires type name".into(),
                    ));
                }
                // first arg must be Const String type name
                let ty = self.get_value(args[0])?;
                let ty_name = match ty {
                    crate::backend::vm::VMValue::String(s) => s,
                    _ => {
                        return Err(VMError::InvalidInstruction(
                            "env.box.new first arg must be string".into(),
                        ))
                    }
                };
                // remaining args as NyashBox
                let mut ny_args: Vec<Box<dyn NyashBox>> = Vec::new();
                for id in args.iter().skip(1) {
                    let v = self.get_value(*id)?;
                    ny_args.push(v.to_nyash_box());
                }
                let reg = crate::runtime::box_registry::get_global_registry();
                match reg.create_box(&ty_name, &ny_args) {
                    Ok(b) => {
                        if let Some(d) = dst {
                            self.set_value(d, crate::backend::vm::VMValue::from_nyash_box(b));
                        }
                    }
                    Err(e) => {
                        return Err(VMError::InvalidInstruction(format!(
                            "env.box.new failed for {}: {}",
                            ty_name, e
                        )));
                    }
                }
                return Ok(ControlFlow::Continue);
            }
            _ => {}
        }
        // Optional routing to name→slot handlers for stability and diagnostics
        if crate::config::env::extern_route_slots() {
            if let Some(slot) =
                crate::runtime::extern_registry::resolve_slot(iface_name, method_name)
            {
                // Decode args to VMValue as needed by handlers below
                let vm_args: Vec<VMValue> = args
                    .iter()
                    .filter_map(|a| self.get_value(*a).ok())
                    .collect();
                match (iface_name, method_name, slot) {
                    ("env.local", "get", 40) => {
                        if let Some(d) = dst {
                            if let Some(a0) = args.get(0) {
                                let v = self.get_value(*a0).unwrap_or(VMValue::Void);
                                self.set_value(d, v);
                            }
                        }
                        return Ok(ControlFlow::Continue);
                    }
                    ("env.local", "set", 41) => {
                        if args.len() >= 2 {
                            let ptr = args[0];
                            let val = vm_args.get(1).cloned().unwrap_or(VMValue::Void);
                            self.set_value(ptr, val);
                        }
                        if let Some(d) = dst {
                            self.set_value(d, VMValue::Void);
                        }
                        return Ok(ControlFlow::Continue);
                    }
                    ("env.box", "new", 50) => {
                        if vm_args.is_empty() {
                            return Err(VMError::InvalidInstruction(
                                "env.box.new requires type".into(),
                            ));
                        }
                        let ty = &vm_args[0];
                        let ty_name = match ty {
                            VMValue::String(s) => s.clone(),
                            _ => {
                                return Err(VMError::InvalidInstruction(
                                    "env.box.new first arg must be string".into(),
                                ))
                            }
                        };
                        let mut ny_args: Vec<Box<dyn NyashBox>> = Vec::new();
                        for v in vm_args.iter().skip(1) {
                            ny_args.push(v.to_nyash_box());
                        }
                        let reg = crate::runtime::box_registry::get_global_registry();
                        match reg.create_box(&ty_name, &ny_args) {
                            Ok(b) => {
                                if let Some(d) = dst {
                                    self.set_value(d, VMValue::from_nyash_box(b));
                                }
                            }
                            Err(e) => {
                                return Err(VMError::InvalidInstruction(format!(
                                    "env.box.new failed for {}: {}",
                                    ty_name, e
                                )));
                            }
                        }
                        return Ok(ControlFlow::Continue);
                    }
                    ("env.console", m @ ("log" | "warn" | "error" | "println"), 10) => {
                        if let Some(a0) = vm_args.get(0) {
                            match m {
                                "warn" => eprintln!("[warn] {}", a0.to_string()),
                                "error" => eprintln!("[error] {}", a0.to_string()),
                                _ => println!("{}", a0.to_string()),
                            }
                        }
                        if let Some(d) = dst {
                            self.set_value(d, VMValue::Void);
                        }
                        return Ok(ControlFlow::Continue);
                    }
                    ("env.debug", "trace", 11) => {
                        if let Some(a0) = vm_args.get(0) {
                            eprintln!("[trace] {}", a0.to_string());
                        }
                        if let Some(d) = dst {
                            self.set_value(d, VMValue::Void);
                        }
                        return Ok(ControlFlow::Continue);
                    }
                    ("env.runtime", "checkpoint", 12) => {
                        if crate::config::env::runtime_checkpoint_trace() {
                            let (func, bb, pc) = self.gc_site_info();
                            eprintln!("[rt] checkpoint @{} bb={} pc={}", func, bb, pc);
                        }
                        self.runtime.gc.safepoint();
                        if let Some(s) = &self.runtime.scheduler {
                            s.poll();
                        }
                        if let Some(d) = dst {
                            self.set_value(d, VMValue::Void);
                        }
                        return Ok(ControlFlow::Continue);
                    }
                    ("env.future", "new", 20) | ("env.future", "birth", 20) => {
                        // Create a new Future and optionally set initial value from arg0
                        let fut = crate::boxes::future::FutureBox::new();
                        if let Some(a0) = vm_args.get(0) {
                            fut.set_result(a0.to_nyash_box());
                        }
                        if let Some(d) = dst {
                            self.set_value(d, VMValue::Future(fut));
                        }
                        return Ok(ControlFlow::Continue);
                    }
                    ("env.future", "set", 21) => {
                        // set(future, value)
                        if vm_args.len() >= 2 {
                            if let VMValue::Future(f) = &vm_args[0] {
                                f.set_result(vm_args[1].to_nyash_box());
                            }
                        }
                        if let Some(d) = dst {
                            self.set_value(d, VMValue::Void);
                        }
                        return Ok(ControlFlow::Continue);
                    }
                    ("env.future", "await", 22) => {
                        if let Some(VMValue::Future(fb)) = vm_args.get(0) {
                            // Simple blocking await
                            let start = std::time::Instant::now();
                            let max_ms = crate::config::env::await_max_ms();
                            while !fb.ready() {
                                std::thread::yield_now();
                                if start.elapsed() >= std::time::Duration::from_millis(max_ms) {
                                    break;
                                }
                            }
                            let result = if fb.ready() {
                                fb.get()
                            } else {
                                Box::new(crate::box_trait::StringBox::new("Timeout"))
                            };
                            let ok = crate::boxes::result::NyashResultBox::new_ok(result);
                            if let Some(d) = dst {
                                self.set_value(d, VMValue::from_nyash_box(Box::new(ok)));
                            }
                        } else if let Some(d) = dst {
                            self.set_value(d, VMValue::Void);
                        }
                        return Ok(ControlFlow::Continue);
                    }
                    ("env.task", "cancelCurrent", 30) => {
                        if let Some(d) = dst {
                            self.set_value(d, VMValue::Void);
                        }
                        return Ok(ControlFlow::Continue);
                    }
                    ("env.task", "currentToken", 31) => {
                        if let Some(d) = dst {
                            self.set_value(d, VMValue::Integer(0));
                        }
                        return Ok(ControlFlow::Continue);
                    }
                    ("env.task", "yieldNow", 32) => {
                        std::thread::yield_now();
                        if let Some(d) = dst {
                            self.set_value(d, VMValue::Void);
                        }
                        return Ok(ControlFlow::Continue);
                    }
                    ("env.task", "sleepMs", 33) => {
                        let ms = vm_args
                            .get(0)
                            .map(|v| match v {
                                VMValue::Integer(i) => *i,
                                _ => 0,
                            })
                            .unwrap_or(0);
                        if ms > 0 {
                            std::thread::sleep(std::time::Duration::from_millis(ms as u64));
                        }
                        if let Some(d) = dst {
                            self.set_value(d, VMValue::Void);
                        }
                        return Ok(ControlFlow::Continue);
                    }
                    _ => { /* fallthrough to host */ }
                }
            }
            // Name-route minimal registry without slot
            // env.modules.set(key:any->string, value:any) ; env.modules.get(key) -> any
            match (iface_name, method_name) {
                ("env.modules", "set") => {
                    // Expect two args
                    let vm_args: Vec<VMValue> = args
                        .iter()
                        .filter_map(|a| self.get_value(*a).ok())
                        .collect();
                    if vm_args.len() >= 2 {
                        let key = vm_args[0].to_string();
                        let val_box = vm_args[1].to_nyash_box();
                        crate::runtime::modules_registry::set(key, val_box);
                    }
                    if let Some(d) = dst {
                        self.set_value(d, VMValue::Void);
                    }
                    return Ok(ControlFlow::Continue);
                }
                ("env.modules", "get") => {
                    let vm_args: Vec<VMValue> = args
                        .iter()
                        .filter_map(|a| self.get_value(*a).ok())
                        .collect();
                    if let Some(k) = vm_args.get(0) {
                        let key = k.to_string();
                        if let Some(v) = crate::runtime::modules_registry::get(&key) {
                            if let Some(d) = dst {
                                self.set_value(d, VMValue::from_nyash_box(v));
                            } else { /* no dst */
                            }
                        } else if let Some(d) = dst {
                            self.set_value(d, VMValue::Void);
                        }
                    } else if let Some(d) = dst {
                        self.set_value(d, VMValue::Void);
                    }
                    return Ok(ControlFlow::Continue);
                }
                _ => {}
            }
        }

        // Name-route minimal registry even when slot routing is disabled
        if iface_name == "env.modules" {
            // Decode args as VMValue for convenience
            let vm_args: Vec<VMValue> = args
                .iter()
                .filter_map(|a| self.get_value(*a).ok())
                .collect();
            match method_name {
                "set" => {
                    if vm_args.len() >= 2 {
                        let key = vm_args[0].to_string();
                        let val_box = vm_args[1].to_nyash_box();
                        crate::runtime::modules_registry::set(key, val_box);
                    }
                    if let Some(d) = dst {
                        self.set_value(d, VMValue::Void);
                    }
                    return Ok(ControlFlow::Continue);
                }
                "get" => {
                    if let Some(k) = vm_args.get(0) {
                        let key = k.to_string();
                        if let Some(v) = crate::runtime::modules_registry::get(&key) {
                            if let Some(d) = dst {
                                self.set_value(d, VMValue::from_nyash_box(v));
                            }
                        } else if let Some(d) = dst {
                            self.set_value(d, VMValue::Void);
                        }
                    } else if let Some(d) = dst {
                        self.set_value(d, VMValue::Void);
                    }
                    return Ok(ControlFlow::Continue);
                }
                _ => {}
            }
        }

        // Evaluate arguments as NyashBox for loader
        let mut nyash_args: Vec<Box<dyn NyashBox>> = Vec::new();
        for arg_id in args {
            let arg_value = self.get_value(*arg_id)?;
            nyash_args.push(arg_value.to_nyash_box());
        }

        if crate::config::env::extern_trace() {
            if let Some(slot) =
                crate::runtime::extern_registry::resolve_slot(iface_name, method_name)
            {
                eprintln!(
                    "[EXT] call {}.{} slot={} argc={}",
                    iface_name,
                    method_name,
                    slot,
                    nyash_args.len()
                );
            } else {
                eprintln!(
                    "[EXT] call {}.{} argc={}",
                    iface_name,
                    method_name,
                    nyash_args.len()
                );
            }
        }
        let host = crate::runtime::get_global_plugin_host();
        let host = host
            .read()
            .map_err(|_| VMError::InvalidInstruction("Plugin host lock poisoned".into()))?;
        match host.extern_call(iface_name, method_name, &nyash_args) {
            Ok(Some(result_box)) => {
                if let Some(dst_id) = dst {
                    self.set_value(dst_id, VMValue::from_nyash_box(result_box));
                }
            }
            Ok(None) => {
                if let Some(dst_id) = dst {
                    self.set_value(dst_id, VMValue::Void);
                }
            }
            Err(_) => {
                let strict =
                    crate::config::env::extern_strict() || crate::config::env::abi_strict();
                let mut msg = String::new();
                if strict {
                    msg.push_str("ExternCall STRICT: unregistered or unsupported call ");
                } else {
                    msg.push_str("ExternCall failed: ");
                }
                msg.push_str(&format!("{}.{}", iface_name, method_name));
                if let Err(detail) = crate::runtime::extern_registry::check_arity(
                    iface_name,
                    method_name,
                    nyash_args.len(),
                ) {
                    msg.push_str(&format!(" ({})", detail));
                }
                if let Some(spec) =
                    crate::runtime::extern_registry::resolve(iface_name, method_name)
                {
                    msg.push_str(&format!(
                        " (expected arity {}..{})",
                        spec.min_arity, spec.max_arity
                    ));
                } else {
                    let known = crate::runtime::extern_registry::known_for_iface(iface_name);
                    if !known.is_empty() {
                        msg.push_str(&format!("; known methods: {}", known.join(", ")));
                    } else {
                        let ifaces = crate::runtime::extern_registry::all_ifaces();
                        msg.push_str(&format!("; known interfaces: {}", ifaces.join(", ")));
                    }
                }
                return Err(VMError::InvalidInstruction(msg));
            }
        }
        Ok(ControlFlow::Continue)
    }
}