diff --git a/crates/oxide_builtins/src/array/from.rs b/crates/oxide_builtins/src/array/from.rs index 5d53e8b5..3f098d20 100644 --- a/crates/oxide_builtins/src/array/from.rs +++ b/crates/oxide_builtins/src/array/from.rs @@ -66,6 +66,12 @@ pub fn array_is_array(vm: &mut H, args: &[u8]) -> NativeResult { NativeResult::Ok(JsValue::bool(unsafe { &*ptr }.is_array())) } +/// `Array[Symbol.species]` 访问器 getter：返回 receiver——派生类沿静态原型链 +/// 解析 `@@species` 时得到自身构造器，`Array` 自身解析得到 `Array`。 +pub fn array_species_get(vm: &mut H, args: &[u8]) -> NativeResult { + NativeResult::ok(vm.reg(args[0])) +} + /// `Array.of(...items)`：以参数为元素构造新数组。 /// /// # 步骤 @@ -109,7 +115,7 @@ pub fn array_of(vm: &mut H, args: &[u8]) -> NativeResult { /// /// # 注意事项 /// - 迭代只读包装器 `next`/`done`/`value` 属性，与 spread 物化共用同一迭代协议。 -/// - new.target 不向被构造的 C 传播（与 Reflect.construct 同一简化）。 +/// - 构造走完整 Construct：new.target 向被构造的 C 传播（与 Reflect.construct 同面）。 pub fn array_from(vm: &mut H, args: &[u8]) -> NativeResult { let items = if args.len() > 1 { vm.reg(args[1]) } else { JsValue::undefined() }; if items.is_null() || items.is_undefined() { @@ -271,8 +277,9 @@ pub(crate) fn from_engine_error(vm: &mut H, err: &str) -> JsValue { .unwrap_or_else(|| crate::error::create_from_text(vm, err)) } -/// 按构造函数 C 构造 Array.from 的结果对象：C 可构造时以 C.prototype 分配 `this` -/// 后调用 C（返回非对象时回退 `this`），否则返回普通空数组。 +/// 按构造函数 C 构造 Array.from/of / species 的结果对象：C 可构造时走完整 +/// Construct(C, args)（native 值传递 / bytecode 压构造帧，含 derived 构造器 +/// super() 语义与 new.target 传播），否则返回普通空数组。 /// /// # 返回值 /// `(结果对象指针, 是否为真数组)`。 @@ -285,42 +292,17 @@ fn construct_array_from_result( let arr = vm.alloc_object(JsObject::new_array(EMPTY_SHAPE_ID, proto_val, 0, vm.epoch().bump())); (arr, true) }; - if !c.is_object() { + // 不可构造（箭头函数 / 非构造器标记的 native 方法 / 普通值）回退普通数组。 + if !is_constructor_value(c) { return Ok(fallback_array()); } - let c_obj = unsafe { &*c.as_js_object_ptr() }; - // 不可构造：箭头函数、非构造器标记的 native 方法。 - let constructible = c_obj.is_function() - && !c_obj.is_arrow() - && !(c_obj.native_fn().is_some() && c_obj.type_tag != JsObject::OBJ_TYPE_CONSTRUCTOR); - if !constructible { - return Ok(fallback_array()); - } - - // 仿 Reflect.construct：以 C.prototype 分配 this 后调用 C。 - let proto_si = vm.kernel_core().perm_interner().intern("prototype").0; - let ctor_proto = match vm.resolve_property(c_obj, proto_si) { - Some(p) if p.is_object() => p, - _ => JsValue::from_js_object(vm.session().builtin_world().object_proto.as_ptr() as *mut JsObject), - }; - let this_ptr = vm.alloc_object(JsObject::new_empty(EMPTY_SHAPE_ID, ctor_proto)); - let this_val = JsValue::from_js_object(this_ptr); - match vm.call_function_sync(c, this_val, args) { - Ok(ret) if ret.is_object() => { - let ret_ptr = ret.as_js_object_ptr(); - let ret_tag = unsafe { &*ret_ptr }.type_tag; - // 原始值包装对象（如 `Object(4)` 返回的 Number 包装）的索引属性存储不完整， - // 回退到刚分配的对象；真数组/普通对象按规范使用构造返回对象。 - if matches!( - ret_tag, - JsObject::OBJ_TYPE_STRING_OBJ | JsObject::OBJ_TYPE_NUMBER_OBJ | JsObject::OBJ_TYPE_BOOLEAN_OBJ - ) { - return Ok((this_ptr, false)); - } - Ok((ret_ptr, unsafe { &*ret_ptr }.is_array())) + match vm.construct_ctor(c, args) { + Ok(obj) => { + let obj_ptr = obj.as_js_object_ptr(); + Ok((obj_ptr, unsafe { &*obj_ptr }.is_array())) } - Ok(_) => Ok((this_ptr, false)), - Err(err) => Err(from_engine_error(vm, &err)), + // 构造器抛错：原值经 Err 直传（保原值身份，不做文本降级重建）。 + Err(err) => Err(err), } } diff --git a/crates/oxide_runtime_api/src/host.rs b/crates/oxide_runtime_api/src/host.rs index 10a30b01..c45b47c5 100644 --- a/crates/oxide_runtime_api/src/host.rs +++ b/crates/oxide_runtime_api/src/host.rs @@ -141,6 +141,20 @@ pub trait VmHost { // 调用基础设施 fn call_function_sync(&mut self, callee: JsValue, receiver: JsValue, args: &[JsValue]) -> Result; + /// 构造调用（Construct(C, args)）：native 构造器以新对象为 receiver 值传递调用， + /// bytecode 构造器压构造帧执行（含 derived 构造器 super() 语义与 new.target + /// 传播），返回值非对象时回退到新对象。 + /// + /// # 边界与前提 + /// - `ctor` 必须为可构造值（箭头 / 非构造 native / 普通值在入口处拒绝， + /// 返回 `Err`）；`args` 为完整实参列表。 + /// + /// # 副作用 + /// - bytecode 构造器压帧内嵌 dispatch：调用方执行状态在帧边界保存/恢复 + /// （寄存器窗口 / 表代际 / spill）。 + /// - 失败时已消费 `last_uncaught_value`，`Err` 直接携带原始抛出值 + /// （保原值身份，不做文本降级）；调用方不得再取槽。 + fn construct_ctor(&mut self, ctor: JsValue, args: &[JsValue]) -> Result; /// 取回在 String 展平调用边界上保留下来的原始抛出 JsValue， /// 使迭代器包装器能重新抛出原错误而非二次包装。 fn take_uncaught_value(&mut self) -> Option; diff --git a/crates/oxide_vm/src/bindings/bind_array.rs b/crates/oxide_vm/src/bindings/bind_array.rs index 0e3846a5..0696625e 100644 --- a/crates/oxide_vm/src/bindings/bind_array.rs +++ b/crates/oxide_vm/src/bindings/bind_array.rs @@ -75,4 +75,15 @@ pub fn bind_array(core: &Arc, session: &KernelSession, global: &mut let ctor_ptr = session.builtin_world().array_constructor.as_ptr() as *mut JsObject; bind_constructor!(core, global, "Array", ctor_ptr, oxide_builtins::array::array_constructor::, 1, hash: true); + // Array[Symbol.species] 访问器：getter 返回 receiver，派生类沿静态原型链 + // 解析 @@species 得自身构造器（规范不给 class 默认 static @@species，类上 + // 无 own 属性）。 + super::bind_accessor_getter_key( + core, + session, + unsafe { &mut *ctor_ptr }, + oxide_types::private_key::make_well_known_symbol_key(oxide_types::private_key::WELL_KNOWN_SYMBOL_SPECIES), + "get [Symbol.species]", + oxide_builtins::array::array_species_get:: as *const (), + ); } diff --git a/crates/oxide_vm/src/bindings/mod.rs b/crates/oxide_vm/src/bindings/mod.rs index a519c384..e493e92d 100644 --- a/crates/oxide_vm/src/bindings/mod.rs +++ b/crates/oxide_vm/src/bindings/mod.rs @@ -146,31 +146,48 @@ pub(crate) fn apply_binding_table( } } -/// 在原型上绑定一个原生访问器 getter（如 Set/Map 的 `size`），set 恒为 undefined。 +/// 在原型上绑定一个字符串键的原生访问器 getter（如 Set/Map 的 `size`）， +/// set 恒为 undefined。 /// /// # 步骤 -/// 1. 构造一个 native getter 函数对象（name 为 `get `，length 0）。 -/// 2. 为属性名开 shape 槽位并写入访问器 meta。 +/// 1. 以 `get ` 为 name 标签委托到 [`Self::bind_accessor_getter_key`]。 /// /// # 注意事项 /// getter 函数对象登记进 world 释放表，与 `bind_method` 的方法 wrapper 同一生命周期约定 /// （session 收尾时统一释放）。 pub(crate) fn bind_accessor_getter( core: &Arc, session: &KernelSession, proto: &mut JsObject, name: &str, getter_fn: *const (), +) { + let si = core.perm_interner().intern(name).0; + let getter_name = format!("get {name}"); + bind_accessor_getter_key(core, session, proto, si, &getter_name, getter_fn) +} + +/// 在原型上按任意属性键（字符串 intern 键或 well-known symbol 键）绑定一个 +/// 原生访问器 getter，set 恒为 undefined。 +/// +/// # 步骤 +/// 1. 构造一个 native getter 函数对象（name 为 `getter_label`，length 0）。 +/// 2. 为键开 shape 槽位并写入访问器 meta（enumerable=false, configurable=true）。 +/// +/// # 注意事项 +/// getter 函数对象登记进 world 释放表，与 `bind_method` 的方法 wrapper 同一生命周期约定 +/// （session 收尾时统一释放）。 +pub(crate) fn bind_accessor_getter_key( + core: &Arc, session: &KernelSession, proto: &mut JsObject, key: u32, getter_label: &str, + getter_fn: *const (), ) { let shape_forge = core.shape_forge().as_ref(); let string_forge = core.perm_interner().as_ref(); let world = session.builtin_world(); - let si = string_forge.intern(name).0; - let getter_name = format!("get {name}"); - let si_label = string_forge.intern(&getter_name).0; + let si_label = string_forge.intern(getter_label).0; // SAFETY: getter_fn 是转成 *const () 的 NativeFn 函数项指针。 let getter_fn_ptr = unsafe { oxide_types::object::NativeFnPtr::from_raw(getter_fn) }; // 选择性重建复用：同家族同槽旧 getter 迁移到新 proto 的访问器槽（proto // 槽已由重建收尾重指），不再新建对象。 let reuse_key = - oxide_kernel::builtin::FnWrapperKey::new(world.wrapper_family_of(proto as *const JsObject), 0, si, si_label); + oxide_kernel::builtin::FnWrapperKey::new(world.wrapper_family_of(proto as *const JsObject), 0, key, si_label); let getter_ptr = match world.find_fn_wrapper(reuse_key, getter_fn_ptr, 0) { Some(ptr) => ptr, None => { @@ -203,7 +220,7 @@ pub(crate) fn bind_accessor_getter( }; let getter_val = JsValue::from_js_object(getter_ptr); - let new_shape = shape_forge.make_shape(proto.shape_id(), si); + let new_shape = shape_forge.make_shape(proto.shape_id(), key); proto.set_shape_id(new_shape); let pos = proto.push_prop(JsValue::undefined()); proto.set_accessor_meta(pos, getter_val, JsValue::undefined(), PropAttributes::new(true, false, true)); diff --git a/crates/oxide_vm/src/dispatch/call.rs b/crates/oxide_vm/src/dispatch/call.rs index d440bee0..067b745d 100644 --- a/crates/oxide_vm/src/dispatch/call.rs +++ b/crates/oxide_vm/src/dispatch/call.rs @@ -580,14 +580,14 @@ impl Vm { } if super_obj.native_fn().is_some() { - self.regs[253] = derived_this; - self.regs[254] = super_ctor; // bind_dispatcher 把 regs[254] 当作包装 callee 读取 - let (args_buf, len) = Self::build_native_args(first_arg_reg, arg_count, 253); - // SAFETY: native_fn 经 set_native_fn 以合法 NativeFn 指针设置； - // native_fn_ptr_to_fn 是 NativeFnPtr → NativeFn 的唯一强制转换点。 - let func: NativeFn = unsafe { native_fn_ptr_to_fn(super_obj.native_fn().unwrap()) }; - match func(self, &args_buf[..len]) { - NativeResult::Ok(val) => { + // 实参先物化再走同步调用收口：native 调用协议把 253/254 槽固定为 + // receiver/callee，实参寄存器（颜色 ≤253）占位 253 时裸引用会被覆写 + // （与 SUPER_CALL_SPREAD 路径同形）。 + let args: Vec = (0..arg_count) + .map(|i| self.regs[first_arg_reg.wrapping_add(i as u8) as usize]) + .collect(); + match self.call_function_sync(super_ctor, derived_this, &args) { + Ok(val) => { // super() 返回实例的 [[Prototype]] 须设为 new.target.prototype //（native 构造器不知道 new.target，由调用方设置）。 let instance = if val.is_object() { val } else { derived_this }; @@ -598,26 +598,18 @@ impl Vm { self.regs[rd] = self.regs[254]; self.mark_super_called(); } - NativeResult::Err(err_val) => { - self.exception_value = Some(err_val); - self.pending_error_kind = Some(self.thrown_error_kind(err_val)); + Err(_) => { + let exc = self + .last_uncaught_value + .take() + .unwrap_or_else(|| oxide_builtins::error::create_error(self, "super() call failed")); + self.exception_value = Some(exc); + self.pending_error_kind = Some(self.thrown_error_kind(exc)); match self.unwind() { Ok(()) => return Ok(true), Err(e) => return Err(e), } } - NativeResult::TailCall { callee, this, args } => { - // 如 bound 函数：解析尾调用，用其返回值作为构造实例 - // （或回退到 derived_this）。 - let val = self.call_function_sync(callee, this, &args)?; - let instance = if val.is_object() { val } else { derived_this }; - if instance.is_object() { - self.set_constructed_proto(instance, new_target_obj)?; - } - self.regs[254] = instance; - self.regs[rd] = self.regs[254]; - self.mark_super_called(); - } } } else if super_obj.sub_module_index() > 0 { let sub_idx = super_obj.sub_module_index() as usize; diff --git a/crates/oxide_vm/src/promise/constructor.rs b/crates/oxide_vm/src/promise/constructor.rs index 0a74b1aa..e0a15fce 100644 --- a/crates/oxide_vm/src/promise/constructor.rs +++ b/crates/oxide_vm/src/promise/constructor.rs @@ -42,7 +42,11 @@ impl Vm { /// 构造调用（Construct(C, args)）：native 构造器值传递调用，bytecode 构造器 /// 压构造帧执行（含 derived 构造器 super() 语义），返回值非对象时回退到新对象。 - pub(super) fn construct_ctor(&mut self, ctor: JsValue, args: &[JsValue]) -> Result { + /// + /// # 边界与前提 + /// - `ctor` 非可构造值（箭头 / 非构造 native / 普通值）返回 TypeError 的 `Err`； + /// 消费 `last_uncaught_value`，调用方不得再取槽。 + pub(crate) fn construct_ctor(&mut self, ctor: JsValue, args: &[JsValue]) -> Result { // IsConstructor 校验：arrow / 非构造 native / 普通值拒绝。 if !is_constructor_value(ctor) { return Err(oxide_builtins::error::create_type_error(self, "constructor is not a constructor")); diff --git a/crates/oxide_vm/src/vm/vmhost.rs b/crates/oxide_vm/src/vm/vmhost.rs index 1f163922..ef147d9d 100644 --- a/crates/oxide_vm/src/vm/vmhost.rs +++ b/crates/oxide_vm/src/vm/vmhost.rs @@ -130,6 +130,9 @@ impl oxide_runtime_api::VmHost for Vm { fn call_function_sync(&mut self, callee: JsValue, receiver: JsValue, args: &[JsValue]) -> Result { self.call_function_sync(callee, receiver, args) } + fn construct_ctor(&mut self, ctor: JsValue, args: &[JsValue]) -> Result { + Vm::construct_ctor(self, ctor, args) + } fn checked_object_ptr(&mut self, val: JsValue, error_msg: &str) -> Result, String> { self.checked_object_ptr(val, error_msg) } diff --git a/crates/oxide_vm/src/vm_dispatch_ctrl.rs b/crates/oxide_vm/src/vm_dispatch_ctrl.rs index c943572d..8ffeb2db 100644 --- a/crates/oxide_vm/src/vm_dispatch_ctrl.rs +++ b/crates/oxide_vm/src/vm_dispatch_ctrl.rs @@ -741,16 +741,26 @@ impl Vm { let is_derived_constructor = frame.is_derived_constructor; let super_called = frame.super_called; let continuation = frame.continuation; + // 隐式返回交付当前 this 绑定：super() 已把 regs[254] 换为父构造器新建 + // 的实例，restore_frame 会把压帧期旧值回写 regs[254]，须先取。 + let current_this = self.regs[254]; vm_trace!("RETURN frame: continuation={:?}, derived={}", continuation, is_derived_constructor); self.restore_frame(frame); if let (Some(target_reg), Some(constructed_this)) = (construct_result_reg, constructed_this) { // 规范 §9.2.2.2：derived 构造器返回非对象值（含 undefined/null/原始值） - // 且未调用 super() 时抛 ReferenceError；调过 super() 则回退构造 this。 + // 且未调用 super() 时抛 ReferenceError；调过 super() 则回退当前 this + // （super 已将其换为父构造器实例，构造 this 仅作非对象兜底）。 if is_derived_constructor && !result.is_object() && !super_called { self.raise_error_kind("ReferenceError", "derived constructor must call super()")?; return Ok(None); } - self.regs[target_reg as usize] = if result.is_object() { result } else { constructed_this }; + self.regs[target_reg as usize] = if result.is_object() { + result + } else if current_this.is_object() { + current_this + } else { + constructed_this + }; self.regs[0] = self.regs[target_reg as usize]; vm_trace!("RETURN constructor: target_reg={} regs[0]={:?}", target_reg, self.regs[0]); } else { diff --git a/crates/oxide_vm/tests/class_species_construct_tests.rs b/crates/oxide_vm/tests/class_species_construct_tests.rs new file mode 100644 index 00000000..099afb5b --- /dev/null +++ b/crates/oxide_vm/tests/class_species_construct_tests.rs @@ -0,0 +1,232 @@ +//! Array[Symbol.species] 访问器绑定 + 内建侧真 [[Construct]] + derived 构造器 +//! 隐式返回交付当前 this 的引擎钉：派生类 B 经 map/filter/slice/flat/flatMap 的 +//! 结果实例身份回 B，静态链解析 B 自身，显式 super 构造器多参元素拷贝。 + +use std::sync::Arc; + +use oxide_compiler::compiler::Compiler; +use oxide_types::value::JsValue; +use oxide_vm::vm::Vm; + +fn eval_value(source: &str) -> Result<(Vm, 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))?; + let mut vm = Vm::new(); + let result = vm.run(&Arc::new(module))?; + Ok((vm, result)) +} + +fn eval_str(source: &str) -> Result { + let (vm, result) = eval_value(source)?; + vm.lookup_str(result) + .ok_or_else(|| "completion value is not a string".to_string()) +} + +// Array[Symbol.species] 是访问器属性：get 函数、set undefined、!enumerable、configurable。 +#[test] +fn eval_species_accessor_descriptor() { + let out = eval_str( + "(() => { const d = Object.getOwnPropertyDescriptor(Array, Symbol.species); \ + return typeof d.get + '|' + (d.set === undefined) + '|' + d.enumerable + '|' + d.configurable; })()", + ) + .unwrap(); + assert_eq!(out, "function|true|false|true"); +} + +// species getter 的 Function.length 为 0。 +#[test] +fn eval_species_getter_length_zero() { + let out = eval_str("String(Object.getOwnPropertyDescriptor(Array, Symbol.species).get.length)").unwrap(); + assert_eq!(out, "0"); +} + +// species getter 的 Function.name 为规范标签。 +#[test] +fn eval_species_getter_name() { + let out = eval_str("Object.getOwnPropertyDescriptor(Array, Symbol.species).get.name").unwrap(); + assert_eq!(out, "get [Symbol.species]"); +} + +// species getter 返回 receiver（显式 call 形态）。 +#[test] +fn eval_species_getter_returns_receiver() { + let out = eval_str( + "(() => { const o = {}; \ + return (Object.getOwnPropertyDescriptor(Array, Symbol.species).get.call(o) === o) + ''; })()", + ) + .unwrap(); + assert_eq!(out, "true"); +} + +// 派生类沿静态原型链解析 @@species 得自身构造器，且类上无 own 属性。 +#[test] +fn eval_species_static_chain_resolves_self() { + let out = eval_str( + "(() => { class B extends Array {} \ + return (B[Symbol.species] === B) + '|' + \ + (Object.getOwnPropertyDescriptor(B, Symbol.species) === undefined); })()", + ) + .unwrap(); + assert_eq!(out, "true|true"); +} + +// B 实例 map 结果 instanceof B（species 主形态）。 +#[test] +fn eval_map_instance_of_derived() { + let out = + eval_str("(() => { class B extends Array {} return (new B(2).map(x => x) instanceof B) + ''; })()").unwrap(); + assert_eq!(out, "true"); +} + +// B 实例 filter/slice/flat/flatMap 四挂载全回 B 实例。 +#[test] +fn eval_filter_slice_flat_flatmap_instance_of_derived() { + let out = eval_str( + "(() => { class B extends Array {} const b = new B(2); b[0] = 1; b[1] = 2; \ + return (b.filter(x => true) instanceof B) + '|' + \ + (b.slice(0) instanceof B) + '|' + \ + (b.flat() instanceof B) + '|' + \ + (b.flatMap(x => x) instanceof B); })()", + ) + .unwrap(); + assert_eq!(out, "true|true|true|true"); +} + +// 嵌套继承 C extends B：C 实例 map 回 C 实例。 +#[test] +fn eval_nested_inheritance_map_instance_of() { + let out = eval_str( + "(() => { class B extends Array {} class C extends B {} \ + return (new C(2).map(x => x) instanceof C) + ''; })()", + ) + .unwrap(); + assert_eq!(out, "true"); +} + +// species 结果是真数组 exotic（Array.isArray 识别）。 +#[test] +fn eval_species_result_is_array() { + let out = + eval_str("(() => { class B extends Array {} return Array.isArray(new B(2).map(x => x)) + ''; })()").unwrap(); + assert_eq!(out, "true"); +} + +// 显式单参 super 构造器：隐式返回交付 super 新建的实例（length 来自父构造器）。 +#[test] +fn eval_explicit_super_single_arg_length() { + let out = eval_str( + "(() => { class Sub extends Array { constructor(a) { super(a); } } \ + return new Sub(42).length + ''; })()", + ) + .unwrap(); + assert_eq!(out, "42"); +} + +// 显式多参 super 构造器：元素经父构造器拷贝进实例。 +#[test] +fn eval_explicit_super_spread_elements() { + let out = eval_str( + "(() => { class Sub extends Array { constructor(...a) { super(...a); } } \ + return JSON.stringify(new Sub(1, 2, 3)); })()", + ) + .unwrap(); + assert_eq!(out, "[1,2,3]"); +} + +// Array.of 经 C 构造：class 形态回 C 实例。 +#[test] +fn eval_array_of_via_derived_ctor() { + let out = + eval_str("(() => { class B extends Array {} return (Array.of.call(B, 1, 2) instanceof B) + ''; })()").unwrap(); + assert_eq!(out, "true"); +} + +// species 为普通可构造 Ctor：返回体直接作结果（元素 CDO 写入其上）。 +#[test] +fn eval_species_plain_ctor_returned_body() { + let out = eval_str( + "(() => { function Ctor(n) { const a = [7, 8]; a.push(n); return a; } \ + const a = [1, 2]; a.constructor = {}; a.constructor[Symbol.species] = Ctor; \ + const r = a.map(x => x); \ + return r.length + '|' + r[0] + '|' + r[1] + '|' + r[2] + '|' + (r instanceof Array); })()", + ) + .unwrap(); + assert_eq!(out, "3|1|2|2|true"); +} + +// 守卫：构造器直 new 面不回归。 +#[test] +fn eval_guard_derived_new_instance() { + let out = eval_str("(() => { class B extends Array {} return (new B(2) instanceof B) + ''; })()").unwrap(); + assert_eq!(out, "true"); +} + +// 守卫：普通数组 map 结果 isArray + 值保真。 +#[test] +fn eval_guard_plain_map_values() { + let out = eval_str("(() => { const m = [1, 2].map(x => x); return Array.isArray(m) + '|' + m[1]; })()").unwrap(); + assert_eq!(out, "true|2"); +} + +// 守卫：隐式 super 构造器 length 与多参元素。 +#[test] +fn eval_guard_implicit_super() { + let out = eval_str( + "(() => { class Sub extends Array {} const s = new Sub(7); const t = new Sub(7, 8); \ + return s.length + '|' + t.length + '|' + t[0] + '|' + t[1]; })()", + ) + .unwrap(); + assert_eq!(out, "7|2|7|8"); +} + +// 守卫：native 父构造器 Reflect.construct 路径在位。 +#[test] +fn eval_guard_reflect_construct_native() { + let out = eval_str("String(Reflect.construct(Array, [3]).length)").unwrap(); + assert_eq!(out, "3"); +} + +// 守卫：静态原型链果——B.prototype 的原型即 Array.prototype。 +#[test] +fn eval_guard_prototype_chain() { + let out = eval_str( + "(() => { class B extends Array {} \ + return (Object.getPrototypeOf(B.prototype) === Array.prototype) + ''; })()", + ) + .unwrap(); + assert_eq!(out, "true"); +} + +// 守卫：c={} 形态（constructor 为普通对象、无 species）slice 回普通数组。 +#[test] +fn eval_guard_plain_ctor_lookup() { + let out = eval_str( + "(() => { const a = [1, 2, 3]; a.constructor = {}; const s = a.slice(1); \ + return s.length + '|' + (s instanceof Array) + '|' + s[0]; })()", + ) + .unwrap(); + assert_eq!(out, "2|true|2"); +} + +// 守卫：普通数组 slice/filter 结果 plain Array。 +#[test] +fn eval_guard_plain_slice_filter() { + let out = eval_str( + "(() => { const a = [1, 2, 3]; \ + return (a.slice(1) instanceof Array) + '|' + (a.filter(x => true) instanceof Array); })()", + ) + .unwrap(); + assert_eq!(out, "true|true"); +} + +// 守卫：String 无 species 绑定（不引入 String[Symbol.species]）。 +#[test] +fn eval_guard_string_no_species() { + let out = eval_str( + "(() => { class S extends String {} \ + return (S[Symbol.species] === undefined) + '|' + (String[Symbol.species] === undefined); })()", + ) + .unwrap(); + assert_eq!(out, "true|true"); +}