fix(wasm): a class without a constructor initializes its fields and runs its parent's

changelog.d/14616-wasm-synthesized-constructors.md

@@ -0,0 +1,5 @@
+`--target web`: a class that declares no constructor dropped its field
+initializers (`class X { tag = "a" }` gave `new X().tag === undefined`), and a
+derived class without one never ran its parent's constructor. Such a class now
+gets the constructor TypeScript gives it: the parent's constructor runs with
+the arguments, then the class's own field initializers.

crates/perry-codegen-wasm/src/emit/compile.rs

@@ -776,6 +776,7 @@ impl WasmModuleEmitter {
         }
 
         // Register class constructors, methods, and static methods
+        self.synthesized_ctors = Self::synthesized_ctors(modules);
         for (_, module) in modules {
             for class in &module.classes {
                 // Record parent class relationship
@@ -784,8 +785,7 @@ impl WasmModuleEmitter {
                         .insert(class.name.clone(), parent.clone());
                 }
                 // Constructor: params = this + declared params, returns f64 (this)
-                if let Some(ctor) = &class.constructor {
-                    let param_count = 1 + ctor.params.len();
+                if let Some(param_count) = self.ctor_param_count(class) {
                     let params = vec![ValType::I64; param_count];
                     let results = vec![ValType::I64];
                     let type_idx = self.get_type_idx(params, results);
@@ -1137,8 +1137,7 @@ impl WasmModuleEmitter {
         // Class constructors, methods, static methods, getters, setters
         for (_, module) in modules {
             for class in &module.classes {
-                if let Some(ctor) = &class.constructor {
-                    let param_count = 1 + ctor.params.len();
+                if let Some(param_count) = self.ctor_param_count(class) {
                     let params = vec![ValType::I64; param_count];
                     let results = vec![ValType::I64];
                     let type_idx = self.get_type_idx(params, results);
@@ -1370,6 +1369,13 @@ impl WasmModuleEmitter {
                 if let Some(ctor) = &class.constructor {
                     let func = self.compile_class_constructor(class, ctor);
                     code_section.function(&func);
+                } else if let Some(&forward) = self.synthesized_ctors.get(&class.name) {
+                    let parent_ctor = class
+                        .extends_name
+                        .as_ref()
+                        .and_then(|parent| self.class_ctor_map.get(parent).copied());
+                    let func = self.compile_synthesized_constructor(class, forward, parent_ctor);
+                    code_section.function(&func);
                 }
                 for method in &class.methods {
                     let func = self.compile_class_method(method);

crates/perry-codegen-wasm/src/emit/function.rs

@@ -162,11 +162,70 @@ impl WasmModuleEmitter {
         let mut func = Function::new(locals);
         let _rt = self.rt.as_ref().unwrap();
 
-        // Emit field initializers: class_set_field(this, field_name, value) via mem_call
+        // A derived class initializes its fields when `super(...)` returns, as in JS:
+        // emitted before the body, they would be overwritten by the parent constructor.
+        // A base class, or a `super` call that is not a top-level statement of the
+        // body, keeps them before the body.
+        let super_at = if class.extends_name.is_some() {
+            ctor.body
+                .iter()
+                .position(|stmt| matches!(stmt, Stmt::Expr(Expr::SuperCall(_))))
+        } else {
+            None
+        };
+        if super_at.is_none() {
+            self.emit_field_initializers(
+                &mut func,
+                class,
+                &local_map,
+                temp_local_idx,
+                temp_i32_idx,
+            );
+        }
+
+        // Emit constructor body.
+        //
+        // Constructors are declared in func_section as `(this, ...params) -> i64`
+        // unconditionally (see mod.rs around line 1688). Pass `in_returning_func=true`
+        // so that any explicit `return;` / `return expr;` inside the constructor
+        // body properly leaves an i64 on the operand stack before the WASM `return`
+        // instruction. Without this, an early `return` produced a bare `return`
+        // with empty stack, failing V8 validation with
+        // "expected i64 but nothing on stack" (#1081 sibling instance, constructor case).
+        let mut ctx = FuncEmitCtx::new(self, &local_map, temp_local_idx, temp_i32_idx);
+        ctx.current_class = Some(class.name.clone());
+        for (i, stmt) in ctor.body.iter().enumerate() {
+            ctx.emit_stmt(&mut func, stmt, true);
+            if super_at == Some(i) {
+                self.emit_field_initializers(
+                    &mut func,
+                    class,
+                    &local_map,
+                    temp_local_idx,
+                    temp_i32_idx,
+                );
+            }
+        }
+
+        // Fallthrough: return `this` as the constructor's result.
+        func.instruction(&Instruction::LocalGet(0));
+        func.instruction(&Instruction::End);
+        func
+    }
+
+    /// The field initializers of `class`, each a `class_set_field(this, name, value)`.
+    fn emit_field_initializers(
+        &self,
+        func: &mut Function,
+        class: &perry_hir::ir::Class,
+        local_map: &BTreeMap<LocalId, u32>,
+        temp_local_idx: u32,
+        temp_i32_idx: u32,
+    ) {
         for field in &class.fields {
             if let Some(init) = &field.init {
-                let mut ctx = FuncEmitCtx::new(self, &local_map, temp_local_idx, temp_i32_idx);
-                ctx.emit_frame_begin(&mut func, 3);
+                let mut ctx = FuncEmitCtx::new(self, local_map, temp_local_idx, temp_i32_idx);
+                ctx.emit_frame_begin(func, 3);
                 // Compute base address (sp - 24) and save to temp_i32 local
                 let sp = self.nan_temp_global;
                 func.instruction(&Instruction::GlobalGet(sp));
@@ -198,28 +257,131 @@ impl WasmModuleEmitter {
                     memory_index: 0,
                 }));
                 // Store value to slot 2
-                ctx.emit_store_arg(&mut func, 2, init);
+                ctx.emit_store_arg(func, 2, init);
                 // Call via mem_call
-                ctx.emit_memcall_void(&mut func, "class_set_field", 3);
+                ctx.emit_memcall_void(func, "class_set_field", 3);
             }
         }
+    }
 
-        // Emit constructor body.
-        //
-        // Constructors are declared in func_section as `(this, ...params) -> i64`
-        // unconditionally (see mod.rs around line 1688). Pass `in_returning_func=true`
-        // so that any explicit `return;` / `return expr;` inside the constructor
-        // body properly leaves an i64 on the operand stack before the WASM `return`
-        // instruction. Without this, an early `return` produced a bare `return`
-        // with empty stack, failing V8 validation with
-        // "expected i64 but nothing on stack" (#1081 sibling instance, constructor case).
-        let mut ctx = FuncEmitCtx::new(self, &local_map, temp_local_idx, temp_i32_idx);
-        ctx.current_class = Some(class.name.clone());
-        for stmt in &ctor.body {
-            ctx.emit_stmt(&mut func, stmt, true);
+    /// The WASM arity (`this` + parameters) of `class`'s constructor, declared or
+    /// synthesized, or `None` when it has none. Registration, the function section
+    /// and the code section all read it, so the three stay in the same order.
+    pub(super) fn ctor_param_count(&self, class: &perry_hir::ir::Class) -> Option<usize> {
+        match &class.constructor {
+            Some(ctor) => Some(1 + ctor.params.len()),
+            None => self
+                .synthesized_ctors
+                .get(&class.name)
+                .map(|forward| 1 + forward),
         }
+    }
+
+    /// Which classes get a constructor from `compile_synthesized_constructor`, and how
+    /// many parameters each forwards. A class gets one when it declares none and either
+    /// has field initializers (they run only inside a constructor) or extends a class
+    /// with a constructor, declared or synthesized (otherwise the parent's never runs).
+    /// A chain that reaches a constructor with a rest parameter is left alone:
+    /// forwarding `...args` through a fixed arity would drop arguments.
+    pub(super) fn synthesized_ctors(
+        modules: &[(String, perry_hir::ir::Module)],
+    ) -> BTreeMap<String, usize> {
+        #[derive(Clone, Copy)]
+        enum Ctor {
+            Absent,
+            Arity(usize),
+            Unsupported,
+        }
+        fn ctor_of(
+            name: &str,
+            classes: &BTreeMap<&str, &perry_hir::ir::Class>,
+            out: &mut BTreeMap<String, usize>,
+            depth: usize,
+        ) -> Ctor {
+            let Some(class) = classes.get(name) else {
+                return Ctor::Absent;
+            };
+            if depth > classes.len() {
+                return Ctor::Unsupported;
+            }
+            if let Some(ctor) = &class.constructor {
+                return if ctor.params.iter().any(|p| p.is_rest) {
+                    Ctor::Unsupported
+                } else {
+                    Ctor::Arity(ctor.params.len())
+                };
+            }
+            let parent = match &class.extends_name {
+                Some(parent) => ctor_of(parent, classes, out, depth + 1),
+                None => Ctor::Absent,
+            };
+            match parent {
+                Ctor::Unsupported => Ctor::Unsupported,
+                Ctor::Arity(n) => {
+                    out.insert(class.name.clone(), n);
+                    Ctor::Arity(n)
+                }
+                Ctor::Absent if class.fields.iter().any(|f| f.init.is_some()) => {
+                    out.insert(class.name.clone(), 0);
+                    Ctor::Arity(0)
+                }
+                Ctor::Absent => Ctor::Absent,
+            }
+        }
+        let classes: BTreeMap<&str, &perry_hir::ir::Class> = modules
+            .iter()
+            .flat_map(|(_, module)| module.classes.iter())
+            .map(|class| (class.name.as_str(), class))
+            .collect();
+        let mut out = BTreeMap::new();
+        for name in classes.keys() {
+            ctor_of(name, &classes, &mut out, 0);
+        }
+        out
+    }
+
+    /// The constructor TypeScript gives a class that declares none: `constructor() {}`
+    /// for a base class, `constructor(...args) { super(...args); }` for a derived one.
+    /// Here `forward` is the arity of the nearest ancestor constructor, whose
+    /// parameters are passed through unchanged, and `parent_ctor` is that parent's
+    /// constructor. As in JS, the parent constructor runs before this class's field
+    /// initializers. See `synthesized_ctors` for which classes get one.
+    pub(super) fn compile_synthesized_constructor(
+        &self,
+        class: &perry_hir::ir::Class,
+        forward: usize,
+        parent_ctor: Option<u32>,
+    ) -> Function {
+        let param_count = 1 + forward;
+        let mut local_map = BTreeMap::new();
+        let mut extra_locals = 0u32;
+        for field in &class.fields {
+            if let Some(init) = &field.init {
+                collect_expr_locals(init, &mut local_map, &mut extra_locals, param_count as u32);
+            }
+        }
+        let temp_local_idx = param_count as u32 + extra_locals;
+        let temp_i32_idx = temp_local_idx + 3;
+        let locals = vec![(extra_locals + 3, ValType::I64), (1, ValType::I32)];
+        let mut func = Function::new(locals);
+
+        if let Some(parent_idx) = parent_ctor {
+            for i in 0..param_count {
+                func.instruction(&Instruction::LocalGet(i as u32));
+            }
+            if let Some(&expected) = self.func_param_counts.get(&parent_idx) {
+                for _ in param_count..expected {
+                    func.instruction(&Instruction::I64Const(TAG_UNDEFINED as i64));
+                }
+            }
+            func.instruction(&Instruction::Call(parent_idx));
+            func.instruction(&Instruction::Drop);
+            let mut ctx = FuncEmitCtx::new(self, &local_map, temp_local_idx, temp_i32_idx);
+            ctx.emit_exception_guard(&mut func);
+        }
+
+        self.emit_field_initializers(&mut func, class, &local_map, temp_local_idx, temp_i32_idx);
 
-        // Fallthrough: return `this` as the constructor's result.
         func.instruction(&Instruction::LocalGet(0));
         func.instruction(&Instruction::End);
         func

crates/perry-codegen-wasm/src/emit/module_emitter.rs

@@ -48,6 +48,9 @@ pub(super) struct WasmModuleEmitter {
     pub(super) ffi_imports: Vec<(String, usize, bool)>,
     /// Class parent map: child_class_name → parent_class_name
     pub(super) class_parent_map: BTreeMap<String, String>,
+    /// Classes that declare no constructor but get one (`synthesized_ctors`), with
+    /// the number of parameters it forwards to the parent constructor.
+    pub(super) synthesized_ctors: BTreeMap<String, usize>,
     /// Enum member values: (enum_name, member_name) → numeric value or string
     pub(super) enum_values: BTreeMap<(String, String), EnumResolvedValue>,
     /// Global index for NaN-safe temp storage (global.set/get may preserve NaN in Firefox)
@@ -114,6 +117,7 @@ impl WasmModuleEmitter {
             func_name_map: BTreeMap::new(),
             ffi_imports: Vec::new(),
             class_parent_map: BTreeMap::new(),
+            synthesized_ctors: BTreeMap::new(),
             enum_values: BTreeMap::new(),
             nan_temp_global: 0, // set during compile()
             async_func_imports: Vec::new(),

crates/perry-codegen-wasm/src/emit/tests.rs

@@ -143,3 +143,51 @@ console.log("b");
         "a 1 true\n\nb"
     );
 }
+
+// A class that declares no constructor still runs its field initializers, and a
+// derived one runs its parent's constructor (with the arguments) before them.
+#[test]
+fn class_without_constructor_initializes_fields_and_runs_the_parent_constructor() {
+    assert_eq!(
+        run_web_source(
+            r#"
+class X { tag = "a"; n = 1 + 1; }
+class A { x: number; constructor(x: number) { this.x = x; } }
+class B extends A { y = 2; }
+class C extends B {}
+class P { v: number; constructor() { this.v = 1; } }
+class Q extends P { w = this.v + 1; }
+class E {}
+class F extends E { t = "f"; }
+const x = new X();
+const b = new B(7);
+const c = new C(9);
+const q = new Q();
+console.log(x.tag + " " + x.n);
+console.log(b.x + " " + b.y + " " + c.x + " " + c.y);
+console.log(q.v + " " + q.w + " " + new F().t);
+"#
+        ),
+        "a 2\n7 2 9 2\n1 2 f"
+    );
+}
+
+// A derived class with its own constructor initializes its fields when `super()`
+// returns (so the parent's constructor cannot overwrite them, and they can read what
+// it set); a base class initializes them before the constructor body.
+#[test]
+fn derived_fields_initialize_after_super_and_base_fields_before_the_body() {
+    assert_eq!(
+        run_web_source(
+            r#"
+class A { x = 1; }
+class B extends A { x = 2; constructor() { super(); } }
+class P { v: number; constructor() { this.v = 1; } }
+class Q extends P { w = this.v + 1; constructor() { super(); this.w = this.w * 10; } }
+class K { a = 1; b: number; constructor() { this.b = this.a + 1; } }
+console.log(new B().x + " " + new Q().w + " " + new K().b);
+"#
+        ),
+        "2 20 2"
+    );
+}