typescript-to-lua 1.0.1 → 1.3.0

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

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

package/dist/transformation/visitors/block.js

@@ -9,16 +9,16 @@ function transformBlockOrStatement(context, statement) {
 }
 exports.transformBlockOrStatement = transformBlockOrStatement;
 function transformScopeBlock(context, node, scopeType) {
-    scope_1.pushScope(context, scopeType);
-    const statements = scope_1.performHoisting(context, context.transformStatements(node.statements));
-    const scope = scope_1.popScope(context);
+    (0, scope_1.pushScope)(context, scopeType);
+    const statements = (0, scope_1.performHoisting)(context, context.transformStatements(node.statements));
+    const scope = (0, scope_1.popScope)(context);
     return [lua.createBlock(statements, node), scope];
 }
 exports.transformScopeBlock = transformScopeBlock;
 const transformBlock = (node, context) => {
-    scope_1.pushScope(context, scope_1.ScopeType.Block);
-    const statements = scope_1.performHoisting(context, context.transformStatements(node.statements));
-    scope_1.popScope(context);
+    (0, scope_1.pushScope)(context, scope_1.ScopeType.Block);
+    const statements = (0, scope_1.performHoisting)(context, context.transformStatements(node.statements));
+    (0, scope_1.popScope)(context);
     return lua.createDoStatement(statements, node);
 };
 exports.transformBlock = transformBlock;

package/dist/transformation/visitors/break-continue.js

@@ -13,9 +13,9 @@ exports.transformBreakStatement = transformBreakStatement;
 const transformContinueStatement = (statement, context) => {
     var _a;
     if (context.luaTarget === CompilerOptions_1.LuaTarget.Universal || context.luaTarget === CompilerOptions_1.LuaTarget.Lua51) {
-        context.diagnostics.push(diagnostics_1.unsupportedForTarget(statement, "Continue statement", CompilerOptions_1.LuaTarget.Lua51));
+        context.diagnostics.push((0, diagnostics_1.unsupportedForTarget)(statement, "Continue statement", CompilerOptions_1.LuaTarget.Lua51));
     }
-    const scope = scope_1.findScope(context, scope_1.ScopeType.Loop);
+    const scope = (0, scope_1.findScope)(context, scope_1.ScopeType.Loop);
     if (scope) {
         scope.loopContinued = true;
     }

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

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

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 => 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 = lua_ast_1.createUnpackCall(context, 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);
-                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)()
-    const argument = ts.isElementAccessExpression(left)
-        ? access_1.transformElementAccessArgument(context, left)
-        : lua.createStringLiteral(left.name.text);
-    const selfIdentifier = lua.createIdentifier("____self");
+    // 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);
-    const index = lua.createTableIndexExpression(selfIdentifier, argument);
-    const callExpression = lua.createCallExpression(index, transformedArguments);
-    return { statements: selfAssignment, result: callExpression };
+    context.addPrecedingStatements(selfAssignment);
+    const argument = ts.isElementAccessExpression(left)
+        ? (0, access_1.transformElementAccessArgument)(context, left)
+        : lua.createStringLiteral(left.name.text);
+    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) && 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, context.options) &&
+        argPrecedingStatements.length === 0) {
         // table:name()
         const table = context.transformExpression(left.expression);
-        if (ts.isOptionalChain(node)) {
-            return 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 (typescript_1.isExpressionWithEvaluationEffect(left.expression)) {
-            return transform_1.transformToImmediatelyInvokedFunctionExpression(context, () => transformElementAccessCall(context, left, args, signature), node);
+        if ((0, typescript_1.isExpressionWithEvaluationEffect)(left.expression)) {
+            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 {
@@ -141,76 +121,90 @@ function transformPropertyCall(context, node) {
         return lua.createCallExpression(context.transformExpression(node.expression), parameters);
     }
     const signatureDeclaration = signature === null || signature === void 0 ? void 0 : signature.getDeclaration();
-    if (!signatureDeclaration || function_context_1.getDeclarationContextType(context, signatureDeclaration) !== function_context_1.ContextType.Void) {
+    if (!signatureDeclaration || (0, function_context_1.getDeclarationContextType)(context, signatureDeclaration) !== function_context_1.ContextType.Void) {
         // table:name()
         return transformContextualCallExpression(context, node, node.arguments, signature);
     }
     else {
         // table.name()
-        const callPath = context.transformExpression(node.expression);
-        const parameters = transformArguments(context, node.arguments, signature);
-        if (ts.isOptionalChain(node)) {
-            return 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) {
     const signature = context.checker.getResolvedSignature(node);
     const signatureDeclaration = signature === null || signature === void 0 ? void 0 : signature.getDeclaration();
-    if (!signatureDeclaration || function_context_1.getDeclarationContextType(context, signatureDeclaration) !== function_context_1.ContextType.Void) {
+    if (!signatureDeclaration || (0, function_context_1.getDeclarationContextType)(context, signatureDeclaration) !== function_context_1.ContextType.Void) {
         // A contextual parameter must be given to this call expression
         return transformContextualCallExpression(context, node, node.arguments, signature);
     }
     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) => {
-    const wrapResultInTable = multi_1.isMultiReturnCall(context, node) && multi_1.shouldMultiReturnCallBeWrapped(context, node);
-    const wrapResultInOptional = ts.isOptionalChain(node);
-    const builtinResult = builtins_1.transformBuiltinCallExpression(context, node);
+    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 builtinResult = (0, builtins_1.transformBuiltinCallExpression)(context, node, optionalContinuation !== undefined);
     if (builtinResult) {
-        return wrapResultInTable ? lua_ast_1.wrapInTable(builtinResult) : builtinResult;
+        if (optionalContinuation) {
+            context.diagnostics.push((0, diagnostics_1.unsupportedBuiltinOptionalCall)(node));
+        }
+        return wrapResultInTable ? (0, lua_ast_1.wrapInTable)(builtinResult) : builtinResult;
     }
-    if (annotations_1.isTupleReturnCall(context, node)) {
-        context.diagnostics.push(diagnostics_1.annotationRemoved(node, annotations_1.AnnotationKind.TupleReturn));
+    if ((0, annotations_1.isTupleReturnCall)(context, node)) {
+        context.diagnostics.push((0, diagnostics_1.annotationRemoved)(node, annotations_1.AnnotationKind.TupleReturn));
     }
-    if (operators_1.isOperatorMapping(context, node)) {
-        return operators_1.transformOperatorMappingExpression(context, node);
+    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 (table_1.isTableDeleteCall(context, node)) {
-        context.diagnostics.push(diagnostics_1.invalidTableDeleteExpression(node));
-        return transform_1.transformToImmediatelyInvokedFunctionExpression(context, () => ({ statements: table_1.transformTableDeleteExpression(context, node), result: lua.createNilLiteral() }), node);
+    if ((0, table_1.isTableDeleteCall)(context, node)) {
+        context.diagnostics.push((0, diagnostics_1.invalidTableDeleteExpression)(node));
+        context.addPrecedingStatements((0, table_1.transformTableDeleteExpression)(context, node));
+        return lua.createNilLiteral();
     }
-    if (table_1.isTableGetCall(context, node)) {
-        return table_1.transformTableGetExpression(context, node);
+    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 (table_1.isTableHasCall(context, node)) {
-        return table_1.transformTableHasExpression(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 (table_1.isTableSetCall(context, node)) {
-        context.diagnostics.push(diagnostics_1.invalidTableSetExpression(node));
-        return transform_1.transformToImmediatelyInvokedFunctionExpression(context, () => ({ statements: table_1.transformTableSetExpression(context, node), result: lua.createNilLiteral() }), node);
+    if ((0, table_1.isTableSetCall)(context, node)) {
+        context.diagnostics.push((0, diagnostics_1.invalidTableSetExpression)(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);
-        const annotations = annotations_1.getTypeAnnotations(ownerType);
+        const annotations = (0, annotations_1.getTypeAnnotations)(ownerType);
         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 result = transformPropertyCall(context, node);
-        // transformPropertyCall already wraps optional so no need to do so here
-        return wrapResultInTable ? lua_ast_1.wrapInTable(result) : result;
+        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 && 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 ? lua_ast_1.wrapInTable(wrappedOptional) : wrappedOptional;
-}
-function wrapOptionalCall(context, call, node) {
-    if (lua.isMethodCallExpression(call)) {
-        return 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 lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.OptionalFunctionCall, node, call.expression, ...call.params);
-    }
-}
 //# sourceMappingURL=call.js.map