TypeScriptToLua
diff --git a/‎src/LuaPrinter.ts‎
Lines changed: 1 addition & 38 deletions b/‎src/LuaPrinter.ts‎
Lines changed: 1 addition & 38 deletions
diff --git a/‎src/TSHelper.ts‎
Lines changed: 37 additions & 0 deletions b/‎src/TSHelper.ts‎
Lines changed: 37 additions & 0 deletions
@@ -709,47 +709,10 @@ export class LuaPrinter {
         return result;
     }
 
-    protected isSimpleExpression(expression: tstl.Expression): boolean {
-        switch (expression.kind) {
-            case tstl.SyntaxKind.CallExpression:
-            case tstl.SyntaxKind.MethodCallExpression:
-            case tstl.SyntaxKind.FunctionExpression:
-                return false;
-
-            case tstl.SyntaxKind.TableExpression:
-                const tableExpression = expression as tstl.TableExpression;
-                return !tableExpression.fields || tableExpression.fields.every(e => this.isSimpleExpression(e));
-
-            case tstl.SyntaxKind.TableFieldExpression:
-                const fieldExpression = expression as tstl.TableFieldExpression;
-                return (
-                    (!fieldExpression.key || this.isSimpleExpression(fieldExpression.key)) &&
-                    this.isSimpleExpression(fieldExpression.value)
-                );
-
-            case tstl.SyntaxKind.TableIndexExpression:
-                const indexExpression = expression as tstl.TableIndexExpression;
-                return this.isSimpleExpression(indexExpression.table) && this.isSimpleExpression(indexExpression.index);
-
-            case tstl.SyntaxKind.UnaryExpression:
-                return this.isSimpleExpression((expression as tstl.UnaryExpression).operand);
-
-            case tstl.SyntaxKind.BinaryExpression:
-                const binaryExpression = expression as tstl.BinaryExpression;
-                return (
-                    this.isSimpleExpression(binaryExpression.left) && this.isSimpleExpression(binaryExpression.right)
-                );
-
-            case tstl.SyntaxKind.ParenthesizedExpression:
-                return this.isSimpleExpression((expression as tstl.ParenthesizedExpression).innerExpression);
-        }
-        return true;
-    }
-
     protected printExpressionList(expressions: tstl.Expression[]): SourceChunk[] {
         const chunks: SourceChunk[] = [];
 
-        if (expressions.every(e => this.isSimpleExpression(e))) {
+        if (expressions.every(e => tsHelper.isSimpleExpression(e))) {
             chunks.push(...this.joinChunks(", ", expressions.map(e => this.printExpression(e))));
         } else {
             chunks.push("\n");
 
@@ -1,5 +1,6 @@
 import * as ts from "typescript";
 import { Decorator, DecoratorKind } from "./Decorator";
+import * as tstl from "./LuaAST";
 
 export enum ContextType {
     None,
@@ -835,3 +836,39 @@ export function isArrayLengthAssignment(
 
     return name === "length";
 }
+
+// Returns true if expression contains no function calls
+export function isSimpleExpression(expression: tstl.Expression): boolean {
+    switch (expression.kind) {
+        case tstl.SyntaxKind.CallExpression:
+        case tstl.SyntaxKind.MethodCallExpression:
+        case tstl.SyntaxKind.FunctionExpression:
+            return false;
+
+        case tstl.SyntaxKind.TableExpression:
+            const tableExpression = expression as tstl.TableExpression;
+            return !tableExpression.fields || tableExpression.fields.every(e => isSimpleExpression(e));
+
+        case tstl.SyntaxKind.TableFieldExpression:
+            const fieldExpression = expression as tstl.TableFieldExpression;
+            return (
+                (!fieldExpression.key || isSimpleExpression(fieldExpression.key)) &&
+                isSimpleExpression(fieldExpression.value)
+            );
+
+        case tstl.SyntaxKind.TableIndexExpression:
+            const indexExpression = expression as tstl.TableIndexExpression;
+            return isSimpleExpression(indexExpression.table) && isSimpleExpression(indexExpression.index);
+
+        case tstl.SyntaxKind.UnaryExpression:
+            return isSimpleExpression((expression as tstl.UnaryExpression).operand);
+
+        case tstl.SyntaxKind.BinaryExpression:
+            const binaryExpression = expression as tstl.BinaryExpression;
+            return isSimpleExpression(binaryExpression.left) && isSimpleExpression(binaryExpression.right);
+
+        case tstl.SyntaxKind.ParenthesizedExpression:
+            return isSimpleExpression((expression as tstl.ParenthesizedExpression).innerExpression);
+    }
+    return true;
+}