feat: 类体计算键访问器落地动态定义访问器指令

crates/oxide_vm/src/ic_helper.rs

@@ -72,7 +72,11 @@ fn ext_word_count(bytecode: &[Instr], pc: usize) -> usize {
         | OpCode::DELETE_PROP_STATIC
         | OpCode::REST_OBJECT
         | OpCode::INIT_PRIVATE => 1,
-        OpCode::DEFINE_ACCESSOR_ATTRS | OpCode::GET_PRIVATE | OpCode::SET_PRIVATE | OpCode::PRIVATE_BRAND_IN => 2,
+        OpCode::DEFINE_ACCESSOR_ATTRS
+        | OpCode::DEFINE_ACCESSOR_ATTRS_DYNAMIC
+        | OpCode::GET_PRIVATE
+        | OpCode::SET_PRIVATE
+        | OpCode::PRIVATE_BRAND_IN => 2,
         // 逃出计数 ext：BREAK/CONTINUE/RETURN 恒带 1 个 pack_escape_counts 字
         // （for-of/for-in 逃出层数打包）；lower 对这三条无条件落 ext 字，
         // dispatch 经 read_escape_counts 消费，扫描必须同步跳过以免错位。

crates/oxide_vm/src/vm/dispatch_loop.rs

@@ -517,6 +517,13 @@ impl Vm {
                     self.dispatch_define_accessor_attrs(rd, a, b, key_word, attrs)?;
                 }
 
+                OpCode::DEFINE_ACCESSOR_ATTRS_DYNAMIC => {
+                    let key_word = self.bytecode[self.pc];
+                    let attrs = self.bytecode[self.pc + 1] as u8;
+                    self.pc += 2;
+                    self.dispatch_define_accessor_attrs_dynamic(rd, a, b, key_word, attrs)?;
+                }
+
                 OpCode::RETURN => match self.dispatch_return(instr) {
                     Ok(Some(result)) => return Ok(result),
                     Ok(None) => {}

crates/oxide_vm/src/vm_dispatch_ctrl.rs

@@ -153,7 +153,8 @@ impl Vm {
         } else {
             self.property_key_si(key_val)?
         };
-        self.dispatch_define_accessor_common(rd, a, b, prop_name_si)
+        // 对象字面量访问器：可枚举数据语义（DEFAULT_DATA）。
+        self.dispatch_define_accessor_common(rd, a, b, prop_name_si, PropAttributes::DEFAULT_DATA)
     }
 
     /// 计算键访问器：ext[0] 高位标记 `0x8000_0000 | key_reg`，键值运行时从寄存器读取。
@@ -163,12 +164,26 @@ impl Vm {
         self.pc += 1;
         let key_reg = (key_word & 0x7FFF_FFFF) as usize;
         let prop_name_si = self.property_key_si(self.regs[key_reg])?;
-        self.dispatch_define_accessor_common(rd, a, b, prop_name_si)
+        // 对象字面量访问器：可枚举数据语义（DEFAULT_DATA）。
+        self.dispatch_define_accessor_common(rd, a, b, prop_name_si, PropAttributes::DEFAULT_DATA)
     }
 
-    /// 访问器定义公共路径：读 get/set 槽、合并已有访问器、写属性。
+    /// 计算键访问器并指定描述符：ext = [key 寄存器（高位标记 `0x8000_0000 | key_reg`）,
+    /// attrs]，attrs 位同 DEFINE_PROP_ATTRS（bit0=writable, bit1=enumerable,
+    /// bit2=configurable）。发射方仅 class 体计算 get/set（规范 DefineMethod，
+    /// enumerable=false）。
+    pub(crate) fn dispatch_define_accessor_attrs_dynamic(
+        &mut self, rd: usize, a: usize, b: usize, key_word: u32, attrs: u8,
+    ) -> Result<(), String> {
+        vm_trace!("DEFINE_ACCESSOR_ATTRS_DYNAMIC rd={} getter={} setter={} attrs={:#04b}", rd, a, b, attrs);
+        let key_reg = (key_word & 0x7FFF_FFFF) as usize;
+        let prop_name_si = self.property_key_si(self.regs[key_reg])?;
+        self.dispatch_define_accessor_common(rd, a, b, prop_name_si, PropAttributes(attrs))
+    }
+
+    /// 访问器定义公共路径：读 get/set 槽、合并已有访问器、按 `attrs` 写属性。
     fn dispatch_define_accessor_common(
-        &mut self, rd: usize, a: usize, b: usize, prop_name_si: u32,
+        &mut self, rd: usize, a: usize, b: usize, prop_name_si: u32, attrs: PropAttributes,
     ) -> Result<(), String> {
         let obj_val = self.regs[rd];
         if !obj_val.is_object() {
@@ -191,7 +206,7 @@ impl Vm {
         } else {
             setter
         };
-        match self.define_accessor_property(obj, prop_name_si, get, set, PropAttributes::DEFAULT_DATA) {
+        match self.define_accessor_property(obj, prop_name_si, get, set, attrs) {
             Ok(()) => Ok(()),
             Err(msg) => self.raise_error_kind("TypeError", &msg),
         }

crates/oxide_vm/tests/class_tests.rs

@@ -933,3 +933,114 @@ fn delete_super_property_uninitialized_this_key_not_evaluated_throws() {
     assert!(err.contains("ReferenceError"), "expected ReferenceError, got: {err}");
     assert!(!err.contains("base constructor called"), "base constructor must not run: {err}");
 }
+
+// ── 计算键访问器（get/set [dyn]）：类定义期键数组取键 + 运行期取键定义 ──
+
+// 计算键实例访问器对：string 键读写。
+#[test]
+fn computed_instance_accessor_pair() {
+    let mut vm = Vm::new();
+    let result = eval(
+        &mut vm,
+        "var k = 'p'; class A { get [k]() { return this.v + 1; } set [k](x) { this.v = x; } } var a = new A(); a.p = 41; a.p",
+    )
+    .unwrap();
+    assert_num(result, 42.0);
+}
+
+// 计算键静态访问器：Symbol.species 键（Promise 同形）。
+#[test]
+fn computed_static_accessor_symbol_species_key() {
+    let mut vm = Vm::new();
+    let result = eval(&mut vm, "class A { static get [Symbol.species]() { return 7; } } A[Symbol.species]").unwrap();
+    assert_eq!(result.as_int(), 7);
+}
+
+// 半对：只有 getter，setter 边为 undefined。
+#[test]
+fn computed_accessor_get_only_set_undefined() {
+    let mut vm = Vm::new();
+    let result = eval(
+        &mut vm,
+        "var k = 'g'; class A { get [k]() { return 3; } } Object.getOwnPropertyDescriptor(Object.getPrototypeOf(new A()), 'g').set === undefined",
+    )
+    .unwrap();
+    assert!(result.is_bool() && result.as_bool(), "set should be undefined");
+}
+
+// 半对：只有 setter，getter 边为 undefined。
+#[test]
+fn computed_accessor_set_only_get_undefined() {
+    let mut vm = Vm::new();
+    let result = eval(
+        &mut vm,
+        "var k = 's'; class A { set [k](v) { this._v = v; } } Object.getOwnPropertyDescriptor(Object.getPrototypeOf(new A()), 's').get === undefined",
+    )
+    .unwrap();
+    assert!(result.is_bool() && result.as_bool(), "get should be undefined");
+}
+
+// 与既有访问器对合并：静态 get b 后被计算键 get ['b'] 覆盖，getter 替换、setter 保留。
+#[test]
+fn computed_accessor_merges_existing_pair() {
+    let mut vm = Vm::new();
+    let result = eval(
+        &mut vm,
+        "var k = 'b'; class A { get b() { return 1; } set b(v) { this._v = v; } get [k]() { return 9; } } var a = new A(); a.b = 5; a.b * 10 + a._v",
+    )
+    .unwrap();
+    assert_num(result, 95.0);
+}
+
+// 描述符核：enumerable=false、configurable=true（规范 DefineMethod，区别于对象
+// 字面量访问器的可枚举）。
+#[test]
+fn computed_accessor_descriptor_non_enumerable_configurable() {
+    let mut vm = Vm::new();
+    let result = eval(
+        &mut vm,
+        "var k = 'd'; class A { get [k]() { return 1; } } var d = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(new A()), 'd'); (d.enumerable === false) * 10 + (d.configurable === true)",
+    )
+    .unwrap();
+    assert_num(result, 11.0);
+}
+
+// 计算键 'constructor'：覆写原型 constructor 数据属性为访问器。
+#[test]
+fn computed_accessor_constructor_key_overrides_prototype() {
+    let mut vm = Vm::new();
+    let result = eval(
+        &mut vm,
+        "class A { get ['constructor']() { return 6; } } var a = new A(); Object.getOwnPropertyDescriptor(Object.getPrototypeOf(a), 'constructor').get !== undefined ? a.constructor : -1",
+    )
+    .unwrap();
+    assert_num(result, 6.0);
+}
+
+// static get ['prototype'] 抛 TypeError（prototype 属性不可配置，定义被拒）。
+#[test]
+fn computed_static_accessor_prototype_key_throws() {
+    let mut vm = Vm::new();
+    let err = eval(&mut vm, "class A { static get ['prototype']() { return 1; } }").unwrap_err();
+    assert!(err.contains("TypeError"), "expected TypeError, got: {err}");
+}
+
+// 键表达式副作用恰执行一次（类定义期键数组构建，方法发射不重求值）。
+#[test]
+fn computed_accessor_key_evaluated_once() {
+    let mut vm = Vm::new();
+    let result = eval(&mut vm, "var n = 0; class A { get [(n++, 'z')]() { return 1; } } new A().z; n").unwrap();
+    assert_eq!(result.as_int(), 1);
+}
+
+// 命名 symbol 计算键：运行期键走 symbol 键面读写。
+#[test]
+fn computed_accessor_symbol_key() {
+    let mut vm = Vm::new();
+    let result = eval(
+        &mut vm,
+        "var s = Symbol('tag'); class A { get [s]() { return 4; } set [s](v) { this._v = v; } } var a = new A(); a[s] = 3; a[s] * 10 + a._v",
+    )
+    .unwrap();
+    assert_num(result, 43.0);
+}