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

crates/oxide_bytecode/src/opcode.rs

@@ -586,6 +586,12 @@ define_opcodes! {
     DEFINE_GLOBAL_FUNC_BIND = 0x9E => "DEFINE_GLOBAL_FUNC_BIND",
         def = None, uses = [SlotSpec::Slot(Slot::Rd), SlotSpec::Slot(Slot::A), SlotSpec::Slot(Slot::B)],
         pure = false, jump = false, term = false, ic = false,
+    // 计算键访问器并指定描述符：同形 DEFINE_ACCESSOR_ATTRS，但 ext[0] 为高位标记
+    // 键寄存器（`0x8000_0000 | key_reg`，键值运行期从寄存器读取）、ext[1] = attrs。
+    // 发射方仅 class 体计算 get/set（规范 DefineMethod，enumerable=false）。
+    DEFINE_ACCESSOR_ATTRS_DYNAMIC = 0x9F => "DEFINE_ACCESSOR_ATTRS_DYNAMIC",
+        def = None, uses = [SlotSpec::Slot(Slot::Rd), SlotSpec::Slot(Slot::A), SlotSpec::Slot(Slot::B), SlotSpec::ExtReg],
+        pure = false, jump = false, term = false, ic = false,
 
     // ── 成员复合赋值：位/移位 (0x64-0x69) ──
     COMPOUND_MEMBER_BIT_AND = 0x64 => "COMPOUND_MEMBER_BIT_AND",
@@ -860,6 +866,7 @@ mod tests {
         assert_eq!(OpCode::DEFINE_ACCESSOR_DYNAMIC as u8, 0x7F);
         assert_eq!(OpCode::SET_PROP_BATCH as u8, 0x92);
         assert_eq!(OpCode::CONCAT_N as u8, 0x93);
+        assert_eq!(OpCode::DEFINE_ACCESSOR_ATTRS_DYNAMIC as u8, 0x9F);
         assert_eq!(OpCode::ADD.to_string(), "ADD");
         assert_eq!(OpCode::COMPOUND_MEMBER_EXP.to_string(), "COMPOUND_MEMBER_EXP");
         assert_eq!(OpCode::MOV.to_string(), "MOV");

crates/oxide_compiler/tests/compile_expr_tests.rs

@@ -701,6 +701,7 @@ fn scan_opcodes(module: &CompiledModule) -> Vec<OpCode> {
                 | OpCode::REST_OBJECT
                 | OpCode::INIT_PRIVATE => 1,
                 OpCode::DEFINE_ACCESSOR_ATTRS
+                | OpCode::DEFINE_ACCESSOR_ATTRS_DYNAMIC
                 | OpCode::GET_PRIVATE
                 | OpCode::SET_PRIVATE
                 | OpCode::PRIVATE_BRAND_IN => 2,

crates/oxide_emit/src/class/method.rs

@@ -65,24 +65,33 @@ impl Emitter {
                         ));
                     }
                     MethodDefinitionKind::Get | MethodDefinitionKind::Set => {
-                        if method.computed {
-                            return Err("computed class accessors not yet supported".into());
-                        }
                         let undef_reg = self.emit_undefined(ctx);
                         let (get_reg, set_reg) = if method.kind == MethodDefinitionKind::Get {
                             (accessor_reg, undef_reg)
                         } else {
                             (undef_reg, accessor_reg)
                         };
-                        let key_name = crate::shared::string_pool::pool_key_property(&method.key)?;
+                        if method.computed {
-                        let key_idx = ctx.add_constant(Constant::String(key_name));
+                            // 计算键：键值在类定义期已入键数组，此处取 slot 键寄存器，
-                        ctx.inst(Inst::define_accessor_attrs(
+                            // 发运行期取键的动态指令（描述符同静态臂）。
-                            Operand::Reg(home_reg),
+                            ctx.inst(Inst::define_accessor_attrs_dynamic(
-                            Operand::Reg(get_reg),
+                                Operand::Reg(home_reg),
-                            Operand::Reg(set_reg),
+                                Operand::Reg(get_reg),
-                            key_idx as u32,
+                                Operand::Reg(set_reg),
-                            CLASS_METHOD_ATTRS,
+                                key_reg,
-                        ));
+                                CLASS_METHOD_ATTRS,
+                            ));
+                        } else {
+                            let key_name = crate::shared::string_pool::pool_key_property(&method.key)?;
+                            let key_idx = ctx.add_constant(Constant::String(key_name));
+                            ctx.inst(Inst::define_accessor_attrs(
+                                Operand::Reg(home_reg),
+                                Operand::Reg(get_reg),
+                                Operand::Reg(set_reg),
+                                key_idx as u32,
+                                CLASS_METHOD_ATTRS,
+                            ));
+                        }
                     }
                     MethodDefinitionKind::Constructor => continue,
                 }

crates/oxide_ir/src/inst.rs

@@ -206,6 +206,12 @@ impl Inst {
     pub fn define_accessor_attrs(home: Operand, get: Operand, set: Operand, key_idx: u32, attrs: u32) -> Self {
         Self::with_ext(OpCode::DEFINE_ACCESSOR_ATTRS, home, get, set, &[key_idx, attrs])
     }
+
+    /// 定义计算键访问器属性并指定描述符：ext = [key 寄存器（高位标记 `0x8000_0000 | key_reg`）,
+    /// attrs]（attrs 位同 DEFINE_PROP_ATTRS），键值运行期从寄存器读取。
+    pub fn define_accessor_attrs_dynamic(home: Operand, get: Operand, set: Operand, key_reg: u32, attrs: u32) -> Self {
+        Self::with_ext(OpCode::DEFINE_ACCESSOR_ATTRS_DYNAMIC, home, get, set, &[0x8000_0000 | key_reg, attrs])
+    }
     /// 定义访问器属性（运行时计算键）：home 为宿主对象，get/set 为访问器函数寄存器，
     /// key_reg 为键值寄存器（编码进 ext[0]，高位标记 `0x8000_0000 | key_reg`）。
     pub fn define_accessor_dynamic(home: Operand, get: Operand, set: Operand, key_reg: u32) -> Self {

crates/oxide_ir/tests/contract_tests.rs

@@ -415,6 +415,9 @@ fn canonical_inst(op: OpCode) -> Inst {
         OpCode::DEFINE_ACCESSOR_DYNAMIC => {
             Inst::define_accessor_dynamic(Operand::Reg(1), Operand::Reg(2), Operand::Reg(3), 7)
         }
+        OpCode::DEFINE_ACCESSOR_ATTRS_DYNAMIC => {
+            Inst::define_accessor_attrs_dynamic(Operand::Reg(1), Operand::Reg(2), Operand::Reg(3), 7, 0b101)
+        }
         OpCode::DELETE_PROP_STATIC => Inst::delete_prop_static(Operand::Reg(1), 9),
         _ => Inst::new(op, Operand::Reg(1), Operand::Reg(2), Operand::Reg(3)),
     }
@@ -598,6 +601,7 @@ fn opcode_semantics_golden_table() {
     assert_contract(OpCode::SET_HOME_OBJECT, None, &[1, 2], false);
     assert_contract(OpCode::DEFINE_ACCESSOR, None, &[1, 2, 3], false);
     assert_contract(OpCode::DEFINE_ACCESSOR_DYNAMIC, None, &[1, 2, 3, 7], false);
+    assert_contract(OpCode::DEFINE_ACCESSOR_ATTRS_DYNAMIC, None, &[1, 2, 3, 7], false);
     // Object Property：GET_PROP 写 a 槽、DYNAMIC 写 b 槽
     assert_contract(OpCode::GET_PROP, Some(2), &[1, 3], false);
     assert_contract(OpCode::GET_PROP_DYNAMIC, Some(3), &[1, 2], false);

crates/oxide_ir/tests/inst_constructors_tests.rs

@@ -79,6 +79,14 @@ fn single_ext_word_instructions() {
     assert_eq!(dyn_accessor.a, Operand::Reg(1));
     assert_eq!(dyn_accessor.b, Operand::Reg(2));
 
+    // 计算键访问器带描述符：ext = [key 寄存器高位标记, attrs] 两字。
+    let attrs_dyn = Inst::define_accessor_attrs_dynamic(Operand::Reg(0), Operand::Reg(1), Operand::Reg(2), 7, 0b101);
+    assert_eq!(attrs_dyn.op, OpCode::DEFINE_ACCESSOR_ATTRS_DYNAMIC);
+    assert_eq!(attrs_dyn.ext.as_slice(), &[0x8000_0000 | 7, 0b101]);
+    assert_eq!(attrs_dyn.rd, Operand::Reg(0));
+    assert_eq!(attrs_dyn.a, Operand::Reg(1));
+    assert_eq!(attrs_dyn.b, Operand::Reg(2));
+
     let rest = Inst::rest_object(Operand::Reg(0), Operand::Reg(1), 7, None);
     assert_eq!(rest.ext.as_slice(), &[7]);
 

crates/oxide_regalloc/src/graph.rs

@@ -80,7 +80,7 @@ pub(super) fn collect_real_vregs(f: &IRFunction) -> BTreeSet<u32> {
             }
         }
         // 计算键访问器：ext[0] 是 key 寄存器（高位标记 `0x8000_0000 | vreg`）。
-        if inst.op == OpCode::DEFINE_ACCESSOR_DYNAMIC {
+        if matches!(inst.op, OpCode::DEFINE_ACCESSOR_DYNAMIC | OpCode::DEFINE_ACCESSOR_ATTRS_DYNAMIC) {
             let r = inst.ext.first().copied().unwrap_or(0) & 0x7FFF_FFFF;
             if r != 0 {
                 real.insert(r);

crates/oxide_regalloc/src/rewrite.rs

@@ -238,9 +238,9 @@ fn rewrite_inst(
             }
             ext
         }
-        // DEFINE_ACCESSOR_DYNAMIC：ext[0] 是 key 寄存器（高位标记 `0x8000_0000 | vreg`），
+        // 计算键访问器：ext[0] 是 key 寄存器（高位标记 `0x8000_0000 | vreg`），
         // 低 31 位重映射后保留高位标记。
-        OpCode::DEFINE_ACCESSOR_DYNAMIC => {
+        OpCode::DEFINE_ACCESSOR_DYNAMIC | OpCode::DEFINE_ACCESSOR_ATTRS_DYNAMIC => {
             let mut ext = inst.ext.clone();
             if let Some(word) = ext.first_mut() {
                 let nr = remap_ext_reg(*word & 0x7FFF_FFFF, slot_color, map);

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);
+}