feat: Map getOrInsertComputed 二扫原位覆盖与±0键规范化

crates/oxide_builtins/src/map.rs

@@ -289,6 +289,64 @@ pub fn map_get_or_insert<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
     NativeResult::Ok(val)
 }
 
+/// `Map.prototype.getOrInsertComputed(key, callback)`：键命中返回存储值（callback
+/// 不求值）；缺失时调用 callback（this 恒为 undefined，唯一实参为规范化后的键），
+/// 以返回值作条目值原位覆盖（callback 期间同键已入表）或末尾追加。
+///
+/// # 步骤
+/// 1. 校验 receiver 持 Map 内部槽（先于 callback 检查）。
+/// 2. callback 须可调用，否则 TypeError。
+/// 3. 键规范化：Double 零值统一为 +0（±0 唯一规范化点，存储、扫描、callback
+///    实参三处同一值；NaN 不归一）。
+/// 4. 首扫：命中即返回存储值，callback 不求值。
+/// 5. 调用 callback；抛错时原异常值上抛，零条目落表。
+/// 6. 二扫：callback 期间同键已入表则原位写值返回，不重新追加。
+/// 7. 否则末尾追加新条目并返回 callback 返回值。
+///
+/// # 边界与前提
+/// - 存储值 undefined 同样计命中：直接返回现值，不得视为缺失。
+/// - callback 内可重入同 Map 方法（native 重入），键值表指针跨重入稳定。
+///
+/// # 注意事项
+/// - 二扫覆盖保序位：命中键值更新不移动插入序，条目不重新追加末尾。
+/// - 无 thisArg 形参：callback 的 this 恒为 undefined，恰一个实参（规范化键）。
+/// - -0 键规范化为 +0 后才进入存储/扫描/callback 实参。
+pub fn map_get_or_insert_computed<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
+    let this_val = vm.reg(if args.is_empty() { 0 } else { args[0] });
+    let inner = native_try!(get_map_inner(vm, this_val));
+    let key = vm.reg(if args.len() > 1 { args[1] } else { 0 });
+    let callback = vm.reg(if args.len() > 2 { args[2] } else { 0 });
+    if !crate::iterator::is_callable(callback) {
+        return NativeResult::Err(crate::error::create_type_error(vm, "callback is not a function"));
+    }
+    let key = if key.is_double() && key.as_double() == 0.0 {
+        JsValue::float(0.0)
+    } else {
+        key
+    };
+    let found = unsafe { (*inner).get(&SetKey(key)).copied() };
+    if let Some(existing) = found {
+        return NativeResult::Ok(existing);
+    }
+    let value = match vm.call_function_sync(callback, JsValue::undefined(), &[key]) {
+        Ok(v) => v,
+        Err(e) => {
+            let exc = vm
+                .take_uncaught_value()
+                .unwrap_or_else(|| crate::error::create_type_error(vm, &e));
+            return NativeResult::Err(exc);
+        }
+    };
+    if let Some(slot) = unsafe { (*inner).get_mut(&SetKey(key)) } {
+        *slot = value;
+        return NativeResult::Ok(value);
+    }
+    unsafe {
+        (*inner).insert(SetKey(key), value);
+    }
+    NativeResult::Ok(value)
+}
+
 /// `Map.prototype.has(key)`：key 是否存在。
 pub fn map_has<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
     let this_val = vm.reg(if args.is_empty() { 0 } else { args[0] });

crates/oxide_vm/src/bindings/bind_map.rs

@@ -26,6 +26,11 @@ pub fn bind_map(core: &Arc<KernelCore>, session: &KernelSession, global: &mut Js
             ("set", oxide_builtins::map::map_set::<crate::vm::Vm> as *const (), 2),
             ("get", oxide_builtins::map::map_get::<crate::vm::Vm> as *const (), 1),
             ("getOrInsert", oxide_builtins::map::map_get_or_insert::<crate::vm::Vm> as *const (), 2),
+            (
+                "getOrInsertComputed",
+                oxide_builtins::map::map_get_or_insert_computed::<crate::vm::Vm> as *const (),
+                2,
+            ),
             ("has", oxide_builtins::map::map_has::<crate::vm::Vm> as *const (), 1),
             ("delete", oxide_builtins::map::map_delete::<crate::vm::Vm> as *const (), 1),
             ("clear", oxide_builtins::map::map_clear::<crate::vm::Vm> as *const (), 0),

crates/oxide_vm/tests/builtins_map_tests.rs

@@ -281,3 +281,121 @@ fn map_length_descriptor() {
     .unwrap();
     assert!(r.as_bool());
 }
+
+// ── getOrInsertComputed：命中短路，缺失回调求值，二扫原位覆盖保序位 ──
+
+#[test]
+fn map_get_or_insert_computed_missing_invokes_callback_once() {
+    // 键缺失：callback 恰调用一次，返回值末尾追加，size 加一。
+    let mut vm = Vm::new();
+    let r = eval(
+        &mut vm,
+        "var m = new Map(); m.set('a', 1); var n = 0; \
+         var v = m.getOrInsertComputed('b', function () { n += 1; return 'vb'; }); \
+         v + '/' + m.size + '/' + n + '/' + m.get('b')",
+    )
+    .unwrap();
+    assert_eq!(str_val(&vm, r), "vb/2/1/vb");
+}
+
+#[test]
+fn map_get_or_insert_computed_present_skips_callback() {
+    // 键命中：callback 不求值，返回存储值，size 不变。
+    let mut vm = Vm::new();
+    let r = eval(
+        &mut vm,
+        "var m = new Map(); m.set('a', 1); var n = 0; \
+         var v = m.getOrInsertComputed('a', function () { n += 1; return 99; }); \
+         v + '/' + m.size + '/' + n",
+    )
+    .unwrap();
+    assert_eq!(str_val(&vm, r), "1/1/0");
+}
+
+#[test]
+fn map_get_or_insert_computed_present_undefined_value_returns_undefined() {
+    // 存储值为 undefined 也计命中：返回 undefined，不插入、size 不变。
+    let mut vm = Vm::new();
+    let r = eval(
+        &mut vm,
+        "var m = new Map(); m.set('u', undefined); var n = 0; \
+         var hit = m.getOrInsertComputed('u', function () { n += 1; return 7; }); \
+         (hit === undefined) + '/' + m.size + '/' + n",
+    )
+    .unwrap();
+    assert_eq!(str_val(&vm, r), "true/1/0");
+}
+
+#[test]
+fn map_get_or_insert_computed_zero_key_canonicalized_for_callback() {
+    // 键规范化：-0 键在传 callback 前归一为 +0（Object.is 区分 ±0）。
+    let mut vm = Vm::new();
+    let r = eval(
+        &mut vm,
+        "var m = new Map(); \
+         var v = m.getOrInsertComputed(-0, function (k) { return (Object.is(k, 0) && (1 / k) === Infinity) ? 5 : 6; }); \
+         v + '/' + m.size + '/' + (m.get(-0) === 5)",
+    )
+    .unwrap();
+    assert_eq!(str_val(&vm, r), "5/1/true");
+}
+
+#[test]
+fn map_get_or_insert_computed_callback_throws_propagates_original() {
+    // callback 抛错：原异常值上抛，零条目落表，size 不变。
+    let mut vm = Vm::new();
+    let r = eval(
+        &mut vm,
+        "var m = new Map(); m.set('a', 1); var e = null; \
+         try { m.getOrInsertComputed('b', function () { throw 'E'; }); } catch (t) { e = t; } \
+         e + '/' + m.size + '/' + m.has('b')",
+    )
+    .unwrap();
+    assert_eq!(str_val(&vm, r), "E/1/false");
+}
+
+#[test]
+fn map_get_or_insert_computed_rejects_non_callable_and_non_map() {
+    // 非函数 callback 抛 TypeError；非 Map receiver 抛 TypeError（receiver 校验先于 callback 检查）。
+    let mut vm = Vm::new();
+    let r = eval(
+        &mut vm,
+        "var m = new Map(); var ok = false; \
+         try { m.getOrInsertComputed('a', 42); } catch (t) { ok = t instanceof TypeError; } \
+         var ok2 = false; \
+         try { Map.prototype.getOrInsertComputed.call({}, 'a', function () {}); } catch (t) { ok2 = t instanceof TypeError; } \
+         ok + '/' + ok2",
+    )
+    .unwrap();
+    assert_eq!(str_val(&vm, r), "true/true");
+}
+
+#[test]
+fn map_get_or_insert_computed_second_scan_overwrites_in_place() {
+    // callback 内 set 同键后返回 3：二扫命中，原位覆盖并返回，插入序保留，size 不变。
+    let mut vm = Vm::new();
+    let r = eval(
+        &mut vm,
+        "var m = new Map(); m.set('first', 'f'); \
+         var v = m.getOrInsertComputed('k', function () { m.set('k', 0); return 3; }); \
+         v + '/' + m.get('k') + '/' + m.size + '/' + \
+         (function () { var out = []; m.forEach(function (val, key) { out.push(key); }); return out.join(','); })()",
+    )
+    .unwrap();
+    assert_eq!(str_val(&vm, r), "3/3/2/first,k");
+}
+
+#[test]
+fn map_get_or_insert_computed_length_name_and_descriptor() {
+    // 函数描述符：length 2、name 'getOrInsertComputed'，原型属性 writable/enumerable/configurable 三属性。
+    let mut vm = Vm::new();
+    let r = eval(
+        &mut vm,
+        "var f = Map.prototype.getOrInsertComputed; \
+         var d = Object.getOwnPropertyDescriptor(Map.prototype, 'getOrInsertComputed'); \
+         f.length === 2 && f.name === 'getOrInsertComputed' && \
+         d.writable === true && d.enumerable === false && d.configurable === true",
+    )
+    .unwrap();
+    assert!(r.as_bool());
+}