typescript-to-lua 1.0.1 → 1.3.0

package/dist/transformation/utils/typescript/nodes.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isFirstDeclaration = exports.getSymbolOfNode = exports.isInDestructingAssignment = exports.isAmbientNode = exports.isDestructuringAssignment = exports.isAssignmentPattern = void 0;
+exports.isFirstDeclaration = exports.getSymbolOfNode = exports.isInGeneratorFunction = exports.isInAsyncFunction = exports.isInDestructingAssignment = exports.isAmbientNode = exports.isDestructuringAssignment = exports.isAssignmentPattern = void 0;
 const ts = require("typescript");
+const _1 = require(".");
 function isAssignmentPattern(node) {
     return ts.isObjectLiteralExpression(node) || ts.isArrayLiteralExpression(node);
 }
@@ -22,6 +23,25 @@ function isInDestructingAssignment(node) {
             (ts.isBinaryExpression(node.parent) && ts.isArrayLiteralExpression(node.parent.left))));
 }
 exports.isInDestructingAssignment = isInDestructingAssignment;
+function isInAsyncFunction(node) {
+    var _a, _b;
+    // Check if node is in function declaration with `async`
+    const declaration = (0, _1.findFirstNodeAbove)(node, ts.isFunctionLike);
+    if (!declaration) {
+        return false;
+    }
+    return (_b = (_a = declaration.modifiers) === null || _a === void 0 ? void 0 : _a.some(m => m.kind === ts.SyntaxKind.AsyncKeyword)) !== null && _b !== void 0 ? _b : false;
+}
+exports.isInAsyncFunction = isInAsyncFunction;
+function isInGeneratorFunction(node) {
+    // Check if node is in function declaration with `async`
+    const declaration = (0, _1.findFirstNodeAbove)(node, ts.isFunctionDeclaration);
+    if (!declaration) {
+        return false;
+    }
+    return declaration.asteriskToken !== undefined;
+}
+exports.isInGeneratorFunction = isInGeneratorFunction;
 /**
  * Quite hacky, avoid unless absolutely necessary!
  */

package/dist/transformation/utils/typescript/types.d.ts

@@ -10,4 +10,6 @@ export declare function isNumberType(context: TransformationContext, type: ts.Ty
  */
 export declare function forTypeOrAnySupertype(context: TransformationContext, type: ts.Type, predicate: (type: ts.Type) => boolean): boolean;
 export declare function isArrayType(context: TransformationContext, type: ts.Type): boolean;
-export declare function isFunctionType(context: TransformationContext, type: ts.Type): boolean;
+export declare function isFunctionType(type: ts.Type): boolean;
+export declare function canBeFalsy(context: TransformationContext, type: ts.Type): boolean;
+export declare function canBeFalsyWhenNotNull(context: TransformationContext, type: ts.Type): boolean;

package/dist/transformation/utils/typescript/types.js

@@ -1,21 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isFunctionType = exports.isArrayType = exports.forTypeOrAnySupertype = exports.isNumberType = exports.isStringType = exports.typeCanSatisfy = exports.typeAlwaysSatisfies = exports.isTypeWithFlags = void 0;
+exports.canBeFalsyWhenNotNull = exports.canBeFalsy = exports.isFunctionType = exports.isArrayType = exports.forTypeOrAnySupertype = exports.isNumberType = exports.isStringType = exports.typeCanSatisfy = exports.typeAlwaysSatisfies = exports.isTypeWithFlags = void 0;
 const ts = require("typescript");
 function isTypeWithFlags(context, type, flags) {
-    const predicate = (type) => {
-        if (type.symbol) {
-            const baseConstraint = context.checker.getBaseConstraintOfType(type);
-            if (baseConstraint && baseConstraint !== type) {
-                return isTypeWithFlags(context, baseConstraint, flags);
-            }
-        }
-        return (type.flags & flags) !== 0;
-    };
+    const predicate = (type) => (type.flags & flags) !== 0;
     return typeAlwaysSatisfies(context, type, predicate);
 }
 exports.isTypeWithFlags = isTypeWithFlags;
 function typeAlwaysSatisfies(context, type, predicate) {
+    const baseConstraint = context.checker.getBaseConstraintOfType(type);
+    if (baseConstraint) {
+        type = baseConstraint;
+    }
     if (predicate(type)) {
         return true;
     }
@@ -29,6 +25,15 @@ function typeAlwaysSatisfies(context, type, predicate) {
 }
 exports.typeAlwaysSatisfies = typeAlwaysSatisfies;
 function typeCanSatisfy(context, type, predicate) {
+    const baseConstraint = context.checker.getBaseConstraintOfType(type);
+    if (!baseConstraint) {
+        // type parameter with no constraint can be anything, assume it might satisfy predicate
+        if (type.isTypeParameter())
+            return true;
+    }
+    else {
+        type = baseConstraint;
+    }
     if (predicate(type)) {
         return true;
     }
@@ -84,9 +89,31 @@ function isArrayType(context, type) {
     return forTypeOrAnySupertype(context, type, t => isExplicitArrayType(context, t));
 }
 exports.isArrayType = isArrayType;
-function isFunctionType(context, type) {
-    const typeNode = context.checker.typeToTypeNode(type, undefined, ts.NodeBuilderFlags.InTypeAlias);
-    return typeNode !== undefined && ts.isFunctionTypeNode(typeNode);
+function isFunctionType(type) {
+    return type.getCallSignatures().length > 0;
 }
 exports.isFunctionType = isFunctionType;
+function canBeFalsy(context, type) {
+    const strictNullChecks = context.options.strict === true || context.options.strictNullChecks === true;
+    const falsyFlags = ts.TypeFlags.Boolean |
+        ts.TypeFlags.BooleanLiteral |
+        ts.TypeFlags.Never |
+        ts.TypeFlags.Void |
+        ts.TypeFlags.Unknown |
+        ts.TypeFlags.Any |
+        ts.TypeFlags.Undefined |
+        ts.TypeFlags.Null;
+    return typeCanSatisfy(context, type, type => (type.flags & falsyFlags) !== 0 || (!strictNullChecks && !type.isLiteral()));
+}
+exports.canBeFalsy = canBeFalsy;
+function canBeFalsyWhenNotNull(context, type) {
+    const falsyFlags = ts.TypeFlags.Boolean |
+        ts.TypeFlags.BooleanLiteral |
+        ts.TypeFlags.Never |
+        ts.TypeFlags.Void |
+        ts.TypeFlags.Unknown |
+        ts.TypeFlags.Any;
+    return typeCanSatisfy(context, type, type => (type.flags & falsyFlags) !== 0);
+}
+exports.canBeFalsyWhenNotNull = canBeFalsyWhenNotNull;
 //# sourceMappingURL=types.js.map

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

@@ -1,7 +1,10 @@
 import * as ts from "typescript";
 import * as lua from "../../LuaAST";
 import { FunctionVisitor, TransformationContext } from "../context";
+import { ExpressionWithThisValue } from "./optional-chaining";
 export declare function transformElementAccessArgument(context: TransformationContext, node: ts.ElementAccessExpression): lua.Expression;
 export declare const transformElementAccessExpression: FunctionVisitor<ts.ElementAccessExpression>;
+export declare function transformElementAccessExpressionWithCapture(context: TransformationContext, node: ts.ElementAccessExpression, thisValueCapture: lua.Identifier | undefined): ExpressionWithThisValue;
 export declare const transformPropertyAccessExpression: FunctionVisitor<ts.PropertyAccessExpression>;
+export declare function transformPropertyAccessExpressionWithCapture(context: TransformationContext, node: ts.PropertyAccessExpression, thisValueCapture: lua.Identifier | undefined): ExpressionWithThisValue;
 export declare const transformQualifiedName: FunctionVisitor<ts.QualifiedName>;

package/dist/transformation/visitors/access.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformQualifiedName = exports.transformPropertyAccessExpression = exports.transformElementAccessExpression = exports.transformElementAccessArgument = void 0;
+exports.transformQualifiedName = exports.transformPropertyAccessExpressionWithCapture = exports.transformPropertyAccessExpression = exports.transformElementAccessExpressionWithCapture = exports.transformElementAccessExpression = exports.transformElementAccessArgument = void 0;
 const ts = require("typescript");
 const lua = require("../../LuaAST");
 const builtins_1 = require("../builtins");
@@ -10,92 +10,119 @@ const lua_ast_1 = require("../utils/lua-ast");
 const lualib_1 = require("../utils/lualib");
 const typescript_1 = require("../utils/typescript");
 const enum_1 = require("./enum");
+const expression_list_1 = require("./expression-list");
 const multi_1 = require("./language-extensions/multi");
-function transformElementAccessArgument(context, node) {
-    const index = context.transformExpression(node.argumentExpression);
+const optional_chaining_1 = require("./optional-chaining");
+function addOneToArrayAccessArgument(context, node, index) {
     const type = context.checker.getTypeAtLocation(node.expression);
     const argumentType = context.checker.getTypeAtLocation(node.argumentExpression);
-    if (typescript_1.isArrayType(context, type) && typescript_1.isNumberType(context, argumentType)) {
-        return lua_ast_1.addToNumericExpression(index, 1);
+    if ((0, typescript_1.isArrayType)(context, type) && (0, typescript_1.isNumberType)(context, argumentType)) {
+        return (0, lua_ast_1.addToNumericExpression)(index, 1);
     }
     return index;
 }
+function transformElementAccessArgument(context, node) {
+    const index = context.transformExpression(node.argumentExpression);
+    return addOneToArrayAccessArgument(context, node, index);
+}
 exports.transformElementAccessArgument = transformElementAccessArgument;
-const transformElementAccessExpression = (node, context) => {
-    const constEnumValue = enum_1.tryGetConstEnumValue(context, node);
+const transformElementAccessExpression = (node, context) => transformElementAccessExpressionWithCapture(context, node, undefined).expression;
+exports.transformElementAccessExpression = transformElementAccessExpression;
+function transformElementAccessExpressionWithCapture(context, node, thisValueCapture) {
+    const constEnumValue = (0, enum_1.tryGetConstEnumValue)(context, node);
     if (constEnumValue) {
-        return constEnumValue;
+        return { expression: constEnumValue };
     }
-    const table = context.transformExpression(node.expression);
+    if (ts.isOptionalChain(node)) {
+        return (0, optional_chaining_1.transformOptionalChainWithCapture)(context, node, thisValueCapture);
+    }
+    const [table, accessExpression] = (0, expression_list_1.transformOrderedExpressions)(context, [node.expression, node.argumentExpression]);
     const type = context.checker.getTypeAtLocation(node.expression);
     const argumentType = context.checker.getTypeAtLocation(node.argumentExpression);
-    if (typescript_1.isStringType(context, type) && typescript_1.isNumberType(context, argumentType)) {
-        const index = context.transformExpression(node.argumentExpression);
-        return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.StringAccess, node, table, index);
+    if ((0, typescript_1.isStringType)(context, type) && (0, typescript_1.isNumberType)(context, argumentType)) {
+        // strings are not callable, so ignore thisValueCapture
+        return {
+            expression: (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.StringAccess, node, table, accessExpression),
+        };
     }
-    const accessExpression = transformElementAccessArgument(context, node);
-    if (multi_1.isMultiReturnCall(context, node.expression)) {
+    const updatedAccessExpression = addOneToArrayAccessArgument(context, node, accessExpression);
+    if ((0, multi_1.isMultiReturnCall)(context, node.expression)) {
         const accessType = context.checker.getTypeAtLocation(node.argumentExpression);
-        if (!typescript_1.isNumberType(context, accessType)) {
-            context.diagnostics.push(diagnostics_1.invalidMultiReturnAccess(node));
+        if (!(0, typescript_1.isNumberType)(context, accessType)) {
+            context.diagnostics.push((0, diagnostics_1.invalidMultiReturnAccess)(node));
         }
         // When selecting the first element, we can shortcut
         if (ts.isNumericLiteral(node.argumentExpression) && node.argumentExpression.text === "0") {
-            return table;
+            return { expression: table };
         }
         else {
             const selectIdentifier = lua.createIdentifier("select");
-            const selectCall = lua.createCallExpression(selectIdentifier, [accessExpression, table]);
-            return selectCall;
+            return { expression: lua.createCallExpression(selectIdentifier, [updatedAccessExpression, table]) };
         }
     }
-    if (ts.isOptionalChain(node)) {
-        return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.OptionalChainAccess, node, table, accessExpression);
+    if (thisValueCapture) {
+        const thisValue = (0, optional_chaining_1.captureThisValue)(context, table, thisValueCapture, node.expression);
+        return {
+            expression: lua.createTableIndexExpression(thisValue, updatedAccessExpression, node),
+            thisValue,
+        };
     }
-    return lua.createTableIndexExpression(table, accessExpression, node);
-};
-exports.transformElementAccessExpression = transformElementAccessExpression;
-const transformPropertyAccessExpression = (node, context) => {
+    return { expression: lua.createTableIndexExpression(table, updatedAccessExpression, node) };
+}
+exports.transformElementAccessExpressionWithCapture = transformElementAccessExpressionWithCapture;
+const transformPropertyAccessExpression = (node, context) => transformPropertyAccessExpressionWithCapture(context, node, undefined).expression;
+exports.transformPropertyAccessExpression = transformPropertyAccessExpression;
+function transformPropertyAccessExpressionWithCapture(context, node, thisValueCapture) {
     const property = node.name.text;
     const type = context.checker.getTypeAtLocation(node.expression);
-    const annotations = annotations_1.getTypeAnnotations(type);
+    const isOptionalLeft = (0, optional_chaining_1.isOptionalContinuation)(node.expression);
+    const annotations = (0, annotations_1.getTypeAnnotations)(type);
     if (annotations.has(annotations_1.AnnotationKind.LuaTable)) {
-        context.diagnostics.push(diagnostics_1.annotationRemoved(node, annotations_1.AnnotationKind.LuaTable));
+        context.diagnostics.push((0, diagnostics_1.annotationRemoved)(node, annotations_1.AnnotationKind.LuaTable));
     }
-    const constEnumValue = enum_1.tryGetConstEnumValue(context, node);
+    const constEnumValue = (0, enum_1.tryGetConstEnumValue)(context, node);
     if (constEnumValue) {
-        return constEnumValue;
+        return { expression: constEnumValue };
     }
-    const builtinResult = builtins_1.transformBuiltinPropertyAccessExpression(context, node);
-    if (builtinResult) {
-        return builtinResult;
+    if (ts.isCallExpression(node.expression) && (0, multi_1.returnsMultiType)(context, node.expression)) {
+        context.diagnostics.push((0, diagnostics_1.invalidMultiReturnAccess)(node));
     }
-    if (ts.isCallExpression(node.expression) && multi_1.returnsMultiType(context, node.expression)) {
-        context.diagnostics.push(diagnostics_1.invalidMultiReturnAccess(node));
+    if (ts.isOptionalChain(node)) {
+        return (0, optional_chaining_1.transformOptionalChainWithCapture)(context, node, thisValueCapture);
     }
     // Do not output path for member only enums
     if (annotations.has(annotations_1.AnnotationKind.CompileMembersOnly)) {
+        if (isOptionalLeft) {
+            context.diagnostics.push((0, diagnostics_1.unsupportedOptionalCompileMembersOnly)(node));
+        }
         if (ts.isPropertyAccessExpression(node.expression)) {
             // in case of ...x.enum.y transform to ...x.y
-            return lua.createTableIndexExpression(context.transformExpression(node.expression.expression), lua.createStringLiteral(property), node);
+            const expression = lua.createTableIndexExpression(context.transformExpression(node.expression.expression), lua.createStringLiteral(property), node);
+            return { expression };
         }
         else {
-            return lua.createIdentifier(property, node);
+            return { expression: lua.createIdentifier(property, node) };
         }
     }
-    if (ts.isOptionalChain(node)) {
-        // Only handle full optional chains separately, not partial ones
-        return transformOptionalChain(context, node);
+    const builtinResult = (0, builtins_1.transformBuiltinPropertyAccessExpression)(context, node);
+    if (builtinResult) {
+        // Ignore thisValueCapture.
+        // This assumes that nothing returned by builtin property accesses are callable.
+        // If this assumption is no longer true, this may need to be updated.
+        return { expression: builtinResult };
     }
-    const callPath = context.transformExpression(node.expression);
-    return lua.createTableIndexExpression(callPath, lua.createStringLiteral(property), node);
-};
-exports.transformPropertyAccessExpression = transformPropertyAccessExpression;
-function transformOptionalChain(context, node) {
-    const left = context.transformExpression(node.expression);
-    const right = lua.createStringLiteral(node.name.text, node.name);
-    return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.OptionalChainAccess, node, left, right);
+    const table = context.transformExpression(node.expression);
+    if (thisValueCapture) {
+        const thisValue = (0, optional_chaining_1.captureThisValue)(context, table, thisValueCapture, node.expression);
+        const expression = lua.createTableIndexExpression(thisValue, lua.createStringLiteral(property), node);
+        return {
+            expression,
+            thisValue,
+        };
+    }
+    return { expression: lua.createTableIndexExpression(table, lua.createStringLiteral(property), node) };
 }
+exports.transformPropertyAccessExpressionWithCapture = transformPropertyAccessExpressionWithCapture;
 const transformQualifiedName = (node, context) => {
     const right = lua.createStringLiteral(node.right.text, node.right);
     const left = context.transformExpression(node.left);

package/dist/transformation/visitors/async-await.js

@@ -9,13 +9,14 @@ const typescript_1 = require("../utils/typescript");
 const transformAwaitExpression = (node, context) => {
     var _a;
     // Check if await is inside an async function, it is not allowed at top level or in non-async functions
-    const containingFunction = typescript_1.findFirstNodeAbove(node, ts.isFunctionLike);
+    const containingFunction = (0, typescript_1.findFirstNodeAbove)(node, ts.isFunctionLike);
     if (containingFunction === undefined ||
         !((_a = containingFunction.modifiers) === null || _a === void 0 ? void 0 : _a.some(m => m.kind === ts.SyntaxKind.AsyncKeyword))) {
-        context.diagnostics.push(diagnostics_1.awaitMustBeInAsyncFunction(node));
+        context.diagnostics.push((0, diagnostics_1.awaitMustBeInAsyncFunction)(node));
     }
     const expression = context.transformExpression(node.expression);
-    return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.Await, node, expression);
+    const catchIdentifier = lua.createIdentifier("____catch");
+    return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.Await, node, catchIdentifier, expression);
 };
 exports.transformAwaitExpression = transformAwaitExpression;
 function isAsyncFunction(declaration) {
@@ -24,7 +25,7 @@ function isAsyncFunction(declaration) {
 }
 exports.isAsyncFunction = isAsyncFunction;
 function wrapInAsyncAwaiter(context, statements) {
-    lualib_1.importLuaLibFeature(context, lualib_1.LuaLibFeature.Await);
+    (0, lualib_1.importLuaLibFeature)(context, lualib_1.LuaLibFeature.Await);
     return [
         lua.createReturnStatement([
             lua.createCallExpression(lua.createIdentifier("__TS__AsyncAwaiter"), [

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

@@ -1,7 +1,8 @@
 import * as ts from "typescript";
 import * as lua from "../../../LuaAST";
 import { TransformationContext } from "../../context";
-export declare function transformAssignmentLeftHandSideExpression(context: TransformationContext, node: ts.Expression): lua.AssignmentLeftHandSideExpression;
-export declare function transformAssignment(context: TransformationContext, lhs: ts.Expression, right: lua.Expression, parent?: ts.Expression): lua.Statement[];
+export declare function transformAssignmentLeftHandSideExpression(context: TransformationContext, node: ts.Expression, rightHasPrecedingStatements?: boolean): lua.AssignmentLeftHandSideExpression;
+export declare function transformAssignment(context: TransformationContext, lhs: ts.Expression, right: lua.Expression, rightHasPrecedingStatements?: boolean, parent?: ts.Expression): lua.Statement[];
+export declare function transformAssignmentWithRightPrecedingStatements(context: TransformationContext, lhs: ts.Expression, right: lua.Expression, rightPrecedingStatements: lua.Statement[], parent?: ts.Expression): lua.Statement[];
 export declare function transformAssignmentExpression(context: TransformationContext, expression: ts.AssignmentExpression<ts.EqualsToken>): lua.Expression;
 export declare function transformAssignmentStatement(context: TransformationContext, expression: ts.AssignmentExpression<ts.EqualsToken>): lua.Statement[];

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformAssignmentStatement = exports.transformAssignmentExpression = exports.transformAssignment = exports.transformAssignmentLeftHandSideExpression = void 0;
+exports.transformAssignmentStatement = exports.transformAssignmentExpression = exports.transformAssignmentWithRightPrecedingStatements = exports.transformAssignment = exports.transformAssignmentLeftHandSideExpression = void 0;
 const ts = require("typescript");
 const lua = require("../../../LuaAST");
 const utils_1 = require("../../../utils");
@@ -9,56 +9,78 @@ const export_1 = require("../../utils/export");
 const lua_ast_1 = require("../../utils/lua-ast");
 const lualib_1 = require("../../utils/lualib");
 const typescript_1 = require("../../utils/typescript");
-const access_1 = require("../access");
 const destructuring_assignments_1 = require("./destructuring-assignments");
 const multi_1 = require("../language-extensions/multi");
-const scope_1 = require("../../utils/scope");
-const transform_1 = require("../../utils/transform");
 const diagnostics_1 = require("../../utils/diagnostics");
-function transformAssignmentLeftHandSideExpression(context, node) {
+const access_1 = require("../access");
+const expression_list_1 = require("../expression-list");
+const preceding_statements_1 = require("../../utils/preceding-statements");
+function transformAssignmentLeftHandSideExpression(context, node, rightHasPrecedingStatements) {
+    // Access expressions need the components of the left side cached in temps before the right side's preceding statements
+    if (rightHasPrecedingStatements && (ts.isElementAccessExpression(node) || ts.isPropertyAccessExpression(node))) {
+        let table = context.transformExpression(node.expression);
+        table = (0, expression_list_1.moveToPrecedingTemp)(context, table, node.expression);
+        let index;
+        if (ts.isElementAccessExpression(node)) {
+            index = (0, access_1.transformElementAccessArgument)(context, node);
+            index = (0, expression_list_1.moveToPrecedingTemp)(context, index, node.argumentExpression);
+        }
+        else {
+            index = lua.createStringLiteral(node.name.text, node.name);
+        }
+        return lua.createTableIndexExpression(table, index, node);
+    }
     const symbol = context.checker.getSymbolAtLocation(node);
     const left = context.transformExpression(node);
-    return lua.isIdentifier(left) && symbol && export_1.isSymbolExported(context, symbol)
-        ? export_1.createExportedIdentifier(context, left)
-        : utils_1.cast(left, lua.isAssignmentLeftHandSideExpression);
+    return lua.isIdentifier(left) && symbol && (0, export_1.isSymbolExported)(context, symbol)
+        ? (0, export_1.createExportedIdentifier)(context, left)
+        : (0, utils_1.cast)(left, lua.isAssignmentLeftHandSideExpression);
 }
 exports.transformAssignmentLeftHandSideExpression = transformAssignmentLeftHandSideExpression;
 function transformAssignment(context, 
 // TODO: Change type to ts.LeftHandSideExpression?
-lhs, right, parent) {
+lhs, right, rightHasPrecedingStatements, parent) {
     if (ts.isOptionalChain(lhs)) {
-        context.diagnostics.push(diagnostics_1.notAllowedOptionalAssignment(lhs));
+        context.diagnostics.push((0, diagnostics_1.notAllowedOptionalAssignment)(lhs));
         return [];
     }
-    if (destructuring_assignments_1.isArrayLength(context, lhs)) {
-        const arrayLengthAssignment = lua.createExpressionStatement(lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.ArraySetLength, parent, context.transformExpression(lhs.expression), right));
+    if ((0, destructuring_assignments_1.isArrayLength)(context, lhs)) {
+        const arrayLengthAssignment = lua.createExpressionStatement((0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ArraySetLength, parent, context.transformExpression(lhs.expression), right));
         return [arrayLengthAssignment];
     }
-    const symbol = ts.isShorthandPropertyAssignment(lhs.parent)
+    const symbol = lhs.parent && ts.isShorthandPropertyAssignment(lhs.parent)
         ? context.checker.getShorthandAssignmentValueSymbol(lhs.parent)
         : context.checker.getSymbolAtLocation(lhs);
-    const dependentSymbols = symbol ? export_1.getDependenciesOfSymbol(context, symbol) : [];
-    const left = transformAssignmentLeftHandSideExpression(context, lhs);
+    const dependentSymbols = symbol ? (0, export_1.getDependenciesOfSymbol)(context, symbol) : [];
+    const left = transformAssignmentLeftHandSideExpression(context, lhs, rightHasPrecedingStatements);
     const rootAssignment = lua.createAssignmentStatement(left, right, lhs.parent);
     return [
         rootAssignment,
         ...dependentSymbols.map(symbol => {
             const [left] = rootAssignment.left;
-            const identifierToAssign = export_1.createExportedIdentifier(context, lua.createIdentifier(symbol.name));
+            const identifierToAssign = (0, export_1.createExportedIdentifier)(context, lua.createIdentifier(symbol.name));
             return lua.createAssignmentStatement(identifierToAssign, left);
         }),
     ];
 }
 exports.transformAssignment = transformAssignment;
+function transformAssignmentWithRightPrecedingStatements(context, lhs, right, rightPrecedingStatements, parent) {
+    return [
+        ...rightPrecedingStatements,
+        ...transformAssignment(context, lhs, right, rightPrecedingStatements.length > 0, parent),
+    ];
+}
+exports.transformAssignmentWithRightPrecedingStatements = transformAssignmentWithRightPrecedingStatements;
 function transformDestructuredAssignmentExpression(context, expression) {
-    const rootIdentifier = lua.createAnonymousIdentifier(expression.left);
-    let right = context.transformExpression(expression.right);
-    if (multi_1.isMultiReturnCall(context, expression.right)) {
-        right = lua_ast_1.wrapInTable(right);
+    const rootIdentifier = context.createTempNameForNode(expression.right);
+    let [rightPrecedingStatements, right] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(expression.right));
+    context.addPrecedingStatements(rightPrecedingStatements);
+    if ((0, multi_1.isMultiReturnCall)(context, expression.right)) {
+        right = (0, lua_ast_1.wrapInTable)(right);
     }
     const statements = [
         lua.createVariableDeclarationStatement(rootIdentifier, right),
-        ...destructuring_assignments_1.transformDestructuringAssignment(context, expression, rootIdentifier),
+        ...(0, destructuring_assignments_1.transformDestructuringAssignment)(context, expression, rootIdentifier, rightPrecedingStatements.length > 0),
     ];
     return { statements, result: rootIdentifier };
 }
@@ -66,69 +88,51 @@ function transformAssignmentExpression(context, expression) {
     // Validate assignment
     const rightType = context.checker.getTypeAtLocation(expression.right);
     const leftType = context.checker.getTypeAtLocation(expression.left);
-    assignment_validation_1.validateAssignment(context, expression.right, rightType, leftType);
-    if (destructuring_assignments_1.isArrayLength(context, expression.left)) {
+    (0, assignment_validation_1.validateAssignment)(context, expression.right, rightType, leftType);
+    if ((0, destructuring_assignments_1.isArrayLength)(context, expression.left)) {
         // array.length = x
-        return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.ArraySetLength, expression, context.transformExpression(expression.left.expression), context.transformExpression(expression.right));
+        return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ArraySetLength, expression, context.transformExpression(expression.left.expression), context.transformExpression(expression.right));
     }
-    if (typescript_1.isDestructuringAssignment(expression)) {
-        return transform_1.transformToImmediatelyInvokedFunctionExpression(context, () => transformDestructuredAssignmentExpression(context, expression), expression);
+    if ((0, typescript_1.isDestructuringAssignment)(expression)) {
+        const { statements, result } = transformDestructuredAssignmentExpression(context, expression);
+        context.addPrecedingStatements(statements);
+        return result;
     }
     if (ts.isPropertyAccessExpression(expression.left) || ts.isElementAccessExpression(expression.left)) {
-        // Left is property/element access: cache result while maintaining order of evaluation
-        // (function(o, i, v) o[i] = v; return v end)(${objExpression}, ${indexExpression}, ${right})
-        const objParameter = lua.createIdentifier("o");
-        const indexParameter = lua.createIdentifier("i");
-        const valueParameter = lua.createIdentifier("v");
-        const indexStatement = lua.createTableIndexExpression(objParameter, indexParameter);
-        const statements = [
-            lua.createAssignmentStatement(indexStatement, valueParameter),
-            lua.createReturnStatement([valueParameter]),
-        ];
-        const iife = lua.createFunctionExpression(lua.createBlock(statements), [
-            objParameter,
-            indexParameter,
-            valueParameter,
+        const tempVar = context.createTempNameForNode(expression.right);
+        const [precedingStatements, right] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(expression.right));
+        const left = transformAssignmentLeftHandSideExpression(context, expression.left, precedingStatements.length > 0);
+        context.addPrecedingStatements([
+            ...precedingStatements,
+            lua.createVariableDeclarationStatement(tempVar, right, expression.right),
+            lua.createAssignmentStatement(left, lua.cloneIdentifier(tempVar), expression.left),
         ]);
-        scope_1.pushScope(context, scope_1.ScopeType.Function);
-        const objExpression = context.transformExpression(expression.left.expression);
-        let indexExpression;
-        if (ts.isPropertyAccessExpression(expression.left)) {
-            // Property access
-            indexExpression = lua.createStringLiteral(expression.left.name.text);
-        }
-        else {
-            // Element access
-            indexExpression = access_1.transformElementAccessArgument(context, expression.left);
-        }
-        const args = [objExpression, indexExpression, context.transformExpression(expression.right)];
-        scope_1.popScope(context);
-        return lua.createCallExpression(iife, args, expression);
+        return lua.cloneIdentifier(tempVar);
     }
     else {
-        return transform_1.transformToImmediatelyInvokedFunctionExpression(context, () => {
-            // Simple assignment
-            // (function() ${left} = ${right}; return ${left} end)()
-            const left = context.transformExpression(expression.left);
-            const right = context.transformExpression(expression.right);
-            const statements = transformAssignment(context, expression.left, right);
-            return { statements, result: left };
-        }, expression);
+        // Simple assignment
+        // ${left} = ${right}; return ${left}
+        const left = context.transformExpression(expression.left);
+        const right = context.transformExpression(expression.right);
+        context.addPrecedingStatements(transformAssignment(context, expression.left, right));
+        return left;
     }
 }
 exports.transformAssignmentExpression = transformAssignmentExpression;
 const canBeTransformedToLuaAssignmentStatement = (context, node) => ts.isArrayLiteralExpression(node.left) &&
     node.left.elements.every(element => {
-        if (destructuring_assignments_1.isArrayLength(context, element)) {
+        if ((0, destructuring_assignments_1.isArrayLength)(context, element)) {
             return false;
         }
         if (ts.isPropertyAccessExpression(element) || ts.isElementAccessExpression(element)) {
-            return true;
+            // Lua's execution order for multi-assignments is not the same as JS's, so we should always
+            // break these down when the left side may have side effects.
+            return false;
         }
         if (ts.isIdentifier(element)) {
             const symbol = context.checker.getSymbolAtLocation(element);
             if (symbol) {
-                const aliases = export_1.getDependenciesOfSymbol(context, symbol);
+                const aliases = (0, export_1.getDependenciesOfSymbol)(context, symbol);
                 return aliases.length === 0;
             }
         }
@@ -137,32 +141,37 @@ function transformAssignmentStatement(context, expression) {
     // Validate assignment
     const rightType = context.checker.getTypeAtLocation(expression.right);
     const leftType = context.checker.getTypeAtLocation(expression.left);
-    assignment_validation_1.validateAssignment(context, expression.right, rightType, leftType);
-    if (typescript_1.isDestructuringAssignment(expression)) {
+    (0, assignment_validation_1.validateAssignment)(context, expression.right, rightType, leftType);
+    if ((0, typescript_1.isDestructuringAssignment)(expression)) {
         if (canBeTransformedToLuaAssignmentStatement(context, expression)) {
             const rightType = context.checker.getTypeAtLocation(expression.right);
-            let right = context.transformExpression(expression.right);
+            let right;
             if (ts.isArrayLiteralExpression(expression.right)) {
-                right = expression.right.elements.map(e => context.transformExpression(e));
+                right = (0, expression_list_1.transformExpressionList)(context, expression.right.elements);
             }
-            else if (!multi_1.isMultiReturnCall(context, expression.right) && typescript_1.isArrayType(context, rightType)) {
-                right = lua_ast_1.createUnpackCall(context, right, expression.right);
+            else {
+                right = context.transformExpression(expression.right);
+                if (!(0, multi_1.isMultiReturnCall)(context, expression.right) && (0, typescript_1.isArrayType)(context, rightType)) {
+                    right = (0, lua_ast_1.createUnpackCall)(context, right, expression.right);
+                }
             }
             const left = expression.left.elements.map(e => transformAssignmentLeftHandSideExpression(context, e));
             return [lua.createAssignmentStatement(left, right, expression)];
         }
-        let right = context.transformExpression(expression.right);
-        if (multi_1.isMultiReturnCall(context, expression.right)) {
-            right = lua_ast_1.wrapInTable(right);
+        let [rightPrecedingStatements, right] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(expression.right));
+        context.addPrecedingStatements(rightPrecedingStatements);
+        if ((0, multi_1.isMultiReturnCall)(context, expression.right)) {
+            right = (0, lua_ast_1.wrapInTable)(right);
         }
-        const rootIdentifier = lua.createAnonymousIdentifier(expression.left);
+        const rootIdentifier = context.createTempNameForNode(expression.left);
         return [
             lua.createVariableDeclarationStatement(rootIdentifier, right),
-            ...destructuring_assignments_1.transformDestructuringAssignment(context, expression, rootIdentifier),
+            ...(0, destructuring_assignments_1.transformDestructuringAssignment)(context, expression, rootIdentifier, rightPrecedingStatements.length > 0),
         ];
     }
     else {
-        return transformAssignment(context, expression.left, context.transformExpression(expression.right));
+        const [precedingStatements, right] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(expression.right));
+        return transformAssignmentWithRightPrecedingStatements(context, expression.left, right, precedingStatements);
     }
 }
 exports.transformAssignmentStatement = transformAssignmentStatement;