typescript-to-lua 1.0.1 → 1.3.0

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

@@ -31,7 +31,7 @@ function transformBitOperatorToLuaOperator(context, node, operator) {
         case ts.SyntaxKind.LessThanLessThanToken:
             return lua.SyntaxKind.BitwiseLeftShiftOperator;
         case ts.SyntaxKind.GreaterThanGreaterThanToken:
-            context.diagnostics.push(diagnostics_1.unsupportedRightShiftOperator(node));
+            context.diagnostics.push((0, diagnostics_1.unsupportedRightShiftOperator)(node));
         case ts.SyntaxKind.GreaterThanGreaterThanGreaterThanToken:
             return lua.SyntaxKind.BitwiseRightShiftOperator;
     }
@@ -40,7 +40,7 @@ function transformBinaryBitOperation(context, node, left, right, operator) {
     switch (context.luaTarget) {
         case CompilerOptions_1.LuaTarget.Universal:
         case CompilerOptions_1.LuaTarget.Lua51:
-            context.diagnostics.push(diagnostics_1.unsupportedForTarget(node, "Bitwise operations", CompilerOptions_1.LuaTarget.Lua51));
+            context.diagnostics.push((0, diagnostics_1.unsupportedForTarget)(node, "Bitwise operations", CompilerOptions_1.LuaTarget.Lua51));
         case CompilerOptions_1.LuaTarget.LuaJIT:
             return transformBinaryBitLibOperation(node, left, right, operator, "bit");
         case CompilerOptions_1.LuaTarget.Lua52:
@@ -58,7 +58,7 @@ function transformUnaryBitLibOperation(node, expression, operator, lib) {
             bitFunction = "bnot";
             break;
         default:
-            utils_1.assertNever(operator);
+            (0, utils_1.assertNever)(operator);
     }
     return lua.createCallExpression(lua.createTableIndexExpression(lua.createIdentifier(lib), lua.createStringLiteral(bitFunction)), [expression], node);
 }
@@ -66,7 +66,7 @@ function transformUnaryBitOperation(context, node, expression, operator) {
     switch (context.luaTarget) {
         case CompilerOptions_1.LuaTarget.Universal:
         case CompilerOptions_1.LuaTarget.Lua51:
-            context.diagnostics.push(diagnostics_1.unsupportedForTarget(node, "Bitwise operations", CompilerOptions_1.LuaTarget.Lua51));
+            context.diagnostics.push((0, diagnostics_1.unsupportedForTarget)(node, "Bitwise operations", CompilerOptions_1.LuaTarget.Lua51));
         case CompilerOptions_1.LuaTarget.LuaJIT:
             return transformUnaryBitLibOperation(node, expression, operator, "bit");
         case CompilerOptions_1.LuaTarget.Lua52:

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

@@ -1,12 +1,13 @@
 import * as ts from "typescript";
 import * as lua from "../../../LuaAST";
 import { TransformationContext } from "../../context";
-import { ImmediatelyInvokedFunctionParameters } from "../../utils/transform";
-export declare function parseAccessExpressionWithEvaluationEffects(context: TransformationContext, node: ts.Expression): [ts.Expression, ts.Expression] | [];
 declare type CompoundAssignmentToken = ts.SyntaxKind.BarToken | ts.SyntaxKind.PlusToken | ts.SyntaxKind.CaretToken | ts.SyntaxKind.MinusToken | ts.SyntaxKind.SlashToken | ts.SyntaxKind.PercentToken | ts.SyntaxKind.AsteriskToken | ts.SyntaxKind.AmpersandToken | ts.SyntaxKind.AsteriskAsteriskToken | ts.SyntaxKind.LessThanLessThanToken | ts.SyntaxKind.GreaterThanGreaterThanToken | ts.SyntaxKind.GreaterThanGreaterThanGreaterThanToken | ts.SyntaxKind.BarBarToken | ts.SyntaxKind.AmpersandAmpersandToken | ts.SyntaxKind.QuestionQuestionToken;
 export declare const isCompoundAssignmentToken: (token: ts.BinaryOperator) => token is ts.CompoundAssignmentOperator;
 export declare const unwrapCompoundAssignmentToken: (token: ts.CompoundAssignmentOperator) => CompoundAssignmentToken;
-export declare function transformCompoundAssignment(context: TransformationContext, expression: ts.Expression, lhs: ts.Expression, rhs: ts.Expression, operator: CompoundAssignmentToken, isPostfix: boolean): ImmediatelyInvokedFunctionParameters;
-export declare function transformCompoundAssignmentExpression(context: TransformationContext, expression: ts.Expression, lhs: ts.Expression, rhs: ts.Expression, operator: CompoundAssignmentToken, isPostfix: boolean): lua.CallExpression;
+export declare function transformCompoundAssignment(context: TransformationContext, expression: ts.Expression, lhs: ts.Expression, rhs: ts.Expression, operator: CompoundAssignmentToken, isPostfix: boolean): {
+    statements: lua.Statement[];
+    result: lua.AssignmentLeftHandSideExpression;
+};
+export declare function transformCompoundAssignmentExpression(context: TransformationContext, expression: ts.Expression, lhs: ts.Expression, rhs: ts.Expression, operator: CompoundAssignmentToken, isPostfix: boolean): lua.Expression;
 export declare function transformCompoundAssignmentStatement(context: TransformationContext, node: ts.Node, lhs: ts.Expression, rhs: ts.Expression, operator: CompoundAssignmentToken): lua.Statement[];
 export {};

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) &&
-        (typescript_1.isExpressionWithEvaluationEffect(node.expression) || typescript_1.isExpressionWithEvaluationEffect(node.argumentExpression))) {
-        const type = context.checker.getTypeAtLocation(node.expression);
-        if (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) && 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,
@@ -52,70 +37,81 @@ exports.isCompoundAssignmentToken = isCompoundAssignmentToken;
 const unwrapCompoundAssignmentToken = (token) => compoundToAssignmentTokens[token];
 exports.unwrapCompoundAssignmentToken = unwrapCompoundAssignmentToken;
 function transformCompoundAssignment(context, expression, lhs, rhs, operator, isPostfix) {
-    const left = utils_1.cast(context.transformExpression(lhs), lua.isAssignmentLeftHandSideExpression);
-    const right = context.transformExpression(rhs);
-    const [objExpression, indexExpression] = parseAccessExpressionWithEvaluationEffects(context, lhs);
-    if (objExpression && indexExpression) {
+    const left = (0, utils_1.cast)(context.transformExpression(lhs), lua.isAssignmentLeftHandSideExpression);
+    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 = 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 = 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 = binary_expression_1.transformBinaryOperation(context, tmpIdentifier, right, operator, expression);
-        const assignStatements = 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 = 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 = 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 = binary_expression_1.transformBinaryOperation(context, left, right, operator, expression);
-        const statements = 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 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 = utils_1.cast(context.transformExpression(lhs), lua.isAssignmentLeftHandSideExpression);
-    const right = context.transformExpression(rhs);
-    const [objExpression, indexExpression] = parseAccessExpressionWithEvaluationEffects(context, lhs);
-    if (objExpression && indexExpression) {
+    const left = (0, utils_1.cast)(context.transformExpression(lhs), lua.isAssignmentLeftHandSideExpression);
+    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 = 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 = binary_expression_1.transformBinaryOperation(context, left, right, operator, node);
-        return 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) {
@@ -178,11 +176,11 @@ function transformSetterSkippingCompoundAssignment(context, lhs, operator, rhs,
         condition = lua.createBinaryExpression(lhs, lua.createNilLiteral(), lua.SyntaxKind.EqualityOperator);
     }
     else {
-        utils_1.assertNever(operator);
+        (0, utils_1.assertNever)(operator);
     }
     // 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) {
@@ -13,7 +16,7 @@ function isArrayLength(context, expression) {
         return false;
     }
     const type = context.checker.getTypeAtLocation(expression.expression);
-    if (!typescript_1.isArrayType(context, type)) {
+    if (!(0, typescript_1.isArrayType)(context, type)) {
         return false;
     }
     const name = ts.isPropertyAccessExpression(expression)
@@ -24,33 +27,35 @@ 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 = assignments_1.transformAssignment(context, element.left, context.transformExpression(element.right));
-                const elseAssignmentStatements = assignments_1.transformAssignment(context, element.left, assignedVariable);
+                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);
                 const ifStatement = lua.createIfStatement(nilCondition, ifBlock, elseBlock, node);
@@ -58,14 +63,16 @@ function transformArrayLiteralAssignmentPattern(context, node, root) {
             case ts.SyntaxKind.Identifier:
             case ts.SyntaxKind.PropertyAccessExpression:
             case ts.SyntaxKind.ElementAccessExpression:
-                return 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 = lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.ArraySlice, undefined, root, lua.createNumericLiteral(index));
-                return assignments_1.transformAssignment(context, element.expression, restElements);
+                const restElements = (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ArraySlice, undefined, root, lua.createNumericLiteral(index));
+                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));
@@ -93,51 +100,73 @@ function transformObjectLiteralAssignmentPattern(context, node, root) {
                 // TypeScript error
                 break;
             default:
-                utils_1.assertNever(property);
+                (0, utils_1.assertNever)(property);
         }
     }
     return result;
 }
 function transformShorthandPropertyAssignment(context, node, root) {
     const result = [];
-    const assignmentVariableName = assignments_1.transformAssignmentLeftHandSideExpression(context, node.name);
+    const assignmentVariableName = (0, assignments_1.transformAssignmentLeftHandSideExpression)(context, node.name);
     const extractionIndex = lua.createStringLiteral(node.name.text);
-    const variableExtractionAssignmentStatements = assignments_1.transformAssignment(context, node.name, lua.createTableIndexExpression(root, extractionIndex));
+    const variableExtractionAssignmentStatements = (0, assignments_1.transformAssignment)(context, node.name, lua.createTableIndexExpression(root, extractionIndex));
     result.push(...variableExtractionAssignmentStatements);
     const defaultInitializer = node.objectAssignmentInitializer
         ? context.transformExpression(node.objectAssignmentInitializer)
         : undefined;
     if (defaultInitializer) {
         const nilCondition = lua.createBinaryExpression(assignmentVariableName, lua.createNilLiteral(), lua.SyntaxKind.EqualityOperator);
-        const assignmentStatements = assignments_1.transformAssignment(context, node.name, defaultInitializer);
+        const assignmentStatements = (0, assignments_1.transformAssignment)(context, node.name, defaultInitializer);
         const ifBlock = lua.createBlock(assignmentStatements);
         result.push(lua.createIfStatement(nilCondition, ifBlock, undefined, node));
     }
     return result;
 }
-function transformPropertyAssignment(context, node, root) {
+function transformPropertyAssignment(context, node, root, rightHasPrecedingStatements) {
     const result = [];
-    if (typescript_1.isAssignmentPattern(node.initializer)) {
-        const propertyAccessString = literal_1.transformPropertyName(context, node.name);
+    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 = 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 = 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(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) {
@@ -152,7 +181,7 @@ function transformSpreadAssignment(context, node, root, properties) {
             usedProperties.push(lua.createTableFieldExpression(lua.createBooleanLiteral(true), name));
         }
     }
-    const extractingExpression = lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.ObjectRest, undefined, root, lua.createTableExpression(usedProperties));
-    return assignments_1.transformAssignment(context, node.expression, extractingExpression);
+    const extractingExpression = (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ObjectRest, undefined, root, lua.createTableExpression(usedProperties));
+    return (0, assignments_1.transformAssignment)(context, node.expression, extractingExpression);
 }
 //# sourceMappingURL=destructuring-assignments.js.map

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 {};