fix: 对齐 class 体 counter/emitter 指令条数，修私有方法、计算键、派生构造器字段注入位置的跳转漂移

crates/oxide_vm/tests/compiler_alignment_class_tests.rs

@@ -0,0 +1,93 @@
+use oxide_compiler::compiler::Compiler;
+use oxide_parser::Allocator;
+use oxide_vm::vm::Vm;
+
+fn eval(source: &str) -> String {
+    let allocator = Allocator::default();
+    let program = match oxide_parser::parse(&allocator, source) {
+        Ok(p) => p,
+        Err(e) => return format!("parse error: {}", e[0].message),
+    };
+    let module = match Compiler::new().compile(&program) {
+        Ok(m) => m,
+        Err(e) => return format!("compile error: {e}"),
+    };
+    let mut vm = Vm::new();
+    match vm.run(&module) {
+        Ok(result) => format!("{result}"),
+        Err(e) => format!("vm error: {e}"),
+    }
+}
+
+// A class body must not drift the instruction count of code that follows it. Each repro
+// places a bounded loop after the class so a wrong count corrupts the loop's jump target.
+
+#[test]
+fn non_static_private_method_then_loop() {
+    assert_eq!(eval("class C{#m(){return 1;}} var c=0; while(c<3){c=c+1;} c"), "3");
+}
+
+#[test]
+fn static_private_method_then_loop() {
+    assert_eq!(eval("class C{static #m(){return 1;}} var c=0; while(c<3){c=c+1;} c"), "3");
+}
+
+// Multi-word computed key — a single-identifier key happens to be one word and would not
+// expose the drift.
+#[test]
+fn computed_method_key_then_loop() {
+    assert_eq!(eval("class C{[\"x\"+\"y\"](){return 1;}} var c=0; while(c<3){c=c+1;} c"), "3");
+}
+
+#[test]
+fn computed_static_field_key_then_loop() {
+    assert_eq!(eval("class C{static [\"a\"+\"b\"]=1;} var c=0; while(c<3){c=c+1;} c"), "3");
+}
+
+// Derived constructor with an instance field and a loop after super(): the field code is
+// injected after SUPER_CALL, so the loop's jump target must account for it.
+#[test]
+fn derived_ctor_field_then_post_super_loop() {
+    assert_eq!(
+        eval("class A{} class B extends A{ x=2; constructor(){super(); this.r=0; while(this.r<3){this.r=this.r+1;}}} new B().r"),
+        "3"
+    );
+}
+
+#[test]
+fn derived_ctor_field_value_initialized() {
+    assert_eq!(eval("class A{} class B extends A{ x=5; constructor(){super();} } new B().x"), "5");
+}
+
+#[test]
+fn derived_ctor_statement_before_super() {
+    assert_eq!(
+        eval("class A{constructor(){this.a=1;}} class B extends A{ y=2; constructor(){var z=0; super(); while(z<3){z=z+1;} this.z=z;} } new B().z"),
+        "3"
+    );
+}
+
+// Non-derived class with an instance field and a ctor loop stays correct (unchanged path).
+#[test]
+fn non_derived_ctor_field_then_loop() {
+    assert_eq!(
+        eval("class C{ x=1; constructor(){this.r=0; while(this.r<3){this.r=this.r+1;}} } new C().r"),
+        "3"
+    );
+}
+
+// Behavioral regressions: methods/getters/private calls still work.
+#[test]
+fn plain_method_call_regression() {
+    assert_eq!(eval("class C{m(){return 9;}} new C().m()"), "9");
+}
+
+#[test]
+fn private_method_call_regression() {
+    assert_eq!(eval("class C{#m(){return 7;} run(){return this.#m();}} new C().run()"), "7");
+}
+
+#[test]
+fn getter_regression() {
+    assert_eq!(eval("class C{get x(){return 5;}} new C().x"), "5");
+}