Implement SharedArrayBuffer, Atomics and refactor TypedArray native methods

- Refactor src/js_typedarray.rs to use Value based arguments for native handlers
- Implement SharedArrayBuffer constructor and prototype with byteLength accessor
- Implement Atomics object and methods including wait/notify
- Update TypedArray and DataView prototypes to use Value::Property getters
- Add accessor handlers for ArrayBuffer and TypedArray properties
- Integrate Atomics and accessor dispatch in src/core/eval.rs

Author: ssrlive

js-scripts/sharedarraybuffer_final.js

@@ -0,0 +1,68 @@
+
+try {
+    console.log("Testing SharedArrayBuffer...");
+    let sab = new SharedArrayBuffer(1024);
+    
+    // Check byteLength
+    if (sab.byteLength !== 1024) {
+         throw new Error("byteLength is incorrect: " + sab.byteLength);
+    }
+    console.log("byteLength OK");
+
+    // Check prototype
+    if (!(sab instanceof SharedArrayBuffer)) {
+         throw new Error("instanceof SharedArrayBuffer failed");
+    }
+    console.log("instanceof OK");
+
+    if (sab instanceof ArrayBuffer) {
+        // SharedArrayBuffer is NOT an ArrayBuffer
+         throw new Error("SharedArrayBuffer should not be instanceof ArrayBuffer");
+    }
+    console.log("Not instanceof ArrayBuffer OK");
+
+    // Check usage with TypedArray
+    let i32 = new Int32Array(sab);
+    if (i32.byteLength !== 1024) {
+        throw new Error("TypedArray byteLength incorrect: " + i32.byteLength);
+    }
+    console.log("Int32Array on SAB OK");
+
+    // Check Atomics
+    Atomics.store(i32, 0, 42);
+    let val = Atomics.load(i32, 0);
+    if (val !== 42) {
+        throw new Error("Atomics store/load failed: " + val);
+    }
+    console.log("Atomics basic OK");
+
+    // Check Atomics.wait (timeout)
+    // Value at index 0 is 42. verification:
+    if (Atomics.load(i32, 0) !== 42) {
+       throw new Error("Value check failed before wait");
+    }
+    console.log("Testing wait (timeout expected)...");
+    let initialTime = Date.now();
+    let waitResult = Atomics.wait(i32, 0, 42, 100); // 100ms timeout
+    let duration = Date.now() - initialTime;
+    
+    // Note: implementation might not be high precision, but should be > 0.
+    console.log("Wait result:", waitResult, "Duration:", duration);
+    
+    if (waitResult !== "timed-out") {
+        throw new Error("Atomics.wait expected 'timed-out', got: " + waitResult);
+    }
+    
+    // Check Atomics.notify (0 waiters)
+    let notifyResult = Atomics.notify(i32, 0, 1);
+    if (notifyResult !== 0) {
+        throw new Error("Atomics.notify expected 0, got: " + notifyResult);
+    }
+    console.log("Atomics wait/notify OK");
+
+    console.log("SharedArrayBuffer Final Test Passed!");
+
+} catch (e) {
+    console.log("Test Failed:");
+    console.log(e);
+}

…-scripts/test_typedarray_constructors.js js-scripts/typedarray_test_1.jsjs-scripts/test_typedarray_constructors.js renamed to js-scripts/typedarray_test_1.js js-scripts/test_typedarray_constructors.js renamed to js-scripts/typedarray_test_1.js

@@ -1,9 +1,18 @@
+"use strict";
+
+function assert(condition, message) {
+    if (!condition) {
+        throw new Error(message);
+    }
+}
+
 // Test TypedArray constructors from JavaScript
 console.log("Testing TypedArray constructors...");
 
 // Test ArrayBuffer
 let buffer = new ArrayBuffer(16);
 console.log("ArrayBuffer created with length:", buffer.byteLength);
+assert(buffer.byteLength === 16, "ArrayBuffer length should be 16");
 
 // Test DataView
 let view = new DataView(buffer);
@@ -12,26 +21,34 @@ console.log("DataView created");
 // Test TypedArrays
 let int8Array = new Int8Array(10);
 console.log("Int8Array created with length:", int8Array.length);
+assert(int8Array.length === 10, "Int8Array length should be 10");
 
 let uint8Array = new Uint8Array(10);
 console.log("Uint8Array created with length:", uint8Array.length);
+assert(uint8Array.length === 10, "Uint8Array length should be 10");
 
 let int16Array = new Int16Array(5);
 console.log("Int16Array created with length:", int16Array.length);
+assert(int16Array.length === 5, "Int16Array length should be 5");
 
 let uint16Array = new Uint16Array(5);
 console.log("Uint16Array created with length:", uint16Array.length);
+assert(uint16Array.length === 5, "Uint16Array length should be 5");
 
 let int32Array = new Int32Array(3);
 console.log("Int32Array created with length:", int32Array.length);
+assert(int32Array.length === 3, "Int32Array length should be 3");
 
 let uint32Array = new Uint32Array(3);
 console.log("Uint32Array created with length:", uint32Array.length);
+assert(uint32Array.length === 3, "Uint32Array length should be 3");
 
 let float32Array = new Float32Array(4);
 console.log("Float32Array created with length:", float32Array.length);
+assert(float32Array.length === 4, "Float32Array length should be 4");
 
 let float64Array = new Float64Array(2);
 console.log("Float64Array created with length:", float64Array.length);
+assert(float64Array.length === 2, "Float64Array length should be 2");
 
 console.log("All TypedArray constructors work!");

src/core/eval.rs

@@ -2151,6 +2151,14 @@ pub fn evaluate_expr<'gc>(mc: &MutationContext<'gc>, env: &JSObjectDataPtr<'gc>,
                                     return Ok(crate::js_weakset::handle_weakset_constructor(mc, &eval_args, env)?);
                                 } else if name == &crate::unicode::utf8_to_utf16("Set") {
                                     return Ok(crate::js_set::handle_set_constructor(mc, &eval_args, env)?);
+                                } else if name == &crate::unicode::utf8_to_utf16("ArrayBuffer") {
+                                    return Ok(crate::js_typedarray::handle_arraybuffer_constructor(mc, &eval_args, env)?);
+                                } else if name == &crate::unicode::utf8_to_utf16("SharedArrayBuffer") {
+                                    return Ok(crate::js_typedarray::handle_sharedarraybuffer_constructor(mc, &eval_args, env)?);
+                                } else if name == &crate::unicode::utf8_to_utf16("DataView") {
+                                    return Ok(crate::js_typedarray::handle_dataview_constructor(mc, &eval_args, env)?);
+                                } else if name == &crate::unicode::utf8_to_utf16("TypedArray") {
+                                    return Ok(crate::js_typedarray::handle_typedarray_constructor(mc, &obj, &eval_args, env)?);
                                 }
                             }
                         }
@@ -2710,6 +2718,66 @@ fn call_native_function<'gc>(
             }
         }
     }
+
+    if name.starts_with("DataView.prototype.") {
+        if let Some(method) = name.strip_prefix("DataView.prototype.") {
+            let this_v = this_val.clone().unwrap_or(Value::Undefined);
+            if let Value::Object(obj) = this_v {
+                return Ok(Some(
+                    crate::js_typedarray::handle_dataview_method(mc, &obj, method, args, env).map_err(EvalError::Js)?,
+                ));
+            } else {
+                return Err(EvalError::Js(raise_eval_error!("TypeError: DataView method called on non-object")));
+            }
+        }
+    }
+
+    if name.starts_with("Atomics.") {
+        if let Some(method) = name.strip_prefix("Atomics.") {
+            return Ok(Some(
+                crate::js_typedarray::handle_atomics_method(mc, method, args, env).map_err(EvalError::Js)?,
+            ));
+        }
+    }
+
+    if name == "ArrayBuffer.prototype.byteLength" {
+        let this_v = this_val.clone().unwrap_or(Value::Undefined);
+        if let Value::Object(obj) = this_v {
+            return Ok(Some(
+                crate::js_typedarray::handle_arraybuffer_accessor(mc, &obj, "byteLength").map_err(EvalError::Js)?,
+            ));
+        } else {
+            return Err(EvalError::Js(raise_eval_error!(
+                "TypeError: ArrayBuffer.prototype.byteLength called on non-object"
+            )));
+        }
+    }
+
+    if name == "SharedArrayBuffer.prototype.byteLength" {
+        let this_v = this_val.clone().unwrap_or(Value::Undefined);
+        if let Value::Object(obj) = this_v {
+            return Ok(Some(
+                crate::js_typedarray::handle_arraybuffer_accessor(mc, &obj, "byteLength").map_err(EvalError::Js)?,
+            ));
+        } else {
+            return Err(EvalError::Js(raise_eval_error!(
+                "TypeError: SharedArrayBuffer.prototype.byteLength called on non-object"
+            )));
+        }
+    }
+
+    if let Some(prop) = name.strip_prefix("TypedArray.prototype.") {
+        let this_v = this_val.clone().unwrap_or(Value::Undefined);
+        if let Value::Object(obj) = this_v {
+            return Ok(Some(
+                crate::js_typedarray::handle_typedarray_accessor(mc, &obj, prop).map_err(EvalError::Js)?,
+            ));
+        } else {
+            return Err(EvalError::Js(raise_eval_error!(
+                "TypeError: TypedArray accessor called on non-object"
+            )));
+        }
+    }
     Ok(None)
 }
 

src/core/mod.rs

@@ -74,6 +74,7 @@ pub fn initialize_global_constructors<'gc>(mc: &MutationContext<'gc>, env: &JSOb
     initialize_regexp(mc, env)?;
     // Initialize Date constructor and prototype
     initialize_date(mc, env)?;
+    crate::js_typedarray::initialize_typedarray(mc, env)?;
     initialize_bigint(mc, env)?;
     initialize_json(mc, env)?;
     initialize_map(mc, env)?;