From 9a36d76544cebe83487e67e8916e83219b5d634b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E7=88=B1=E7=89=B9=E6=AF=8F=E7=BE=8A=E9=98=9F?= Date: Tue, 23 Jun 2026 22:33:37 +0800 Subject: [PATCH] =?UTF-8?q?feat:=20=E5=AE=9E=E7=8E=B0=20new=20String=20?= =?UTF-8?q?=E8=A3=85=E7=AE=B1=E6=9E=84=E9=80=A0=20+=20String.prototype.toS?= =?UTF-8?q?tring=EF=BC=8C=E8=A1=A5=E9=BD=90=20boxed=20primitives?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- crates/oxide_vm/src/bindings/bind_string.rs | 14 +++++ crates/oxide_vm/src/builtins/string.rs | 52 +++++++++++++++++++ .../oxide_vm/tests/builtins_boolean_tests.rs | 13 +++++ .../oxide_vm/tests/builtins_number_tests.rs | 25 +++++++++ .../oxide_vm/tests/builtins_string_tests.rs | 30 +++++++++++ 5 files changed, 134 insertions(+) diff --git a/crates/oxide_vm/src/bindings/bind_string.rs b/crates/oxide_vm/src/bindings/bind_string.rs index 39dc721..cbd70b1 100644 --- a/crates/oxide_vm/src/bindings/bind_string.rs +++ b/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, 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); diff --git a/crates/oxide_vm/src/builtins/string.rs b/crates/oxide_vm/src/builtins/string.rs index 229e159..862b384 100644 --- a/crates/oxide_vm/src/builtins/string.rs +++ b/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(); diff --git a/crates/oxide_vm/tests/builtins_boolean_tests.rs b/crates/oxide_vm/tests/builtins_boolean_tests.rs index 12031ac..c5b6e8b 100644 --- a/crates/oxide_vm/tests/builtins_boolean_tests.rs +++ b/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"); +} diff --git a/crates/oxide_vm/tests/builtins_number_tests.rs b/crates/oxide_vm/tests/builtins_number_tests.rs index a63e95d..824bec2 100644 --- a/crates/oxide_vm/tests/builtins_number_tests.rs +++ b/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); +} diff --git a/crates/oxide_vm/tests/builtins_string_tests.rs b/crates/oxide_vm/tests/builtins_string_tests.rs index 9f60597..bd1be7c 100644 --- a/crates/oxide_vm/tests/builtins_string_tests.rs +++ b/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"); +}