typescript-to-lua 1.1.1 → 1.2.0

package/dist/transformation/visitors/call.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformCallExpression = exports.transformContextualCallExpression = exports.transformArguments = exports.flattenSpreadExpressions = void 0;
+exports.transformCallExpression = exports.transformContextualCallExpression = exports.transformCallAndArguments = exports.transformArguments = exports.validateArguments = void 0;
 const ts = require("typescript");
 const lua = require("../../LuaAST");
 const builtins_1 = require("../builtins");
@@ -8,7 +8,6 @@ const annotations_1 = require("../utils/annotations");
 const assignment_validation_1 = require("../utils/assignment-validation");
 const function_context_1 = require("../utils/function-context");
 const lua_ast_1 = require("../utils/lua-ast");
-const lualib_1 = require("../utils/lualib");
 const safe_names_1 = require("../utils/safe-names");
 const typescript_1 = require("../utils/typescript");
 const access_1 = require("./access");
@@ -16,116 +15,97 @@ const multi_1 = require("./language-extensions/multi");
 const operators_1 = require("./language-extensions/operators");
 const table_1 = require("./language-extensions/table");
 const diagnostics_1 = require("../utils/diagnostics");
-const transform_1 = require("../utils/transform");
-function getExpressionsBeforeAndAfterFirstSpread(expressions) {
-    // [a, b, ...c, d, ...e] --> [a, b] and [...c, d, ...e]
-    const index = expressions.findIndex(ts.isSpreadElement);
-    const hasSpreadElement = index !== -1;
-    const before = hasSpreadElement ? expressions.slice(0, index) : expressions;
-    const after = hasSpreadElement ? expressions.slice(index) : [];
-    return [before, after];
-}
-function transformSpreadableExpressionsIntoArrayConcatArguments(context, expressions) {
-    // [...array, a, b, ...tuple()] --> [ [...array], [a, b], [...tuple()] ]
-    // chunk non-spread arguments together so they don't concat
-    const chunks = [];
-    for (const [index, expression] of expressions.entries()) {
-        if (ts.isSpreadElement(expression)) {
-            chunks.push([expression]);
-            const next = expressions[index + 1];
-            if (next && !ts.isSpreadElement(next)) {
-                chunks.push([]);
-            }
-        }
-        else {
-            let lastChunk = chunks[chunks.length - 1];
-            if (!lastChunk) {
-                lastChunk = [];
-                chunks.push(lastChunk);
-            }
-            lastChunk.push(expression);
+const expression_list_1 = require("./expression-list");
+const preceding_statements_1 = require("../utils/preceding-statements");
+const optional_chaining_1 = require("./optional-chaining");
+function validateArguments(context, params, signature) {
+    if (!signature || signature.parameters.length < params.length) {
+        return;
+    }
+    for (const [index, param] of params.entries()) {
+        const signatureParameter = signature.parameters[index];
+        const paramType = context.checker.getTypeAtLocation(param);
+        if (signatureParameter.valueDeclaration !== undefined) {
+            const signatureType = context.checker.getTypeAtLocation(signatureParameter.valueDeclaration);
+            (0, assignment_validation_1.validateAssignment)(context, param, paramType, signatureType, signatureParameter.name);
         }
     }
-    return chunks.map(chunk => (0, lua_ast_1.wrapInTable)(...chunk.map(expression => context.transformExpression(expression))));
 }
-function flattenSpreadExpressions(context, expressions) {
-    const [preSpreadExpressions, postSpreadExpressions] = getExpressionsBeforeAndAfterFirstSpread(expressions);
-    const transformedPreSpreadExpressions = preSpreadExpressions.map(a => context.transformExpression(a));
-    // Nothing special required
-    if (postSpreadExpressions.length === 0) {
-        return transformedPreSpreadExpressions;
-    }
-    // Only one spread element at the end? Will work as expected
-    if (postSpreadExpressions.length === 1) {
-        return [...transformedPreSpreadExpressions, context.transformExpression(postSpreadExpressions[0])];
-    }
-    // Use Array.concat and unpack the result of that as the last Expression
-    const concatArguments = transformSpreadableExpressionsIntoArrayConcatArguments(context, postSpreadExpressions);
-    const lastExpression = (0, lua_ast_1.createUnpackCall)(context, (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ArrayConcat, undefined, ...concatArguments));
-    return [...transformedPreSpreadExpressions, lastExpression];
-}
-exports.flattenSpreadExpressions = flattenSpreadExpressions;
+exports.validateArguments = validateArguments;
 function transformArguments(context, params, signature, callContext) {
-    const parameters = flattenSpreadExpressions(context, params);
-    // Add context as first param if present
+    validateArguments(context, params, signature);
+    return (0, expression_list_1.transformExpressionList)(context, callContext ? [callContext, ...params] : params);
+}
+exports.transformArguments = transformArguments;
+function transformCallWithArguments(context, callExpression, transformedArguments, argPrecedingStatements, callContext) {
+    let call = context.transformExpression(callExpression);
+    let transformedContext;
     if (callContext) {
-        parameters.unshift(context.transformExpression(callContext));
-    }
-    if (signature && signature.parameters.length >= params.length) {
-        for (const [index, param] of params.entries()) {
-            const signatureParameter = signature.parameters[index];
-            const paramType = context.checker.getTypeAtLocation(param);
-            if (signatureParameter.valueDeclaration !== undefined) {
-                const signatureType = context.checker.getTypeAtLocation(signatureParameter.valueDeclaration);
-                (0, assignment_validation_1.validateAssignment)(context, param, paramType, signatureType, signatureParameter.name);
-            }
+        transformedContext = context.transformExpression(callContext);
+    }
+    if (argPrecedingStatements.length > 0) {
+        if (transformedContext) {
+            transformedContext = (0, expression_list_1.moveToPrecedingTemp)(context, transformedContext, callContext);
         }
+        call = (0, expression_list_1.moveToPrecedingTemp)(context, call, callExpression);
+        context.addPrecedingStatements(argPrecedingStatements);
     }
-    return parameters;
+    if (transformedContext) {
+        transformedArguments.unshift(transformedContext);
+    }
+    return [call, transformedArguments];
 }
-exports.transformArguments = transformArguments;
-function transformElementAccessCall(context, left, args, signature) {
-    const transformedArguments = transformArguments(context, args, signature, ts.factory.createIdentifier("____self"));
+function transformCallAndArguments(context, callExpression, params, signature, callContext) {
+    const [argPrecedingStatements, transformedArguments] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => transformArguments(context, params, signature, callContext));
+    return transformCallWithArguments(context, callExpression, transformedArguments, argPrecedingStatements);
+}
+exports.transformCallAndArguments = transformCallAndArguments;
+function transformElementAccessCall(context, left, transformedArguments, argPrecedingStatements) {
     // Cache left-side if it has effects
-    // (function() local ____self = context; return ____self[argument](parameters); end)()
+    // local ____self = context; return ____self[argument](parameters);
+    const selfIdentifier = lua.createIdentifier(context.createTempName("self"));
+    const callContext = context.transformExpression(left.expression);
+    const selfAssignment = lua.createVariableDeclarationStatement(selfIdentifier, callContext);
+    context.addPrecedingStatements(selfAssignment);
     const argument = ts.isElementAccessExpression(left)
         ? (0, access_1.transformElementAccessArgument)(context, left)
         : lua.createStringLiteral(left.name.text);
-    const selfIdentifier = lua.createIdentifier("____self");
-    const callContext = context.transformExpression(left.expression);
-    const selfAssignment = lua.createVariableDeclarationStatement(selfIdentifier, callContext);
-    const index = lua.createTableIndexExpression(selfIdentifier, argument);
-    const callExpression = lua.createCallExpression(index, transformedArguments);
-    return { statements: selfAssignment, result: callExpression };
+    let index = lua.createTableIndexExpression(selfIdentifier, argument);
+    if (argPrecedingStatements.length > 0) {
+        // Cache index in temp if args had preceding statements
+        index = (0, expression_list_1.moveToPrecedingTemp)(context, index);
+        context.addPrecedingStatements(argPrecedingStatements);
+    }
+    return lua.createCallExpression(index, [selfIdentifier, ...transformedArguments]);
 }
 function transformContextualCallExpression(context, node, args, signature) {
+    if (ts.isOptionalChain(node)) {
+        return (0, optional_chaining_1.transformOptionalChain)(context, node);
+    }
     const left = ts.isCallExpression(node) ? node.expression : node.tag;
-    if (ts.isPropertyAccessExpression(left) && ts.isIdentifier(left.name) && (0, safe_names_1.isValidLuaIdentifier)(left.name.text)) {
+    let [argPrecedingStatements, transformedArguments] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => transformArguments(context, args, signature));
+    if (ts.isPropertyAccessExpression(left) &&
+        ts.isIdentifier(left.name) &&
+        (0, safe_names_1.isValidLuaIdentifier)(left.name.text) &&
+        argPrecedingStatements.length === 0) {
         // table:name()
         const table = context.transformExpression(left.expression);
-        if (ts.isOptionalChain(node)) {
-            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.OptionalMethodCall, node, table, lua.createStringLiteral(left.name.text, left.name), lua.createBooleanLiteral(node.questionDotToken !== undefined), // Require method is present if no ?.() call
-            ...transformArguments(context, args, signature));
-        }
-        else {
-            return lua.createMethodCallExpression(table, lua.createIdentifier(left.name.text, left.name), transformArguments(context, args, signature), node);
-        }
+        return lua.createMethodCallExpression(table, lua.createIdentifier(left.name.text, left.name), transformedArguments, node);
     }
     else if (ts.isElementAccessExpression(left) || ts.isPropertyAccessExpression(left)) {
         if ((0, typescript_1.isExpressionWithEvaluationEffect)(left.expression)) {
-            return (0, transform_1.transformToImmediatelyInvokedFunctionExpression)(context, () => transformElementAccessCall(context, left, args, signature), node);
+            return transformElementAccessCall(context, left, transformedArguments, argPrecedingStatements);
         }
         else {
-            const callContext = context.transformExpression(left.expression);
-            const expression = context.transformExpression(left);
-            const transformedArguments = transformArguments(context, args, signature);
-            return lua.createCallExpression(expression, [callContext, ...transformedArguments]);
+            let expression;
+            [expression, transformedArguments] = transformCallWithArguments(context, left, transformedArguments, argPrecedingStatements, left.expression);
+            return lua.createCallExpression(expression, transformedArguments, node);
         }
     }
     else if (ts.isIdentifier(left)) {
         const callContext = context.isStrict ? ts.factory.createNull() : ts.factory.createIdentifier("_G");
-        const transformedArguments = transformArguments(context, args, signature, callContext);
-        const expression = context.transformExpression(left);
+        let expression;
+        [expression, transformedArguments] = transformCallWithArguments(context, left, transformedArguments, argPrecedingStatements, callContext);
         return lua.createCallExpression(expression, transformedArguments, node);
     }
     else {
@@ -147,14 +127,8 @@ function transformPropertyCall(context, node) {
     }
     else {
         // table.name()
-        const callPath = context.transformExpression(node.expression);
-        const parameters = transformArguments(context, node.arguments, signature);
-        if (ts.isOptionalChain(node)) {
-            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.OptionalFunctionCall, node, callPath, ...parameters);
-        }
-        else {
-            return lua.createCallExpression(callPath, parameters, node);
-        }
+        const [callPath, parameters] = transformCallAndArguments(context, node.expression, node.arguments, signature);
+        return lua.createCallExpression(callPath, parameters, node);
     }
 }
 function transformElementCall(context, node) {
@@ -166,37 +140,58 @@ function transformElementCall(context, node) {
     }
     else {
         // No context
-        const expression = context.transformExpression(node.expression);
-        const parameters = transformArguments(context, node.arguments, signature);
+        const [expression, parameters] = transformCallAndArguments(context, node.expression, node.arguments, signature);
         return lua.createCallExpression(expression, parameters);
     }
 }
 const transformCallExpression = (node, context) => {
+    if (ts.isOptionalChain(node)) {
+        return (0, optional_chaining_1.transformOptionalChain)(context, node);
+    }
+    const optionalContinuation = ts.isIdentifier(node.expression)
+        ? (0, optional_chaining_1.getOptionalContinuationData)(node.expression)
+        : undefined;
     const wrapResultInTable = (0, multi_1.isMultiReturnCall)(context, node) && (0, multi_1.shouldMultiReturnCallBeWrapped)(context, node);
-    const wrapResultInOptional = ts.isOptionalChain(node);
-    const builtinResult = (0, builtins_1.transformBuiltinCallExpression)(context, node);
+    const builtinResult = (0, builtins_1.transformBuiltinCallExpression)(context, node, optionalContinuation !== undefined);
     if (builtinResult) {
+        if (optionalContinuation) {
+            context.diagnostics.push((0, diagnostics_1.unsupportedBuiltinOptionalCall)(node));
+        }
         return wrapResultInTable ? (0, lua_ast_1.wrapInTable)(builtinResult) : builtinResult;
     }
     if ((0, annotations_1.isTupleReturnCall)(context, node)) {
         context.diagnostics.push((0, diagnostics_1.annotationRemoved)(node, annotations_1.AnnotationKind.TupleReturn));
     }
     if ((0, operators_1.isOperatorMapping)(context, node)) {
+        if (optionalContinuation) {
+            context.diagnostics.push((0, diagnostics_1.unsupportedBuiltinOptionalCall)(node));
+            return lua.createNilLiteral();
+        }
         return (0, operators_1.transformOperatorMappingExpression)(context, node);
     }
     if ((0, table_1.isTableDeleteCall)(context, node)) {
         context.diagnostics.push((0, diagnostics_1.invalidTableDeleteExpression)(node));
-        return (0, transform_1.transformToImmediatelyInvokedFunctionExpression)(context, () => ({ statements: (0, table_1.transformTableDeleteExpression)(context, node), result: lua.createNilLiteral() }), node);
+        context.addPrecedingStatements((0, table_1.transformTableDeleteExpression)(context, node));
+        return lua.createNilLiteral();
     }
     if ((0, table_1.isTableGetCall)(context, node)) {
+        if (optionalContinuation) {
+            context.diagnostics.push((0, diagnostics_1.unsupportedBuiltinOptionalCall)(node));
+            return lua.createNilLiteral();
+        }
         return (0, table_1.transformTableGetExpression)(context, node);
     }
     if ((0, table_1.isTableHasCall)(context, node)) {
+        if (optionalContinuation) {
+            context.diagnostics.push((0, diagnostics_1.unsupportedBuiltinOptionalCall)(node));
+            return lua.createNilLiteral();
+        }
         return (0, table_1.transformTableHasExpression)(context, node);
     }
     if ((0, table_1.isTableSetCall)(context, node)) {
         context.diagnostics.push((0, diagnostics_1.invalidTableSetExpression)(node));
-        return (0, transform_1.transformToImmediatelyInvokedFunctionExpression)(context, () => ({ statements: (0, table_1.transformTableSetExpression)(context, node), result: lua.createNilLiteral() }), node);
+        context.addPrecedingStatements((0, table_1.transformTableSetExpression)(context, node));
+        return lua.createNilLiteral();
     }
     if (ts.isPropertyAccessExpression(node.expression)) {
         const ownerType = context.checker.getTypeAtLocation(node.expression.expression);
@@ -205,12 +200,11 @@ const transformCallExpression = (node, context) => {
             context.diagnostics.push((0, diagnostics_1.annotationRemoved)(node, annotations_1.AnnotationKind.LuaTable));
         }
         const result = transformPropertyCall(context, node);
-        // transformPropertyCall already wraps optional so no need to do so here
         return wrapResultInTable ? (0, lua_ast_1.wrapInTable)(result) : result;
     }
     if (ts.isElementAccessExpression(node.expression)) {
         const result = transformElementCall(context, node);
-        return wrapIfRequired(context, wrapResultInTable, wrapResultInOptional, result, node);
+        return wrapResultInTable ? (0, lua_ast_1.wrapInTable)(result) : result;
     }
     const signature = context.checker.getResolvedSignature(node);
     // Handle super calls properly
@@ -218,31 +212,24 @@ const transformCallExpression = (node, context) => {
         const parameters = transformArguments(context, node.arguments, signature, ts.factory.createThis());
         return lua.createCallExpression(lua.createTableIndexExpression(context.transformExpression(ts.factory.createSuper()), lua.createStringLiteral("____constructor")), parameters);
     }
-    const callPath = context.transformExpression(node.expression);
     const signatureDeclaration = signature === null || signature === void 0 ? void 0 : signature.getDeclaration();
-    let parameters = [];
-    if (signatureDeclaration && (0, function_context_1.getDeclarationContextType)(context, signatureDeclaration) === function_context_1.ContextType.Void) {
-        parameters = transformArguments(context, node.arguments, signature);
+    let callPath;
+    let parameters;
+    const isContextualCall = !signatureDeclaration || (0, function_context_1.getDeclarationContextType)(context, signatureDeclaration) !== function_context_1.ContextType.Void;
+    if (!isContextualCall) {
+        [callPath, parameters] = transformCallAndArguments(context, node.expression, node.arguments, signature);
     }
     else {
-        const callContext = context.isStrict ? ts.factory.createNull() : ts.factory.createIdentifier("_G");
-        parameters = transformArguments(context, node.arguments, signature, callContext);
+        // if is optionalContinuation, context will be handled by transformOptionalChain.
+        const useGlobalContext = !context.isStrict && optionalContinuation === undefined;
+        const callContext = useGlobalContext ? ts.factory.createIdentifier("_G") : ts.factory.createNull();
+        [callPath, parameters] = transformCallAndArguments(context, node.expression, node.arguments, signature, callContext);
     }
     const callExpression = lua.createCallExpression(callPath, parameters, node);
-    return wrapIfRequired(context, wrapResultInTable, wrapResultInOptional, callExpression, node);
+    if (optionalContinuation && isContextualCall) {
+        optionalContinuation.contextualCall = callExpression;
+    }
+    return wrapResultInTable ? (0, lua_ast_1.wrapInTable)(callExpression) : callExpression;
 };
 exports.transformCallExpression = transformCallExpression;
-function wrapIfRequired(context, shouldWrapInTable, shouldWrapOptional, call, node) {
-    const wrappedOptional = shouldWrapOptional ? wrapOptionalCall(context, call, node) : call;
-    return shouldWrapInTable ? (0, lua_ast_1.wrapInTable)(wrappedOptional) : wrappedOptional;
-}
-function wrapOptionalCall(context, call, node) {
-    if (lua.isMethodCallExpression(call)) {
-        return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.OptionalMethodCall, node, call.prefixExpression, lua.createStringLiteral(call.name.text), lua.createBooleanLiteral(node.questionDotToken !== undefined), // Require method is present if no ?.() call
-        ...call.params);
-    }
-    else {
-        return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.OptionalFunctionCall, node, call.expression, ...call.params);
-    }
-}
 //# sourceMappingURL=call.js.map

package/dist/transformation/visitors/class/index.js

@@ -9,7 +9,6 @@ const diagnostics_1 = require("../../utils/diagnostics");
 const export_1 = require("../../utils/export");
 const lua_ast_1 = require("../../utils/lua-ast");
 const safe_names_1 = require("../../utils/safe-names");
-const transform_1 = require("../../utils/transform");
 const identifier_1 = require("../identifier");
 const decorators_1 = require("./decorators");
 const accessors_1 = require("./members/accessors");
@@ -33,10 +32,9 @@ exports.transformClassDeclaration = transformClassDeclaration;
 const transformThisExpression = node => (0, lua_ast_1.createSelfIdentifier)(node);
 exports.transformThisExpression = transformThisExpression;
 function transformClassAsExpression(expression, context) {
-    return (0, transform_1.transformToImmediatelyInvokedFunctionExpression)(context, () => {
-        const { statements, name } = transformClassLikeDeclaration(expression, context);
-        return { statements: (0, lua_ast_1.unwrapVisitorResult)(statements), result: name };
-    }, expression);
+    const { statements, name } = transformClassLikeDeclaration(expression, context);
+    context.addPrecedingStatements(statements);
+    return name;
 }
 exports.transformClassAsExpression = transformClassAsExpression;
 const classSuperInfos = new WeakMap();
@@ -49,8 +47,7 @@ function transformClassLikeDeclaration(classDeclaration, context, nameOverride)
         className = (0, identifier_1.transformIdentifier)(context, classDeclaration.name);
     }
     else {
-        // TypeScript error
-        className = lua.createAnonymousIdentifier();
+        className = lua.createIdentifier(context.createTempName("class"), classDeclaration);
     }
     const annotations = (0, annotations_1.getTypeAnnotations)(context.checker.getTypeAtLocation(classDeclaration));
     if (annotations.has(annotations_1.AnnotationKind.Extension)) {

package/dist/transformation/visitors/class/new.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.transformNewExpression = exports.checkForLuaLibType = void 0;
+const ts = require("typescript");
 const lua = require("../../../LuaAST");
 const annotations_1 = require("../../utils/annotations");
 const diagnostics_1 = require("../../utils/diagnostics");
@@ -46,7 +47,7 @@ function checkForLuaLibType(context, type) {
 }
 exports.checkForLuaLibType = checkForLuaLibType;
 const transformNewExpression = (node, context) => {
-    var _a;
+    var _a, _b;
     const type = context.checker.getTypeAtLocation(node);
     const annotations = (0, annotations_1.getTypeAnnotations)(type);
     if (annotations.has(annotations_1.AnnotationKind.LuaTable)) {
@@ -56,15 +57,12 @@ const transformNewExpression = (node, context) => {
         return lua.createTableExpression(undefined, node);
     }
     const signature = context.checker.getResolvedSignature(node);
-    const params = node.arguments
-        ? (0, call_1.transformArguments)(context, node.arguments, signature)
-        : [lua.createBooleanLiteral(true)];
+    const [name, params] = (0, call_1.transformCallAndArguments)(context, node.expression, (_a = node.arguments) !== null && _a !== void 0 ? _a : [ts.factory.createTrue()], signature);
     checkForLuaLibType(context, type);
-    const name = context.transformExpression(node.expression);
     const customConstructorAnnotation = annotations.get(annotations_1.AnnotationKind.CustomConstructor);
     if (customConstructorAnnotation) {
         if (customConstructorAnnotation.args.length === 1) {
-            return lua.createCallExpression(lua.createIdentifier(customConstructorAnnotation.args[0]), (0, call_1.transformArguments)(context, (_a = node.arguments) !== null && _a !== void 0 ? _a : []), node);
+            return lua.createCallExpression(lua.createIdentifier(customConstructorAnnotation.args[0]), (0, call_1.transformArguments)(context, (_b = node.arguments) !== null && _b !== void 0 ? _b : []), node);
         }
         else {
             context.diagnostics.push((0, diagnostics_1.annotationInvalidArgumentCount)(node, annotations_1.AnnotationKind.CustomConstructor, customConstructorAnnotation.args.length, 1));

package/dist/transformation/visitors/conditional.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.transformIfStatement = exports.transformConditionalExpression = void 0;
 const ts = require("typescript");
 const lua = require("../../LuaAST");
+const preceding_statements_1 = require("../utils/preceding-statements");
 const scope_1 = require("../utils/scope");
 const block_1 = require("./block");
 function canBeFalsy(context, type) {
@@ -27,20 +28,18 @@ function canBeFalsy(context, type) {
         return false;
     }
 }
-function wrapInFunctionCall(expression) {
-    const returnStatement = lua.createReturnStatement([expression]);
-    return lua.createFunctionExpression(lua.createBlock([returnStatement]), undefined, undefined, lua.FunctionExpressionFlags.Inline);
-}
 function transformProtectedConditionalExpression(context, expression) {
+    const tempVar = context.createTempNameForNode(expression.condition);
     const condition = context.transformExpression(expression.condition);
-    const val1 = context.transformExpression(expression.whenTrue);
-    const val2 = context.transformExpression(expression.whenFalse);
-    const val1Function = wrapInFunctionCall(val1);
-    const val2Function = wrapInFunctionCall(val2);
-    // (condition and (() => v1) or (() => v2))()
-    const conditionAnd = lua.createBinaryExpression(condition, val1Function, lua.SyntaxKind.AndOperator);
-    const orExpression = lua.createBinaryExpression(conditionAnd, val2Function, lua.SyntaxKind.OrOperator);
-    return lua.createCallExpression(orExpression, [], expression);
+    const [trueStatements, val1] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(expression.whenTrue));
+    trueStatements.push(lua.createAssignmentStatement(lua.cloneIdentifier(tempVar), val1, expression.whenTrue));
+    const [falseStatements, val2] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(expression.whenFalse));
+    falseStatements.push(lua.createAssignmentStatement(lua.cloneIdentifier(tempVar), val2, expression.whenFalse));
+    context.addPrecedingStatements([
+        lua.createVariableDeclarationStatement(tempVar, undefined, expression.condition),
+        lua.createIfStatement(condition, lua.createBlock(trueStatements, expression.whenTrue), lua.createBlock(falseStatements, expression.whenFalse), expression),
+    ]);
+    return lua.cloneIdentifier(tempVar);
 }
 const transformConditionalExpression = (expression, context) => {
     if (canBeFalsy(context, context.checker.getTypeAtLocation(expression.whenTrue))) {
@@ -62,8 +61,23 @@ function transformIfStatement(statement, context) {
     const ifBlock = lua.createBlock(statements);
     if (statement.elseStatement) {
         if (ts.isIfStatement(statement.elseStatement)) {
-            const elseStatement = transformIfStatement(statement.elseStatement, context);
-            return lua.createIfStatement(condition, ifBlock, elseStatement);
+            const tsElseStatement = statement.elseStatement;
+            const [precedingStatements, elseStatement] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => transformIfStatement(tsElseStatement, context));
+            // If else-if condition generates preceding statements, we can't use elseif, we have to break it down:
+            // if conditionA then
+            //     ...
+            // else
+            //     conditionB's preceding statements
+            //     if conditionB then
+            //     end
+            // end
+            if (precedingStatements.length > 0) {
+                const elseBlock = lua.createBlock([...precedingStatements, elseStatement]);
+                return lua.createIfStatement(condition, ifBlock, elseBlock);
+            }
+            else {
+                return lua.createIfStatement(condition, ifBlock, elseStatement);
+            }
         }
         else {
             (0, scope_1.pushScope)(context, scope_1.ScopeType.Conditional);

package/dist/transformation/visitors/delete.js

@@ -7,7 +7,11 @@ const lualib_1 = require("../utils/lualib");
 const diagnostics_1 = require("../utils/diagnostics");
 const typescript_1 = require("../utils/typescript");
 const lua_ast_1 = require("../utils/lua-ast");
+const optional_chaining_1 = require("./optional-chaining");
 const transformDeleteExpression = (node, context) => {
+    if (ts.isOptionalChain(node.expression)) {
+        return (0, optional_chaining_1.transformOptionalDeleteExpression)(context, node, node.expression);
+    }
     let ownerExpression;
     let propertyExpression;
     if (ts.isPropertyAccessExpression(node.expression)) {

package/dist/transformation/visitors/expression-list.d.ts

@@ -0,0 +1,7 @@
+import * as ts from "typescript";
+import * as lua from "../../LuaAST";
+import { TransformationContext } from "../context";
+export declare function shouldMoveToTemp(context: TransformationContext, expression: lua.Expression, tsOriginal?: ts.Node): boolean;
+export declare function moveToPrecedingTemp(context: TransformationContext, expression: lua.Expression, tsOriginal?: ts.Node): lua.Expression;
+export declare function transformExpressionList(context: TransformationContext, expressions: readonly ts.Expression[]): lua.Expression[];
+export declare function transformOrderedExpressions(context: TransformationContext, expressions: readonly ts.Expression[]): lua.Expression[];

package/dist/transformation/visitors/expression-list.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformOrderedExpressions = exports.transformExpressionList = exports.moveToPrecedingTemp = exports.shouldMoveToTemp = void 0;
+const assert = require("assert");
+const ts = require("typescript");
+const lua = require("../../LuaAST");
+const context_1 = require("../context");
+const lualib_1 = require("../utils/lualib");
+const preceding_statements_1 = require("../utils/preceding-statements");
+const typescript_1 = require("../utils/typescript");
+const optional_chaining_1 = require("./optional-chaining");
+function shouldMoveToTemp(context, expression, tsOriginal) {
+    return (!lua.isLiteral(expression) &&
+        !(lua.isIdentifier(expression) && expression.symbolId === context_1.tempSymbolId) && // Treat generated temps as consts
+        !(tsOriginal && ((0, typescript_1.isConstIdentifier)(context, tsOriginal) || (0, optional_chaining_1.isOptionalContinuation)(tsOriginal))));
+}
+exports.shouldMoveToTemp = shouldMoveToTemp;
+// Cache an expression in a preceding statement and return the temp identifier
+function moveToPrecedingTemp(context, expression, tsOriginal) {
+    if (!shouldMoveToTemp(context, expression, tsOriginal)) {
+        return expression;
+    }
+    const tempIdentifier = context.createTempNameForLuaExpression(expression);
+    const tempDeclaration = lua.createVariableDeclarationStatement(tempIdentifier, expression, tsOriginal);
+    context.addPrecedingStatements(tempDeclaration);
+    return lua.cloneIdentifier(tempIdentifier, tsOriginal);
+}
+exports.moveToPrecedingTemp = moveToPrecedingTemp;
+function transformExpressions(context, expressions) {
+    const precedingStatements = [];
+    const transformedExpressions = [];
+    let lastPrecedingStatementsIndex = -1;
+    for (let i = 0; i < expressions.length; ++i) {
+        const [expressionPrecedingStatements, expression] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(expressions[i]));
+        transformedExpressions.push(expression);
+        if (expressionPrecedingStatements.length > 0) {
+            lastPrecedingStatementsIndex = i;
+        }
+        precedingStatements.push(expressionPrecedingStatements);
+    }
+    return { transformedExpressions, precedingStatements, lastPrecedingStatementsIndex };
+}
+function transformExpressionsUsingTemps(context, expressions, transformedExpressions, precedingStatements, lastPrecedingStatementsIndex) {
+    for (let i = 0; i < transformedExpressions.length; ++i) {
+        context.addPrecedingStatements(precedingStatements[i]);
+        if (i < lastPrecedingStatementsIndex) {
+            transformedExpressions[i] = moveToPrecedingTemp(context, transformedExpressions[i], expressions[i]);
+        }
+    }
+    return transformedExpressions;
+}
+function pushToSparseArray(context, arrayIdentifier, expressions) {
+    if (!arrayIdentifier) {
+        arrayIdentifier = lua.createIdentifier(context.createTempName("array"));
+        const libCall = (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.SparseArrayNew, undefined, ...expressions);
+        const declaration = lua.createVariableDeclarationStatement(arrayIdentifier, libCall);
+        context.addPrecedingStatements(declaration);
+    }
+    else {
+        const libCall = (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.SparseArrayPush, undefined, arrayIdentifier, ...expressions);
+        context.addPrecedingStatements(lua.createExpressionStatement(libCall));
+    }
+    return arrayIdentifier;
+}
+function transformExpressionsUsingSparseArray(context, expressions, transformedExpressions, precedingStatements) {
+    let arrayIdentifier;
+    let expressionBatch = [];
+    for (let i = 0; i < expressions.length; ++i) {
+        // Expressions with preceding statements should always be at the start of a batch
+        if (precedingStatements[i].length > 0 && expressionBatch.length > 0) {
+            arrayIdentifier = pushToSparseArray(context, arrayIdentifier, expressionBatch);
+            expressionBatch = [];
+        }
+        context.addPrecedingStatements(precedingStatements[i]);
+        expressionBatch.push(transformedExpressions[i]);
+        // Spread expressions should always be at the end of a batch
+        if (ts.isSpreadElement(expressions[i])) {
+            arrayIdentifier = pushToSparseArray(context, arrayIdentifier, expressionBatch);
+            expressionBatch = [];
+        }
+    }
+    if (expressionBatch.length > 0) {
+        arrayIdentifier = pushToSparseArray(context, arrayIdentifier, expressionBatch);
+    }
+    assert(arrayIdentifier);
+    return [(0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.SparseArraySpread, undefined, arrayIdentifier)];
+}
+function countNeededTemps(context, expressions, transformedExpressions, lastPrecedingStatementsIndex) {
+    if (lastPrecedingStatementsIndex < 0) {
+        return 0;
+    }
+    return transformedExpressions
+        .slice(0, lastPrecedingStatementsIndex)
+        .filter((e, i) => shouldMoveToTemp(context, e, expressions[i])).length;
+}
+// Transforms a list of expressions while flattening spreads and maintaining execution order
+function transformExpressionList(context, expressions) {
+    const { transformedExpressions, precedingStatements, lastPrecedingStatementsIndex } = transformExpressions(context, expressions);
+    // If more than this number of temps are required to preserve execution order, we'll fall back to using the
+    // sparse array lib functions instead to prevent excessive locals.
+    const maxTemps = 2;
+    // Use sparse array lib if there are spreads before the last expression
+    // or if too many temps are needed to preserve order
+    const lastSpread = expressions.findIndex(e => ts.isSpreadElement(e));
+    if ((lastSpread >= 0 && lastSpread < expressions.length - 1) ||
+        countNeededTemps(context, expressions, transformedExpressions, lastPrecedingStatementsIndex) > maxTemps) {
+        return transformExpressionsUsingSparseArray(context, expressions, transformedExpressions, precedingStatements);
+    }
+    else {
+        return transformExpressionsUsingTemps(context, expressions, transformedExpressions, precedingStatements, lastPrecedingStatementsIndex);
+    }
+}
+exports.transformExpressionList = transformExpressionList;
+// Transforms a series of expressions while maintaining execution order
+function transformOrderedExpressions(context, expressions) {
+    const { transformedExpressions, precedingStatements, lastPrecedingStatementsIndex } = transformExpressions(context, expressions);
+    return transformExpressionsUsingTemps(context, expressions, transformedExpressions, precedingStatements, lastPrecedingStatementsIndex);
+}
+exports.transformOrderedExpressions = transformOrderedExpressions;
+//# sourceMappingURL=expression-list.js.map