typescript-to-lua 1.1.1 → 1.3.2

package/dist/transformation/visitors/binary-expression/compound.js

@@ -1,35 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformCompoundAssignmentStatement = exports.transformCompoundAssignmentExpression = exports.transformCompoundAssignment = exports.unwrapCompoundAssignmentToken = exports.isCompoundAssignmentToken = exports.parseAccessExpressionWithEvaluationEffects = void 0;
+exports.transformCompoundAssignmentStatement = exports.transformCompoundAssignmentExpression = exports.transformCompoundAssignment = exports.unwrapCompoundAssignmentToken = exports.isCompoundAssignmentToken = void 0;
 const ts = require("typescript");
 const lua = require("../../../LuaAST");
 const utils_1 = require("../../../utils");
-const transform_1 = require("../../utils/transform");
-const typescript_1 = require("../../utils/typescript");
+const preceding_statements_1 = require("../../utils/preceding-statements");
 const binary_expression_1 = require("../binary-expression");
 const assignments_1 = require("./assignments");
-// If expression is property/element access with possible effects from being evaluated, returns separated object and index expressions.
-function parseAccessExpressionWithEvaluationEffects(context, node) {
-    if (ts.isElementAccessExpression(node) &&
-        ((0, typescript_1.isExpressionWithEvaluationEffect)(node.expression) || (0, typescript_1.isExpressionWithEvaluationEffect)(node.argumentExpression))) {
-        const type = context.checker.getTypeAtLocation(node.expression);
-        if ((0, typescript_1.isArrayType)(context, type)) {
-            // Offset arrays by one
-            const oneLit = ts.factory.createNumericLiteral("1");
-            const exp = ts.factory.createParenthesizedExpression(node.argumentExpression);
-            const addExp = ts.factory.createBinaryExpression(exp, ts.SyntaxKind.PlusToken, oneLit);
-            return [node.expression, addExp];
-        }
-        else {
-            return [node.expression, node.argumentExpression];
-        }
-    }
-    else if (ts.isPropertyAccessExpression(node) && (0, typescript_1.isExpressionWithEvaluationEffect)(node.expression)) {
-        return [node.expression, ts.factory.createStringLiteral(node.name.text)];
-    }
-    return [];
+function isLuaExpressionWithSideEffect(expression) {
+    return !(lua.isLiteral(expression) || lua.isIdentifier(expression));
+}
+function shouldCacheTableIndexExpressions(expression, rightPrecedingStatements) {
+    return (isLuaExpressionWithSideEffect(expression.table) ||
+        isLuaExpressionWithSideEffect(expression.index) ||
+        rightPrecedingStatements.length > 0);
 }
-exports.parseAccessExpressionWithEvaluationEffects = parseAccessExpressionWithEvaluationEffects;
 const compoundToAssignmentTokens = {
     [ts.SyntaxKind.BarEqualsToken]: ts.SyntaxKind.BarToken,
     [ts.SyntaxKind.PlusEqualsToken]: ts.SyntaxKind.PlusToken,
@@ -53,69 +38,80 @@ const unwrapCompoundAssignmentToken = (token) => compoundToAssignmentTokens[toke
 exports.unwrapCompoundAssignmentToken = unwrapCompoundAssignmentToken;
 function transformCompoundAssignment(context, expression, lhs, rhs, operator, isPostfix) {
     const left = (0, utils_1.cast)(context.transformExpression(lhs), lua.isAssignmentLeftHandSideExpression);
-    const right = context.transformExpression(rhs);
-    const [objExpression, indexExpression] = parseAccessExpressionWithEvaluationEffects(context, lhs);
-    if (objExpression && indexExpression) {
+    const [rightPrecedingStatements, right] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(rhs));
+    if (lua.isTableIndexExpression(left) && shouldCacheTableIndexExpressions(left, rightPrecedingStatements)) {
         // Complex property/element accesses need to cache object/index expressions to avoid repeating side-effects
         // local __obj, __index = ${objExpression}, ${indexExpression};
-        const obj = lua.createIdentifier("____obj");
-        const index = lua.createIdentifier("____index");
-        const objAndIndexDeclaration = lua.createVariableDeclarationStatement([obj, index], [context.transformExpression(objExpression), context.transformExpression(indexExpression)]);
+        const obj = context.createTempNameForLuaExpression(left.table);
+        const index = context.createTempNameForLuaExpression(left.index);
+        const objAndIndexDeclaration = lua.createVariableDeclarationStatement([obj, index], [left.table, left.index]);
         const accessExpression = lua.createTableIndexExpression(obj, index);
-        const tmp = lua.createIdentifier("____tmp");
-        let tmpDeclaration;
-        let assignStatement;
+        const tmp = context.createTempNameForLuaExpression(left);
         if (isPostfix) {
             // local ____tmp = ____obj[____index];
             // ____obj[____index] = ____tmp ${replacementOperator} ${right};
-            tmpDeclaration = lua.createVariableDeclarationStatement(tmp, accessExpression);
-            const operatorExpression = (0, binary_expression_1.transformBinaryOperation)(context, tmp, right, operator, expression);
-            assignStatement = lua.createAssignmentStatement(accessExpression, operatorExpression);
+            // return ____tmp
+            const tmpDeclaration = lua.createVariableDeclarationStatement(tmp, accessExpression);
+            const [precedingStatements, operatorExpression] = (0, binary_expression_1.transformBinaryOperation)(context, tmp, right, rightPrecedingStatements, operator, expression);
+            const assignStatement = lua.createAssignmentStatement(accessExpression, operatorExpression);
+            return {
+                statements: [objAndIndexDeclaration, ...precedingStatements, tmpDeclaration, assignStatement],
+                result: tmp,
+            };
         }
         else {
             // local ____tmp = ____obj[____index] ${replacementOperator} ${right};
             // ____obj[____index] = ____tmp;
-            const operatorExpression = (0, binary_expression_1.transformBinaryOperation)(context, accessExpression, right, operator, expression);
-            tmpDeclaration = lua.createVariableDeclarationStatement(tmp, operatorExpression);
-            assignStatement = lua.createAssignmentStatement(accessExpression, tmp);
+            // return ____tmp
+            const [precedingStatements, operatorExpression] = (0, binary_expression_1.transformBinaryOperation)(context, accessExpression, right, rightPrecedingStatements, operator, expression);
+            const tmpDeclaration = lua.createVariableDeclarationStatement(tmp, operatorExpression);
+            const assignStatement = lua.createAssignmentStatement(accessExpression, tmp);
+            return {
+                statements: [objAndIndexDeclaration, ...precedingStatements, tmpDeclaration, assignStatement],
+                result: tmp,
+            };
         }
-        // return ____tmp
-        return { statements: [objAndIndexDeclaration, tmpDeclaration, assignStatement], result: tmp };
     }
     else if (isPostfix) {
         // Postfix expressions need to cache original value in temp
         // local ____tmp = ${left};
         // ${left} = ____tmp ${replacementOperator} ${right};
         // return ____tmp
-        const tmpIdentifier = lua.createIdentifier("____tmp");
+        const tmpIdentifier = context.createTempNameForLuaExpression(left);
         const tmpDeclaration = lua.createVariableDeclarationStatement(tmpIdentifier, left);
-        const operatorExpression = (0, binary_expression_1.transformBinaryOperation)(context, tmpIdentifier, right, operator, expression);
-        const assignStatements = (0, assignments_1.transformAssignment)(context, lhs, operatorExpression);
-        return { statements: [tmpDeclaration, ...assignStatements], result: tmpIdentifier };
+        const [precedingStatements, operatorExpression] = (0, binary_expression_1.transformBinaryOperation)(context, tmpIdentifier, right, rightPrecedingStatements, operator, expression);
+        const assignStatements = (0, assignments_1.transformAssignmentWithRightPrecedingStatements)(context, lhs, operatorExpression, rightPrecedingStatements);
+        return { statements: [tmpDeclaration, ...precedingStatements, ...assignStatements], result: tmpIdentifier };
     }
     else if (ts.isPropertyAccessExpression(lhs) || ts.isElementAccessExpression(lhs)) {
         // Simple property/element access expressions need to cache in temp to avoid double-evaluation
         // local ____tmp = ${left} ${replacementOperator} ${right};
         // ${left} = ____tmp;
         // return ____tmp
-        const tmpIdentifier = lua.createIdentifier("____tmp");
-        const operatorExpression = (0, binary_expression_1.transformBinaryOperation)(context, left, right, operator, expression);
+        const tmpIdentifier = context.createTempNameForLuaExpression(left);
+        const [precedingStatements, operatorExpression] = (0, binary_expression_1.transformBinaryOperation)(context, left, right, rightPrecedingStatements, operator, expression);
         const tmpDeclaration = lua.createVariableDeclarationStatement(tmpIdentifier, operatorExpression);
-        const assignStatements = (0, assignments_1.transformAssignment)(context, lhs, tmpIdentifier);
         if (isSetterSkippingCompoundAssignmentOperator(operator)) {
             const statements = [
                 tmpDeclaration,
-                ...transformSetterSkippingCompoundAssignment(context, tmpIdentifier, operator, rhs),
+                ...transformSetterSkippingCompoundAssignment(tmpIdentifier, operator, right, precedingStatements),
             ];
             return { statements, result: tmpIdentifier };
         }
+        const assignStatements = (0, assignments_1.transformAssignmentWithRightPrecedingStatements)(context, lhs, tmpIdentifier, precedingStatements);
         return { statements: [tmpDeclaration, ...assignStatements], result: tmpIdentifier };
     }
     else {
+        if (rightPrecedingStatements.length > 0 && isSetterSkippingCompoundAssignmentOperator(operator)) {
+            return {
+                statements: transformSetterSkippingCompoundAssignment(left, operator, right, rightPrecedingStatements),
+                result: left,
+            };
+        }
         // Simple expressions
-        // ${left} = ${right}; return ${right}
-        const operatorExpression = (0, binary_expression_1.transformBinaryOperation)(context, left, right, operator, expression);
-        const statements = (0, assignments_1.transformAssignment)(context, lhs, operatorExpression);
+        // ${left} = ${left} ${operator} ${right}
+        const [precedingStatements, operatorExpression] = (0, binary_expression_1.transformBinaryOperation)(context, left, right, rightPrecedingStatements, operator, expression);
+        const statements = (0, assignments_1.transformAssignmentWithRightPrecedingStatements)(context, lhs, operatorExpression, precedingStatements);
         return { statements, result: left };
     }
 }
@@ -123,40 +119,42 @@ exports.transformCompoundAssignment = transformCompoundAssignment;
 function transformCompoundAssignmentExpression(context, expression, 
 // TODO: Change type to ts.LeftHandSideExpression?
 lhs, rhs, operator, isPostfix) {
-    return (0, transform_1.transformToImmediatelyInvokedFunctionExpression)(context, () => transformCompoundAssignment(context, expression, lhs, rhs, operator, isPostfix), expression);
+    const { statements, result } = transformCompoundAssignment(context, expression, lhs, rhs, operator, isPostfix);
+    context.addPrecedingStatements(statements);
+    return result;
 }
 exports.transformCompoundAssignmentExpression = transformCompoundAssignmentExpression;
 function transformCompoundAssignmentStatement(context, node, lhs, rhs, operator) {
     const left = (0, utils_1.cast)(context.transformExpression(lhs), lua.isAssignmentLeftHandSideExpression);
-    const right = context.transformExpression(rhs);
-    const [objExpression, indexExpression] = parseAccessExpressionWithEvaluationEffects(context, lhs);
-    if (objExpression && indexExpression) {
+    let [rightPrecedingStatements, right] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(rhs));
+    if (lua.isTableIndexExpression(left) && shouldCacheTableIndexExpressions(left, rightPrecedingStatements)) {
         // Complex property/element accesses need to cache object/index expressions to avoid repeating side-effects
         // local __obj, __index = ${objExpression}, ${indexExpression};
         // ____obj[____index] = ____obj[____index] ${replacementOperator} ${right};
-        const obj = lua.createIdentifier("____obj");
-        const index = lua.createIdentifier("____index");
-        const objAndIndexDeclaration = lua.createVariableDeclarationStatement([obj, index], [context.transformExpression(objExpression), context.transformExpression(indexExpression)]);
+        const obj = context.createTempNameForLuaExpression(left.table);
+        const index = context.createTempNameForLuaExpression(left.index);
+        const objAndIndexDeclaration = lua.createVariableDeclarationStatement([obj, index], [left.table, left.index]);
         const accessExpression = lua.createTableIndexExpression(obj, index);
         if (isSetterSkippingCompoundAssignmentOperator(operator)) {
             return [
                 objAndIndexDeclaration,
-                ...transformSetterSkippingCompoundAssignment(context, accessExpression, operator, rhs, node),
+                ...transformSetterSkippingCompoundAssignment(accessExpression, operator, right, rightPrecedingStatements, node),
             ];
         }
-        const operatorExpression = (0, binary_expression_1.transformBinaryOperation)(context, accessExpression, right, operator, node);
+        let operatorExpression;
+        [rightPrecedingStatements, operatorExpression] = (0, binary_expression_1.transformBinaryOperation)(context, accessExpression, right, rightPrecedingStatements, operator, node);
         const assignStatement = lua.createAssignmentStatement(accessExpression, operatorExpression);
-        return [objAndIndexDeclaration, assignStatement];
+        return [objAndIndexDeclaration, ...rightPrecedingStatements, assignStatement];
     }
     else {
         if (isSetterSkippingCompoundAssignmentOperator(operator)) {
-            const luaLhs = context.transformExpression(lhs);
-            return transformSetterSkippingCompoundAssignment(context, luaLhs, operator, rhs, node);
+            return transformSetterSkippingCompoundAssignment(left, operator, right, rightPrecedingStatements, node);
         }
         // Simple statements
         // ${left} = ${left} ${replacementOperator} ${right}
-        const operatorExpression = (0, binary_expression_1.transformBinaryOperation)(context, left, right, operator, node);
-        return (0, assignments_1.transformAssignment)(context, lhs, operatorExpression);
+        let operatorExpression;
+        [rightPrecedingStatements, operatorExpression] = (0, binary_expression_1.transformBinaryOperation)(context, left, right, rightPrecedingStatements, operator, node);
+        return (0, assignments_1.transformAssignmentWithRightPrecedingStatements)(context, lhs, operatorExpression, rightPrecedingStatements);
     }
 }
 exports.transformCompoundAssignmentStatement = transformCompoundAssignmentStatement;
@@ -165,7 +163,7 @@ function isSetterSkippingCompoundAssignmentOperator(operator) {
         operator === ts.SyntaxKind.BarBarToken ||
         operator === ts.SyntaxKind.QuestionQuestionToken);
 }
-function transformSetterSkippingCompoundAssignment(context, lhs, operator, rhs, node) {
+function transformSetterSkippingCompoundAssignment(lhs, operator, right, rightPrecedingStatements, node) {
     // These assignments have the form 'if x then y = z', figure out what condition x is first.
     let condition;
     if (operator === ts.SyntaxKind.AmpersandAmpersandToken) {
@@ -182,7 +180,7 @@ function transformSetterSkippingCompoundAssignment(context, lhs, operator, rhs,
     }
     // if condition then lhs = rhs end
     return [
-        lua.createIfStatement(condition, lua.createBlock([lua.createAssignmentStatement(lhs, context.transformExpression(rhs))]), undefined, node),
+        lua.createIfStatement(condition, lua.createBlock([...rightPrecedingStatements, lua.createAssignmentStatement(lhs, right, node)]), undefined, node),
     ];
 }
 //# sourceMappingURL=compound.js.map

package/dist/transformation/visitors/binary-expression/destructuring-assignments.d.ts

@@ -2,5 +2,5 @@ import * as ts from "typescript";
 import * as lua from "../../../LuaAST";
 import { TransformationContext } from "../../context";
 export declare function isArrayLength(context: TransformationContext, expression: ts.Expression): expression is ts.PropertyAccessExpression | ts.ElementAccessExpression;
-export declare function transformDestructuringAssignment(context: TransformationContext, node: ts.DestructuringAssignment, root: lua.Expression): lua.Statement[];
-export declare function transformAssignmentPattern(context: TransformationContext, node: ts.AssignmentPattern, root: lua.Expression): lua.Statement[];
+export declare function transformDestructuringAssignment(context: TransformationContext, node: ts.DestructuringAssignment, root: lua.Expression, rightHasPrecedingStatements: boolean): lua.Statement[];
+export declare function transformAssignmentPattern(context: TransformationContext, node: ts.AssignmentPattern, root: lua.Expression, rightHasPrecedingStatements: boolean): lua.Statement[];

package/dist/transformation/visitors/binary-expression/destructuring-assignments.js

@@ -2,10 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.transformAssignmentPattern = exports.transformDestructuringAssignment = exports.isArrayLength = void 0;
 const ts = require("typescript");
+const _1 = require(".");
 const lua = require("../../../LuaAST");
 const utils_1 = require("../../../utils");
 const lualib_1 = require("../../utils/lualib");
+const preceding_statements_1 = require("../../utils/preceding-statements");
 const typescript_1 = require("../../utils/typescript");
+const expression_list_1 = require("../expression-list");
 const literal_1 = require("../literal");
 const assignments_1 = require("./assignments");
 function isArrayLength(context, expression) {
@@ -24,32 +27,34 @@ function isArrayLength(context, expression) {
     return name === "length";
 }
 exports.isArrayLength = isArrayLength;
-function transformDestructuringAssignment(context, node, root) {
-    return transformAssignmentPattern(context, node.left, root);
+function transformDestructuringAssignment(context, node, root, rightHasPrecedingStatements) {
+    return transformAssignmentPattern(context, node.left, root, rightHasPrecedingStatements);
 }
 exports.transformDestructuringAssignment = transformDestructuringAssignment;
-function transformAssignmentPattern(context, node, root) {
+function transformAssignmentPattern(context, node, root, rightHasPrecedingStatements) {
     switch (node.kind) {
         case ts.SyntaxKind.ObjectLiteralExpression:
-            return transformObjectLiteralAssignmentPattern(context, node, root);
+            return transformObjectLiteralAssignmentPattern(context, node, root, rightHasPrecedingStatements);
         case ts.SyntaxKind.ArrayLiteralExpression:
-            return transformArrayLiteralAssignmentPattern(context, node, root);
+            return transformArrayLiteralAssignmentPattern(context, node, root, rightHasPrecedingStatements);
     }
 }
 exports.transformAssignmentPattern = transformAssignmentPattern;
-function transformArrayLiteralAssignmentPattern(context, node, root) {
+function transformArrayLiteralAssignmentPattern(context, node, root, rightHasPrecedingStatements) {
     return node.elements.flatMap((element, index) => {
         const indexedRoot = lua.createTableIndexExpression(root, lua.createNumericLiteral(index + 1), element);
         switch (element.kind) {
             case ts.SyntaxKind.ObjectLiteralExpression:
-                return transformObjectLiteralAssignmentPattern(context, element, indexedRoot);
+                return transformObjectLiteralAssignmentPattern(context, element, indexedRoot, rightHasPrecedingStatements);
             case ts.SyntaxKind.ArrayLiteralExpression:
-                return transformArrayLiteralAssignmentPattern(context, element, indexedRoot);
+                return transformArrayLiteralAssignmentPattern(context, element, indexedRoot, rightHasPrecedingStatements);
             case ts.SyntaxKind.BinaryExpression:
-                const assignedVariable = lua.createIdentifier("____bindingAssignmentValue");
+                const assignedVariable = context.createTempNameForLuaExpression(indexedRoot);
                 const assignedVariableDeclaration = lua.createVariableDeclarationStatement(assignedVariable, indexedRoot);
                 const nilCondition = lua.createBinaryExpression(assignedVariable, lua.createNilLiteral(), lua.SyntaxKind.EqualityOperator);
-                const defaultAssignmentStatements = (0, assignments_1.transformAssignment)(context, element.left, context.transformExpression(element.right));
+                const [defaultPrecedingStatements, defaultAssignmentStatements] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => (0, assignments_1.transformAssignment)(context, element.left, context.transformExpression(element.right)));
+                // Keep preceding statements inside if block
+                defaultAssignmentStatements.unshift(...defaultPrecedingStatements);
                 const elseAssignmentStatements = (0, assignments_1.transformAssignment)(context, element.left, assignedVariable);
                 const ifBlock = lua.createBlock(defaultAssignmentStatements);
                 const elseBlock = lua.createBlock(elseAssignmentStatements);
@@ -58,14 +63,16 @@ function transformArrayLiteralAssignmentPattern(context, node, root) {
             case ts.SyntaxKind.Identifier:
             case ts.SyntaxKind.PropertyAccessExpression:
             case ts.SyntaxKind.ElementAccessExpression:
-                return (0, assignments_1.transformAssignment)(context, element, indexedRoot);
+                const [precedingStatements, statements] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => (0, assignments_1.transformAssignment)(context, element, indexedRoot, rightHasPrecedingStatements));
+                return [...precedingStatements, ...statements]; // Keep preceding statements in order
             case ts.SyntaxKind.SpreadElement:
                 if (index !== node.elements.length - 1) {
                     // TypeScript error
                     return [];
                 }
                 const restElements = (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ArraySlice, undefined, root, lua.createNumericLiteral(index));
-                return (0, assignments_1.transformAssignment)(context, element.expression, restElements);
+                const [spreadPrecedingStatements, spreadStatements] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => (0, assignments_1.transformAssignment)(context, element.expression, restElements, rightHasPrecedingStatements));
+                return [...spreadPrecedingStatements, ...spreadStatements]; // Keep preceding statements in order
             case ts.SyntaxKind.OmittedExpression:
                 return [];
             default:
@@ -74,7 +81,7 @@ function transformArrayLiteralAssignmentPattern(context, node, root) {
         }
     });
 }
-function transformObjectLiteralAssignmentPattern(context, node, root) {
+function transformObjectLiteralAssignmentPattern(context, node, root, rightHasPrecedingStatements) {
     const result = [];
     for (const property of node.properties) {
         switch (property.kind) {
@@ -82,7 +89,7 @@ function transformObjectLiteralAssignmentPattern(context, node, root) {
                 result.push(...transformShorthandPropertyAssignment(context, property, root));
                 break;
             case ts.SyntaxKind.PropertyAssignment:
-                result.push(...transformPropertyAssignment(context, property, root));
+                result.push(...transformPropertyAssignment(context, property, root, rightHasPrecedingStatements));
                 break;
             case ts.SyntaxKind.SpreadAssignment:
                 result.push(...transformSpreadAssignment(context, property, root, node.properties));
@@ -115,29 +122,51 @@ function transformShorthandPropertyAssignment(context, node, root) {
     }
     return result;
 }
-function transformPropertyAssignment(context, node, root) {
+function transformPropertyAssignment(context, node, root, rightHasPrecedingStatements) {
     const result = [];
     if ((0, typescript_1.isAssignmentPattern)(node.initializer)) {
         const propertyAccessString = (0, literal_1.transformPropertyName)(context, node.name);
         const newRootAccess = lua.createTableIndexExpression(root, propertyAccessString);
         if (ts.isObjectLiteralExpression(node.initializer)) {
-            return transformObjectLiteralAssignmentPattern(context, node.initializer, newRootAccess);
+            return transformObjectLiteralAssignmentPattern(context, node.initializer, newRootAccess, rightHasPrecedingStatements);
         }
         if (ts.isArrayLiteralExpression(node.initializer)) {
-            return transformArrayLiteralAssignmentPattern(context, node.initializer, newRootAccess);
+            return transformArrayLiteralAssignmentPattern(context, node.initializer, newRootAccess, rightHasPrecedingStatements);
         }
     }
-    const leftExpression = ts.isBinaryExpression(node.initializer) ? node.initializer.left : node.initializer;
-    const variableToExtract = (0, literal_1.transformPropertyName)(context, node.name);
+    context.pushPrecedingStatements();
+    let variableToExtract = (0, literal_1.transformPropertyName)(context, node.name);
+    // Must be evaluated before left's preceding statements
+    variableToExtract = (0, expression_list_1.moveToPrecedingTemp)(context, variableToExtract, node.name);
     const extractingExpression = lua.createTableIndexExpression(root, variableToExtract);
-    const destructureAssignmentStatements = (0, assignments_1.transformAssignment)(context, leftExpression, extractingExpression);
-    result.push(...destructureAssignmentStatements);
+    let destructureAssignmentStatements;
     if (ts.isBinaryExpression(node.initializer)) {
-        const assignmentLeftHandSide = context.transformExpression(node.initializer.left);
-        const nilCondition = lua.createBinaryExpression(assignmentLeftHandSide, lua.createNilLiteral(), lua.SyntaxKind.EqualityOperator);
-        const ifBlock = lua.createBlock((0, assignments_1.transformAssignmentStatement)(context, node.initializer));
-        result.push(lua.createIfStatement(nilCondition, ifBlock, undefined, node));
+        if (ts.isPropertyAccessExpression(node.initializer.left) ||
+            ts.isElementAccessExpression(node.initializer.left)) {
+            // Access expressions need their table and index expressions cached to preserve execution order
+            const left = (0, utils_1.cast)(context.transformExpression(node.initializer.left), lua.isTableIndexExpression);
+            const rightExpression = node.initializer.right;
+            const [defaultPrecedingStatements, defaultExpression] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(rightExpression));
+            const tableTemp = context.createTempNameForLuaExpression(left.table);
+            const indexTemp = context.createTempNameForLuaExpression(left.index);
+            const tempsDeclaration = lua.createVariableDeclarationStatement([tableTemp, indexTemp], [left.table, left.index]);
+            // obj[index] = extractingExpression ?? defaultExpression
+            const [rightPrecedingStatements, rhs] = (0, _1.transformBinaryOperation)(context, extractingExpression, defaultExpression, defaultPrecedingStatements, ts.SyntaxKind.QuestionQuestionToken, node.initializer);
+            const assignStatement = lua.createAssignmentStatement(lua.createTableIndexExpression(tableTemp, indexTemp), rhs);
+            destructureAssignmentStatements = [tempsDeclaration, ...rightPrecedingStatements, assignStatement];
+        }
+        else {
+            const assignmentLeftHandSide = context.transformExpression(node.initializer.left);
+            const nilCondition = lua.createBinaryExpression(assignmentLeftHandSide, lua.createNilLiteral(), lua.SyntaxKind.EqualityOperator);
+            const ifBlock = lua.createBlock((0, assignments_1.transformAssignmentStatement)(context, node.initializer));
+            destructureAssignmentStatements = [lua.createIfStatement(nilCondition, ifBlock, undefined, node)];
+        }
+    }
+    else {
+        destructureAssignmentStatements = (0, assignments_1.transformAssignment)(context, node.initializer, extractingExpression, rightHasPrecedingStatements);
     }
+    result.push(...context.popPrecedingStatements());
+    result.push(...destructureAssignmentStatements);
     return result;
 }
 function transformSpreadAssignment(context, node, root, properties) {

package/dist/transformation/visitors/binary-expression/index.d.ts

@@ -2,8 +2,10 @@ import * as ts from "typescript";
 import * as lua from "../../../LuaAST";
 import { FunctionVisitor, TransformationContext } from "../../context";
 import { BitOperator } from "./bit";
+declare type ShortCircuitOperator = ts.SyntaxKind.AmpersandAmpersandToken | ts.SyntaxKind.BarBarToken | ts.SyntaxKind.QuestionQuestionToken;
 declare type SimpleOperator = ts.AdditiveOperatorOrHigher | Exclude<ts.RelationalOperator, ts.SyntaxKind.InstanceOfKeyword | ts.SyntaxKind.InKeyword> | ts.EqualityOperator | ts.LogicalOperator;
-export declare function transformBinaryOperation(context: TransformationContext, left: lua.Expression, right: lua.Expression, operator: BitOperator | SimpleOperator | ts.SyntaxKind.QuestionQuestionToken, node: ts.Node): lua.Expression;
+export declare function createShortCircuitBinaryExpressionPrecedingStatements(context: TransformationContext, lhs: lua.Expression, rhs: lua.Expression, rightPrecedingStatements: lua.Statement[], operator: ShortCircuitOperator, node?: ts.BinaryExpression): [lua.Statement[], lua.Expression];
+export declare function transformBinaryOperation(context: TransformationContext, left: lua.Expression, right: lua.Expression, rightPrecedingStatements: lua.Statement[], operator: BitOperator | SimpleOperator | ts.SyntaxKind.QuestionQuestionToken, node: ts.Node): [lua.Statement[], lua.Expression];
 export declare const transformBinaryExpression: FunctionVisitor<ts.BinaryExpression>;
 export declare function transformBinaryExpressionStatement(context: TransformationContext, node: ts.ExpressionStatement): lua.Statement[] | lua.Statement | undefined;
 export {};

package/dist/transformation/visitors/binary-expression/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformBinaryExpressionStatement = exports.transformBinaryExpression = exports.transformBinaryOperation = void 0;
+exports.transformBinaryExpressionStatement = exports.transformBinaryExpression = exports.transformBinaryOperation = exports.createShortCircuitBinaryExpressionPrecedingStatements = void 0;
 const ts = require("typescript");
 const lua = require("../../../LuaAST");
 const lua_ast_1 = require("../../utils/lua-ast");
@@ -11,7 +11,11 @@ const assignments_1 = require("./assignments");
 const bit_1 = require("./bit");
 const compound_1 = require("./compound");
 const utils_1 = require("../../../utils");
-const transform_1 = require("../../utils/transform");
+const expression_list_1 = require("../expression-list");
+const preceding_statements_1 = require("../../utils/preceding-statements");
+const isShortCircuitOperator = (value) => value === ts.SyntaxKind.AmpersandAmpersandToken ||
+    value === ts.SyntaxKind.BarBarToken ||
+    value === ts.SyntaxKind.QuestionQuestionToken;
 const simpleOperatorsToLua = {
     [ts.SyntaxKind.AmpersandAmpersandToken]: lua.SyntaxKind.AndOperator,
     [ts.SyntaxKind.BarBarToken]: lua.SyntaxKind.OrOperator,
@@ -30,13 +34,13 @@ const simpleOperatorsToLua = {
     [ts.SyntaxKind.ExclamationEqualsToken]: lua.SyntaxKind.InequalityOperator,
     [ts.SyntaxKind.ExclamationEqualsEqualsToken]: lua.SyntaxKind.InequalityOperator,
 };
-function transformBinaryOperation(context, left, right, operator, node) {
+function transformBinaryOperationWithNoPrecedingStatements(context, left, right, operator, node) {
     if ((0, bit_1.isBitOperator)(operator)) {
         return (0, bit_1.transformBinaryBitOperation)(context, node, left, right, operator);
     }
     if (operator === ts.SyntaxKind.QuestionQuestionToken) {
         (0, utils_1.assert)(ts.isBinaryExpression(node));
-        return transformNullishCoalescingExpression(context, node, left, right);
+        return transformNullishCoalescingOperationNoPrecedingStatements(context, node, left, right);
     }
     let luaOperator = simpleOperatorsToLua[operator];
     // Check if we need to use string concat operator
@@ -53,6 +57,40 @@ function transformBinaryOperation(context, left, right, operator, node) {
     }
     return lua.createBinaryExpression(left, right, luaOperator, node);
 }
+function createShortCircuitBinaryExpressionPrecedingStatements(context, lhs, rhs, rightPrecedingStatements, operator, node) {
+    const conditionIdentifier = context.createTempNameForLuaExpression(lhs);
+    const assignmentStatement = lua.createVariableDeclarationStatement(conditionIdentifier, lhs, node === null || node === void 0 ? void 0 : node.left);
+    let condition;
+    switch (operator) {
+        case ts.SyntaxKind.BarBarToken:
+            condition = lua.createUnaryExpression(lua.cloneIdentifier(conditionIdentifier), lua.SyntaxKind.NotOperator, node);
+            break;
+        case ts.SyntaxKind.AmpersandAmpersandToken:
+            condition = lua.cloneIdentifier(conditionIdentifier);
+            break;
+        case ts.SyntaxKind.QuestionQuestionToken:
+            condition = lua.createBinaryExpression(lua.cloneIdentifier(conditionIdentifier), lua.createNilLiteral(), lua.SyntaxKind.EqualityOperator, node);
+            break;
+    }
+    const ifStatement = lua.createIfStatement(condition, lua.createBlock([...rightPrecedingStatements, lua.createAssignmentStatement(conditionIdentifier, rhs)]), undefined, node === null || node === void 0 ? void 0 : node.left);
+    return [[assignmentStatement, ifStatement], conditionIdentifier];
+}
+exports.createShortCircuitBinaryExpressionPrecedingStatements = createShortCircuitBinaryExpressionPrecedingStatements;
+function transformShortCircuitBinaryExpression(context, node, operator) {
+    const lhs = context.transformExpression(node.left);
+    const [rightPrecedingStatements, rhs] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(node.right));
+    return transformBinaryOperation(context, lhs, rhs, rightPrecedingStatements, operator, node);
+}
+function transformBinaryOperation(context, left, right, rightPrecedingStatements, operator, node) {
+    if (rightPrecedingStatements.length > 0 && isShortCircuitOperator(operator)) {
+        (0, utils_1.assert)(ts.isBinaryExpression(node));
+        return createShortCircuitBinaryExpressionPrecedingStatements(context, left, right, rightPrecedingStatements, operator, node);
+    }
+    return [
+        rightPrecedingStatements,
+        transformBinaryOperationWithNoPrecedingStatements(context, left, right, operator, node),
+    ];
+}
 exports.transformBinaryOperation = transformBinaryOperation;
 const transformBinaryExpression = (node, context) => {
     const operator = node.operatorToken.kind;
@@ -83,14 +121,25 @@ const transformBinaryExpression = (node, context) => {
             return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.InstanceOf, node, lhs, rhs);
         }
         case ts.SyntaxKind.CommaToken: {
-            return (0, transform_1.transformToImmediatelyInvokedFunctionExpression)(context, () => ({
-                statements: context.transformStatements(ts.factory.createExpressionStatement(node.left)),
-                result: context.transformExpression(node.right),
-            }), node);
+            const statements = context.transformStatements(ts.factory.createExpressionStatement(node.left));
+            const [precedingStatements, result] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(node.right));
+            statements.push(...precedingStatements);
+            context.addPrecedingStatements(statements);
+            return result;
+        }
+        case ts.SyntaxKind.QuestionQuestionToken:
+        case ts.SyntaxKind.AmpersandAmpersandToken:
+        case ts.SyntaxKind.BarBarToken: {
+            const [precedingStatements, result] = transformShortCircuitBinaryExpression(context, node, operator);
+            context.addPrecedingStatements(precedingStatements);
+            return result;
         }
-        default:
-            return transformBinaryOperation(context, context.transformExpression(node.left), context.transformExpression(node.right), operator, node);
     }
+    let [precedingStatements, [lhs, rhs]] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => (0, expression_list_1.transformOrderedExpressions)(context, [node.left, node.right]));
+    let result;
+    [precedingStatements, result] = transformBinaryOperation(context, lhs, rhs, precedingStatements, operator, node);
+    context.addPrecedingStatements(precedingStatements);
+    return result;
 };
 exports.transformBinaryExpression = transformBinaryExpression;
 function transformBinaryExpressionStatement(context, node) {
@@ -115,21 +164,14 @@ function transformBinaryExpressionStatement(context, node) {
     }
 }
 exports.transformBinaryExpressionStatement = transformBinaryExpressionStatement;
-function transformNullishCoalescingExpression(context, node, transformedLeft, transformedRight) {
+function transformNullishCoalescingOperationNoPrecedingStatements(context, node, transformedLeft, transformedRight) {
     const lhsType = context.checker.getTypeAtLocation(node.left);
     // Check if we can take a shortcut to 'lhs or rhs' if the left-hand side cannot be 'false'.
-    const typeCanBeFalse = (type) => (type.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown | ts.TypeFlags.Boolean)) !== 0 ||
-        (type.flags & ts.TypeFlags.BooleanLiteral & ts.TypeFlags.PossiblyFalsy) !== 0;
-    if ((0, typescript_1.typeCanSatisfy)(context, lhsType, typeCanBeFalse)) {
-        // lhs can be false, transform to IIFE
-        const lhsIdentifier = lua.createIdentifier("____lhs");
-        const nilComparison = lua.createBinaryExpression(lua.cloneIdentifier(lhsIdentifier), lua.createNilLiteral(), lua.SyntaxKind.EqualityOperator);
-        // if ____ == nil then return rhs else return ____ end
-        const ifStatement = lua.createIfStatement(nilComparison, lua.createBlock([lua.createReturnStatement([transformedRight])]), lua.createBlock([lua.createReturnStatement([lua.cloneIdentifier(lhsIdentifier)])]));
-        // (function(lhs') if lhs' == nil then return rhs else return lhs' end)(lhs)
-        return lua.createCallExpression(lua.createFunctionExpression(lua.createBlock([ifStatement]), [lhsIdentifier]), [
-            transformedLeft,
-        ]);
+    if ((0, typescript_1.canBeFalsyWhenNotNull)(context, lhsType)) {
+        // reuse logic from case with preceding statements
+        const [precedingStatements, result] = createShortCircuitBinaryExpressionPrecedingStatements(context, transformedLeft, transformedRight, [], ts.SyntaxKind.QuestionQuestionToken, node);
+        context.addPrecedingStatements(precedingStatements);
+        return result;
     }
     else {
         // lhs or rhs

package/dist/transformation/visitors/call.d.ts

@@ -4,7 +4,8 @@ import { FunctionVisitor, TransformationContext } from "../context";
 export declare type PropertyCallExpression = ts.CallExpression & {
     expression: ts.PropertyAccessExpression;
 };
-export declare function flattenSpreadExpressions(context: TransformationContext, expressions: readonly ts.Expression[]): lua.Expression[];
+export declare function validateArguments(context: TransformationContext, params: readonly ts.Expression[], signature?: ts.Signature): void;
 export declare function transformArguments(context: TransformationContext, params: readonly ts.Expression[], signature?: ts.Signature, callContext?: ts.Expression): lua.Expression[];
-export declare function transformContextualCallExpression(context: TransformationContext, node: ts.CallExpression | ts.TaggedTemplateExpression, args: ts.Expression[] | ts.NodeArray<ts.Expression>, signature?: ts.Signature): lua.CallExpression | lua.MethodCallExpression;
+export declare function transformCallAndArguments(context: TransformationContext, callExpression: ts.Expression, params: readonly ts.Expression[], signature?: ts.Signature, callContext?: ts.Expression): [lua.Expression, lua.Expression[]];
+export declare function transformContextualCallExpression(context: TransformationContext, node: ts.CallExpression | ts.TaggedTemplateExpression, args: ts.Expression[] | ts.NodeArray<ts.Expression>, signature?: ts.Signature): lua.Expression;
 export declare const transformCallExpression: FunctionVisitor<ts.CallExpression>;