From f199cd9632d6644dd08a8593ae3d693b85943695 Mon Sep 17 00:00:00 2001 From: pjh456 <147148383@qq.com> Date: Wed, 23 Sep 2026 11:13:56 +0000 Subject: [PATCH] =?UTF-8?q?feat:=20Reflect.has=20=E5=88=87=E7=BB=9F?= =?UTF-8?q?=E4=B8=80=E6=95=B0=E5=80=BC=E9=94=AE=E9=97=A8=E5=B9=B6=E4=BF=AE?= =?UTF-8?q?=202^32=20=E7=B4=A2=E5=BC=95=E8=BE=B9=E7=95=8C?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- crates/oxide_builtins/src/object.rs | 4 +- crates/oxide_builtins/src/reflect.rs | 9 +- .../tests/builtins_typed_array_tests.rs | 157 ++++++++++++++++++ 3 files changed, 166 insertions(+), 4 deletions(-) diff --git a/crates/oxide_builtins/src/object.rs b/crates/oxide_builtins/src/object.rs index bedb61a6..e04af4e5 100644 --- a/crates/oxide_builtins/src/object.rs +++ b/crates/oxide_builtins/src/object.rs @@ -11,12 +11,12 @@ use oxide_runtime_api::{NativeResult, VmHost}; use crate::builtins_debug; -/// 判断字符串是否为规范整数索引：非空、无前导零、全数字且值 < 2^32-1。 +/// 判断字符串是否为规范整数索引：非空、无前导零、全数字且值 < 2^32。 fn is_integer_index(key: &str) -> bool { if key.is_empty() || key.len() > 1 && key.as_bytes()[0] == b'0' { return false; } - key.bytes().all(|b| b.is_ascii_digit()) && key.parse::().unwrap_or(u64::MAX) < (1u64 << 32) - 1 + key.bytes().all(|b| b.is_ascii_digit()) && key.parse::().unwrap_or(u64::MAX) < (1u64 << 32) } /// 收集对象全部自身属性（数组元素区 + shape 链），按规范顺序排列：整数索引在前 diff --git a/crates/oxide_builtins/src/reflect.rs b/crates/oxide_builtins/src/reflect.rs index 835e9108..a5cf16e3 100644 --- a/crates/oxide_builtins/src/reflect.rs +++ b/crates/oxide_builtins/src/reflect.rs @@ -154,14 +154,19 @@ pub fn reflect_get_prototype_of(vm: &mut H, args: &[u8]) -> NativeRes NativeResult::Ok(unsafe { &*target_ptr }.proto()) } -/// `Reflect.has(target, key)`：属性是否存在（含原型链）。 +/// `Reflect.has(target, key)`：属性存在性判定（规范 HasProperty，含原型链）。 +/// +/// TypedArray 经统一数值键门（exotic [[HasProperty]]）：界内整数索引判存在； +/// 数字无效键（负/分数/±Infinity/NaN/越界，含 "-0" 特例）立即 false，不查 +/// 自身命名属性也不走原型链；非规范数字串落普通路径。原型链上的 TA 按同口径 +/// 经门判定。 pub fn reflect_has(vm: &mut H, args: &[u8]) -> NativeResult { let target_val = arg(vm, args, 1); let Some(target_ptr) = object_ptr(target_val) else { return type_error(vm, "Reflect.has target is not an object"); }; let key_si = vm.property_key_si(arg(vm, args, 2)); - NativeResult::Ok(JsValue::bool(vm.resolve_property(unsafe { &*target_ptr }, key_si).is_some())) + NativeResult::Ok(JsValue::bool(vm.has_property(unsafe { &*target_ptr }, key_si))) } /// `Reflect.isExtensible(target)`：对象是否可扩展。 diff --git a/crates/oxide_vm/tests/builtins_typed_array_tests.rs b/crates/oxide_vm/tests/builtins_typed_array_tests.rs index fb8792d2..46bc9efc 100644 --- a/crates/oxide_vm/tests/builtins_typed_array_tests.rs +++ b/crates/oxide_vm/tests/builtins_typed_array_tests.rs @@ -1889,3 +1889,160 @@ fn ta_integrity_freeze_seal_no_element_touch() { .unwrap(); assert!(result.as_bool()); } + +#[test] +fn ta_reflect_has_in_range_true() { + // 界内整数键 Reflect.has 判 true：int 与规范串同臂；len-0 形判 false； + // BigInt 族键集同形。 + let mut vm = Vm::new(); + let result = eval( + &mut vm, + "(function () { var ta = new Uint8Array([7, 8]); \ + if (!Reflect.has(ta, 0) || !Reflect.has(ta, 1) || !Reflect.has(ta, '1')) return false; \ + var ta0 = new Uint8Array(0); \ + if (Reflect.has(ta0, 0)) return false; \ + var b = new BigInt64Array([1n, 2n]); \ + if (!Reflect.has(b, 0) || !Reflect.has(b, 1) || !Reflect.has(b, '1')) return false; \ + var b0 = new BigInt64Array(0); \ + return !Reflect.has(b0, 0); })()", + ) + .unwrap(); + assert!(result.as_bool()); +} + +#[test] +fn ta_reflect_has_numeric_invalid_false() { + // 数字无效键（越界整数/负/"-0"/分数）判 false：原型逐键预置抓假阳， + // 数字臂不走原型链。 + let mut vm = Vm::new(); + let result = eval( + &mut vm, + "(function () { var ta = new Uint8Array([7]); \ + var keys = ['1', '-1', '-0', '1.1', '0.000001']; \ + for (var i = 0; i < keys.length; i++) Uint8Array.prototype[keys[i]] = 'test262'; \ + for (var i = 0; i < keys.length; i++) if (Reflect.has(ta, keys[i])) return false; \ + return true; })()", + ) + .unwrap(); + assert!(result.as_bool()); +} + +#[test] +fn ta_reflect_has_inherited_ordinary() { + // 普通键路径：继承串属性 true；原型预置 "42" 后越界规范串仍 false； + // 缺失 symbol false、own symbol true；非规范串无 own false、defineProperty + // 后 true 且读值同键；"1" 规范越界恒 false。 + let mut vm = Vm::new(); + let result = eval( + &mut vm, + "(function () { var ta = new Uint8Array([7]); \ + Object.getPrototypeOf(ta).foo = 42; \ + if (!Reflect.has(ta, 'foo')) return false; \ + Object.getPrototypeOf(ta)['42'] = true; \ + if (Reflect.has(ta, '42')) return false; \ + var s = Symbol('s'); \ + if (Reflect.has(ta, s)) return false; \ + ta[s] = 5; \ + if (!Reflect.has(ta, s)) return false; \ + if (Reflect.has(ta, '1.0') || Reflect.has(ta, '+1')) return false; \ + Object.defineProperty(ta, '+1', { value: 7 }); \ + if (!Reflect.has(ta, '+1') || ta['+1'] !== 7) return false; \ + return !Reflect.has(ta, '1'); })()", + ) + .unwrap(); + assert!(result.as_bool()); +} + +#[test] +fn ta_reflect_has_chain_ta() { + // 链上 TA 经门判定：一层链 has(p,0) true / has(p,3) false；两层链 + // has(q,0) true；`0 in p` 与 Reflect.has 同值（has_property 同源锚）。 + let mut vm = Vm::new(); + let result = eval( + &mut vm, + "(function () { var ta3 = new Uint8Array(3); \ + var p = Object.create(ta3); \ + if (!Reflect.has(p, 0)) return false; \ + if (Reflect.has(p, 3)) return false; \ + var q = Object.create(p); \ + if (!Reflect.has(q, 0)) return false; \ + return 0 in p; })()", + ) + .unwrap(); + assert!(result.as_bool()); +} + +#[test] +fn ta_reflect_has_detached_false() { + // detach 后 live 长 0：界内/负键归数字无效判 false；缺失 symbol false； + // own symbol 与真属性值不动。 + let mut vm = Vm::new(); + let result = eval( + &mut vm, + "(function () { var ab = new ArrayBuffer(8); var ta = new Uint8Array(ab); \ + ta[0] = 9; ta.foo = 42; \ + var s1 = Symbol('s1'); ta[s1] = 5; \ + var s2 = Symbol('s2'); \ + ab.transfer(); \ + if (Reflect.has(ta, '0')) return false; \ + if (Reflect.has(ta, '-1')) return false; \ + if (Reflect.has(ta, s2)) return false; \ + return Reflect.has(ta, s1) && ta.foo === 42; })()", + ) + .unwrap(); + assert!(result.as_bool()); +} + +#[test] +fn ta_reflect_has_resize_follows() { + // auto 视图 has 跟随 live 长：初始 3 键 0..2 true 且 3 false；grow 8 后 + // 3..7 true；shrink-0 全 false。fixed 窗口 grow 键集不变、裁出窗口全 false。 + let mut vm = Vm::new(); + let result = eval( + &mut vm, + "(function () { var ab = new ArrayBuffer(3, { maxByteLength: 12 }); \ + var ta = new Uint8Array(ab); \ + if (!Reflect.has(ta, 0) || !Reflect.has(ta, 1) || !Reflect.has(ta, 2)) return false; \ + if (Reflect.has(ta, 3)) return false; \ + ab.resize(8); \ + for (var i = 3; i < 8; i++) if (!Reflect.has(ta, i)) return false; \ + ab.resize(0); \ + if (Reflect.has(ta, 0)) return false; \ + var ab2 = new ArrayBuffer(8, { maxByteLength: 16 }); \ + var ta2 = new Uint8Array(ab2, 2, 2); \ + ab2.resize(16); \ + if (!Reflect.has(ta2, 0) || !Reflect.has(ta2, 1) || Reflect.has(ta2, 2)) return false; \ + ab2.resize(3); \ + return !Reflect.has(ta2, 0); })()", + ) + .unwrap(); + assert!(result.as_bool()); +} + +#[test] +fn ta_reflect_has_subarray_view() { + // 视图相对下标：subarray(2) 键集 0..视图长-1，越界 false。 + let mut vm = Vm::new(); + let result = eval( + &mut vm, + "(function () { var ta = new Uint8Array(4).subarray(2); \ + return Reflect.has(ta, 0) && Reflect.has(ta, 1) && !Reflect.has(ta, 2); })()", + ) + .unwrap(); + assert!(result.as_bool()); +} + +#[test] +fn ta_keys_int_index_2pow32_boundary() { + // 2^32 边界：2^32-1 为规范数组索引（升序前置），2^32 起为串键（插入序）。 + let mut vm = Vm::new(); + let result = eval( + &mut vm, + "(function () { var ks1 = Object.keys({ a: 1, '4294967295': 2 }); \ + if (ks1.join(',') !== '4294967295,a') return false; \ + var ks2 = Object.keys({ b: 1, '4294967296': 2 }); \ + return ks2.join(',') === 'b,4294967296'; })()", + ) + .unwrap(); + assert!(result.as_bool()); +}