Ensuring super call is always first statement in constructors (#524)

tomblind · web-flow · commit 576c7e5eac76 · 2019-04-14T12:46:47.000-06:00
* made sure super calls in constructors are always first statement

* adhering to strictness

* a slight refactor
diff --git a/src/LuaTransformer.ts b/src/LuaTransformer.ts
@@ -1007,7 +1007,10 @@ export class LuaTransformer {
             return undefined;
         }
 
-        const bodyStatements: tstl.Statement[] = this.transformClassInstanceFields(classDeclaration, instanceFields);
+        const bodyWithFieldInitializers: tstl.Statement[] = this.transformClassInstanceFields(
+            classDeclaration,
+            instanceFields
+        );
 
         // Check for field declarations in constructor
         const constructorFieldsDeclarations = statement.parameters.filter(p => p.modifiers !== undefined);
@@ -1027,7 +1030,7 @@ export class LuaTransformer {
                         tstl.SyntaxKind.OrOperator
                     )
                 );
-                bodyStatements.push(assignement);
+                bodyWithFieldInitializers.push(assignement);
             } else {
                 // self.declarationName = declarationName
                 const assignement = tstl.createAssignmentStatement(
@@ -1037,7 +1040,7 @@ export class LuaTransformer {
                     ),
                     declarationName
                 );
-                bodyStatements.push(assignement);
+                bodyWithFieldInitializers.push(assignement);
             }
         }
 
@@ -1049,9 +1052,24 @@ export class LuaTransformer {
         );
 
         const [body] = this.transformFunctionBody(statement.parameters, statement.body, restParamName);
-        bodyStatements.push(...body);
 
-        const block: tstl.Block = tstl.createBlock(bodyStatements);
+        // If there are field initializers and the first statement is a super call, hoist the super call to the top
+        if (bodyWithFieldInitializers.length > 0 && statement.body && statement.body.statements.length > 0) {
+            const firstStatement = statement.body.statements[0];
+            if (ts.isExpressionStatement(firstStatement)
+                && ts.isCallExpression(firstStatement.expression)
+                && firstStatement.expression.expression.kind === ts.SyntaxKind.SuperKeyword)
+            {
+                const superCall = body.shift();
+                if (superCall) {
+                    bodyWithFieldInitializers.unshift(superCall);
+                }
+            }
+        }
+
+        bodyWithFieldInitializers.push(...body);
+
+        const block: tstl.Block = tstl.createBlock(bodyWithFieldInitializers);
 
         const result = tstl.createAssignmentStatement(
             this.createConstructorName(className),
diff --git a/test/unit/class.spec.ts b/test/unit/class.spec.ts
@@ -797,3 +797,29 @@ test("Class annonymous expression name via constructor", () => {
     `;
     expect(util.transpileAndExecute(code)).toBe("____");
 });
+
+test("Class field override in subclass", () => {
+    const code = `
+        class Foo {
+            field = "foo";
+        }
+        class Bar extends Foo {
+            field = "bar";
+        }
+        return (new Foo()).field + (new Bar()).field;`;
+    expect(util.transpileAndExecute(code)).toBe("foobar");
+});
+
+test("Class field override in subclass with constructors", () => {
+    const code = `
+        class Foo {
+            field = "foo";
+            constructor() {}
+        }
+        class Bar extends Foo {
+            field = "bar";
+            constructor() { super(); }
+        }
+        return (new Foo()).field + (new Bar()).field;`;
+    expect(util.transpileAndExecute(code)).toBe("foobar");
+});
