feat: 实现 new String 装箱构造 + String.prototype.toString，补齐 boxed primitives

crates/oxide_vm/src/bindings/bind_string.rs

@@ -1,5 +1,6 @@
 use std::sync::Arc;
 
+use crate::bindings::{apply_binding_table, configure_native_constructor};
 use oxide_kernel::builtin::StringMethods;
 use oxide_kernel::kernel::{KernelCore, KernelSession};
 use oxide_types::object::JsObject;
@@ -41,6 +42,19 @@ pub fn bind_string(core: &Arc<KernelCore>, session: &KernelSession, global: &mut
         core.shape_forge().as_ref(),
     );
 
+    let ctor_ptr = session.builtin_world().string_constructor.as_ptr() as *mut JsObject;
+    let ctor = unsafe { &mut *ctor_ptr };
+    configure_native_constructor(ctor, crate::builtins::string::string_constructor as *const (), 1);
+
+    let proto_ptr = session.builtin_world().string_proto.as_ptr() as *mut JsObject;
+    let proto = unsafe { &mut *proto_ptr };
+    apply_binding_table(
+        session.builtin_world(),
+        proto,
+        core,
+        &[("toString", crate::builtins::string::string_to_string as *const (), 0)],
+    );
+
     let si_str = core.string_forge().intern("String").0;
     let str_shape = core.shape_forge().make_shape(global.shape_id(), si_str);
     let str_val = JsValue::from_js_object(session.builtin_world().string_constructor.as_ptr() as *mut JsObject);

crates/oxide_vm/src/builtins/string.rs

@@ -44,6 +44,58 @@ pub fn string_value_of(vm: &mut Vm, args: &[u8]) -> NativeResult {
     ))
 }
 
+pub fn string_constructor(vm: &mut Vm, args: &[u8]) -> NativeResult {
+    let s = if args.len() > 1 {
+        coercion::to_string(vm.kernel_core().string_forge().as_ref(), vm.reg(args[1]))
+    } else {
+        String::new()
+    };
+    let str_val = vm.intern(&s);
+
+    let string_proto = vm.session().builtin_world().string_proto.as_ptr() as *mut JsObject;
+    let this_val = vm.reg(if args.is_empty() { 0 } else { args[0] });
+    let is_ctor = if this_val.is_object() {
+        let ptr = this_val.as_js_object_ptr();
+        if ptr.is_null() {
+            false
+        } else {
+            let proto_ptr = unsafe { (*ptr).proto().as_js_object_ptr() };
+            !proto_ptr.is_null() && std::ptr::eq(proto_ptr, string_proto)
+        }
+    } else {
+        false
+    };
+
+    if !is_ctor {
+        return NativeResult::Ok(str_val);
+    }
+
+    let obj = unsafe { &mut *this_val.as_js_object_ptr() };
+    obj.type_tag = JsObject::OBJ_TYPE_STRING_OBJ;
+    obj.push_prop(str_val);
+    NativeResult::Ok(this_val)
+}
+
+pub fn string_to_string(vm: &mut Vm, args: &[u8]) -> NativeResult {
+    let this_val = vm.reg(args[0]);
+    if this_val.is_string() {
+        return NativeResult::Ok(this_val);
+    }
+    if this_val.is_object() {
+        let ptr = this_val.as_js_object_ptr();
+        if !ptr.is_null() {
+            let obj = unsafe { &*ptr };
+            if obj.is_string_obj() {
+                return NativeResult::Ok(obj.get_prop_at(0));
+            }
+        }
+    }
+    NativeResult::Err(crate::builtins::error::create_type_error(
+        vm,
+        "String.prototype.toString called on non-String object",
+    ))
+}
+
 fn make_string_array(vm: &mut Vm, parts: &[String]) -> JsValue {
     let proto = vm.session().builtin_world().array_proto.as_ptr() as *mut JsObject;
     let n = parts.len();

crates/oxide_vm/tests/builtins_boolean_tests.rs

@@ -136,3 +136,16 @@ fn boolean_boxes_participate_in_numeric_coercion() {
     let r = eval(&mut vm, "new Boolean(false) | 0").unwrap();
     assert_eq!(r.as_int(), 0);
 }
+
+#[test]
+fn boxed_boolean_valueof_tostring_and_object_e2e() {
+    let mut vm = Vm::new();
+    assert!(!eval(&mut vm, "new Boolean(false).valueOf()").unwrap().as_bool());
+    assert!(eval(&mut vm, "new Boolean(1).valueOf()").unwrap().as_bool());
+
+    let t = eval(&mut vm, "new Boolean(false).toString()").unwrap();
+    assert_eq!(str_val(&vm, t), "false");
+
+    let ty = eval(&mut vm, "typeof new Boolean(true)").unwrap();
+    assert_eq!(str_val(&vm, ty), "object");
+}

crates/oxide_vm/tests/builtins_number_tests.rs

@@ -135,3 +135,28 @@ fn number_static_constants_remain_bound() {
     assert_eq!(eval(&mut vm, "Number.MAX_SAFE_INTEGER").unwrap().as_double(), 9007199254740991f64);
     assert!(eval(&mut vm, "Number.POSITIVE_INFINITY > 0").unwrap().as_bool());
 }
+
+#[test]
+fn boxed_number_valueof_preserves_int_and_float() {
+    let mut vm = Vm::new();
+    let i = eval(&mut vm, "new Number(5).valueOf()").unwrap();
+    assert!(i.is_int());
+    assert_eq!(i.as_int(), 5);
+
+    let f = eval(&mut vm, "new Number(1.5).valueOf()").unwrap();
+    assert!(f.is_double());
+    assert_eq!(f.as_double(), 1.5);
+
+    let s = eval(&mut vm, "new Number('7').valueOf()").unwrap();
+    assert_eq!(s.as_int(), 7);
+}
+
+#[test]
+fn boxed_number_is_object_and_call_stays_primitive() {
+    let mut vm = Vm::new();
+    let ty = eval(&mut vm, "typeof new Number(5)").unwrap();
+    assert_eq!(vm.kernel_core().string_forge().lookup(ty.as_string_index()).unwrap(), "object");
+
+    let n = eval(&mut vm, "Number('7')").unwrap();
+    assert_eq!(n.as_int(), 7);
+}

crates/oxide_vm/tests/builtins_string_tests.rs

@@ -240,3 +240,33 @@ fn string_replace_all() {
     let result = eval(&mut vm, "'aba'.replaceAll('a', 'c')").unwrap();
     assert_eq!(to_str(&vm, result), "cbc");
 }
+
+#[test]
+fn boxed_string_valueof_and_tostring() {
+    let mut vm = Vm::new();
+    let v = eval(&mut vm, "new String('abc').valueOf()").unwrap();
+    assert!(v.is_string());
+    assert_eq!(to_str(&vm, v), "abc");
+
+    let t = eval(&mut vm, "new String('abc').toString()").unwrap();
+    assert!(t.is_string());
+    assert_eq!(to_str(&vm, t), "abc");
+}
+
+#[test]
+fn boxed_string_is_object_and_empty_default() {
+    let mut vm = Vm::new();
+    let ty = eval(&mut vm, "typeof new String('x')").unwrap();
+    assert_eq!(to_str(&vm, ty), "object");
+
+    let empty = eval(&mut vm, "new String().valueOf()").unwrap();
+    assert_eq!(to_str(&vm, empty), "");
+}
+
+#[test]
+fn string_call_conversion_stays_primitive() {
+    let mut vm = Vm::new();
+    let v = eval(&mut vm, "String(123)").unwrap();
+    assert!(v.is_string());
+    assert_eq!(to_str(&vm, v), "123");
+}