feat: 添加 ArrayBuffer 全局构造器

crates/oxide_vm/src/bindings/bind_array_buffer.rs

@@ -0,0 +1,42 @@
+use std::sync::Arc;
+
+use crate::bind_constructor_hash;
+use crate::bindings::{apply_binding_table, configure_native_constructor};
+use oxide_kernel::kernel::{KernelCore, KernelSession};
+use oxide_types::object::JsObject;
+
+pub fn bind_array_buffer(core: &Arc<KernelCore>, session: &KernelSession, global: &mut JsObject) {
+    let ctor_ptr = session.builtin_world().array_buffer_constructor.as_ptr() as *mut JsObject;
+    let ctor = unsafe { &mut *ctor_ptr };
+    let proto_ptr = session.builtin_world().array_buffer_proto.as_ptr() as *mut JsObject;
+    let proto = unsafe { &mut *proto_ptr };
+
+    configure_native_constructor(ctor, crate::builtins::array_buffer::array_buffer_constructor as *const (), 1);
+
+    apply_binding_table(
+        session.builtin_world(),
+        ctor,
+        core,
+        &[("isView", crate::builtins::array_buffer::array_buffer_is_view as *const (), 1)],
+    );
+
+    apply_binding_table(
+        session.builtin_world(),
+        proto,
+        core,
+        &[
+            ("byteLength", crate::builtins::array_buffer::array_buffer_byte_length as *const (), 0),
+            ("slice", crate::builtins::array_buffer::array_buffer_slice as *const (), 2),
+            ("toString", crate::builtins::array_buffer::array_buffer_to_string as *const (), 0),
+        ],
+    );
+
+    bind_constructor_hash!(
+        core,
+        global,
+        "ArrayBuffer",
+        ctor_ptr,
+        crate::builtins::array_buffer::array_buffer_constructor,
+        1
+    );
+}

crates/oxide_vm/src/bindings/mod.rs

@@ -1,4 +1,5 @@
 pub mod bind_array;
+pub mod bind_array_buffer;
 pub mod bind_boolean;
 pub mod bind_date;
 pub mod bind_error;
@@ -87,6 +88,7 @@ pub fn init_kernel_builtins(core: &Arc<KernelCore>, session: &mut KernelSession)
 
     bind_object::bind_object(core, session, global);
     bind_array::bind_array(core, session, global);
+    bind_array_buffer::bind_array_buffer(core, session, global);
     bind_error::bind_error(core, session, global);
     bind_string::bind_string(core, session, global);
     bind_number::bind_number(core, session, global);

crates/oxide_vm/src/builtins/array_buffer.rs

@@ -0,0 +1,148 @@
+use oxide_kernel::shape_forge::EMPTY_SHAPE_ID;
+use oxide_types::object::{JsObject, NativeFnPtr, PropAttributes};
+use oxide_types::value::JsValue;
+
+use crate::coercion;
+use crate::native::NativeResult;
+use crate::vm::Vm;
+
+const MAX_ARRAY_BUFFER_LENGTH: usize = 1 << 30;
+
+macro_rules! native_try {
+    ($expr:expr) => {
+        match $expr {
+            Ok(value) => value,
+            Err(err) => return NativeResult::Err(err),
+        }
+    };
+}
+
+fn type_error(vm: &mut Vm, msg: &str) -> NativeResult {
+    NativeResult::Err(crate::builtins::error::create_type_error(vm, msg))
+}
+
+fn to_index(vm: &mut Vm, value: JsValue) -> Result<usize, JsValue> {
+    let n = coercion::to_number(value, vm.kernel_core().string_forge().as_ref());
+    if n.is_nan() {
+        return Ok(0);
+    }
+    if !n.is_finite() || n < 0.0 || n > MAX_ARRAY_BUFFER_LENGTH as f64 {
+        return Err(crate::builtins::error::create_range_error(vm, "invalid ArrayBuffer length"));
+    }
+    Ok(n.trunc() as usize)
+}
+
+fn normalize_index(vm: &mut Vm, value: JsValue, len: usize) -> usize {
+    let n = coercion::to_number(value, vm.kernel_core().string_forge().as_ref());
+    if n.is_nan() {
+        return 0;
+    }
+    let int = n.trunc() as isize;
+    if int < 0 {
+        len.saturating_sub((-int) as usize)
+    } else {
+        (int as usize).min(len)
+    }
+}
+
+fn set_named_prop(vm: &mut Vm, obj: &mut JsObject, name: &str, value: JsValue, attributes: PropAttributes) {
+    let si = vm.kernel_core().string_forge().intern(name).0;
+    let _ = vm.define_data_property(obj, si, value, attributes);
+}
+
+fn new_array_buffer(vm: &mut Vm, data: Vec<u8>) -> *mut JsObject {
+    let proto = vm.session().builtin_world().array_buffer_proto.as_ptr() as *mut JsObject;
+    let mut obj = JsObject::new_empty(EMPTY_SHAPE_ID, JsValue::from_js_object(proto));
+    obj.type_tag = JsObject::OBJ_TYPE_ARRAY_BUFFER;
+    let len = data.len();
+    let data_ptr = Box::into_raw(Box::new(data));
+    // SAFETY: ArrayBuffer objects are not callable, so their native_fn slot is reused
+    // as an opaque Box<Vec<u8>> pointer, matching the existing RegExp storage pattern.
+    obj.set_native_fn(Some(unsafe { NativeFnPtr::from_raw(data_ptr as *const ()) }));
+    set_named_prop(
+        vm,
+        &mut obj,
+        "byteLength",
+        JsValue::int(len as i32),
+        PropAttributes::new(false, false, false),
+    );
+    vm.epoch().alloc(obj)
+}
+
+pub(crate) fn array_buffer_data_ptr(vm: &mut Vm, this_val: JsValue) -> Result<*mut Vec<u8>, JsValue> {
+    if !this_val.is_object() {
+        return Err(crate::builtins::error::create_type_error(
+            vm,
+            "ArrayBuffer method called on incompatible receiver",
+        ));
+    }
+    let obj_ptr = this_val.as_js_object_ptr();
+    if obj_ptr.is_null() {
+        return Err(crate::builtins::error::create_type_error(vm, "ArrayBuffer internal state invalid"));
+    }
+    let obj = unsafe { &*obj_ptr };
+    if !obj.is_array_buffer_obj() {
+        return Err(crate::builtins::error::create_type_error(
+            vm,
+            "ArrayBuffer method called on incompatible receiver",
+        ));
+    }
+    let Some(data_ptr) = obj.native_fn() else {
+        return Err(crate::builtins::error::create_type_error(vm, "ArrayBuffer internal state invalid"));
+    };
+    let data_ptr = data_ptr.as_ptr() as *mut Vec<u8>;
+    if data_ptr.is_null() {
+        return Err(crate::builtins::error::create_type_error(vm, "ArrayBuffer internal state invalid"));
+    }
+    Ok(data_ptr)
+}
+
+pub fn array_buffer_constructor(vm: &mut Vm, args: &[u8]) -> NativeResult {
+    let length = if args.len() > 1 {
+        match to_index(vm, vm.reg(args[1])) {
+            Ok(length) => length,
+            Err(err) => return NativeResult::Err(err),
+        }
+    } else {
+        0
+    };
+    NativeResult::Ok(JsValue::from_js_object(new_array_buffer(vm, vec![0; length])))
+}
+
+pub fn array_buffer_byte_length(vm: &mut Vm, args: &[u8]) -> NativeResult {
+    let this_val = vm.reg(if args.is_empty() { 0 } else { args[0] });
+    let data_ptr = native_try!(array_buffer_data_ptr(vm, this_val));
+    NativeResult::Ok(JsValue::int(unsafe { (*data_ptr).len() } as i32))
+}
+
+pub fn array_buffer_slice(vm: &mut Vm, args: &[u8]) -> NativeResult {
+    let this_val = vm.reg(if args.is_empty() { 0 } else { args[0] });
+    let data_ptr = native_try!(array_buffer_data_ptr(vm, this_val));
+    let data = unsafe { &*data_ptr };
+    let len = data.len();
+    let start = if args.len() > 1 { normalize_index(vm, vm.reg(args[1]), len) } else { 0 };
+    let end = if args.len() > 2 { normalize_index(vm, vm.reg(args[2]), len) } else { len };
+    let end = end.max(start);
+    NativeResult::Ok(JsValue::from_js_object(new_array_buffer(vm, data[start..end].to_vec())))
+}
+
+pub fn array_buffer_is_view(vm: &mut Vm, args: &[u8]) -> NativeResult {
+    let value = if args.len() > 1 { vm.reg(args[1]) } else { JsValue::undefined() };
+    if !value.is_object() {
+        return NativeResult::Ok(JsValue::bool(false));
+    }
+    let ptr = value.as_js_object_ptr();
+    if ptr.is_null() {
+        return NativeResult::Ok(JsValue::bool(false));
+    }
+    let obj = unsafe { &*ptr };
+    NativeResult::Ok(JsValue::bool(obj.is_data_view_obj() || obj.is_typed_array_obj()))
+}
+
+pub fn array_buffer_to_string(vm: &mut Vm, args: &[u8]) -> NativeResult {
+    let this_val = vm.reg(if args.is_empty() { 0 } else { args[0] });
+    if array_buffer_data_ptr(vm, this_val).is_err() {
+        return type_error(vm, "ArrayBuffer.prototype.toString called on incompatible receiver");
+    }
+    NativeResult::Ok(vm.intern("[object ArrayBuffer]"))
+}

crates/oxide_vm/src/builtins/mod.rs

@@ -1,4 +1,5 @@
 pub mod array;
+pub mod array_buffer;
 pub mod boolean;
 pub mod date;
 pub mod error;

crates/oxide_vm/tests/builtins_array_buffer_tests.rs

@@ -0,0 +1,75 @@
+use oxide_compiler::compiler::Compiler;
+use oxide_types::value::JsValue;
+use oxide_vm::vm::Vm;
+
+fn eval(vm: &mut Vm, source: &str) -> Result<JsValue, String> {
+    let allocator = oxide_parser::Allocator::default();
+    let program = oxide_parser::parse(&allocator, source).map_err(|e| format!("Parse error: {:?}", e))?;
+    let module = Compiler::new().compile(&program).map_err(|e| format!("Compile error: {}", e))?;
+    vm.run(&module)
+}
+
+fn to_str(vm: &Vm, val: JsValue) -> String {
+    vm.kernel_core()
+        .string_forge()
+        .lookup(val.as_string_index())
+        .unwrap_or_default()
+}
+
+#[test]
+fn array_buffer_global_and_static_method_exist() {
+    let mut vm = Vm::new();
+    let result =
+        eval(&mut vm, "typeof ArrayBuffer === 'function' && typeof ArrayBuffer.isView === 'function'").unwrap();
+    assert!(result.as_bool());
+}
+
+#[test]
+fn array_buffer_constructor_sets_byte_length_property() {
+    let mut vm = Vm::new();
+    let result = eval(&mut vm, "var buf = new ArrayBuffer(8); buf.byteLength").unwrap();
+    assert_eq!(result.as_int(), 8);
+}
+
+#[test]
+fn array_buffer_slice_returns_copied_buffer_with_length() {
+    let mut vm = Vm::new();
+    let result = eval(&mut vm, "var buf = new ArrayBuffer(8); var slice = buf.slice(2, 6); slice.byteLength").unwrap();
+    assert_eq!(result.as_int(), 4);
+}
+
+#[test]
+fn array_buffer_slice_normalizes_negative_indices() {
+    let mut vm = Vm::new();
+    let result = eval(
+        &mut vm,
+        "var buf = new ArrayBuffer(8); var start = -4; var end = -1; buf.slice(start, end).byteLength",
+    )
+    .unwrap();
+    assert_eq!(result.as_int(), 3);
+}
+
+#[test]
+fn array_buffer_is_view_returns_false_for_buffer_and_plain_object() {
+    let mut vm = Vm::new();
+    let result = eval(
+        &mut vm,
+        "var buf = new ArrayBuffer(8); ArrayBuffer.isView(buf) === false && ArrayBuffer.isView({}) === false",
+    )
+    .unwrap();
+    assert!(result.as_bool());
+}
+
+#[test]
+fn array_buffer_negative_length_throws_range_error() {
+    let mut vm = Vm::new();
+    let result = eval(&mut vm, "try { new ArrayBuffer(-1) } catch (e) { e instanceof RangeError }").unwrap();
+    assert!(result.as_bool());
+}
+
+#[test]
+fn array_buffer_to_string_is_identifiable() {
+    let mut vm = Vm::new();
+    let result = eval(&mut vm, "var buf = new ArrayBuffer(1); buf.toString()").unwrap();
+    assert_eq!(to_str(&vm, result), "[object ArrayBuffer]");
+}