-added support for class expressions (#236)

andreiradu · Perryvw · commit c6159e1ebcfb · 2018-10-13T16:45:32.000+02:00
* -added support for class expressions

* -minor refactor

* -test for base class method calling when using class expression
diff --git a/src/TSHelper.ts b/src/TSHelper.ts
@@ -28,7 +28,7 @@ export class TSHelper {
         return statements.some(statement => statement.kind === kind);
     }
 
-    public static getExtendedType(node: ts.ClassDeclaration, checker: ts.TypeChecker): ts.Type | undefined {
+    public static getExtendedType(node: ts.ClassLikeDeclarationBase, checker: ts.TypeChecker): ts.Type | undefined {
         if (node && node.heritageClauses) {
             for (const clause of node.heritageClauses) {
                 if (clause.token === ts.SyntaxKind.ExtendsKeyword) {
diff --git a/src/Transpiler.ts b/src/Transpiler.ts
@@ -807,6 +807,11 @@ export abstract class LuaTranspiler {
                 return this.transpileSpreadElement(node as ts.SpreadElement);
             case ts.SyntaxKind.NonNullExpression:
                 return this.transpileExpression((node as ts.NonNullExpression).expression);
+            case ts.SyntaxKind.ClassExpression:
+                this.namespace.push("");
+                const classDeclaration =  this.transpileClass(node as ts.ClassExpression, "_");
+                this.namespace.pop();
+                return `(function() ${classDeclaration}; return _ end)()`;
             case ts.SyntaxKind.Block:
                 this.pushIndent();
                 const ret = "do \n" + this.transpileBlock(node as ts.Block) + "end\n";
@@ -1615,13 +1620,12 @@ export abstract class LuaTranspiler {
     }
 
     // Transpile a class declaration
-    public transpileClass(node: ts.ClassDeclaration): string {
-        if (!node.name) {
+    public transpileClass(node: ts.ClassLikeDeclarationBase, nameOverride?: string): string {
+        let className = node.name ? this.transpileIdentifier(node.name) : nameOverride;
+        if (!className) {
             throw TSTLErrors.MissingClassName(node);
         }
 
-        let className = this.transpileIdentifier(node.name);
-
         const decorators = tsHelper.getCustomDecorators(this.checker.getTypeAtLocation(node), this.checker);
 
         // Find out if this class is extension of existing class
@@ -1667,7 +1671,7 @@ export abstract class LuaTranspiler {
         }
 
         if (!isExtension && !isMetaExtension) {
-            result += this.transpileClassCreationMethods(node, instanceFields, extendsType);
+            result += this.transpileClassCreationMethods(node, className, instanceFields, extendsType);
         } else {
             for (const f of instanceFields) {
                 // Get identifier
@@ -1716,10 +1720,9 @@ export abstract class LuaTranspiler {
         return result;
     }
 
-    public transpileClassCreationMethods(node: ts.ClassDeclaration, instanceFields: ts.PropertyDeclaration[],
+    public transpileClassCreationMethods(node: ts.ClassLikeDeclarationBase, className: string,
+                                         instanceFields: ts.PropertyDeclaration[],
                                          extendsType: ts.Type): string {
-        const className = this.transpileIdentifier(node.name);
-
         let noClassOr = false;
         if (extendsType) {
             const decorators = tsHelper.getCustomDecorators(extendsType, this.checker);
diff --git a/test/unit/class.spec.ts b/test/unit/class.spec.ts
@@ -466,4 +466,47 @@ export class ClassTests {
         // Assert
         Expect(result).toBe(10);
     }
+    @Test("classExpression")
+    public classExpression(): void {
+        const lua = util.transpileString(
+            `class a {
+                public method() {
+                    return "instance of a";
+                }
+            }
+            b = class extends a {
+                public method() {
+                    return "instance of b";
+                }
+            }
+            let inst = new b(6);
+            return inst.method();`
+        );
+
+        // Execute
+        const result = util.executeLua(lua);
+
+        // Assert
+        Expect(result).toBe("instance of b");
+    }
+    @Test("classExpressionBaseClassMethod")
+    public classExpressionBaseClassMethod(): void {
+        const lua = util.transpileString(
+            `class a {
+                public method() {
+                    return 42;
+                }
+            }
+            b = class extends a {
+            }
+            let inst = new b();
+            return inst.method();`
+        );
+
+        // Execute
+        const result = util.executeLua(lua);
+
+        // Assert
+        Expect(result).toBe(42);
+    }
 }

Original file line number	Diff line number	Diff line change
`@@ -28,7 +28,7 @@ export class TSHelper {`
`28`	`28`	`return statements.some(statement => statement.kind === kind);`
`29`	`29`	`}`
`30`	`30`
`31`		`- public static getExtendedType(node: ts.ClassDeclaration, checker: ts.TypeChecker): ts.Type \| undefined {`
	`31`	`+ public static getExtendedType(node: ts.ClassLikeDeclarationBase, checker: ts.TypeChecker): ts.Type \| undefined {`
`32`	`32`	`if (node && node.heritageClauses) {`
`33`	`33`	`for (const clause of node.heritageClauses) {`
`34`	`34`	`if (clause.token === ts.SyntaxKind.ExtendsKeyword) {`