feat: 支持复合运算符

crates/oxide_vm/src/vm.rs

@@ -527,6 +527,51 @@ impl Vm {
                     }
                 }
 
+                OpCode::COMPOUND_ADD => {
+                    let lhs = self.regs[rd];
+                    let rhs = self.regs[a];
+                    if lhs.is_string() || rhs.is_string() {
+                        let ls = coercion::to_string(self.kernel.string_forge().as_ref(), lhs);
+                        let rs = coercion::to_string(self.kernel.string_forge().as_ref(), rhs);
+                        let concat = format!("{ls}{rs}");
+                        self.regs[rd] = self.intern(&concat);
+                    } else {
+                        let ln = coercion::to_number(lhs, self.kernel.string_forge().as_ref());
+                        let rn = coercion::to_number(rhs, self.kernel.string_forge().as_ref());
+                        self.regs[rd] = JsValue::float(ln + rn);
+                    }
+                }
+
+                OpCode::COMPOUND_SUB => {
+                    let l = coercion::to_number(self.regs[rd], self.kernel.string_forge().as_ref());
+                    let r = coercion::to_number(self.regs[a], self.kernel.string_forge().as_ref());
+                    self.regs[rd] = JsValue::float(l - r);
+                }
+
+                OpCode::COMPOUND_MUL => {
+                    let l = coercion::to_number(self.regs[rd], self.kernel.string_forge().as_ref());
+                    let r = coercion::to_number(self.regs[a], self.kernel.string_forge().as_ref());
+                    self.regs[rd] = JsValue::float(l * r);
+                }
+
+                OpCode::COMPOUND_DIV => {
+                    let l = coercion::to_number(self.regs[rd], self.kernel.string_forge().as_ref());
+                    let r = coercion::to_number(self.regs[a], self.kernel.string_forge().as_ref());
+                    self.regs[rd] = JsValue::float(l / r);
+                }
+
+                OpCode::COMPOUND_MOD => {
+                    let l = coercion::to_number(self.regs[rd], self.kernel.string_forge().as_ref());
+                    let r = coercion::to_number(self.regs[a], self.kernel.string_forge().as_ref());
+                    self.regs[rd] = JsValue::float(l % r);
+                }
+
+                OpCode::COMPOUND_EXP => {
+                    let l = coercion::to_number(self.regs[rd], self.kernel.string_forge().as_ref());
+                    let r = coercion::to_number(self.regs[a], self.kernel.string_forge().as_ref());
+                    self.regs[rd] = JsValue::float(l.powf(r));
+                }
+
                 OpCode::TYPEOF => {
                     let val = self.regs[a];
                     let result = if val.is_undefined() {

crates/oxide_vm/tests/arithmetic_tests.rs

@@ -63,3 +63,43 @@ fn eval_division_by_zero() {
 fn eval_string_concat() {
     assert_eq!(eval("1 + 2 + 3"), "6");
 }
+
+#[test]
+fn eval_compound_add() {
+    assert_eq!(eval("var x=5; x+=3; x"), "8");
+}
+
+#[test]
+fn eval_compound_sub() {
+    assert_eq!(eval("var x=10; x-=4; x"), "6");
+}
+
+#[test]
+fn eval_compound_mul() {
+    assert_eq!(eval("var x=2; x*=3; x"), "6");
+}
+
+#[test]
+fn eval_compound_div() {
+    assert_eq!(eval("var x=10; x/=2; x"), "5");
+}
+
+#[test]
+fn eval_compound_mod() {
+    assert_eq!(eval("var x=7; x%=3; x"), "1");
+}
+
+#[test]
+fn eval_compound_exp() {
+    assert_eq!(eval("var x=2; x**=3; x"), "8");
+}
+
+#[test]
+fn eval_compound_add_expr_value() {
+    assert_eq!(eval("var x=5; x+=3"), "8");
+}
+
+#[test]
+fn eval_compound_undefined() {
+    assert_eq!(eval("var x; x+=1; x"), "NaN");
+}