Implement WeakRef, FinalizationRegistry, and Atomics.waitAsync

- Add WeakRef constructor and prototype.deref() in new js_weakref.rs
- Add FinalizationRegistry constructor, register, unregister, cleanupSome in new js_finalization_registry.rs
- Add Atomics.waitAsync with background thread waiter and promise resolution in js_typedarray.rs
- Define InternalSlot variants for WeakRef and FinalizationRegistry in value.rs
- Register new builtins in global initialization (mod.rs, lib.rs)
- Wire constructor dispatch in js_class.rs and eval.rs for new/Reflect.construct
- Fix parser to allow keyword tokens (e.g. async) as destructuring property keys
- Fix parser async lookahead in object literals so { async: true } is not parsed as async method
- Fix FinalizationRegistry.prototype.register.length (2) and unregister.length (1) across dot-access, bracket-access, and getOwnPropertyDescriptor paths
- Add FinalizationRegistry.js feature probe for test262 runner
- Add manual test scripts for WeakRef, FinalizationRegistry, and Atomics.waitAsync

Author: ssrlive

ci/feature_probes/FinalizationRegistry.js

@@ -0,0 +1,9 @@
+// feature probe for 'FinalizationRegistry'
+try {
+  if (typeof FinalizationRegistry !== 'function') throw new Error('FinalizationRegistry missing');
+  const fr = new FinalizationRegistry(function() {});
+  if (!fr) throw new Error('FinalizationRegistry failed');
+  console.log('OK');
+} catch (e) {
+  console.log('NO');
+}

js-scripts/test_atomics_waitasync.js

@@ -0,0 +1,72 @@
+// Inline assert helper
+function assert(cond, msg) { if (!cond) throw new Error("Assertion failed: " + msg); }
+
+// Test Atomics.waitAsync existence
+(function testWaitAsyncExists() {
+    assert(typeof Atomics.waitAsync === 'function', "Atomics.waitAsync should be a function");
+    assert(Atomics.waitAsync.length === 4, "Atomics.waitAsync.length should be 4");
+    console.log("PASS: Atomics.waitAsync exists with correct length");
+})();
+
+// Test Atomics.waitAsync with non-equal value (synchronous not-equal result)
+(function testWaitAsyncNotEqual() {
+    const sab = new SharedArrayBuffer(16);
+    const ia = new Int32Array(sab);
+    ia[0] = 42;
+
+    const result = Atomics.waitAsync(ia, 0, 0); // expected=0, actual=42
+    assert(result.async === false, "Should be synchronous for not-equal, got async=" + result.async);
+    assert(result.value === "not-equal", "Should be 'not-equal', got: " + result.value);
+    console.log("PASS: Atomics.waitAsync returns not-equal synchronously");
+})();
+
+// Test Atomics.waitAsync with equal value and immediate timeout
+(function testWaitAsyncImmediateTimeout() {
+    const sab = new SharedArrayBuffer(16);
+    const ia = new Int32Array(sab);
+    ia[0] = 0;
+
+    const result = Atomics.waitAsync(ia, 0, 0, 0); // timeout=0
+    assert(result.async === false, "Should be synchronous for timeout=0, got async=" + result.async);
+    assert(result.value === "timed-out", "Should be 'timed-out', got: " + result.value);
+    console.log("PASS: Atomics.waitAsync returns timed-out for zero timeout");
+})();
+
+// Test Atomics.waitAsync returns promise with matching value
+(function testWaitAsyncPromise() {
+    const sab = new SharedArrayBuffer(16);
+    const ia = new Int32Array(sab);
+    ia[0] = 0;
+
+    const result = Atomics.waitAsync(ia, 0, 0, 100); // timeout=100ms
+    assert(result.async === true, "Should be async for matching value with timeout, got: " + result.async);
+    assert(typeof result.value === 'object', "value should be a Promise object");
+    console.log("PASS: Atomics.waitAsync returns {async: true, value: Promise}");
+})();
+
+// Test Atomics.waitAsync validation
+(function testWaitAsyncValidation() {
+    // Must be Int32Array or BigInt64Array
+    try {
+        const sab = new SharedArrayBuffer(16);
+        const ua = new Uint8Array(sab);
+        Atomics.waitAsync(ua, 0, 0);
+        assert(false, "Should throw for Uint8Array");
+    } catch (e) {
+        assert(e instanceof TypeError, "Should be TypeError");
+        console.log("PASS: Atomics.waitAsync rejects non-Int32Array");
+    }
+
+    // Must be SharedArrayBuffer
+    try {
+        const ab = new ArrayBuffer(16);
+        const ia = new Int32Array(ab);
+        Atomics.waitAsync(ia, 0, 0);
+        assert(false, "Should throw for non-shared buffer");
+    } catch (e) {
+        assert(e instanceof TypeError, "Should be TypeError");
+        console.log("PASS: Atomics.waitAsync rejects non-SharedArrayBuffer");
+    }
+})();
+
+console.log("All Atomics.waitAsync tests passed!");

js-scripts/test_finalization_registry.js

@@ -0,0 +1,125 @@
+// Inline assert helper
+function assert(cond, msg) { if (!cond) throw new Error("Assertion failed: " + msg); }
+
+// Test FinalizationRegistry basic functionality
+(function testFRBasic() {
+    let called = false;
+    const fr = new FinalizationRegistry(function(heldValue) {
+        called = true;
+    });
+
+    assert(fr instanceof FinalizationRegistry, "should be instanceof FinalizationRegistry");
+    console.log("PASS: FinalizationRegistry basic creation");
+})();
+
+// Test FinalizationRegistry.register
+(function testFRRegister() {
+    const fr = new FinalizationRegistry(function(heldValue) {});
+
+    const target = {};
+    const result = fr.register(target, "held value");
+    assert(result === undefined, "register should return undefined");
+    console.log("PASS: FinalizationRegistry.register returns undefined");
+})();
+
+// Test FinalizationRegistry.register with unregister token
+(function testFRRegisterWithToken() {
+    const fr = new FinalizationRegistry(function(heldValue) {});
+
+    const target = {};
+    const token = {};
+    fr.register(target, "held value", token);
+    console.log("PASS: FinalizationRegistry.register with unregister token");
+})();
+
+// Test FinalizationRegistry.register validation
+(function testFRRegisterValidation() {
+    const fr = new FinalizationRegistry(function() {});
+
+    // target must be an object
+    try {
+        fr.register(42, "held");
+        assert(false, "Should throw for primitive target");
+    } catch (e) {
+        assert(e instanceof TypeError, "Should be TypeError");
+        console.log("PASS: FR rejects primitive target");
+    }
+
+    // target and heldValue cannot be the same
+    try {
+        const obj = {};
+        fr.register(obj, obj);
+        assert(false, "Should throw when target===heldValue");
+    } catch (e) {
+        assert(e instanceof TypeError, "Should be TypeError");
+        console.log("PASS: FR rejects target===heldValue");
+    }
+
+    // unregisterToken must be object/symbol/undefined
+    try {
+        fr.register({}, "held", 42);
+        assert(false, "Should throw for primitive unregisterToken");
+    } catch (e) {
+        assert(e instanceof TypeError, "Should be TypeError");
+        console.log("PASS: FR rejects primitive unregisterToken");
+    }
+})();
+
+// Test FinalizationRegistry.unregister
+(function testFRUnregister() {
+    const fr = new FinalizationRegistry(function() {});
+
+    const target1 = {};
+    const target2 = {};
+    const token = {};
+
+    fr.register(target1, "held1", token);
+    fr.register(target2, "held2", token);
+
+    const removed = fr.unregister(token);
+    assert(removed === true, "unregister should return true when entries were removed");
+    console.log("PASS: FinalizationRegistry.unregister removes entries");
+})();
+
+// Test FinalizationRegistry.unregister with no matching token
+(function testFRUnregisterNoMatch() {
+    const fr = new FinalizationRegistry(function() {});
+
+    const target = {};
+    const token1 = {};
+    const token2 = {};
+
+    fr.register(target, "held", token1);
+
+    const removed = fr.unregister(token2);
+    assert(removed === false, "unregister should return false when no entries matched");
+    console.log("PASS: FinalizationRegistry.unregister returns false for no match");
+})();
+
+// Test FinalizationRegistry constructor validation
+(function testFRCtorValidation() {
+    try {
+        new FinalizationRegistry(42);
+        assert(false, "Should throw for non-callable cleanup");
+    } catch (e) {
+        assert(e instanceof TypeError, "Should be TypeError");
+        console.log("PASS: FR constructor rejects non-callable");
+    }
+})();
+
+// Test FinalizationRegistry toString tag
+(function testFRToStringTag() {
+    const fr = new FinalizationRegistry(function() {});
+    const tag = Object.prototype.toString.call(fr);
+    assert(tag === "[object FinalizationRegistry]", "toStringTag should be FinalizationRegistry, got: " + tag);
+    console.log("PASS: FinalizationRegistry toStringTag");
+})();
+
+// Test FinalizationRegistry constructor properties
+(function testFRCtorProps() {
+    assert(FinalizationRegistry.length === 1, "FinalizationRegistry.length should be 1");
+    assert(FinalizationRegistry.name === "FinalizationRegistry", "FinalizationRegistry.name should be 'FinalizationRegistry'");
+    console.log("PASS: FinalizationRegistry constructor properties");
+})();
+
+console.log("All FinalizationRegistry tests passed!");

js-scripts/test_weakref.js

@@ -0,0 +1,76 @@
+// Inline assert helper
+function assert(cond, msg) { if (!cond) throw new Error("Assertion failed: " + msg); }
+
+// Test WeakRef basic functionality
+(function testWeakRefBasic() {
+    let target = { name: "test" };
+    const wr = new WeakRef(target);
+
+    // deref() should return the target while it's alive
+    const derefed = wr.deref();
+    assert(derefed === target, "WeakRef.deref() should return target");
+    assert(derefed.name === "test", "deref().name should be 'test'");
+    console.log("PASS: WeakRef basic deref");
+})();
+
+// Test WeakRef with symbol
+(function testWeakRefSymbol() {
+    const sym = Symbol("test");
+    const wr = new WeakRef(sym);
+    const derefed = wr.deref();
+    assert(derefed === sym, "WeakRef.deref() should return symbol");
+    console.log("PASS: WeakRef symbol deref");
+})();
+
+// Test WeakRef constructor validation
+(function testWeakRefValidation() {
+    // Cannot create WeakRef with primitive
+    try {
+        new WeakRef(42);
+        assert(false, "Should have thrown");
+    } catch (e) {
+        assert(e instanceof TypeError, "Should be TypeError for primitive target");
+        console.log("PASS: WeakRef rejects primitive target");
+    }
+
+    try {
+        new WeakRef("string");
+        assert(false, "Should have thrown");
+    } catch (e) {
+        assert(e instanceof TypeError, "Should be TypeError for string target");
+        console.log("PASS: WeakRef rejects string target");
+    }
+
+    // Cannot create WeakRef with registered symbol
+    try {
+        new WeakRef(Symbol.for("registered"));
+        assert(false, "Should have thrown");
+    } catch (e) {
+        assert(e instanceof TypeError, "Should be TypeError for registered symbol");
+        console.log("PASS: WeakRef rejects registered symbol");
+    }
+})();
+
+// Test WeakRef toString tag
+(function testWeakRefToStringTag() {
+    const wr = new WeakRef({});
+    const tag = Object.prototype.toString.call(wr);
+    assert(tag === "[object WeakRef]", "toStringTag should be WeakRef, got: " + tag);
+    console.log("PASS: WeakRef toStringTag");
+})();
+
+// Test WeakRef instanceof
+(function testWeakRefInstanceof() {
+    const wr = new WeakRef({});
+    assert(wr instanceof WeakRef, "should be instanceof WeakRef");
+    console.log("PASS: WeakRef instanceof");
+})();
+
+// Test WeakRef constructor properties
+(function testWeakRefCtorProps() {
+    assert(WeakRef.length === 1, "WeakRef.length should be 1");
+    assert(WeakRef.name === "WeakRef", "WeakRef.name should be 'WeakRef'");
+    console.log("PASS: WeakRef constructor properties");
+})();
+
+console.log("All WeakRef tests passed!");

src/core/eval.rs

@@ -13384,6 +13384,46 @@ pub fn evaluate_call_dispatch<'gc>(
                 } else {
                     Err(raise_type_error!(format!("Unknown WeakSet function: {}", name)).into())
                 }
+            } else if name.starts_with("WeakRef.") {
+                if let Some(method) = name.strip_prefix("WeakRef.prototype.") {
+                    let this_v = this_val.unwrap_or(&Value::Undefined);
+                    if let Value::Object(obj) = this_v {
+                        if slot_get_chained(obj, &InternalSlot::WeakRefMarker).is_some() {
+                            Ok(crate::js_weakref::handle_weakref_instance_method(mc, obj, method, eval_args, env)?)
+                        } else {
+                            Err(raise_type_error!(format!("Method WeakRef.prototype.{} called on incompatible receiver", method)).into())
+                        }
+                    } else {
+                        Err(raise_type_error!(format!("Method WeakRef.prototype.{} called on incompatible receiver", method)).into())
+                    }
+                } else {
+                    Err(raise_type_error!(format!("Unknown WeakRef function: {}", name)).into())
+                }
+            } else if name.starts_with("FinalizationRegistry.") {
+                if let Some(method) = name.strip_prefix("FinalizationRegistry.prototype.") {
+                    let this_v = this_val.unwrap_or(&Value::Undefined);
+                    if let Value::Object(obj) = this_v {
+                        if slot_get_chained(obj, &InternalSlot::FRMarker).is_some() {
+                            Ok(crate::js_finalization_registry::handle_fr_instance_method(
+                                mc, obj, method, eval_args, env,
+                            )?)
+                        } else {
+                            Err(raise_type_error!(format!(
+                                "Method FinalizationRegistry.prototype.{} called on incompatible receiver",
+                                method
+                            ))
+                            .into())
+                        }
+                    } else {
+                        Err(raise_type_error!(format!(
+                            "Method FinalizationRegistry.prototype.{} called on incompatible receiver",
+                            method
+                        ))
+                        .into())
+                    }
+                } else {
+                    Err(raise_type_error!(format!("Unknown FinalizationRegistry function: {}", name)).into())
+                }
             } else if name == "Set[Symbol.species]" {
                 let this_v = this_val.unwrap_or(&Value::Undefined);
                 Ok(this_v.clone())
@@ -17134,6 +17174,7 @@ fn evaluate_expr_property<'gc>(
             | "WeakSet.prototype.add"
             | "WeakSet.prototype.has"
             | "WeakSet.prototype.delete"
+            | "FinalizationRegistry.prototype.unregister"
             | "Number.isNaN"
             | "Number.isFinite"
             | "Number.isInteger"
@@ -17237,6 +17278,7 @@ fn evaluate_expr_property<'gc>(
             | "Map.prototype.getOrInsert"
             | "Map.prototype.getOrInsertComputed"
             | "WeakMap.prototype.set"
+            | "FinalizationRegistry.prototype.register"
             | "WeakMap.prototype.getOrInsert"
             | "WeakMap.prototype.getOrInsertComputed"
             | "Array.prototype.toSpliced"
@@ -18707,6 +18749,7 @@ fn evaluate_expr_index<'gc>(
                     | "WeakSet.prototype.add"
                     | "WeakSet.prototype.has"
                     | "WeakSet.prototype.delete"
+                    | "FinalizationRegistry.prototype.unregister"
                     | "Number.isNaN"
                     | "Number.isFinite"
                     | "Number.isInteger"
@@ -18810,6 +18853,7 @@ fn evaluate_expr_index<'gc>(
                     | "WeakMap.prototype.set"
                     | "WeakMap.prototype.getOrInsert"
                     | "WeakMap.prototype.getOrInsertComputed"
+                    | "FinalizationRegistry.prototype.register"
                     | "Array.prototype.toSpliced"
                     | "Array.prototype.with"
                     | "Math.atan2"
@@ -23339,8 +23383,12 @@ fn evaluate_expr_new<'gc>(
                         return crate::js_proxy::handle_proxy_constructor(mc, &eval_args, env);
                     } else if name_str == "WeakMap" {
                         return crate::js_weakmap::handle_weakmap_constructor(mc, &eval_args, env, None);
+                    } else if name_str == "WeakRef" {
+                        return crate::js_weakref::handle_weakref_constructor(mc, &eval_args, env, None);
                     } else if name_str == "WeakSet" {
                         return crate::js_weakset::handle_weakset_constructor(mc, &eval_args, env, None);
+                    } else if name_str == "FinalizationRegistry" {
+                        return crate::js_finalization_registry::handle_fr_constructor(mc, &eval_args, env, None);
                     } else if name_str == "Set" {
                         return crate::js_set::handle_set_constructor(mc, &eval_args, env, None);
                     } else if name_str == "ArrayBuffer" {