Cleaned up obsolete TSHelper getChildren functions

Perryvw · Perryvw · commit acf4ee0dd6a0 · 2018-05-05T14:50:41.000+02:00
diff --git a/src/TSHelper.ts b/src/TSHelper.ts
@@ -1,19 +1,6 @@
 import * as ts from "typescript";
 
 export class TSHelper {
-    // Get all children of a node, required until microsoft fixes node.getChildren()
-    public static getChildren(node: ts.Node): ts.Node[] {
-        const children: ts.Node[] = [];
-        node.forEachChild((child) => {
-            children.push(child);
-        });
-        return children;
-    }
-
-    // Get children filtered by function and cast to predefined type
-    public static getChildrenOfType<T>(node: ts.Node, typeFilter: (node: ts.Node) => boolean): T[] {
-        return this.getChildren(node).filter(typeFilter) as any as T[];
-    }
 
     // Reverse lookup of enum key by value
     public static enumName(needle, haystack) {
diff --git a/src/Transpiler.ts b/src/Transpiler.ts
@@ -148,9 +148,7 @@ export class LuaTranspiler {
     // Transpile a node of unknown kind.
     public transpileNode(node: ts.Node): string {
         // Ignore declarations
-        if (tsEx.getChildrenOfType(node, (child) =>
-            child.kind === ts.SyntaxKind.DeclareKeyword).length > 0
-           ) {
+        if (node.modifiers && node.modifiers.some((modifier) => modifier.kind === ts.SyntaxKind.DeclareKeyword)) {
             return "";
         }
 
@@ -172,7 +170,7 @@ export class LuaTranspiler {
                        this.transpileVariableStatement(node as ts.VariableStatement) + "\n";
             case ts.SyntaxKind.ExpressionStatement:
                 return this.indent +
-                       this.transpileExpression(tsEx.getChildren(node)[0] as ts.Expression) + "\n";
+                       this.transpileExpression((node as ts.ExpressionStatement).expression) + "\n";
             case ts.SyntaxKind.ReturnStatement:
                 return this.indent + this.transpileReturn(node as ts.ReturnStatement) + "\n";
             case ts.SyntaxKind.IfStatement:
@@ -1385,16 +1383,21 @@ export class LuaTranspiler {
     public transpileObjectLiteral(node: ts.ObjectLiteralExpression): string {
         const properties: string[] = [];
         // Add all property assignments
-        node.properties.forEach((assignment) => {
-            const [key, value] = tsEx.getChildren(assignment);
-            if (ts.isIdentifier(key)) {
-                properties.push(`${key.escapedText}=` + this.transpileExpression(value));
-            } else if (ts.isComputedPropertyName(key)) {
-                const index = this.transpileExpression(key);
-                properties.push(`${index}=` + this.transpileExpression(value));
+        node.properties.forEach((element) => {
+            let name = "";
+            if (ts.isIdentifier(element.name)) {
+                name = element.name.escapedText as string;
+            } else if (ts.isComputedPropertyName(element.name)) {
+                name = this.transpileExpression(element.name);
+            } else {
+                name = `[${this.transpileExpression(element.name)}]`;
+            }
+
+            if (ts.isPropertyAssignment(element)) {
+                const expression = this.transpileExpression(element.initializer);
+                properties.push(`${name} = ${expression}`);
             } else {
-                const index = this.transpileExpression(key as ts.Expression);
-                properties.push(`[${index}]=` + this.transpileExpression(value));
+                throw new TranspileError(`Encountered unsupported object literal element ${element.kind}.`, node);
             }
         });
 
diff --git a/test/unit/assignments.spec.ts b/test/unit/assignments.spec.ts
@@ -10,7 +10,7 @@ export class AssignmentTests {
     @TestCase("[1,2,3]", "{1,2,3}")
     @TestCase("true", "true")
     @TestCase("false", "false")
-    @TestCase(`{a:3,b:"4"}`, `{a=3,b="4"}`)
+    @TestCase(`{a:3,b:"4"}`, `{a = 3,b = "4"}`)
     @Test("Const assignment")
     public constAssignment(inp: string, out: string) {
         var lua = util.transpileString(`const myvar = ${inp};`)
@@ -22,7 +22,7 @@ export class AssignmentTests {
     @TestCase("[1,2,3]", "{1,2,3}")
     @TestCase("true", "true")
     @TestCase("false", "false")
-    @TestCase(`{a:3,b:"4"}`, `{a=3,b="4"}`)
+    @TestCase(`{a:3,b:"4"}`, `{a = 3,b = "4"}`)
     @Test("Const assignment")
     public letAssignment(inp: string, out: string) {
         var lua = util.transpileString(`let myvar = ${inp};`)
@@ -34,7 +34,7 @@ export class AssignmentTests {
     @TestCase("[1,2,3]", "{1,2,3}")
     @TestCase("true", "true")
     @TestCase("false", "false")
-    @TestCase(`{a:3,b:"4"}`, `{a=3,b="4"}`)
+    @TestCase(`{a:3,b:"4"}`, `{a = 3,b = "4"}`)
     @Test("Const assignment")
     public varAssignment(inp: string, out: string) {
         var lua = util.transpileString(`var myvar = ${inp};`)
diff --git a/test/unit/objectLiteral.spec.ts b/test/unit/objectLiteral.spec.ts
@@ -0,0 +1,18 @@
+import { Expect, Test, TestCase } from "alsatian";
+
+import * as util from "../src/util";
+const fs = require("fs");
+
+export class ObjectLiteralTests {
+
+    @TestCase(`{a:3,b:"4"}`, `{a = 3,b = "4"}`)
+    @TestCase(`{"a":3,b:"4"}`, `{["a"] = 3,b = "4"}`)
+    @TestCase(`{["a"]:3,b:"4"}`, `{["a"] = 3,b = "4"}`)
+    @TestCase(`{["a"+123]:3,b:"4"}`, `{["a" .. 123] = 3,b = "4"}`)
+    @TestCase(`{[myFunc()]:3,b:"4"}`, `{[myFunc()] = 3,b = "4"}`)
+    @Test("Object Literal")
+    public objectLiteral(inp: string, out: string) {
+        var lua = util.transpileString(`const myvar = ${inp};`)
+        Expect(lua).toBe(`local myvar = ${out}`);
+    }
+}
