TypeScriptToLua · Perryvw · Jan 19, 2020 · Jan 15, 2020 · Jan 15, 2020 · Jan 17, 2020
diff --git a/src/LuaAST.ts b/src/LuaAST.ts
@@ -36,7 +36,6 @@ export enum SyntaxKind {
     TableExpression,
     UnaryExpression,
     BinaryExpression,
-    ParenthesizedExpression,
     CallExpression,
     MethodCallExpression,
     Identifier,
@@ -669,24 +668,6 @@ export function createBinaryExpression(
     return expression;
 }
 
-export interface ParenthesizedExpression extends Expression {
-    kind: SyntaxKind.ParenthesizedExpression;
-    innerExpression: Expression;
-}
-
-export function isParenthesizedExpression(node: Node): node is ParenthesizedExpression {
-    return node.kind === SyntaxKind.ParenthesizedExpression;
-}
-
-export function createParenthesizedExpression(
-    innerExpression: Expression,
-    tsOriginal?: ts.Node
-): ParenthesizedExpression {
-    const expression = createNode(SyntaxKind.ParenthesizedExpression, tsOriginal) as ParenthesizedExpression;
-    expression.innerExpression = innerExpression;
-    return expression;
-}
-
 export interface CallExpression extends Expression {
     kind: SyntaxKind.CallExpression;
     expression: Expression;

diff --git a/src/LuaPrinter.ts b/src/LuaPrinter.ts
@@ -64,9 +64,6 @@ function isSimpleExpression(expression: lua.Expression): boolean {
         case lua.SyntaxKind.BinaryExpression:
             const binaryExpression = expression as lua.BinaryExpression;
             return isSimpleExpression(binaryExpression.left) && isSimpleExpression(binaryExpression.right);
-
-        case lua.SyntaxKind.ParenthesizedExpression:
-            return isSimpleExpression((expression as lua.ParenthesizedExpression).innerExpression);
     }
 
     return true;
@@ -560,8 +557,6 @@ export class LuaPrinter {
                 return this.printUnaryExpression(expression as lua.UnaryExpression);
             case lua.SyntaxKind.BinaryExpression:
                 return this.printBinaryExpression(expression as lua.BinaryExpression);
-            case lua.SyntaxKind.ParenthesizedExpression:
-                return this.printParenthesizedExpression(expression as lua.ParenthesizedExpression);
             case lua.SyntaxKind.CallExpression:
                 return this.printCallExpression(expression as lua.CallExpression);
             case lua.SyntaxKind.MethodCallExpression:
@@ -689,46 +684,40 @@ export class LuaPrinter {
         const chunks: SourceChunk[] = [];
 
         chunks.push(this.printOperator(expression.operator));
-        chunks.push(this.printExpression(expression.operand));
+        chunks.push(this.printExpressionInParenthesesIfNeeded(expression.operand));
 
         return this.createSourceNode(expression, chunks);
     }
 
     public printBinaryExpression(expression: lua.BinaryExpression): SourceNode {
         const chunks: SourceChunk[] = [];
 
-        chunks.push(this.printExpression(expression.left));
+        chunks.push(this.printExpressionInParenthesesIfNeeded(expression.left));
         chunks.push(" ", this.printOperator(expression.operator), " ");
-        chunks.push(this.printExpression(expression.right));
+        chunks.push(this.printExpressionInParenthesesIfNeeded(expression.right));
 
         return this.createSourceNode(expression, chunks);
     }
 
-    private canStripParenthesis(expression: lua.Expression): boolean {
-        return (
-            lua.isParenthesizedExpression(expression) ||
-            lua.isTableIndexExpression(expression) ||
-            lua.isCallExpression(expression) ||
-            lua.isMethodCallExpression(expression) ||
-            lua.isIdentifier(expression) ||
-            lua.isNilLiteral(expression) ||
-            lua.isNumericLiteral(expression) ||
-            lua.isBooleanLiteral(expression)
-        );
+    private printExpressionInParenthesesIfNeeded(expression: lua.Expression): SourceNode {
+        return this.needsParenthesis(expression)
+            ? this.createSourceNode(expression, ["(", this.printExpression(expression), ")"])
+            : this.printExpression(expression);
     }
 
-    public printParenthesizedExpression(expression: lua.ParenthesizedExpression): SourceNode {
-        const innerExpression = this.printExpression(expression.innerExpression);
-        if (this.canStripParenthesis(expression.innerExpression)) {
-            return this.createSourceNode(expression, innerExpression);
-        }
-        return this.createSourceNode(expression, ["(", innerExpression, ")"]);
+    private needsParenthesis(expression: lua.Expression): boolean {
+        return (
+            lua.isBinaryExpression(expression) ||
+            lua.isFunctionExpression(expression) ||
+            lua.isTableExpression(expression) ||
+            (lua.isUnaryExpression(expression) && expression.operator === lua.SyntaxKind.NotOperator)
+        );
     }
 
     public printCallExpression(expression: lua.CallExpression): SourceNode {
         const chunks = [];
 
-        chunks.push(this.printExpression(expression.expression), "(");
+        chunks.push(this.printExpressionInParenthesesIfNeeded(expression.expression), "(");
 
         if (expression.params) {
             chunks.push(...this.printExpressionList(expression.params));
@@ -742,13 +731,14 @@ export class LuaPrinter {
     public printMethodCallExpression(expression: lua.MethodCallExpression): SourceNode {
         const chunks = [];
 
-        const prefix = lua.isStringLiteral(expression.prefixExpression)
-            ? this.printExpression(lua.createParenthesizedExpression(expression.prefixExpression))
-            : this.printExpression(expression.prefixExpression);
+        const prefix =
+            this.needsParenthesis(expression.prefixExpression) || lua.isStringLiteral(expression.prefixExpression)
+                ? ["(", this.printExpression(expression.prefixExpression), ")"]
+                : [this.printExpression(expression.prefixExpression)];
 
         const name = this.printIdentifier(expression.name);
 
-        chunks.push(prefix, ":", name, "(");
+        chunks.push(...prefix, ":", name, "(");
 
         if (expression.params) {
             chunks.push(...this.printExpressionList(expression.params));
@@ -770,7 +760,7 @@ export class LuaPrinter {
     public printTableIndexExpression(expression: lua.TableIndexExpression): SourceNode {
         const chunks: SourceChunk[] = [];
 
-        chunks.push(this.printExpression(expression.table));
+        chunks.push(this.printExpressionInParenthesesIfNeeded(expression.table));
         if (
             lua.isStringLiteral(expression.index) &&
             isValidLuaIdentifier(expression.index.value) &&

diff --git a/src/transformation/builtins/array.ts b/src/transformation/builtins/array.ts
@@ -89,10 +89,7 @@ export function transformArrayProperty(
 ): lua.UnaryExpression | undefined {
     switch (node.name.text) {
         case "length":
-            let expression = context.transformExpression(node.expression);
-            if (lua.isTableExpression(expression)) {
-                expression = lua.createParenthesizedExpression(expression);
-            }
+            const expression = context.transformExpression(node.expression);
             return lua.createUnaryExpression(expression, lua.SyntaxKind.LengthOperator, node);
         default:
             return undefined;

diff --git a/src/transformation/builtins/index.ts b/src/transformation/builtins/index.ts
@@ -120,13 +120,11 @@ export function transformBuiltinIdentifierExpression(
 ): lua.Expression | undefined {
     switch (node.text) {
         case "NaN":
-            return lua.createParenthesizedExpression(
-                lua.createBinaryExpression(
-                    lua.createNumericLiteral(0),
-                    lua.createNumericLiteral(0),
-                    lua.SyntaxKind.DivisionOperator,
-                    node
-                )
+            return lua.createBinaryExpression(
+                lua.createNumericLiteral(0),
+                lua.createNumericLiteral(0),
+                lua.SyntaxKind.DivisionOperator,
+                node
             );
 
         case "Infinity":

diff --git a/src/transformation/builtins/math.ts b/src/transformation/builtins/math.ts
@@ -50,8 +50,7 @@ export function transformMathCall(context: TransformationContext, node: Property
             const log1 = lua.createTableIndexExpression(math, lua.createStringLiteral("log"));
             const logCall1 = lua.createCallExpression(log1, params);
             const e = lua.createNumericLiteral(expressionName === "log10" ? Math.LN10 : Math.LN2);
-            const div = lua.createBinaryExpression(logCall1, e, lua.SyntaxKind.DivisionOperator);
-            return lua.createParenthesizedExpression(div, node);
+            return lua.createBinaryExpression(logCall1, e, lua.SyntaxKind.DivisionOperator, node);
         }
 
         // math.log(1 + x)

diff --git a/src/transformation/builtins/object.ts b/src/transformation/builtins/object.ts
@@ -49,8 +49,11 @@ export function transformObjectPrototypeCall(
             const parameters = transformArguments(context, node.arguments, signature);
             const rawGetIdentifier = lua.createIdentifier("rawget");
             const rawGetCall = lua.createCallExpression(rawGetIdentifier, [expr, ...parameters]);
-            return lua.createParenthesizedExpression(
-                lua.createBinaryExpression(rawGetCall, lua.createNilLiteral(), lua.SyntaxKind.InequalityOperator, node)
+            return lua.createBinaryExpression(
+                rawGetCall,
+                lua.createNilLiteral(),
+                lua.SyntaxKind.InequalityOperator,
+                node
             );
     }
 }
diff --git a/src/transformation/builtins/string.ts b/src/transformation/builtins/string.ts
@@ -40,34 +40,20 @@ export function transformStringPrototypeCall(
                 lua.createBooleanLiteral(true)
             );
 
-            return lua.createParenthesizedExpression(
-                lua.createBinaryExpression(
-                    lua.createParenthesizedExpression(
-                        lua.createBinaryExpression(
-                            stringExpression,
-                            lua.createNumericLiteral(0),
-                            lua.SyntaxKind.OrOperator
-                        )
-                    ),
-                    lua.createNumericLiteral(1),
-                    lua.SyntaxKind.SubtractionOperator,
-                    node
-                )
+            return lua.createBinaryExpression(
+                lua.createBinaryExpression(stringExpression, lua.createNumericLiteral(0), lua.SyntaxKind.OrOperator),
+                lua.createNumericLiteral(1),
+                lua.SyntaxKind.SubtractionOperator,
+                node
             );
         case "substr":
             if (node.arguments.length === 1) {
                 const argument = context.transformExpression(node.arguments[0]);
                 const arg1 = createExpressionPlusOne(argument);
                 return createStringCall("sub", node, caller, arg1);
             } else {
-                const arg1 = params[0];
-                const arg2 = params[1];
-                const sumArg = lua.createBinaryExpression(
-                    lua.createParenthesizedExpression(arg1),
-                    lua.createParenthesizedExpression(arg2),
-                    lua.SyntaxKind.AdditionOperator
-                );
-                return createStringCall("sub", node, caller, createExpressionPlusOne(arg1), sumArg);
+                const sumArg = lua.createBinaryExpression(params[0], params[1], lua.SyntaxKind.AdditionOperator);
+                return createStringCall("sub", node, caller, createExpressionPlusOne(params[0]), sumArg);
             }
         case "substring":
             if (node.arguments.length === 1) {
@@ -156,10 +142,7 @@ export function transformStringProperty(
 ): lua.UnaryExpression {
     switch (node.name.text) {
         case "length":
-            let expression = context.transformExpression(node.expression);
-            if (ts.isTemplateExpression(node.expression)) {
-                expression = lua.createParenthesizedExpression(expression);
-            }
+            const expression = context.transformExpression(node.expression);
             return lua.createUnaryExpression(expression, lua.SyntaxKind.LengthOperator, node);
         default:
             throw UnsupportedProperty("string", node.name.text, node);

diff --git a/src/transformation/utils/lua-ast.ts b/src/transformation/utils/lua-ast.ts
@@ -41,8 +41,6 @@ export function createExpressionPlusOne(expression: lua.Expression): lua.Express
         ) {
             return expression.left;
         }
-
-        expression = lua.createParenthesizedExpression(expression);
     }
 
     return lua.createBinaryExpression(expression, lua.createNumericLiteral(1), lua.SyntaxKind.AdditionOperator);
@@ -57,7 +55,7 @@ export function createImmediatelyInvokedFunctionExpression(
     body.push(lua.createReturnStatement(Array.isArray(result) ? result : [result]));
     const flags = statements.length === 0 ? lua.FunctionExpressionFlags.Inline : lua.FunctionExpressionFlags.None;
     const iife = lua.createFunctionExpression(lua.createBlock(body), undefined, undefined, undefined, flags);
-    return lua.createCallExpression(lua.createParenthesizedExpression(iife), [], tsOriginal);
+    return lua.createCallExpression(iife, [], tsOriginal);
 }
 
 export function createUnpackCall(
@@ -73,9 +71,9 @@ export function createUnpackCall(
     return lua.createCallExpression(unpack, [expression], tsOriginal);
 }
 
-export function wrapInTable(...expressions: lua.Expression[]): lua.ParenthesizedExpression {
+export function wrapInTable(...expressions: lua.Expression[]): lua.TableExpression {
     const fields = expressions.map(e => lua.createTableFieldExpression(e));
-    return lua.createParenthesizedExpression(lua.createTableExpression(fields));
+    return lua.createTableExpression(fields);
 }
 
 export function wrapInToStringForConcat(expression: lua.Expression): lua.Expression {

diff --git a/src/transformation/visitors/access.ts b/src/transformation/visitors/access.ts
@@ -31,10 +31,7 @@ export const transformElementAccessExpression: FunctionVisitor<ts.ElementAccessE
         return constEnumValue;
     }
 
-    let table = context.transformExpression(expression.expression);
-    if (lua.isTableExpression(table)) {
-        table = lua.createParenthesizedExpression(table);
-    }
+    const table = context.transformExpression(expression.expression);
 
     const argumentType = context.checker.getTypeAtLocation(expression.argumentExpression);
     const type = context.checker.getTypeAtLocation(expression.expression);
@@ -87,11 +84,7 @@ export const transformPropertyAccessExpression: FunctionVisitor<ts.PropertyAcces
         }
     }
 
-    let callPath = context.transformExpression(expression.expression);
-    if (lua.isTableExpression(callPath)) {
-        callPath = lua.createParenthesizedExpression(callPath);
-    }
-
+    const callPath = context.transformExpression(expression.expression);
     return lua.createTableIndexExpression(callPath, lua.createStringLiteral(property), expression);
 };
 

diff --git a/src/transformation/visitors/binary-expression/assignments.ts b/src/transformation/visitors/binary-expression/assignments.ts
@@ -127,7 +127,7 @@ export function transformAssignmentExpression(
         }
 
         const args = [objExpression, indexExpression, context.transformExpression(expression.right)];
-        return lua.createCallExpression(lua.createParenthesizedExpression(iife), args, expression);
+        return lua.createCallExpression(iife, args, expression);
     } else {
         // Simple assignment
         // (function() ${left} = ${right}; return ${left} end)()

diff --git a/src/transformation/visitors/binary-expression/compound.ts b/src/transformation/visitors/binary-expression/compound.ts
@@ -64,7 +64,7 @@ export function transformCompoundAssignmentExpression(
     isPostfix: boolean
 ): lua.CallExpression {
     const left = cast(context.transformExpression(lhs), lua.isAssignmentLeftHandSideExpression);
-    let right = context.transformExpression(rhs);
+    const right = context.transformExpression(rhs);
 
     const [objExpression, indexExpression] = parseAccessExpressionWithEvaluationEffects(context, lhs);
     if (objExpression && indexExpression) {
@@ -79,7 +79,6 @@ export function transformCompoundAssignmentExpression(
         const accessExpression = lua.createTableIndexExpression(obj, index);
 
         const tmp = lua.createIdentifier("____tmp");
-        right = lua.createParenthesizedExpression(right);
         let tmpDeclaration: lua.VariableDeclarationStatement;
         let assignStatement: lua.AssignmentStatement;
         if (isPostfix) {
@@ -175,7 +174,7 @@ export function transformCompoundAssignmentStatement(
         const operatorExpression = transformBinaryOperation(
             context,
             accessExpression,
-            lua.createParenthesizedExpression(right),
+            right,
             replacementOperator,
             node
         );

diff --git a/src/transformation/visitors/call.ts b/src/transformation/visitors/call.ts
@@ -53,10 +53,7 @@ export function transformContextualCallExpression(
         isValidLuaIdentifier(left.name.text)
     ) {
         // table:name()
-        let table = context.transformExpression(left.expression);
-        if (lua.isTableExpression(table)) {
-            table = lua.createParenthesizedExpression(table);
-        }
+        const table = context.transformExpression(left.expression);
 
         return lua.createMethodCallExpression(
             table,
@@ -109,10 +106,7 @@ function transformPropertyCall(context: TransformationContext, node: PropertyCal
         // table:name()
         return transformContextualCallExpression(context, node, parameters);
     } else {
-        let table = context.transformExpression(node.expression.expression);
-        if (lua.isTableExpression(table)) {
-            table = lua.createParenthesizedExpression(table);
-        }
+        const table = context.transformExpression(node.expression.expression);
 
         // table.name()
         const name = node.expression.name.text;
@@ -130,11 +124,7 @@ function transformElementCall(context: TransformationContext, node: ts.CallExpre
         return transformContextualCallExpression(context, node, parameters);
     } else {
         // No context
-        let expression = context.transformExpression(node.expression);
-        if (lua.isTableExpression(expression)) {
-            expression = lua.createParenthesizedExpression(expression);
-        }
-
+        const expression = context.transformExpression(node.expression);
         return lua.createCallExpression(expression, parameters);
     }
 }