feat: 支持 to_string 与错误栈

crates/oxide_vm/src/bindings/bind_error.rs

@@ -1,5 +1,6 @@
 use std::sync::Arc;
 
+use crate::bind_constructor_hash;
 use oxide_kernel::builtin::ErrorMethods;
 use oxide_kernel::kernel::OxideKernel;
 use oxide_types::object::JsObject;
@@ -14,6 +15,8 @@ pub fn bind_error(kernel: &Arc<OxideKernel>, global: &mut JsObject) {
         syntax_error: crate::builtins::error::syntax_error_constructor as *const (),
         uri_error: crate::builtins::error::uri_error_constructor as *const (),
         eval_error: crate::builtins::error::eval_error_constructor as *const (),
+        to_string: crate::builtins::error::error_to_string as *const (),
+        stack: crate::builtins::error::error_stack_getter as *const (),
     };
     kernel.builtin_world().bind_error_methods(
         &error_methods,
@@ -29,6 +32,13 @@ pub fn bind_error(kernel: &Arc<OxideKernel>, global: &mut JsObject) {
     global.ensure_hash_props().push(Box::new(err_val));
     global.bump_generation();
 
+    bind_constructor_hash!(kernel, global, "TypeError", kernel.builtin_world().type_error_proto.as_ptr() as *mut JsObject, crate::builtins::error::type_error_constructor, 1);
+    bind_constructor_hash!(kernel, global, "ReferenceError", kernel.builtin_world().reference_error_proto.as_ptr() as *mut JsObject, crate::builtins::error::reference_error_constructor, 1);
+    bind_constructor_hash!(kernel, global, "RangeError", kernel.builtin_world().range_error_proto.as_ptr() as *mut JsObject, crate::builtins::error::range_error_constructor, 1);
+    bind_constructor_hash!(kernel, global, "SyntaxError", kernel.builtin_world().syntax_error_proto.as_ptr() as *mut JsObject, crate::builtins::error::syntax_error_constructor, 1);
+    bind_constructor_hash!(kernel, global, "URIError", kernel.builtin_world().uri_error_proto.as_ptr() as *mut JsObject, crate::builtins::error::uri_error_constructor, 1);
+    bind_constructor_hash!(kernel, global, "EvalError", kernel.builtin_world().eval_error_proto.as_ptr() as *mut JsObject, crate::builtins::error::eval_error_constructor, 1);
+
     {
         let err_ctor_ptr = kernel.builtin_world().error_constructor.as_ptr() as *mut JsObject;
         let err_ctor = unsafe { &mut *err_ctor_ptr };

crates/oxide_vm/src/bindings/bind_function.rs

@@ -8,6 +8,7 @@ pub fn bind_function(kernel: &Arc<OxideKernel>) {
         call: crate::builtins::function::function_call as *const (),
         apply: crate::builtins::function::function_apply as *const (),
         bind: crate::builtins::function::function_bind as *const (),
+        to_string: crate::builtins::function::function_to_string as *const (),
     };
     kernel.builtin_world().bind_function_methods(
         &function_methods,

crates/oxide_vm/src/bindings/bind_number.rs

@@ -14,6 +14,11 @@ pub fn bind_number(kernel: &Arc<OxideKernel>, global: &mut JsObject) {
         parse_float: crate::builtins::number::number_parse_float as *const (),
         to_string: crate::builtins::number::number_to_string as *const (),
         to_fixed: crate::builtins::number::number_to_fixed as *const (),
+        is_integer: crate::builtins::number::number_is_integer as *const (),
+        is_safe_integer: crate::builtins::number::number_is_safe_integer as *const (),
+        to_exponential: crate::builtins::number::number_to_exponential as *const (),
+        to_precision: crate::builtins::number::number_to_precision as *const (),
+        value_of: crate::builtins::number::number_value_of as *const (),
     };
     kernel.builtin_world().bind_number_methods(
         &number_methods,
@@ -37,6 +42,46 @@ pub fn bind_number(kernel: &Arc<OxideKernel>, global: &mut JsObject) {
             crate::builtins::number::number_constructor as *const (),
         ));
         num_ctor.set_native_arg_count(1);
+
+        num_ctor.ensure_hash_props().push(Box::new(JsValue::float(2.220446049250313e-16)));
+        let eps_si = kernel.string_forge().intern("EPSILON").0;
+        let _shape1 = kernel.shape_forge().make_shape(num_ctor.shape_id(), eps_si);
+        num_ctor.set_shape_id(_shape1);
+
+        num_ctor.ensure_hash_props().push(Box::new(JsValue::float(9007199254740991f64)));
+        let max_safe_si = kernel.string_forge().intern("MAX_SAFE_INTEGER").0;
+        let _shape2 = kernel.shape_forge().make_shape(num_ctor.shape_id(), max_safe_si);
+        num_ctor.set_shape_id(_shape2);
+
+        num_ctor.ensure_hash_props().push(Box::new(JsValue::float(-9007199254740991f64)));
+        let min_safe_si = kernel.string_forge().intern("MIN_SAFE_INTEGER").0;
+        let _shape3 = kernel.shape_forge().make_shape(num_ctor.shape_id(), min_safe_si);
+        num_ctor.set_shape_id(_shape3);
+
+        num_ctor.ensure_hash_props().push(Box::new(JsValue::float(1.7976931348623157e308)));
+        let max_val_si = kernel.string_forge().intern("MAX_VALUE").0;
+        let _shape4 = kernel.shape_forge().make_shape(num_ctor.shape_id(), max_val_si);
+        num_ctor.set_shape_id(_shape4);
+
+        num_ctor.ensure_hash_props().push(Box::new(JsValue::float(5e-324)));
+        let min_val_si = kernel.string_forge().intern("MIN_VALUE").0;
+        let _shape5 = kernel.shape_forge().make_shape(num_ctor.shape_id(), min_val_si);
+        num_ctor.set_shape_id(_shape5);
+
+        num_ctor.ensure_hash_props().push(Box::new(JsValue::float(f64::NAN)));
+        let nan_si = kernel.string_forge().intern("NaN").0;
+        let _shape6 = kernel.shape_forge().make_shape(num_ctor.shape_id(), nan_si);
+        num_ctor.set_shape_id(_shape6);
+
+        num_ctor.ensure_hash_props().push(Box::new(JsValue::float(f64::NEG_INFINITY)));
+        let neg_inf_si = kernel.string_forge().intern("NEGATIVE_INFINITY").0;
+        let _shape7 = kernel.shape_forge().make_shape(num_ctor.shape_id(), neg_inf_si);
+        num_ctor.set_shape_id(_shape7);
+
+        num_ctor.ensure_hash_props().push(Box::new(JsValue::float(f64::INFINITY)));
+        let pos_inf_si = kernel.string_forge().intern("POSITIVE_INFINITY").0;
+        let _shape8 = kernel.shape_forge().make_shape(num_ctor.shape_id(), pos_inf_si);
+        num_ctor.set_shape_id(_shape8);
     }
 
     let pi_fn = crate::builtins::number::number_parse_int as *const ();

crates/oxide_vm/src/builtins/error.rs

@@ -116,3 +116,31 @@ pub fn eval_error_constructor(vm: &mut Vm, args: &[u8]) -> NativeResult {
     let proto_ptr = P::as_ptr(&vm.kernel().builtin_world().eval_error_proto) as *mut JsObject;
     Ok(create_error_object(vm, proto_ptr, "EvalError", &msg))
 }
+
+pub fn error_to_string(vm: &mut Vm, args: &[u8]) -> NativeResult {
+    let this_val = vm.reg(args[0]);
+    let (name, msg) = if this_val.is_object() {
+        let obj = unsafe { &*this_val.as_js_object_ptr() };
+        let name_val = obj.hash_props_vec().and_then(|v| v.first()).map(|b| **b).unwrap_or(JsValue::undefined());
+        let msg_val = obj.hash_props_vec().and_then(|v| v.get(1)).map(|b| **b).unwrap_or(JsValue::undefined());
+        (vm.lookup_str(name_val).unwrap_or_else(|| "Error".to_string()),
+         vm.lookup_str(msg_val).unwrap_or_default())
+    } else {
+        ("Error".to_string(), String::new())
+    };
+    let result = if msg.is_empty() { name } else { format!("{}: {}", name, msg) };
+    let si = vm.kernel().string_forge().intern(&result).0;
+    Ok(JsValue::string(si, 0))
+}
+
+pub fn error_stack_getter(vm: &mut Vm, _args: &[u8]) -> NativeResult {
+    let mut lines = vec![];
+    for frame in vm.frames.iter().rev() {
+        let func_name = vm.kernel().string_forge().lookup(frame.function_name).unwrap_or_else(|| "<anonymous>".to_string());
+        lines.push(format!("    at {} (native)", func_name));
+    }
+    lines.push("    at <anonymous> (native)".to_string());
+    let result = lines.join("\n");
+    let si = vm.kernel().string_forge().intern(&result).0;
+    Ok(JsValue::string(si, 0))
+}

crates/oxide_vm/src/builtins/function.rs

@@ -158,3 +158,14 @@ pub fn function_bind(vm: &mut Vm, args: &[u8]) -> NativeResult {
 
     Ok(JsValue::from_js_object(wrapper))
 }
+
+pub fn function_to_string(vm: &mut Vm, args: &[u8]) -> NativeResult {
+    let name = vm.kernel().string_forge().lookup(vm.reg(args[0]).as_string_index()).unwrap_or_default();
+    let result = if name.is_empty() {
+        "function () { [native code] }".to_string()
+    } else {
+        format!("function {}() {{ [native code] }}", name)
+    };
+    let si = vm.kernel().string_forge().intern(&result).0;
+    Ok(JsValue::string(si, 0))
+}

crates/oxide_vm/src/builtins/number.rs

@@ -167,3 +167,50 @@ pub fn number_to_fixed(vm: &mut Vm, args: &[u8]) -> NativeResult {
     let formatted = format!("{:.digits$}", n);
     Ok(vm.intern(&formatted))
 }
+
+pub fn number_is_integer(vm: &mut Vm, args: &[u8]) -> NativeResult {
+    let val = vm.reg(if args.len() > 1 { args[1] } else { args[0] });
+    let n = coercion::to_number(val, vm.kernel().string_forge().as_ref());
+    Ok(JsValue::bool(n.trunc() == n && n.is_finite()))
+}
+
+pub fn number_is_safe_integer(vm: &mut Vm, args: &[u8]) -> NativeResult {
+    let val = vm.reg(if args.len() > 1 { args[1] } else { args[0] });
+    let n = coercion::to_number(val, vm.kernel().string_forge().as_ref());
+    let safe = n.trunc() == n && n.is_finite() && n >= -9007199254740991i64 as f64 && n <= 9007199254740991i64 as f64;
+    Ok(JsValue::bool(safe))
+}
+
+pub fn number_to_exponential(vm: &mut Vm, args: &[u8]) -> NativeResult {
+    let n = coercion::to_number(vm.reg(args[0]), vm.kernel().string_forge().as_ref());
+    let digits = if args.len() > 1 {
+        coercion::to_number(vm.reg(args[1]), vm.kernel().string_forge().as_ref()) as usize
+    } else { 0usize }.min(100);
+    if n.is_nan() { return Ok(vm.intern("NaN")); }
+    if n.is_infinite() {
+        return Ok(vm.intern(if n.is_sign_positive() { "Infinity" } else { "-Infinity" }));
+    }
+    let formatted = format!("{:.digits$e}", n);
+    Ok(vm.intern(&formatted))
+}
+
+pub fn number_to_precision(vm: &mut Vm, args: &[u8]) -> NativeResult {
+    let n = coercion::to_number(vm.reg(args[0]), vm.kernel().string_forge().as_ref());
+    let precision = if args.len() > 1 {
+        coercion::to_number(vm.reg(args[1]), vm.kernel().string_forge().as_ref()) as usize
+    } else { 0usize }.min(21);
+    if n.is_nan() { return Ok(vm.intern("NaN")); }
+    if n.is_infinite() {
+        return Ok(vm.intern(if n.is_sign_positive() { "Infinity" } else { "-Infinity" }));
+    }
+    let formatted = format!("{:.precision$}", n);
+    Ok(vm.intern(&formatted))
+}
+
+pub fn number_value_of(vm: &mut Vm, args: &[u8]) -> NativeResult {
+    let this_val = vm.reg(args[0]);
+    if this_val.is_int() || this_val.is_double() {
+        return Ok(this_val);
+    }
+    Ok(JsValue::float(f64::NAN))
+}

crates/oxide_vm/src/vm.rs

@@ -139,6 +139,7 @@ pub struct CallFrame {
     pub n_args: u8,
     pub function_obj_reg: u8,
     pub frame_base: u8,
+    pub function_name: u32,
 }
 
 pub struct ForInIter<'bump> {
@@ -729,6 +730,7 @@ impl Vm {
                                         n_args: sub_n_args as u8,
                                         function_obj_reg: callee_reg as u8,
                                         frame_base: sub_builtin_count as u8,
+                                        function_name: 0,
                                     });
 
                                     // Convert sub_module constants