typescript-to-lua 1.0.1 → 1.3.0

package/dist/transformation/visitors/optional-chaining.js

@@ -0,0 +1,172 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformOptionalDeleteExpression = exports.transformOptionalChainWithCapture = exports.transformOptionalChain = exports.getOptionalContinuationData = exports.isOptionalContinuation = exports.captureThisValue = void 0;
+const ts = require("typescript");
+const lua = require("../../LuaAST");
+const context_1 = require("../context");
+const utils_1 = require("../../utils");
+const preceding_statements_1 = require("../utils/preceding-statements");
+const access_1 = require("./access");
+const expression_list_1 = require("./expression-list");
+function skipNonNullChains(chain) {
+    while (ts.isNonNullChain(chain)) {
+        chain = chain.expression;
+    }
+    return chain;
+}
+function flattenChain(chain) {
+    chain = skipNonNullChains(chain);
+    const links = [chain];
+    while (!chain.questionDotToken && !ts.isTaggedTemplateExpression(chain)) {
+        const nextLink = chain.expression;
+        (0, utils_1.assert)(ts.isOptionalChain(nextLink));
+        chain = skipNonNullChains(nextLink);
+        links.unshift(chain);
+    }
+    return { expression: chain.expression, chain: links };
+}
+function transformExpressionWithThisValueCapture(context, node, thisValueCapture) {
+    if (ts.isParenthesizedExpression(node)) {
+        return transformExpressionWithThisValueCapture(context, node.expression, thisValueCapture);
+    }
+    if (ts.isPropertyAccessExpression(node)) {
+        return (0, access_1.transformPropertyAccessExpressionWithCapture)(context, node, thisValueCapture);
+    }
+    if (ts.isElementAccessExpression(node)) {
+        return (0, access_1.transformElementAccessExpressionWithCapture)(context, node, thisValueCapture);
+    }
+    return { expression: context.transformExpression(node) };
+}
+// returns thisValueCapture exactly if a temp variable was used.
+function captureThisValue(context, expression, thisValueCapture, tsOriginal) {
+    if (!(0, expression_list_1.shouldMoveToTemp)(context, expression, tsOriginal) && !isOptionalContinuation(tsOriginal)) {
+        return expression;
+    }
+    const tempAssignment = lua.createAssignmentStatement(thisValueCapture, expression, tsOriginal);
+    context.addPrecedingStatements(tempAssignment);
+    return thisValueCapture;
+}
+exports.captureThisValue = captureThisValue;
+const optionalContinuations = new WeakMap();
+// should be translated verbatim to lua
+function createOptionalContinuationIdentifier(text, tsOriginal) {
+    const identifier = ts.factory.createIdentifier(text);
+    ts.setOriginalNode(identifier, tsOriginal);
+    optionalContinuations.set(identifier, {});
+    return identifier;
+}
+function isOptionalContinuation(node) {
+    return ts.isIdentifier(node) && optionalContinuations.has(node);
+}
+exports.isOptionalContinuation = isOptionalContinuation;
+function getOptionalContinuationData(identifier) {
+    return optionalContinuations.get(identifier);
+}
+exports.getOptionalContinuationData = getOptionalContinuationData;
+function transformOptionalChain(context, node) {
+    return transformOptionalChainWithCapture(context, node, undefined).expression;
+}
+exports.transformOptionalChain = transformOptionalChain;
+function transformOptionalChainWithCapture(context, node, thisValueCapture, isDelete) {
+    var _a;
+    const luaTemp = context.createTempNameForNode(node);
+    const { expression: tsLeftExpression, chain } = flattenChain(node);
+    // build temp.b.c.d
+    const tsTemp = createOptionalContinuationIdentifier(luaTemp.text, tsLeftExpression);
+    let tsRightExpression = tsTemp;
+    for (const link of chain) {
+        if (ts.isPropertyAccessExpression(link)) {
+            tsRightExpression = ts.factory.createPropertyAccessExpression(tsRightExpression, link.name);
+        }
+        else if (ts.isElementAccessExpression(link)) {
+            tsRightExpression = ts.factory.createElementAccessExpression(tsRightExpression, link.argumentExpression);
+        }
+        else if (ts.isCallExpression(link)) {
+            tsRightExpression = ts.factory.createCallExpression(tsRightExpression, undefined, link.arguments);
+        }
+        else {
+            (0, utils_1.assertNever)(link);
+        }
+        ts.setOriginalNode(tsRightExpression, link);
+    }
+    if (isDelete) {
+        tsRightExpression = ts.factory.createDeleteExpression(tsRightExpression);
+        ts.setOriginalNode(tsRightExpression, isDelete);
+    }
+    // transform right expression first to check if thisValue capture is needed
+    // capture and return thisValue if requested from outside
+    let returnThisValue;
+    const [rightPrecedingStatements, rightAssignment] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => {
+        let result;
+        if (thisValueCapture) {
+            ({ expression: result, thisValue: returnThisValue } = transformExpressionWithThisValueCapture(context, tsRightExpression, thisValueCapture));
+        }
+        else {
+            result = context.transformExpression(tsRightExpression);
+        }
+        return lua.createAssignmentStatement(luaTemp, result);
+    });
+    // transform left expression, handle thisValue if needed by rightExpression
+    const thisValueCaptureName = context.createTempName("this");
+    const leftThisValueTemp = lua.createIdentifier(thisValueCaptureName, undefined, context_1.tempSymbolId);
+    let capturedThisValue;
+    const rightContextualCall = (_a = getOptionalContinuationData(tsTemp)) === null || _a === void 0 ? void 0 : _a.contextualCall;
+    const [leftPrecedingStatements, leftExpression] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => {
+        let result;
+        if (rightContextualCall) {
+            ({ expression: result, thisValue: capturedThisValue } = transformExpressionWithThisValueCapture(context, tsLeftExpression, leftThisValueTemp));
+        }
+        else {
+            result = context.transformExpression(tsLeftExpression);
+        }
+        return result;
+    });
+    // handle context
+    if (rightContextualCall) {
+        if (capturedThisValue) {
+            rightContextualCall.params[0] = capturedThisValue;
+            if (capturedThisValue === leftThisValueTemp) {
+                context.addPrecedingStatements(lua.createVariableDeclarationStatement(leftThisValueTemp));
+            }
+        }
+        else {
+            if (context.isStrict) {
+                rightContextualCall.params[0] = lua.createNilLiteral();
+            }
+            else {
+                const identifier = lua.createIdentifier("_G");
+                if (rightPrecedingStatements.length === 0) {
+                    rightContextualCall.params[0] = identifier;
+                }
+                else {
+                    const tempContext = context.createTempNameForLuaExpression(identifier);
+                    rightPrecedingStatements.unshift(lua.createVariableDeclarationStatement(tempContext, identifier));
+                    rightContextualCall.params[0] = tempContext;
+                }
+            }
+        }
+    }
+    // <left preceding statements>
+    // local temp = <left>
+    // if temp ~= nil then
+    //   <right preceding statements>
+    //   temp = temp.b.c.d
+    // end
+    // return temp
+    context.addPrecedingStatements([
+        ...leftPrecedingStatements,
+        lua.createVariableDeclarationStatement(luaTemp, leftExpression),
+        lua.createIfStatement(lua.createBinaryExpression(luaTemp, lua.createNilLiteral(), lua.SyntaxKind.InequalityOperator), lua.createBlock([...rightPrecedingStatements, rightAssignment])),
+    ]);
+    return {
+        expression: luaTemp,
+        thisValue: returnThisValue,
+    };
+}
+exports.transformOptionalChainWithCapture = transformOptionalChainWithCapture;
+function transformOptionalDeleteExpression(context, node, innerExpression) {
+    transformOptionalChainWithCapture(context, innerExpression, undefined, node);
+    return lua.createBooleanLiteral(true, node);
+}
+exports.transformOptionalDeleteExpression = transformOptionalDeleteExpression;
+//# sourceMappingURL=optional-chaining.js.map

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

@@ -3,3 +3,4 @@ import * as lua from "../../LuaAST";
 import { FunctionVisitor, TransformationContext } from "../context";
 export declare function transformExpressionBodyToReturnStatement(context: TransformationContext, node: ts.Expression): lua.Statement;
 export declare const transformReturnStatement: FunctionVisitor<ts.ReturnStatement>;
+export declare function createReturnStatement(context: TransformationContext, values: lua.Expression[], node: ts.Node): lua.ReturnStatement;

package/dist/transformation/visitors/return.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformReturnStatement = exports.transformExpressionBodyToReturnStatement = void 0;
+exports.createReturnStatement = exports.transformReturnStatement = exports.transformExpressionBodyToReturnStatement = void 0;
 const ts = require("typescript");
 const lua = require("../../LuaAST");
 const assignment_validation_1 = require("../utils/assignment-validation");
@@ -9,65 +9,79 @@ const scope_1 = require("../utils/scope");
 const call_1 = require("./call");
 const multi_1 = require("./language-extensions/multi");
 const diagnostics_1 = require("../utils/diagnostics");
+const typescript_1 = require("../utils/typescript");
 function transformExpressionsInReturn(context, node, insideTryCatch) {
     const expressionType = context.checker.getTypeAtLocation(node);
     if (ts.isCallExpression(node)) {
         // $multi(...)
-        if (multi_1.isMultiFunctionCall(context, node)) {
+        if ((0, multi_1.isMultiFunctionCall)(context, node)) {
             // Don't allow $multi to be implicitly cast to something other than LuaMultiReturn
             const type = context.checker.getContextualType(node);
-            if (type && !multi_1.canBeMultiReturnType(type)) {
-                context.diagnostics.push(diagnostics_1.invalidMultiFunctionReturnType(node));
+            if (type && !(0, multi_1.canBeMultiReturnType)(type)) {
+                context.diagnostics.push((0, diagnostics_1.invalidMultiFunctionReturnType)(node));
             }
-            let returnValues = call_1.transformArguments(context, node.arguments);
+            let returnValues = (0, call_1.transformArguments)(context, node.arguments);
             if (insideTryCatch) {
-                returnValues = [lua_ast_1.wrapInTable(...returnValues)]; // Wrap results when returning inside try/catch
+                returnValues = [(0, lua_ast_1.wrapInTable)(...returnValues)]; // Wrap results when returning inside try/catch
             }
             return returnValues;
         }
         // Force-wrap LuaMultiReturn when returning inside try/catch
-        if (insideTryCatch && multi_1.returnsMultiType(context, node) && !multi_1.shouldMultiReturnCallBeWrapped(context, node)) {
-            return [lua_ast_1.wrapInTable(context.transformExpression(node))];
+        if (insideTryCatch && (0, multi_1.returnsMultiType)(context, node) && !(0, multi_1.shouldMultiReturnCallBeWrapped)(context, node)) {
+            return [(0, lua_ast_1.wrapInTable)(context.transformExpression(node))];
         }
     }
-    else if (multi_1.isInMultiReturnFunction(context, node) && multi_1.isMultiReturnType(expressionType)) {
+    else if ((0, multi_1.isInMultiReturnFunction)(context, node) && (0, multi_1.isMultiReturnType)(expressionType)) {
         // Unpack objects typed as LuaMultiReturn
-        return [lua_ast_1.createUnpackCall(context, context.transformExpression(node), node)];
+        return [(0, lua_ast_1.createUnpackCall)(context, context.transformExpression(node), node)];
     }
     return [context.transformExpression(node)];
 }
 function transformExpressionBodyToReturnStatement(context, node) {
     const expressions = transformExpressionsInReturn(context, node, false);
-    return lua.createReturnStatement(expressions, node);
+    return createReturnStatement(context, expressions, node);
 }
 exports.transformExpressionBodyToReturnStatement = transformExpressionBodyToReturnStatement;
 const transformReturnStatement = (statement, context) => {
-    // Bubble up explicit return flag and check if we're inside a try/catch block
-    let insideTryCatch = false;
-    for (const scope of scope_1.walkScopesUp(context)) {
-        scope.functionReturned = true;
-        if (scope.type === scope_1.ScopeType.Function) {
-            break;
-        }
-        insideTryCatch = insideTryCatch || scope.type === scope_1.ScopeType.Try || scope.type === scope_1.ScopeType.Catch;
-    }
     let results;
     if (statement.expression) {
         const expressionType = context.checker.getTypeAtLocation(statement.expression);
         const returnType = context.checker.getContextualType(statement.expression);
         if (returnType) {
-            assignment_validation_1.validateAssignment(context, statement, expressionType, returnType);
+            (0, assignment_validation_1.validateAssignment)(context, statement, expressionType, returnType);
         }
-        results = transformExpressionsInReturn(context, statement.expression, insideTryCatch);
+        results = transformExpressionsInReturn(context, statement.expression, isInTryCatch(context));
     }
     else {
         // Empty return
         results = [];
     }
-    if (insideTryCatch) {
-        results.unshift(lua.createBooleanLiteral(true));
-    }
-    return lua.createReturnStatement(results, statement);
+    return createReturnStatement(context, results, statement);
 };
 exports.transformReturnStatement = transformReturnStatement;
+function createReturnStatement(context, values, node) {
+    const results = [...values];
+    if (isInTryCatch(context)) {
+        // Bubble up explicit return flag and check if we're inside a try/catch block
+        results.unshift(lua.createBooleanLiteral(true));
+    }
+    else if ((0, typescript_1.isInAsyncFunction)(node)) {
+        // Add nil error handler in async function and not in try
+        results.unshift(lua.createNilLiteral());
+    }
+    return lua.createReturnStatement(results, node);
+}
+exports.createReturnStatement = createReturnStatement;
+function isInTryCatch(context) {
+    // Check if context is in a try or catch
+    let insideTryCatch = false;
+    for (const scope of (0, scope_1.walkScopesUp)(context)) {
+        scope.functionReturned = true;
+        if (scope.type === scope_1.ScopeType.Function) {
+            break;
+        }
+        insideTryCatch = insideTryCatch || scope.type === scope_1.ScopeType.Try || scope.type === scope_1.ScopeType.Catch;
+    }
+    return insideTryCatch;
+}
 //# sourceMappingURL=return.js.map

package/dist/transformation/visitors/sourceFile.js

@@ -6,6 +6,7 @@ const lua = require("../../LuaAST");
 const utils_1 = require("../../utils");
 const lua_ast_1 = require("../utils/lua-ast");
 const lualib_1 = require("../utils/lualib");
+const preceding_statements_1 = require("../utils/preceding-statements");
 const scope_1 = require("../utils/scope");
 const typescript_1 = require("../utils/typescript");
 const transformSourceFileNode = (node, context) => {
@@ -14,8 +15,10 @@ const transformSourceFileNode = (node, context) => {
     if (node.flags & ts.NodeFlags.JsonFile) {
         const [statement] = node.statements;
         if (statement) {
-            utils_1.assert(ts.isExpressionStatement(statement));
-            statements.push(lua.createReturnStatement([context.transformExpression(statement.expression)]));
+            (0, utils_1.assert)(ts.isExpressionStatement(statement));
+            const [precedingStatements, expression] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(statement.expression));
+            statements.push(...precedingStatements);
+            statements.push(lua.createReturnStatement([expression]));
         }
         else {
             const errorCall = lua.createCallExpression(lua.createIdentifier("error"), [
@@ -25,21 +28,21 @@ const transformSourceFileNode = (node, context) => {
         }
     }
     else {
-        scope_1.pushScope(context, scope_1.ScopeType.File);
-        statements = scope_1.performHoisting(context, context.transformStatements(node.statements));
-        scope_1.popScope(context);
+        (0, scope_1.pushScope)(context, scope_1.ScopeType.File);
+        statements = (0, scope_1.performHoisting)(context, context.transformStatements(node.statements));
+        (0, scope_1.popScope)(context);
         if (context.isModule) {
             // If export equals was not used. Create the exports table.
             // local ____exports = {}
-            if (!typescript_1.hasExportEquals(node)) {
-                statements.unshift(lua.createVariableDeclarationStatement(lua_ast_1.createExportsIdentifier(), lua.createTableExpression()));
+            if (!(0, typescript_1.hasExportEquals)(node)) {
+                statements.unshift(lua.createVariableDeclarationStatement((0, lua_ast_1.createExportsIdentifier)(), lua.createTableExpression()));
             }
             // return ____exports
-            statements.push(lua.createReturnStatement([lua_ast_1.createExportsIdentifier()]));
+            statements.push(lua.createReturnStatement([(0, lua_ast_1.createExportsIdentifier)()]));
         }
     }
     const trivia = (_b = (_a = node.getFullText().match(/^#!.*\r?\n/)) === null || _a === void 0 ? void 0 : _a[0]) !== null && _b !== void 0 ? _b : "";
-    return lua.createFile(statements, lualib_1.getUsedLuaLibFeatures(context), trivia, node);
+    return lua.createFile(statements, (0, lualib_1.getUsedLuaLibFeatures)(context), trivia, node);
 };
 exports.transformSourceFileNode = transformSourceFileNode;
 //# sourceMappingURL=sourceFile.js.map

package/dist/transformation/visitors/spread.js

@@ -11,22 +11,28 @@ const typescript_1 = require("../utils/typescript");
 const multi_1 = require("./language-extensions/multi");
 const diagnostics_1 = require("../utils/diagnostics");
 const vararg_1 = require("./language-extensions/vararg");
+function skipOuterExpressionParents(node) {
+    while (ts.isOuterExpression(node)) {
+        node = node.parent;
+    }
+    return node;
+}
 function isOptimizedVarArgSpread(context, symbol, identifier) {
     var _a;
-    if (!ts.isSpreadElement(identifier.parent)) {
+    if (!ts.isSpreadElement(skipOuterExpressionParents(identifier.parent))) {
         return false;
     }
     // Walk up, stopping at any scope types which could stop optimization
-    const scope = scope_1.findScope(context, scope_1.ScopeType.Function | scope_1.ScopeType.Try | scope_1.ScopeType.Catch | scope_1.ScopeType.File);
+    const scope = (0, scope_1.findScope)(context, scope_1.ScopeType.Function | scope_1.ScopeType.Try | scope_1.ScopeType.Catch | scope_1.ScopeType.File);
     if (!scope) {
         return;
     }
     // $vararg global constant
-    if (vararg_1.isGlobalVarargConstant(context, symbol, scope)) {
+    if ((0, vararg_1.isGlobalVarargConstant)(context, symbol, scope)) {
         return true;
     }
     // Scope must be a function scope associated with a real ts function
-    if (!scope_1.isFunctionScopeWithDefinition(scope)) {
+    if (!(0, scope_1.isFunctionScopeWithDefinition)(scope)) {
         return false;
     }
     // Scope cannot be an async function
@@ -39,11 +45,11 @@ function isOptimizedVarArgSpread(context, symbol, identifier) {
         return false;
     }
     // De-optimize if already referenced outside of a spread, as the array may have been modified
-    if (scope_1.hasReferencedSymbol(context, scope, symbol)) {
+    if ((0, scope_1.hasReferencedSymbol)(context, scope, symbol)) {
         return false;
     }
     // De-optimize if a function is being hoisted from below to above, as it may have modified the array
-    if (scope_1.hasReferencedUndefinedLocalFunction(context, scope)) {
+    if ((0, scope_1.hasReferencedUndefinedLocalFunction)(context, scope)) {
         return false;
     }
     return true;
@@ -51,23 +57,24 @@ function isOptimizedVarArgSpread(context, symbol, identifier) {
 exports.isOptimizedVarArgSpread = isOptimizedVarArgSpread;
 // TODO: Currently it's also used as an array member
 const transformSpreadElement = (node, context) => {
-    if (ts.isIdentifier(node.expression)) {
-        if (annotations_1.isVarargType(context, node.expression)) {
-            context.diagnostics.push(diagnostics_1.annotationRemoved(node, annotations_1.AnnotationKind.Vararg));
+    const tsInnerExpression = ts.skipOuterExpressions(node.expression);
+    if (ts.isIdentifier(tsInnerExpression)) {
+        if ((0, annotations_1.isVarargType)(context, tsInnerExpression)) {
+            context.diagnostics.push((0, diagnostics_1.annotationRemoved)(node, annotations_1.AnnotationKind.Vararg));
         }
-        const symbol = context.checker.getSymbolAtLocation(node.expression);
-        if (symbol && isOptimizedVarArgSpread(context, symbol, node.expression)) {
+        const symbol = context.checker.getSymbolAtLocation(tsInnerExpression);
+        if (symbol && isOptimizedVarArgSpread(context, symbol, tsInnerExpression)) {
             return lua.createDotsLiteral(node);
         }
     }
     const innerExpression = context.transformExpression(node.expression);
-    if (multi_1.isMultiReturnCall(context, node.expression))
+    if ((0, multi_1.isMultiReturnCall)(context, tsInnerExpression))
         return innerExpression;
-    const type = context.checker.getTypeAtLocation(node.expression);
-    if (typescript_1.isArrayType(context, type)) {
-        return lua_ast_1.createUnpackCall(context, innerExpression, node);
+    const type = context.checker.getTypeAtLocation(node.expression); // not ts-inner expression, in case of casts
+    if ((0, typescript_1.isArrayType)(context, type)) {
+        return (0, lua_ast_1.createUnpackCall)(context, innerExpression, node);
     }
-    return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.Spread, node, innerExpression);
+    return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.Spread, node, innerExpression);
 };
 exports.transformSpreadElement = transformSpreadElement;
 //# sourceMappingURL=spread.js.map

package/dist/transformation/visitors/switch.js

@@ -3,7 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.transformSwitchStatement = 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 binary_expression_1 = require("./binary-expression");
 const containsBreakOrReturn = (nodes) => {
     for (const s of nodes) {
         if (ts.isBreakStatement(s) || ts.isReturnStatement(s)) {
@@ -18,16 +20,26 @@ const containsBreakOrReturn = (nodes) => {
     }
     return false;
 };
-const coalesceCondition = (condition, switchVariable, expression, context) => {
+const createOrExpression = (context, left, right, rightPrecedingStatements) => {
+    if (rightPrecedingStatements.length > 0) {
+        return (0, binary_expression_1.createShortCircuitBinaryExpressionPrecedingStatements)(context, left, right, rightPrecedingStatements, ts.SyntaxKind.BarBarToken);
+    }
+    else {
+        return [rightPrecedingStatements, lua.createBinaryExpression(left, right, lua.SyntaxKind.OrOperator)];
+    }
+};
+const coalesceCondition = (condition, conditionPrecedingStatements, switchVariable, expression, context) => {
+    const [precedingStatements, transformedExpression] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(expression));
     // Coalesce skipped statements
+    const comparison = lua.createBinaryExpression(switchVariable, transformedExpression, lua.SyntaxKind.EqualityOperator);
     if (condition) {
-        return lua.createBinaryExpression(condition, lua.createBinaryExpression(switchVariable, context.transformExpression(expression), lua.SyntaxKind.EqualityOperator), lua.SyntaxKind.OrOperator);
+        return createOrExpression(context, condition, comparison, precedingStatements);
     }
     // Next condition
-    return lua.createBinaryExpression(switchVariable, context.transformExpression(expression), lua.SyntaxKind.EqualityOperator);
+    return [[...conditionPrecedingStatements, ...precedingStatements], comparison];
 };
 const transformSwitchStatement = (statement, context) => {
-    const scope = scope_1.pushScope(context, scope_1.ScopeType.Switch);
+    const scope = (0, scope_1.pushScope)(context, scope_1.ScopeType.Switch);
     // Give the switch and condition accumulator a unique name to prevent nested switches from acting up.
     const switchName = `____switch${scope.id}`;
     const conditionName = `____cond${scope.id}`;
@@ -35,18 +47,25 @@ const transformSwitchStatement = (statement, context) => {
     const conditionVariable = lua.createIdentifier(conditionName);
     // If the switch only has a default clause, wrap it in a single do.
     // Otherwise, we need to generate a set of if statements to emulate the switch.
-    let statements = [];
+    const statements = [];
+    const hoistedStatements = [];
+    const hoistedIdentifiers = [];
     const clauses = statement.caseBlock.clauses;
     if (clauses.length === 1 && ts.isDefaultClause(clauses[0])) {
         const defaultClause = clauses[0].statements;
         if (defaultClause.length) {
-            statements.push(lua.createDoStatement(context.transformStatements(defaultClause)));
+            const { statements: defaultStatements, hoistedStatements: defaultHoistedStatements, hoistedIdentifiers: defaultHoistedIdentifiers, } = (0, scope_1.separateHoistedStatements)(context, context.transformStatements(defaultClause));
+            hoistedStatements.push(...defaultHoistedStatements);
+            hoistedIdentifiers.push(...defaultHoistedIdentifiers);
+            statements.push(lua.createDoStatement(defaultStatements));
         }
     }
     else {
         // Build up the condition for each if statement
+        let defaultTransformed = false;
         let isInitialCondition = true;
         let condition = undefined;
+        let conditionPrecedingStatements = [];
         for (let i = 0; i < clauses.length; i++) {
             const clause = clauses[i];
             const previousClause = clauses[i - 1];
@@ -58,42 +77,55 @@ const transformSwitchStatement = (statement, context) => {
             }
             // Compute the condition for the if statement
             if (!ts.isDefaultClause(clause)) {
-                condition = coalesceCondition(condition, switchVariable, clause.expression, context);
+                [conditionPrecedingStatements, condition] = coalesceCondition(condition, conditionPrecedingStatements, switchVariable, clause.expression, context);
                 // Skip empty clauses unless final clause (i.e side-effects)
                 if (i !== clauses.length - 1 && clause.statements.length === 0)
                     continue;
                 // Declare or assign condition variable
-                statements.push(isInitialCondition
-                    ? lua.createVariableDeclarationStatement(conditionVariable, condition)
-                    : lua.createAssignmentStatement(conditionVariable, lua.createBinaryExpression(conditionVariable, condition, lua.SyntaxKind.OrOperator)));
+                if (isInitialCondition) {
+                    statements.push(...conditionPrecedingStatements, lua.createVariableDeclarationStatement(conditionVariable, condition));
+                }
+                else {
+                    [conditionPrecedingStatements, condition] = createOrExpression(context, conditionVariable, condition, conditionPrecedingStatements);
+                    statements.push(...conditionPrecedingStatements, lua.createAssignmentStatement(conditionVariable, condition));
+                }
                 isInitialCondition = false;
             }
             else {
                 // If the default is proceeded by empty clauses and will be emitted we may need to initialize the condition
                 if (isInitialCondition) {
-                    statements.push(lua.createVariableDeclarationStatement(conditionVariable, condition !== null && condition !== void 0 ? condition : lua.createBooleanLiteral(false)));
+                    statements.push(...conditionPrecedingStatements, lua.createVariableDeclarationStatement(conditionVariable, condition !== null && condition !== void 0 ? condition : lua.createBooleanLiteral(false)));
                     // Clear condition ot ensure it is not evaluated twice
                     condition = undefined;
+                    conditionPrecedingStatements = [];
                     isInitialCondition = false;
                 }
                 // Allow default to fallthrough to final default clause
                 if (i === clauses.length - 1) {
                     // Evaluate the final condition that we may be skipping
                     if (condition) {
-                        statements.push(lua.createAssignmentStatement(conditionVariable, lua.createBinaryExpression(conditionVariable, condition, lua.SyntaxKind.OrOperator)));
+                        [conditionPrecedingStatements, condition] = createOrExpression(context, conditionVariable, condition, conditionPrecedingStatements);
+                        statements.push(...conditionPrecedingStatements, lua.createAssignmentStatement(conditionVariable, condition));
                     }
                     continue;
                 }
             }
             // Transform the clause and append the final break statement if necessary
-            const clauseStatements = context.transformStatements(clause.statements);
+            const { statements: clauseStatements, hoistedStatements: clauseHoistedStatements, hoistedIdentifiers: clauseHoistedIdentifiers, } = (0, scope_1.separateHoistedStatements)(context, context.transformStatements(clause.statements));
             if (i === clauses.length - 1 && !containsBreakOrReturn(clause.statements)) {
                 clauseStatements.push(lua.createBreakStatement());
             }
+            hoistedStatements.push(...clauseHoistedStatements);
+            hoistedIdentifiers.push(...clauseHoistedIdentifiers);
+            // Remember that we transformed default clause so we don't duplicate hoisted statements later
+            if (ts.isDefaultClause(clause)) {
+                defaultTransformed = true;
+            }
             // Push if statement for case
             statements.push(lua.createIfStatement(conditionVariable, lua.createBlock(clauseStatements)));
             // Clear condition for next clause
             condition = undefined;
+            conditionPrecedingStatements = [];
         }
         // If no conditions above match, we need to create the final default case code-path,
         // as we only handle fallthrough into defaults in the previous if statement chain
@@ -101,11 +133,19 @@ const transformSwitchStatement = (statement, context) => {
         if (start >= 0) {
             // Find the last clause that we can fallthrough to
             const end = clauses.findIndex((clause, index) => index >= start && containsBreakOrReturn(clause.statements));
-            // Combine the default and all fallthrough statements
-            const defaultStatements = [];
-            clauses
-                .slice(start, end >= 0 ? end + 1 : undefined)
-                .forEach(c => defaultStatements.push(...context.transformStatements(c.statements)));
+            const { statements: defaultStatements, hoistedStatements: defaultHoistedStatements, hoistedIdentifiers: defaultHoistedIdentifiers, } = (0, scope_1.separateHoistedStatements)(context, context.transformStatements(clauses[start].statements));
+            // Only push hoisted statements if this is the first time we're transforming the default clause
+            if (!defaultTransformed) {
+                hoistedStatements.push(...defaultHoistedStatements);
+                hoistedIdentifiers.push(...defaultHoistedIdentifiers);
+            }
+            // Combine the fallthrough statements
+            for (const clause of clauses.slice(start + 1, end >= 0 ? end + 1 : undefined)) {
+                let statements = context.transformStatements(clause.statements);
+                // Drop hoisted statements as they were already added when clauses were initially transformed above
+                ({ statements } = (0, scope_1.separateHoistedStatements)(context, statements));
+                defaultStatements.push(...statements);
+            }
             // Add the default clause if it has any statements
             // The switch will always break on the final clause and skip execution if valid to do so
             if (defaultStatements.length) {
@@ -114,8 +154,11 @@ const transformSwitchStatement = (statement, context) => {
         }
     }
     // Hoist the variable, function, and import statements to the top of the switch
-    statements = scope_1.performHoisting(context, statements);
-    scope_1.popScope(context);
+    statements.unshift(...hoistedStatements);
+    if (hoistedIdentifiers.length > 0) {
+        statements.unshift(lua.createVariableDeclarationStatement(hoistedIdentifiers));
+    }
+    (0, scope_1.popScope)(context);
     // Add the switch expression after hoisting
     const expression = context.transformExpression(statement.expression);
     statements.unshift(lua.createVariableDeclarationStatement(switchVariable, expression));

package/dist/transformation/visitors/template.js

@@ -7,6 +7,7 @@ const function_context_1 = require("../utils/function-context");
 const lua_ast_1 = require("../utils/lua-ast");
 const types_1 = require("../utils/typescript/types");
 const call_1 = require("./call");
+const expression_list_1 = require("./expression-list");
 // TODO: Source positions
 function getRawLiteral(node) {
     let text = node.getText();
@@ -21,14 +22,16 @@ const transformTemplateExpression = (node, context) => {
     if (head.length > 0) {
         parts.push(lua.createStringLiteral(head, node.head));
     }
-    for (const span of node.templateSpans) {
-        const expression = context.transformExpression(span.expression);
+    const transformedExpressions = (0, expression_list_1.transformOrderedExpressions)(context, node.templateSpans.map(s => s.expression));
+    for (let i = 0; i < node.templateSpans.length; ++i) {
+        const span = node.templateSpans[i];
+        const expression = transformedExpressions[i];
         const spanType = context.checker.getTypeAtLocation(span.expression);
-        if (types_1.isStringType(context, spanType)) {
+        if ((0, types_1.isStringType)(context, spanType)) {
             parts.push(expression);
         }
         else {
-            parts.push(lua_ast_1.wrapInToStringForConcat(expression));
+            parts.push((0, lua_ast_1.wrapInToStringForConcat)(expression));
         }
         const text = span.literal.text;
         if (text.length > 0) {
@@ -65,12 +68,12 @@ const transformTaggedTemplateExpression = (expression, context) => {
     // Evaluate if there is a self parameter to be used.
     const signature = context.checker.getResolvedSignature(expression);
     const signatureDeclaration = signature === null || signature === void 0 ? void 0 : signature.getDeclaration();
-    const useSelfParameter = signatureDeclaration && function_context_1.getDeclarationContextType(context, signatureDeclaration) !== function_context_1.ContextType.Void;
+    const useSelfParameter = signatureDeclaration && (0, function_context_1.getDeclarationContextType)(context, signatureDeclaration) !== function_context_1.ContextType.Void;
     if (useSelfParameter) {
-        return call_1.transformContextualCallExpression(context, expression, expressions, signature);
+        return (0, call_1.transformContextualCallExpression)(context, expression, expressions, signature);
     }
     // Argument evaluation.
-    const callArguments = call_1.transformArguments(context, expressions, signature);
+    const callArguments = (0, call_1.transformArguments)(context, expressions, signature);
     const leftHandSideExpression = context.transformExpression(expression.tag);
     return lua.createCallExpression(leftHandSideExpression, callArguments);
 };