feat: 支持访问器描述符与 get/set 语法

crates/oxide_vm/src/builtins/object.rs

@@ -1,6 +1,6 @@
 use oxide_kernel::shape_forge::{ShapeForge, EMPTY_SHAPE_ID};
 use oxide_kernel::string_forge::StringForge;
-use oxide_types::object::JsObject;
+use oxide_types::object::{JsObject, PropAttributes};
 use oxide_types::value::JsValue;
 
 use crate::coercion;
@@ -153,18 +153,54 @@ pub fn object_define_property(vm: &mut Vm, args: &[u8]) -> NativeResult {
     }
     let prop_name_str = coercion::to_string(vm.kernel().string_forge().as_ref(), vm.reg(args[2]));
     let si = vm.kernel().string_forge().intern(&prop_name_str).0;
-    let shape_forge = vm.kernel().shape_forge().as_ref();
-    let new_shape = shape_forge.make_shape(unsafe { (&*obj_ptr).shape_id() }, si);
-    let value = {
-        let desc = unsafe { &*desc_ptr };
-        desc.hash_props_vec()
-            .and_then(|v| v.first().map(|b| **b))
-            .unwrap_or(JsValue::undefined())
-    };
-    {
-        let obj = unsafe { &mut *obj_ptr };
-        obj.set_shape_id(new_shape);
-        obj.ensure_hash_props().push(Box::new(value));
+
+    let value_si = vm.kernel().string_forge().intern("value").0;
+    let get_si = vm.kernel().string_forge().intern("get").0;
+    let set_si = vm.kernel().string_forge().intern("set").0;
+    let writable_si = vm.kernel().string_forge().intern("writable").0;
+    let enumerable_si = vm.kernel().string_forge().intern("enumerable").0;
+    let configurable_si = vm.kernel().string_forge().intern("configurable").0;
+
+    let desc = unsafe { &*desc_ptr };
+    let value_field = own_field(vm, desc, value_si);
+    let get_field = own_field(vm, desc, get_si);
+    let set_field = own_field(vm, desc, set_si);
+    let writable_field = own_field(vm, desc, writable_si);
+    let enumerable = own_field(vm, desc, enumerable_si)
+        .map(|v| coercion::to_boolean(v, vm.kernel().string_forge().as_ref()))
+        .unwrap_or(false);
+    let configurable = own_field(vm, desc, configurable_si)
+        .map(|v| coercion::to_boolean(v, vm.kernel().string_forge().as_ref()))
+        .unwrap_or(false);
+
+    let has_data = value_field.is_some() || writable_field.is_some();
+    let has_accessor = get_field.is_some() || set_field.is_some();
+    if has_data && has_accessor {
+        return Err(crate::builtins::error::create_type_error(
+            vm,
+            "Invalid property descriptor: cannot mix data and accessor fields",
+        ));
+    }
+
+    let obj = unsafe { &mut *obj_ptr };
+    if has_accessor {
+        let get = get_field.unwrap_or(JsValue::undefined());
+        let set = set_field.unwrap_or(JsValue::undefined());
+        if (!get.is_undefined() && !is_callable(get)) || (!set.is_undefined() && !is_callable(set)) {
+            return Err(crate::builtins::error::create_type_error(
+                vm,
+                "accessor descriptor get/set must be callable or undefined",
+            ));
+        }
+        vm.define_accessor_property(obj, si, get, set, PropAttributes::new(false, enumerable, configurable))
+            .map_err(|_| crate::builtins::error::create_type_error(vm, "Cannot define property"))?;
+    } else {
+        let value = value_field.unwrap_or(JsValue::undefined());
+        let writable = writable_field
+            .map(|v| coercion::to_boolean(v, vm.kernel().string_forge().as_ref()))
+            .unwrap_or(false);
+        vm.define_data_property(obj, si, value, PropAttributes::new(writable, enumerable, configurable))
+            .map_err(|_| crate::builtins::error::create_type_error(vm, "Cannot define property"))?;
     }
     Ok(obj_val)
 }
@@ -184,19 +220,21 @@ pub fn object_get_own_property_descriptor(vm: &mut Vm, args: &[u8]) -> NativeRes
     let prop_name_str = coercion::to_string(vm.kernel().string_forge().as_ref(), vm.reg(args[2]));
     let si = vm.kernel().string_forge().intern(&prop_name_str).0;
 
-    let (found_value, found) = {
+    let (found_value, found_meta, found) = {
         let obj = unsafe { &*obj_ptr };
         let keys = walk_own_keys(vm, obj);
         let mut found_value = JsValue::undefined();
+        let mut found_meta = None;
         let mut found = false;
         for (prop_si, offset) in keys {
             if prop_si == si {
                 found_value = obj.get_prop_at(offset);
+                found_meta = obj.prop_meta_at(offset);
                 found = true;
                 break;
             }
         }
-        (found_value, found)
+        (found_value, found_meta, found)
     };
 
     if !found {
@@ -209,34 +247,49 @@ pub fn object_get_own_property_descriptor(vm: &mut Vm, args: &[u8]) -> NativeRes
     let desc = vm
         .epoch()
         .alloc(JsObject::new_empty(EMPTY_SHAPE_ID, JsValue::from_js_object(desc_proto)));
-    let true_val = JsValue::bool(true);
     let sf = unsafe { &*sf_ptr };
     let sh = unsafe { &*sh_ptr };
 
     let d: &mut JsObject = unsafe { &mut *desc };
-    let si_val = sf.intern("value").0;
-    let sh_val = sh.make_shape(EMPTY_SHAPE_ID, si_val);
-    d.set_shape_id(sh_val);
-    d.ensure_hash_props().push(Box::new(found_value));
-
-    let si_wr = sf.intern("writable").0;
-    let sh_wr = sh.make_shape(sh_val, si_wr);
-    d.set_shape_id(sh_wr);
-    d.ensure_hash_props().push(Box::new(true_val));
-
-    let si_en = sf.intern("enumerable").0;
-    let sh_en = sh.make_shape(sh_wr, si_en);
-    d.set_shape_id(sh_en);
-    d.ensure_hash_props().push(Box::new(true_val));
-
-    let si_cf = sf.intern("configurable").0;
-    let sh_cf = sh.make_shape(sh_en, si_cf);
-    d.set_shape_id(sh_cf);
-    d.ensure_hash_props().push(Box::new(true_val));
+    let meta = found_meta.unwrap_or_else(|| oxide_types::object::PropMetaEntry::data(PropAttributes::DEFAULT_DATA));
+    if meta.is_accessor {
+        push_desc_prop(d, sh, sf.intern("get").0, meta.get);
+        push_desc_prop(d, sh, sf.intern("set").0, meta.set);
+        push_desc_prop(d, sh, sf.intern("enumerable").0, JsValue::bool(meta.attributes.enumerable()));
+        push_desc_prop(d, sh, sf.intern("configurable").0, JsValue::bool(meta.attributes.configurable()));
+    } else {
+        push_desc_prop(d, sh, sf.intern("value").0, found_value);
+        push_desc_prop(d, sh, sf.intern("writable").0, JsValue::bool(meta.attributes.writable()));
+        push_desc_prop(d, sh, sf.intern("enumerable").0, JsValue::bool(meta.attributes.enumerable()));
+        push_desc_prop(d, sh, sf.intern("configurable").0, JsValue::bool(meta.attributes.configurable()));
+    }
 
     Ok(JsValue::from_js_object(desc))
 }
 
+fn own_field(vm: &Vm, obj: &JsObject, prop_si: u32) -> Option<JsValue> {
+    vm.kernel()
+        .shape_forge()
+        .lookup_position(obj.shape_id(), prop_si)
+        .and_then(|pos| {
+            if obj.prop_vec_len() > pos as usize {
+                Some(obj.get_prop_at(pos))
+            } else {
+                None
+            }
+        })
+}
+
+fn is_callable(value: JsValue) -> bool {
+    value.is_object() && unsafe { &*value.as_js_object_ptr() }.is_function()
+}
+
+fn push_desc_prop(obj: &mut JsObject, shape_forge: &ShapeForge, prop_si: u32, val: JsValue) {
+    let shape_id = shape_forge.make_shape(obj.shape_id(), prop_si);
+    obj.set_shape_id(shape_id);
+    obj.push_prop(val);
+}
+
 fn require_obj_arg(vm: &mut Vm, args: &[u8], fn_name: &str) -> Result<*mut JsObject, JsValue> {
     if args.len() < 2 {
         return Err(crate::builtins::error::create_type_error(

crates/oxide_vm/src/dispatch/call.rs

@@ -30,17 +30,21 @@ impl Vm {
                 Ok(())
             }
             Err(err_val) => {
-                let msg = if err_val.is_string() {
-                    self.kernel()
-                        .string_forge()
-                        .lookup(err_val.as_string_index())
-                        .unwrap_or_else(|| format!("{err_val}"))
+                let (error, kind) = if err_val.is_object() {
+                    (err_val, self.thrown_error_kind(err_val))
                 } else {
-                    format!("{err_val}")
+                    let msg = if err_val.is_string() {
+                        self.kernel()
+                            .string_forge()
+                            .lookup(err_val.as_string_index())
+                            .unwrap_or_else(|| format!("{err_val}"))
+                    } else {
+                        format!("{err_val}")
+                    };
+                    (crate::builtins::error::create_error(self, &msg), "Error")
                 };
-                let error = crate::builtins::error::create_error(self, &msg);
                 self.exception_value = Some(error);
-                self.pending_error_kind = Some("Error");
+                self.pending_error_kind = Some(kind);
                 self.unwind()
             }
         }

crates/oxide_vm/src/dispatch/property.rs

@@ -127,21 +127,23 @@ impl Vm {
                 self.write_ic_back(obj.shape_id(), ptr);
             }
         } else {
-            let new_shape_id = self.kernel.shape_forge().make_shape(obj.shape_id(), prop_name_si);
-            obj.set_shape_id(new_shape_id);
-            let new_pos = obj.push_prop(value);
-            obj.bump_generation();
-            if let Some(ptr) = obj.prop_ptr_at(new_pos) {
-                self.write_ic_back(new_shape_id, ptr);
-                self.kernel.prop_forge().upsert(
-                    new_shape_id,
-                    PropTemplate {
-                        shape_id: new_shape_id,
-                        prop_name: prop_name_si,
-                        position: new_pos,
-                        generation: obj.generation(),
-                    },
-                );
+            let old_shape = obj.shape_id();
+            self.ordinary_set(obj, prop_name_si, value, receiver)?;
+            if old_shape != obj.shape_id() {
+                if let Some(pos) = self.kernel.shape_forge().lookup_position(obj.shape_id(), prop_name_si) {
+                    if let Some(ptr) = obj.prop_ptr_at(pos) {
+                        self.write_ic_back(obj.shape_id(), ptr);
+                        self.kernel.prop_forge().upsert(
+                            obj.shape_id(),
+                            PropTemplate {
+                                shape_id: obj.shape_id(),
+                                prop_name: prop_name_si,
+                                position: pos,
+                                generation: obj.generation(),
+                            },
+                        );
+                    }
+                }
             }
         }
 

crates/oxide_vm/src/vm.rs

@@ -14,7 +14,7 @@ use oxide_kernel::kernel::{KernelConfig, OxideKernel};
 use oxide_kernel::prop_forge::PropTemplate;
 use oxide_kernel::shape_forge::EMPTY_SHAPE_ID;
 use oxide_types::mem::{Epoch, P};
-use oxide_types::object::JsObject;
+use oxide_types::object::{JsObject, PropAttributes};
 use oxide_types::value::JsValue;
 
 #[allow(unused_macros)]
@@ -364,7 +364,7 @@ impl Vm {
         self.kernel.string_forge().lookup(val.as_string_index())
     }
 
-    fn thrown_error_kind(&self, val: JsValue) -> &'static str {
+    pub(crate) fn thrown_error_kind(&self, val: JsValue) -> &'static str {
         if !val.is_object() {
             return "Error";
         }
@@ -700,6 +700,67 @@ impl Vm {
         }
     }
 
+    pub(crate) fn define_data_property(
+        &mut self, obj: &mut JsObject, prop_name_si: u32, val: JsValue, attributes: PropAttributes,
+    ) -> Result<(), String> {
+        let pos = if let Some(pos) = self.kernel.shape_forge().lookup_position(obj.shape_id(), prop_name_si) {
+            pos
+        } else {
+            let new_shape_id = self.kernel.shape_forge().make_shape(obj.shape_id(), prop_name_si);
+            obj.set_shape_id(new_shape_id);
+            obj.push_prop(JsValue::undefined())
+        };
+        if let Some(current) = obj.prop_meta_at(pos) {
+            if !current.attributes.configurable() {
+                if current.is_accessor {
+                    return self.raise_type_error("cannot redefine non-configurable property");
+                }
+                if current.attributes.enumerable() != attributes.enumerable() {
+                    return self.raise_type_error("cannot redefine non-configurable property");
+                }
+                if !current.attributes.writable()
+                    && (attributes.writable() || !coercion::same_value(obj.get_prop_at(pos), val))
+                {
+                    return self.raise_type_error("cannot redefine non-configurable property");
+                }
+                if current.attributes.configurable() != attributes.configurable() {
+                    return self.raise_type_error("cannot redefine non-configurable property");
+                }
+            }
+        }
+        obj.set_prop_at(pos, val);
+        obj.set_data_meta(pos, attributes);
+        obj.bump_generation();
+        Ok(())
+    }
+
+    pub(crate) fn define_accessor_property(
+        &mut self, obj: &mut JsObject, prop_name_si: u32, get: JsValue, set: JsValue, attributes: PropAttributes,
+    ) -> Result<(), String> {
+        let pos = if let Some(pos) = self.kernel.shape_forge().lookup_position(obj.shape_id(), prop_name_si) {
+            pos
+        } else {
+            let new_shape_id = self.kernel.shape_forge().make_shape(obj.shape_id(), prop_name_si);
+            obj.set_shape_id(new_shape_id);
+            obj.push_prop(JsValue::undefined())
+        };
+        if let Some(current) = obj.prop_meta_at(pos) {
+            if !current.attributes.configurable()
+                && (!current.is_accessor
+                    || current.attributes.enumerable() != attributes.enumerable()
+                    || current.attributes.configurable() != attributes.configurable()
+                    || current.get != get
+                    || current.set != set)
+            {
+                return self.raise_type_error("cannot redefine non-configurable property");
+            }
+        }
+        obj.set_prop_at(pos, JsValue::undefined());
+        obj.set_accessor_meta(pos, get, set, attributes);
+        obj.bump_generation();
+        Ok(())
+    }
+
     pub(crate) fn write_ic_back(&mut self, shape_id: u32, ptr: *const JsValue) {
         debug_assert!(self.pc >= 3, "IC write-back requires 3 extension words before pc");
         self.bytecode[self.pc - 3] = shape_id & 0x00FF_FFFF;
@@ -1399,7 +1460,7 @@ impl Vm {
                         self.regs[rd] = JsValue::undefined();
                     } else {
                         let super_obj = unsafe { &*super_base.as_js_object_ptr() };
-                        self.regs[rd] = self.resolve_property(super_obj, prop_name_si).unwrap_or(JsValue::undefined());
+                        self.regs[rd] = self.ordinary_get(super_obj, prop_name_si, self.regs[a])?;
                     }
                 }
 
@@ -1416,6 +1477,37 @@ impl Vm {
                     func_obj.set_home_object(home_val);
                 }
 
+                OpCode::DEFINE_ACCESSOR => {
+                    let prop_idx = self.bytecode[self.pc] as usize;
+                    self.pc += 1;
+                    if prop_idx >= self.constants.len() {
+                        throw_err!(self, TypeError, "DEFINE_ACCESSOR constant index out of bounds");
+                    }
+                    let obj_val = self.regs[rd];
+                    if !obj_val.is_object() {
+                        throw_err!(self, TypeError, "DEFINE_ACCESSOR target is not object");
+                    }
+                    let prop_name_si = self.property_key_si(self.constants[prop_idx]);
+                    let getter = self.regs[a];
+                    let setter = self.regs[b];
+                    let obj = unsafe { &mut *obj_val.as_js_object_ptr() };
+                    let existing = self
+                        .get_own_property_slot(obj, prop_name_si)
+                        .and_then(|pos| obj.prop_meta_at(pos))
+                        .filter(|meta| meta.is_accessor);
+                    let get = if getter.is_undefined() {
+                        existing.map(|meta| meta.get).unwrap_or(JsValue::undefined())
+                    } else {
+                        getter
+                    };
+                    let set = if setter.is_undefined() {
+                        existing.map(|meta| meta.set).unwrap_or(JsValue::undefined())
+                    } else {
+                        setter
+                    };
+                    self.define_accessor_property(obj, prop_name_si, get, set, PropAttributes::DEFAULT_DATA)?;
+                }
+
                 OpCode::RETURN => {
                     let result = self.regs[rd];
                     if let Some(frame) = self.frames.pop() {

crates/oxide_vm/tests/builtins_object_tests.rs

@@ -55,6 +55,48 @@ fn object_define_property_sets_value() {
     assert!(result.is_object());
 }
 
+#[test]
+fn object_define_property_data_defaults_non_writable() {
+    let (_vm, result) =
+        eval("var o={}; Object.defineProperty(o,'x',{value:1}); Object.getOwnPropertyDescriptor(o,'x').writable")
+            .unwrap();
+    assert_eq!(result, JsValue::bool(false));
+}
+
+#[test]
+fn object_define_property_accessor_descriptor_gets() {
+    let (_vm, result) = eval(
+        "var o={}; Object.defineProperty(o,'x',{get:function(){return 7}, enumerable:true, configurable:true}); o.x",
+    )
+    .unwrap();
+    assert_eq!(result, JsValue::int(7));
+}
+
+#[test]
+fn object_define_property_rejects_mixed_descriptor() {
+    let err = match eval("var o={}; Object.defineProperty(o,'x',{value:1,get:function(){return 2}})") {
+        Ok(_) => panic!("expected mixed descriptor to fail"),
+        Err(err) => err,
+    };
+    assert!(err.contains("TypeError"));
+}
+
+#[test]
+fn object_define_property_non_writable_assignment_throws() {
+    let err = match eval("var o={}; Object.defineProperty(o,'x',{value:1}); o.x=2") {
+        Ok(_) => panic!("expected assignment to fail"),
+        Err(err) => err,
+    };
+    assert!(err.contains("TypeError"));
+}
+
+#[test]
+fn object_get_own_property_descriptor_accessor_shape() {
+    let (_vm, result) =
+        eval("var o={}; Object.defineProperty(o,'x',{get:function(){return 1}, configurable:true}); Object.getOwnPropertyDescriptor(o,'x').value").unwrap();
+    assert!(result.is_undefined());
+}
+
 #[test]
 fn object_get_prototype_of() {
     let (_vm, result) = eval("Object.getPrototypeOf({})").unwrap();

crates/oxide_vm/tests/class_tests.rs

@@ -29,6 +29,27 @@ fn class_method_is_on_prototype() {
     assert_eq!(result.as_int(), 1);
 }
 
+#[test]
+fn class_instance_getter_returns_value() {
+    let mut vm = Vm::new();
+    let result = eval(&mut vm, "class A { get x() { return 2; } } new A().x").unwrap();
+    assert_eq!(result.as_int(), 2);
+}
+
+#[test]
+fn class_instance_setter_updates_receiver() {
+    let mut vm = Vm::new();
+    let result = eval(&mut vm, "class A { set x(v) { this.y = v; } } var a = new A(); a.x = 4; a.y").unwrap();
+    assert_eq!(result.as_int(), 4);
+}
+
+#[test]
+fn class_static_getter_returns_value() {
+    let mut vm = Vm::new();
+    let result = eval(&mut vm, "class A { static get x() { return 5; } } A.x").unwrap();
+    assert_eq!(result.as_int(), 5);
+}
+
 #[test]
 fn class_constructor_initializes_instance_state() {
     let mut vm = Vm::new();

crates/oxide_vm/tests/object_tests.rs

@@ -137,3 +137,18 @@ fn eval_numeric_property_key_compound_update() {
 fn eval_in_operator_coerces_numeric_key() {
     assert_eq!(eval("var o={}; o[1]=42; 1 in o"), "true");
 }
+
+#[test]
+fn object_literal_getter_returns_value() {
+    assert_eq!(eval("var o={ get x(){ return 7 } }; o.x"), "7");
+}
+
+#[test]
+fn object_literal_setter_updates_receiver() {
+    assert_eq!(eval("var o={ set x(v){ this.y=v } }; o.x=4; o.y"), "4");
+}
+
+#[test]
+fn object_literal_getter_setter_pair() {
+    assert_eq!(eval("var o={ get x(){ return this.y }, set x(v){ this.y=v } }; o.x=9; o.x"), "9");
+}