typescript-to-lua 1.0.1 → 1.3.0

package/dist/transformation/visitors/identifier.js

@@ -16,53 +16,57 @@ const operators_1 = require("./language-extensions/operators");
 const range_1 = require("./language-extensions/range");
 const table_1 = require("./language-extensions/table");
 const vararg_1 = require("./language-extensions/vararg");
+const optional_chaining_1 = require("./optional-chaining");
 function transformIdentifier(context, identifier) {
-    if (multi_1.isMultiFunctionNode(context, identifier)) {
-        context.diagnostics.push(diagnostics_1.invalidMultiFunctionUse(identifier));
+    if ((0, optional_chaining_1.isOptionalContinuation)(identifier)) {
+        return lua.createIdentifier(identifier.text);
+    }
+    if ((0, multi_1.isMultiFunctionNode)(context, identifier)) {
+        context.diagnostics.push((0, diagnostics_1.invalidMultiFunctionUse)(identifier));
         return lua.createAnonymousIdentifier(identifier);
     }
-    if (operators_1.isOperatorMapping(context, identifier)) {
-        context.diagnostics.push(diagnostics_1.invalidOperatorMappingUse(identifier));
+    if ((0, operators_1.isOperatorMapping)(context, identifier)) {
+        context.diagnostics.push((0, diagnostics_1.invalidOperatorMappingUse)(identifier));
     }
-    if (table_1.isTableExtensionIdentifier(context, identifier)) {
-        context.diagnostics.push(diagnostics_1.invalidTableExtensionUse(identifier));
+    if ((0, table_1.isTableExtensionIdentifier)(context, identifier)) {
+        context.diagnostics.push((0, diagnostics_1.invalidTableExtensionUse)(identifier));
     }
-    if (range_1.isRangeFunctionNode(context, identifier)) {
-        context.diagnostics.push(diagnostics_1.invalidRangeUse(identifier));
+    if ((0, range_1.isRangeFunctionNode)(context, identifier)) {
+        context.diagnostics.push((0, diagnostics_1.invalidRangeUse)(identifier));
         return lua.createAnonymousIdentifier(identifier);
     }
-    if (vararg_1.isVarargConstantNode(context, identifier)) {
-        context.diagnostics.push(diagnostics_1.invalidVarargUse(identifier));
+    if ((0, vararg_1.isVarargConstantNode)(context, identifier)) {
+        context.diagnostics.push((0, diagnostics_1.invalidVarargUse)(identifier));
         return lua.createAnonymousIdentifier(identifier);
     }
-    if (annotations_1.isForRangeType(context, identifier)) {
-        context.diagnostics.push(diagnostics_1.annotationRemoved(identifier, annotations_1.AnnotationKind.ForRange));
+    if ((0, annotations_1.isForRangeType)(context, identifier)) {
+        context.diagnostics.push((0, diagnostics_1.annotationRemoved)(identifier, annotations_1.AnnotationKind.ForRange));
     }
-    if (promise_1.isPromiseClass(context, identifier)) {
-        lualib_1.importLuaLibFeature(context, lualib_1.LuaLibFeature.Promise);
-        return promise_1.createPromiseIdentifier(identifier);
+    if ((0, promise_1.isPromiseClass)(context, identifier)) {
+        (0, lualib_1.importLuaLibFeature)(context, lualib_1.LuaLibFeature.Promise);
+        return (0, promise_1.createPromiseIdentifier)(identifier);
     }
-    const text = safe_names_1.hasUnsafeIdentifierName(context, identifier) ? safe_names_1.createSafeName(identifier.text) : identifier.text;
-    const symbolId = symbols_1.getIdentifierSymbolId(context, identifier);
+    const text = (0, safe_names_1.hasUnsafeIdentifierName)(context, identifier) ? (0, safe_names_1.createSafeName)(identifier.text) : identifier.text;
+    const symbolId = (0, symbols_1.getIdentifierSymbolId)(context, identifier);
     return lua.createIdentifier(text, identifier, symbolId, identifier.text);
 }
 exports.transformIdentifier = transformIdentifier;
 const transformIdentifierExpression = (node, context) => {
     const symbol = context.checker.getSymbolAtLocation(node);
     if (symbol) {
-        const exportScope = export_1.getSymbolExportScope(context, symbol);
+        const exportScope = (0, export_1.getSymbolExportScope)(context, symbol);
         if (exportScope) {
             const name = symbol.name;
-            const text = safe_names_1.hasUnsafeIdentifierName(context, node) ? safe_names_1.createSafeName(name) : name;
-            const symbolId = symbols_1.getIdentifierSymbolId(context, node);
+            const text = (0, safe_names_1.hasUnsafeIdentifierName)(context, node) ? (0, safe_names_1.createSafeName)(name) : name;
+            const symbolId = (0, symbols_1.getIdentifierSymbolId)(context, node);
             const identifier = lua.createIdentifier(text, node, symbolId, name);
-            return export_1.createExportedIdentifier(context, identifier, exportScope);
+            return (0, export_1.createExportedIdentifier)(context, identifier, exportScope);
         }
     }
     if (node.originalKeywordKind === ts.SyntaxKind.UndefinedKeyword) {
         return lua.createNilLiteral();
     }
-    const builtinResult = builtins_1.transformBuiltinIdentifierExpression(context, node);
+    const builtinResult = (0, builtins_1.transformBuiltinIdentifierExpression)(context, node);
     if (builtinResult) {
         return builtinResult;
     }

package/dist/transformation/visitors/index.js

@@ -33,14 +33,13 @@ const typeof_1 = require("./typeof");
 const typescript_1 = require("./typescript");
 const unary_expression_1 = require("./unary-expression");
 const variable_declaration_1 = require("./variable-declaration");
-const jsx_1 = require("./jsx/jsx");
 const async_await_1 = require("./async-await");
+const void_1 = require("./void");
 const transformEmptyStatement = () => undefined;
 const transformParenthesizedExpression = (node, context) => context.transformExpression(node.expression);
 exports.standardVisitors = {
     ...literal_1.literalVisitors,
     ...typescript_1.typescriptVisitors,
-    ...jsx_1.jsxVisitors,
     [ts.SyntaxKind.ArrowFunction]: function_1.transformFunctionLikeDeclaration,
     [ts.SyntaxKind.AwaitExpression]: async_await_1.transformAwaitExpression,
     [ts.SyntaxKind.BinaryExpression]: binary_expression_1.transformBinaryExpression,
@@ -90,5 +89,6 @@ exports.standardVisitors = {
     [ts.SyntaxKind.VariableStatement]: variable_declaration_1.transformVariableStatement,
     [ts.SyntaxKind.WhileStatement]: do_while_1.transformWhileStatement,
     [ts.SyntaxKind.YieldExpression]: function_1.transformYieldExpression,
+    [ts.SyntaxKind.VoidExpression]: void_1.transformVoidExpression,
 };
 //# sourceMappingURL=index.js.map

package/dist/transformation/visitors/language-extensions/iterable.js

@@ -30,12 +30,12 @@ function transformForOfMultiIterableStatement(context, statement, block) {
     if (ts.isVariableDeclarationList(statement.initializer)) {
         // Variables declared in for loop
         // for ${initializer} in ${iterable} do
-        const binding = utils_1.getVariableDeclarationBinding(context, statement.initializer);
+        const binding = (0, utils_1.getVariableDeclarationBinding)(context, statement.initializer);
         if (ts.isArrayBindingPattern(binding)) {
-            identifiers = binding.elements.map(e => variable_declaration_1.transformArrayBindingElement(context, e));
+            identifiers = binding.elements.map(e => (0, variable_declaration_1.transformArrayBindingElement)(context, e));
         }
         else {
-            context.diagnostics.push(diagnostics_1.invalidMultiIterableWithoutDestructuring(binding));
+            context.diagnostics.push((0, diagnostics_1.invalidMultiIterableWithoutDestructuring)(binding));
         }
     }
     else if (ts.isArrayLiteralExpression(statement.initializer)) {
@@ -44,11 +44,11 @@ function transformForOfMultiIterableStatement(context, statement, block) {
         //     ${initializer} = ____value0
         identifiers = statement.initializer.elements.map((_, i) => lua.createIdentifier(`____value${i}`));
         if (identifiers.length > 0) {
-            block.statements.unshift(lua.createAssignmentStatement(statement.initializer.elements.map(e => utils_2.cast(context.transformExpression(e), lua.isAssignmentLeftHandSideExpression)), identifiers));
+            block.statements.unshift(lua.createAssignmentStatement(statement.initializer.elements.map(e => (0, utils_2.cast)(context.transformExpression(e), lua.isAssignmentLeftHandSideExpression)), identifiers));
         }
     }
     else {
-        context.diagnostics.push(diagnostics_1.invalidMultiIterableWithoutDestructuring(statement.initializer));
+        context.diagnostics.push((0, diagnostics_1.invalidMultiIterableWithoutDestructuring)(statement.initializer));
     }
     if (identifiers.length === 0) {
         identifiers.push(lua.createAnonymousIdentifier());
@@ -58,11 +58,11 @@ function transformForOfMultiIterableStatement(context, statement, block) {
 function transformForOfIterableStatement(context, statement, block) {
     var _a;
     const type = context.checker.getTypeAtLocation(statement.expression);
-    if (((_a = type.aliasTypeArguments) === null || _a === void 0 ? void 0 : _a.length) === 2 && multi_1.isMultiReturnType(type.aliasTypeArguments[0])) {
+    if (((_a = type.aliasTypeArguments) === null || _a === void 0 ? void 0 : _a.length) === 2 && (0, multi_1.isMultiReturnType)(type.aliasTypeArguments[0])) {
         return transformForOfMultiIterableStatement(context, statement, block);
     }
     const luaIterator = context.transformExpression(statement.expression);
-    const identifier = utils_1.transformForInitializer(context, statement.initializer, block);
+    const identifier = (0, utils_1.transformForInitializer)(context, statement.initializer, block);
     return lua.createForInStatement(block, [identifier], [luaIterator], statement);
 }
 exports.transformForOfIterableStatement = transformForOfIterableStatement;

package/dist/transformation/visitors/language-extensions/multi.d.ts

@@ -8,4 +8,4 @@ export declare function isMultiReturnCall(context: TransformationContext, expres
 export declare function isMultiFunctionNode(context: TransformationContext, node: ts.Node): boolean;
 export declare function isInMultiReturnFunction(context: TransformationContext, node: ts.Node): boolean;
 export declare function shouldMultiReturnCallBeWrapped(context: TransformationContext, node: ts.CallExpression): boolean;
-export declare function findMultiAssignmentViolations(context: TransformationContext, node: ts.ObjectLiteralExpressionBase<ts.ObjectLiteralElement>): ts.Node[];
+export declare function findMultiAssignmentViolations(context: TransformationContext, node: ts.ObjectLiteralExpression): ts.Node[];

package/dist/transformation/visitors/language-extensions/multi.js

@@ -34,7 +34,7 @@ function isMultiFunctionNode(context, node) {
 }
 exports.isMultiFunctionNode = isMultiFunctionNode;
 function isInMultiReturnFunction(context, node) {
-    const declaration = typescript_1.findFirstNodeAbove(node, ts.isFunctionLike);
+    const declaration = (0, typescript_1.findFirstNodeAbove)(node, ts.isFunctionLike);
     if (!declaration) {
         return false;
     }
@@ -75,7 +75,7 @@ function shouldMultiReturnCallBeWrapped(context, node) {
         return false;
     }
     // LuaIterable in for...of
-    if (ts.isForOfStatement(node.parent) && iterable_1.isIterableExpression(context, node)) {
+    if (ts.isForOfStatement(node.parent) && (0, iterable_1.isIterableExpression)(context, node)) {
         return false;
     }
     return true;
@@ -89,7 +89,7 @@ function findMultiAssignmentViolations(context, node) {
         const valueSymbol = context.checker.getShorthandAssignmentValueSymbol(element);
         if (valueSymbol) {
             if (extensions.isExtensionValue(context, valueSymbol, extensions.ExtensionKind.MultiFunction)) {
-                context.diagnostics.push(diagnostics_1.invalidMultiFunctionUse(element));
+                context.diagnostics.push((0, diagnostics_1.invalidMultiFunctionUse)(element));
                 result.push(element);
             }
         }

package/dist/transformation/visitors/language-extensions/operators.js

@@ -64,7 +64,7 @@ const bitwiseOperatorMapExtensions = new Set([
     extensions.ExtensionKind.BitwiseNotOperatorMethodType,
 ]);
 function getOperatorMapExtensionKindForCall(context, node) {
-    const type = typescript_1.getFunctionTypeForCall(context, node);
+    const type = (0, typescript_1.getFunctionTypeForCall)(context, node);
     return type && operatorMapExtensions.find(extensionKind => extensions.isExtensionType(type, extensionKind));
 }
 function isOperatorMapping(context, node) {
@@ -79,7 +79,7 @@ function isOperatorMapping(context, node) {
 exports.isOperatorMapping = isOperatorMapping;
 function transformOperatorMappingExpression(context, node) {
     const extensionKind = getOperatorMapExtensionKindForCall(context, node);
-    utils_1.assert(extensionKind);
+    (0, utils_1.assert)(extensionKind);
     const isBefore53 = context.luaTarget === CompilerOptions_1.LuaTarget.Lua51 ||
         context.luaTarget === CompilerOptions_1.LuaTarget.Lua52 ||
         context.luaTarget === CompilerOptions_1.LuaTarget.LuaJIT ||
@@ -87,11 +87,11 @@ function transformOperatorMappingExpression(context, node) {
     if (isBefore53) {
         const luaTarget = context.luaTarget === CompilerOptions_1.LuaTarget.Universal ? CompilerOptions_1.LuaTarget.Lua51 : context.luaTarget;
         if (bitwiseOperatorMapExtensions.has(extensionKind)) {
-            context.diagnostics.push(diagnostics_1.unsupportedForTarget(node, "Native bitwise operations", luaTarget));
+            context.diagnostics.push((0, diagnostics_1.unsupportedForTarget)(node, "Native bitwise operations", luaTarget));
         }
         else if (extensionKind === extensions.ExtensionKind.FloorDivisionOperatorType ||
             extensionKind === extensions.ExtensionKind.FloorDivisionOperatorMethodType) {
-            context.diagnostics.push(diagnostics_1.unsupportedForTarget(node, "Floor division operator", luaTarget));
+            context.diagnostics.push((0, diagnostics_1.unsupportedForTarget)(node, "Floor division operator", luaTarget));
         }
     }
     const args = node.arguments.slice();
@@ -101,7 +101,7 @@ function transformOperatorMappingExpression(context, node) {
             args.unshift(node.expression.expression);
         }
         const luaOperator = binaryOperatorMappings.get(extensionKind);
-        utils_1.assert(luaOperator);
+        (0, utils_1.assert)(luaOperator);
         return lua.createBinaryExpression(context.transformExpression(args[0]), context.transformExpression(args[1]), luaOperator);
     }
     else {
@@ -114,7 +114,7 @@ function transformOperatorMappingExpression(context, node) {
             arg = args[0];
         }
         const luaOperator = unaryOperatorMappings.get(extensionKind);
-        utils_1.assert(luaOperator);
+        (0, utils_1.assert)(luaOperator);
         return lua.createUnaryExpression(context.transformExpression(arg), luaOperator);
     }
 }

package/dist/transformation/visitors/language-extensions/pairsIterable.d.ts

@@ -0,0 +1,5 @@
+import * as ts from "typescript";
+import * as lua from "../../../LuaAST";
+import { TransformationContext } from "../../context";
+export declare function isPairsIterableExpression(context: TransformationContext, expression: ts.Expression): boolean;
+export declare function transformForOfPairsIterableStatement(context: TransformationContext, statement: ts.ForOfStatement, block: lua.Block): lua.Statement;

package/dist/transformation/visitors/language-extensions/pairsIterable.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformForOfPairsIterableStatement = exports.isPairsIterableExpression = void 0;
+const ts = require("typescript");
+const lua = require("../../../LuaAST");
+const utils_1 = require("../../../utils");
+const diagnostics_1 = require("../../utils/diagnostics");
+const extensions = require("../../utils/language-extensions");
+const utils_2 = require("../loops/utils");
+const variable_declaration_1 = require("../variable-declaration");
+function isPairsIterableType(type) {
+    return extensions.isExtensionType(type, extensions.ExtensionKind.PairsIterableType);
+}
+function isPairsIterableExpression(context, expression) {
+    const type = context.checker.getTypeAtLocation(expression);
+    return isPairsIterableType(type);
+}
+exports.isPairsIterableExpression = isPairsIterableExpression;
+function transformForOfPairsIterableStatement(context, statement, block) {
+    const pairsCall = lua.createCallExpression(lua.createIdentifier("pairs"), [
+        context.transformExpression(statement.expression),
+    ]);
+    let identifiers = [];
+    if (ts.isVariableDeclarationList(statement.initializer)) {
+        // Variables declared in for loop
+        // for key, value in iterable do
+        const binding = (0, utils_2.getVariableDeclarationBinding)(context, statement.initializer);
+        if (ts.isArrayBindingPattern(binding)) {
+            identifiers = binding.elements.map(e => (0, variable_declaration_1.transformArrayBindingElement)(context, e));
+        }
+        else {
+            context.diagnostics.push((0, diagnostics_1.invalidPairsIterableWithoutDestructuring)(binding));
+        }
+    }
+    else if (ts.isArrayLiteralExpression(statement.initializer)) {
+        // Variables NOT declared in for loop - catch iterator values in temps and assign
+        // for ____key, ____value in iterable do
+        //     key, value = ____key, ____value
+        identifiers = statement.initializer.elements.map(e => context.createTempNameForNode(e));
+        if (identifiers.length > 0) {
+            block.statements.unshift(lua.createAssignmentStatement(statement.initializer.elements.map(e => (0, utils_1.cast)(context.transformExpression(e), lua.isAssignmentLeftHandSideExpression)), identifiers));
+        }
+    }
+    else {
+        context.diagnostics.push((0, diagnostics_1.invalidPairsIterableWithoutDestructuring)(statement.initializer));
+    }
+    if (identifiers.length === 0) {
+        identifiers.push(lua.createAnonymousIdentifier());
+    }
+    return lua.createForInStatement(block, identifiers, [pairsCall], statement);
+}
+exports.transformForOfPairsIterableStatement = transformForOfPairsIterableStatement;
+//# sourceMappingURL=pairsIterable.js.map

package/dist/transformation/visitors/language-extensions/range.js

@@ -20,21 +20,21 @@ function isRangeFunctionNode(context, node) {
 exports.isRangeFunctionNode = isRangeFunctionNode;
 function getControlVariable(context, statement) {
     if (!ts.isVariableDeclarationList(statement.initializer)) {
-        context.diagnostics.push(diagnostics_1.invalidRangeControlVariable(statement.initializer));
+        context.diagnostics.push((0, diagnostics_1.invalidRangeControlVariable)(statement.initializer));
         return;
     }
-    const binding = utils_1.getVariableDeclarationBinding(context, statement.initializer);
+    const binding = (0, utils_1.getVariableDeclarationBinding)(context, statement.initializer);
     if (!ts.isIdentifier(binding)) {
-        context.diagnostics.push(diagnostics_1.invalidRangeControlVariable(statement.initializer));
+        context.diagnostics.push((0, diagnostics_1.invalidRangeControlVariable)(statement.initializer));
         return;
     }
-    return identifier_1.transformIdentifier(context, binding);
+    return (0, identifier_1.transformIdentifier)(context, binding);
 }
 function transformRangeStatement(context, statement, block) {
     var _a;
-    utils_2.assert(ts.isCallExpression(statement.expression));
+    (0, utils_2.assert)(ts.isCallExpression(statement.expression));
     const controlVariable = (_a = getControlVariable(context, statement)) !== null && _a !== void 0 ? _a : lua.createAnonymousIdentifier(statement.initializer);
-    const [start = lua.createNumericLiteral(0), limit = lua.createNumericLiteral(0), step] = call_1.transformArguments(context, statement.expression.arguments, context.checker.getResolvedSignature(statement.expression));
+    const [start = lua.createNumericLiteral(0), limit = lua.createNumericLiteral(0), step] = (0, call_1.transformArguments)(context, statement.expression.arguments, context.checker.getResolvedSignature(statement.expression));
     return lua.createForStatement(block, controlVariable, start, limit, step, statement);
 }
 exports.transformRangeStatement = transformRangeStatement;

package/dist/transformation/visitors/language-extensions/table.js

@@ -21,7 +21,7 @@ const tableExtensions = [
     ...tableSetExtensions,
 ];
 function getTableExtensionKindForCall(context, node, validExtensions) {
-    const type = typescript_1.getFunctionTypeForCall(context, node);
+    const type = (0, typescript_1.getFunctionTypeForCall)(context, node);
     return type && validExtensions.find(extensionKind => extensions.isExtensionType(type, extensionKind));
 }
 function isTableExtensionIdentifier(context, node) {
@@ -52,7 +52,7 @@ function isTableNewCall(context, node) {
 exports.isTableNewCall = isTableNewCall;
 function transformTableDeleteExpression(context, node) {
     const extensionKind = getTableExtensionKindForCall(context, node, tableDeleteExtensions);
-    utils_1.assert(extensionKind);
+    (0, utils_1.assert)(extensionKind);
     const args = node.arguments.slice();
     if (args.length === 1 &&
         (ts.isPropertyAccessExpression(node.expression) || ts.isElementAccessExpression(node.expression))) {
@@ -65,7 +65,7 @@ function transformTableDeleteExpression(context, node) {
 exports.transformTableDeleteExpression = transformTableDeleteExpression;
 function transformTableGetExpression(context, node) {
     const extensionKind = getTableExtensionKindForCall(context, node, tableGetExtensions);
-    utils_1.assert(extensionKind);
+    (0, utils_1.assert)(extensionKind);
     const args = node.arguments.slice();
     if (args.length === 1 &&
         (ts.isPropertyAccessExpression(node.expression) || ts.isElementAccessExpression(node.expression))) {
@@ -78,7 +78,7 @@ function transformTableGetExpression(context, node) {
 exports.transformTableGetExpression = transformTableGetExpression;
 function transformTableHasExpression(context, node) {
     const extensionKind = getTableExtensionKindForCall(context, node, tableHasExtensions);
-    utils_1.assert(extensionKind);
+    (0, utils_1.assert)(extensionKind);
     const args = node.arguments.slice();
     if (args.length === 1 &&
         (ts.isPropertyAccessExpression(node.expression) || ts.isElementAccessExpression(node.expression))) {
@@ -93,7 +93,7 @@ function transformTableHasExpression(context, node) {
 exports.transformTableHasExpression = transformTableHasExpression;
 function transformTableSetExpression(context, node) {
     const extensionKind = getTableExtensionKindForCall(context, node, tableSetExtensions);
-    utils_1.assert(extensionKind);
+    (0, utils_1.assert)(extensionKind);
     const args = node.arguments.slice();
     if (args.length === 2 &&
         (ts.isPropertyAccessExpression(node.expression) || ts.isElementAccessExpression(node.expression))) {

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

@@ -1,7 +1,6 @@
 import * as ts from "typescript";
 import * as lua from "../../LuaAST";
-import { FunctionVisitor, TransformationContext, Visitors } from "../context";
+import { TransformationContext, Visitors } from "../context";
 export declare function transformPropertyName(context: TransformationContext, node: ts.PropertyName): lua.Expression;
 export declare function createShorthandIdentifier(context: TransformationContext, valueSymbol: ts.Symbol | undefined, propertyIdentifier: ts.Identifier): lua.Expression;
-export declare const transformJsxAttributes: FunctionVisitor<ts.JsxAttributes>;
 export declare const literalVisitors: Visitors;

package/dist/transformation/visitors/literal.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.literalVisitors = exports.transformJsxAttributes = exports.createShorthandIdentifier = exports.transformPropertyName = void 0;
+exports.literalVisitors = exports.createShorthandIdentifier = exports.transformPropertyName = void 0;
 const ts = require("typescript");
 const lua = require("../../LuaAST");
 const utils_1 = require("../../utils");
@@ -11,9 +11,8 @@ const safe_names_1 = require("../utils/safe-names");
 const symbols_1 = require("../utils/symbols");
 const typescript_1 = require("../utils/typescript");
 const function_1 = require("./function");
-const call_1 = require("./call");
+const expression_list_1 = require("./expression-list");
 const multi_1 = require("./language-extensions/multi");
-const jsx_1 = require("./jsx/jsx");
 // TODO: Move to object-literal.ts?
 function transformPropertyName(context, node) {
     if (ts.isComputedPropertyName(node)) {
@@ -33,16 +32,16 @@ exports.transformPropertyName = transformPropertyName;
 function createShorthandIdentifier(context, valueSymbol, propertyIdentifier) {
     const propertyName = propertyIdentifier.text;
     const isUnsafeName = valueSymbol
-        ? safe_names_1.hasUnsafeSymbolName(context, valueSymbol, propertyIdentifier)
-        : safe_names_1.hasUnsafeIdentifierName(context, propertyIdentifier, false);
-    const name = isUnsafeName ? safe_names_1.createSafeName(propertyName) : propertyName;
+        ? (0, safe_names_1.hasUnsafeSymbolName)(context, valueSymbol, propertyIdentifier)
+        : (0, safe_names_1.hasUnsafeIdentifierName)(context, propertyIdentifier, false);
+    const name = isUnsafeName ? (0, safe_names_1.createSafeName)(propertyName) : propertyName;
     let identifier = context.transformExpression(ts.factory.createIdentifier(name));
     lua.setNodeOriginal(identifier, propertyIdentifier);
     if (valueSymbol !== undefined && lua.isIdentifier(identifier)) {
-        identifier.symbolId = symbols_1.getSymbolIdOfSymbol(context, valueSymbol);
-        const exportScope = export_1.getSymbolExportScope(context, valueSymbol);
+        identifier.symbolId = (0, symbols_1.getSymbolIdOfSymbol)(context, valueSymbol);
+        const exportScope = (0, export_1.getSymbolExportScope)(context, valueSymbol);
         if (exportScope) {
-            identifier = export_1.createExportedIdentifier(context, identifier, exportScope);
+            identifier = (0, export_1.createExportedIdentifier)(context, identifier, exportScope);
         }
     }
     return identifier;
@@ -56,96 +55,127 @@ const transformNumericLiteralExpression = expression => {
     }
     return lua.createNumericLiteral(Number(expression.text), expression);
 };
-const transformObjectLiteralExpressionOrJsxAttributes = (expression, context) => {
-    const violations = multi_1.findMultiAssignmentViolations(context, expression);
+const transformObjectLiteralExpression = (expression, context) => {
+    const violations = (0, multi_1.findMultiAssignmentViolations)(context, expression);
     if (violations.length > 0) {
-        context.diagnostics.push(...violations.map(e => diagnostics_1.invalidMultiFunctionUse(e)));
+        context.diagnostics.push(...violations.map(e => (0, diagnostics_1.invalidMultiFunctionUse)(e)));
         return lua.createNilLiteral(expression);
     }
-    let properties = [];
-    const tableExpressions = [];
-    for (const element of expression.properties) {
+    const properties = [];
+    const initializers = [];
+    const keyPrecedingStatements = [];
+    const valuePrecedingStatements = [];
+    let lastPrecedingStatementsIndex = -1;
+    for (let i = 0; i < expression.properties.length; ++i) {
+        const element = expression.properties[i];
+        // Transform key and cache preceding statements
+        context.pushPrecedingStatements();
         const name = element.name ? transformPropertyName(context, element.name) : undefined;
+        let precedingStatements = context.popPrecedingStatements();
+        keyPrecedingStatements.push(precedingStatements);
+        if (precedingStatements.length > 0) {
+            lastPrecedingStatementsIndex = i;
+        }
+        // Transform value and cache preceding statements
+        context.pushPrecedingStatements();
         if (ts.isPropertyAssignment(element)) {
             const expression = context.transformExpression(element.initializer);
             properties.push(lua.createTableFieldExpression(expression, name, element));
-        }
-        else if (ts.isJsxAttribute(element)) {
-            const initializer = element.initializer;
-            let expression;
-            if (initializer === undefined) {
-                expression = lua.createBooleanLiteral(true);
-            }
-            else if (ts.isStringLiteral(initializer)) {
-                const text = jsx_1.formatJSXStringValueLiteral(initializer.text);
-                expression = lua.createStringLiteral(text, initializer);
-            }
-            else if (ts.isJsxExpression(initializer)) {
-                expression = initializer.expression
-                    ? context.transformExpression(initializer.expression)
-                    : lua.createBooleanLiteral(true);
-            }
-            else {
-                utils_1.assertNever(initializer);
-            }
-            properties.push(lua.createTableFieldExpression(expression, name, element));
+            initializers.push(element.initializer);
         }
         else if (ts.isShorthandPropertyAssignment(element)) {
             const valueSymbol = context.checker.getShorthandAssignmentValueSymbol(element);
             if (valueSymbol) {
-                symbols_1.trackSymbolReference(context, valueSymbol, element.name);
+                (0, symbols_1.trackSymbolReference)(context, valueSymbol, element.name);
             }
             const identifier = createShorthandIdentifier(context, valueSymbol, element.name);
             properties.push(lua.createTableFieldExpression(identifier, name, element));
+            initializers.push(element);
         }
         else if (ts.isMethodDeclaration(element)) {
-            const expression = function_1.transformFunctionLikeDeclaration(element, context);
+            const expression = (0, function_1.transformFunctionLikeDeclaration)(element, context);
             properties.push(lua.createTableFieldExpression(expression, name, element));
+            initializers.push(element);
         }
-        else if (ts.isSpreadAssignment(element) || ts.isJsxSpreadAttribute(element)) {
-            // Create a table for preceding properties to preserve property order
-            // { x: 0, ...{ y: 2 }, y: 1, z: 2 } --> __TS__ObjectAssign({x = 0}, {y = 2}, {y = 1, z = 2})
-            if (properties.length > 0) {
-                const tableExpression = lua.createTableExpression(properties, expression);
-                tableExpressions.push(tableExpression);
-                properties = [];
-            }
+        else if (ts.isSpreadAssignment(element)) {
             const type = context.checker.getTypeAtLocation(element.expression);
             let tableExpression;
-            if (typescript_1.isArrayType(context, type)) {
-                tableExpression = lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.ArrayToObject, element.expression, context.transformExpression(element.expression));
+            if ((0, typescript_1.isArrayType)(context, type)) {
+                tableExpression = (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ArrayToObject, element.expression, context.transformExpression(element.expression));
             }
             else {
                 tableExpression = context.transformExpression(element.expression);
             }
-            tableExpressions.push(tableExpression);
+            properties.push(tableExpression);
+            initializers.push(element.expression);
         }
         else if (ts.isAccessor(element)) {
-            context.diagnostics.push(diagnostics_1.unsupportedAccessorInObjectLiteral(element));
+            context.diagnostics.push((0, diagnostics_1.unsupportedAccessorInObjectLiteral)(element));
         }
         else {
-            utils_1.assertNever(element);
+            (0, utils_1.assertNever)(element);
+        }
+        precedingStatements = context.popPrecedingStatements();
+        valuePrecedingStatements.push(precedingStatements);
+        if (precedingStatements.length > 0) {
+            lastPrecedingStatementsIndex = i;
+        }
+    }
+    // Expressions referenced before others that produced preceding statements need to be cached in temps
+    if (lastPrecedingStatementsIndex >= 0) {
+        for (let i = 0; i < properties.length; ++i) {
+            const property = properties[i];
+            // Bubble up key's preceding statements
+            context.addPrecedingStatements(keyPrecedingStatements[i]);
+            // Cache computed property name in temp if before the last expression that generated preceding statements
+            if (i <= lastPrecedingStatementsIndex && lua.isTableFieldExpression(property) && property.key) {
+                property.key = (0, expression_list_1.moveToPrecedingTemp)(context, property.key, expression.properties[i].name);
+            }
+            // Bubble up value's preceding statements
+            context.addPrecedingStatements(valuePrecedingStatements[i]);
+            // Cache property value in temp if before the last expression that generated preceding statements
+            if (i < lastPrecedingStatementsIndex) {
+                if (lua.isTableFieldExpression(property)) {
+                    property.value = (0, expression_list_1.moveToPrecedingTemp)(context, property.value, initializers[i]);
+                }
+                else {
+                    properties[i] = (0, expression_list_1.moveToPrecedingTemp)(context, property, initializers[i]);
+                }
+            }
+        }
+    }
+    // Sort into field expressions and tables to pass into __TS__ObjectAssign
+    let fields = [];
+    const tableExpressions = [];
+    for (const property of properties) {
+        if (lua.isTableFieldExpression(property)) {
+            fields.push(property);
+        }
+        else {
+            if (fields.length > 0) {
+                tableExpressions.push(lua.createTableExpression(fields));
+            }
+            tableExpressions.push(property);
+            fields = [];
         }
     }
     if (tableExpressions.length === 0) {
-        return lua.createTableExpression(properties, expression);
+        return lua.createTableExpression(fields, expression);
     }
     else {
-        if (properties.length > 0) {
-            const tableExpression = lua.createTableExpression(properties, expression);
+        if (fields.length > 0) {
+            const tableExpression = lua.createTableExpression(fields, expression);
             tableExpressions.push(tableExpression);
         }
         if (tableExpressions[0].kind !== lua.SyntaxKind.TableExpression) {
             tableExpressions.unshift(lua.createTableExpression(undefined, expression));
         }
-        return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.ObjectAssign, expression, ...tableExpressions);
+        return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ObjectAssign, expression, ...tableExpressions);
     }
 };
-const transformObjectLiteralExpression = transformObjectLiteralExpressionOrJsxAttributes;
-exports.transformJsxAttributes = transformObjectLiteralExpressionOrJsxAttributes;
 const transformArrayLiteralExpression = (expression, context) => {
     const filteredElements = expression.elements.map(e => ts.isOmittedExpression(e) ? ts.factory.createIdentifier("undefined") : e);
-    const values = call_1.flattenSpreadExpressions(context, filteredElements).map(e => lua.createTableFieldExpression(e));
+    const values = (0, expression_list_1.transformExpressionList)(context, filteredElements).map(e => lua.createTableFieldExpression(e));
     return lua.createTableExpression(values, expression);
 };
 exports.literalVisitors = {