typescript-to-lua 0.41.2 → 1.1.0

package/dist/transformation/visitors/return.js

@@ -1,95 +1,87 @@
 "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 annotations_1 = require("../utils/annotations");
 const assignment_validation_1 = require("../utils/assignment-validation");
 const lua_ast_1 = require("../utils/lua-ast");
 const scope_1 = require("../utils/scope");
-const typescript_1 = require("../utils/typescript");
 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.isMultiReturnType(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)];
-    }
-    if (!annotations_1.isInTupleReturnFunction(context, node)) {
-        return [context.transformExpression(node)];
-    }
-    let results;
-    // Parent function is a TupleReturn function
-    if (ts.isArrayLiteralExpression(node)) {
-        // If return expression is an array literal, leave out brackets.
-        results = node.elements.map(e => context.transformExpression(e));
-    }
-    else if (!annotations_1.isTupleReturnCall(context, node) && typescript_1.isArrayType(context, expressionType)) {
-        // If return expression is an array-type and not another TupleReturn call, unpack it
-        results = [lua_ast_1.createUnpackCall(context, context.transformExpression(node), node)];
-    }
-    else {
-        results = [context.transformExpression(node)];
+        return [(0, lua_ast_1.createUnpackCall)(context, context.transformExpression(node), node)];
     }
-    // Wrap tupleReturn results when returning inside try/catch
-    if (insideTryCatch) {
-        results = [lua_ast_1.wrapInTable(...results)];
-    }
-    return results;
+    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

@@ -14,7 +14,7 @@ const transformSourceFileNode = (node, context) => {
     if (node.flags & ts.NodeFlags.JsonFile) {
         const [statement] = node.statements;
         if (statement) {
-            utils_1.assert(ts.isExpressionStatement(statement));
+            (0, utils_1.assert)(ts.isExpressionStatement(statement));
             statements.push(lua.createReturnStatement([context.transformExpression(statement.expression)]));
         }
         else {
@@ -25,21 +25,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

@@ -12,20 +12,25 @@ const multi_1 = require("./language-extensions/multi");
 const diagnostics_1 = require("../utils/diagnostics");
 const vararg_1 = require("./language-extensions/vararg");
 function isOptimizedVarArgSpread(context, symbol, identifier) {
+    var _a;
     if (!ts.isSpreadElement(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
+    if ((_a = scope.node.modifiers) === null || _a === void 0 ? void 0 : _a.some(m => m.kind === ts.SyntaxKind.AsyncKeyword)) {
         return false;
     }
     // Identifier must be a vararg in the local function scope's parameters
@@ -34,11 +39,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;
@@ -47,8 +52,8 @@ 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));
+        if ((0, annotations_1.isVarargType)(context, node.expression)) {
+            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)) {
@@ -56,15 +61,13 @@ const transformSpreadElement = (node, context) => {
         }
     }
     const innerExpression = context.transformExpression(node.expression);
-    if (annotations_1.isTupleReturnCall(context, node.expression))
-        return innerExpression;
-    if (ts.isCallExpression(node.expression) && multi_1.returnsMultiType(context, node.expression))
+    if ((0, multi_1.isMultiReturnCall)(context, node.expression))
         return innerExpression;
     const type = context.checker.getTypeAtLocation(node.expression);
-    if (typescript_1.isArrayType(context, type)) {
-        return lua_ast_1.createUnpackCall(context, innerExpression, node);
+    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

@@ -2,46 +2,148 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.transformSwitchStatement = void 0;
 const ts = require("typescript");
-const CompilerOptions_1 = require("../../CompilerOptions");
 const lua = require("../../LuaAST");
-const diagnostics_1 = require("../utils/diagnostics");
 const scope_1 = require("../utils/scope");
-const transformSwitchStatement = (statement, context) => {
-    if (context.luaTarget === CompilerOptions_1.LuaTarget.Universal || context.luaTarget === CompilerOptions_1.LuaTarget.Lua51) {
-        context.diagnostics.push(diagnostics_1.unsupportedForTarget(statement, "Switch statements", CompilerOptions_1.LuaTarget.Lua51));
+const containsBreakOrReturn = (nodes) => {
+    for (const s of nodes) {
+        if (ts.isBreakStatement(s) || ts.isReturnStatement(s)) {
+            return true;
+        }
+        else if (ts.isBlock(s) && containsBreakOrReturn(s.getChildren())) {
+            return true;
+        }
+        else if (s.kind === ts.SyntaxKind.SyntaxList && containsBreakOrReturn(s.getChildren())) {
+            return true;
+        }
+    }
+    return false;
+};
+const coalesceCondition = (condition, switchVariable, expression, context) => {
+    // Coalesce skipped statements
+    if (condition) {
+        return lua.createBinaryExpression(condition, lua.createBinaryExpression(switchVariable, context.transformExpression(expression), lua.SyntaxKind.EqualityOperator), lua.SyntaxKind.OrOperator);
     }
-    const scope = scope_1.pushScope(context, scope_1.ScopeType.Switch);
-    // Give the switch a unique name to prevent nested switches from acting up.
+    // Next condition
+    return lua.createBinaryExpression(switchVariable, context.transformExpression(expression), lua.SyntaxKind.EqualityOperator);
+};
+const transformSwitchStatement = (statement, context) => {
+    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}`;
     const switchVariable = lua.createIdentifier(switchName);
-    let statements = [];
-    // Starting from the back, concatenating ifs into one big if/elseif statement
-    const concatenatedIf = statement.caseBlock.clauses.reduceRight((previousCondition, clause, index) => {
-        if (ts.isDefaultClause(clause)) {
-            // Skip default clause here (needs to be included to ensure index lines up with index later)
-            return previousCondition;
+    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.
+    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) {
+            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;
+        for (let i = 0; i < clauses.length; i++) {
+            const clause = clauses[i];
+            const previousClause = clauses[i - 1];
+            // Skip redundant default clauses, will be handled in final default case
+            if (i === 0 && ts.isDefaultClause(clause))
+                continue;
+            if (ts.isDefaultClause(clause) && previousClause && containsBreakOrReturn(previousClause.statements)) {
+                continue;
+            }
+            // Compute the condition for the if statement
+            if (!ts.isDefaultClause(clause)) {
+                condition = coalesceCondition(condition, 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)));
+                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)));
+                    // Clear condition ot ensure it is not evaluated twice
+                    condition = undefined;
+                    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)));
+                    }
+                    continue;
+                }
+            }
+            // Transform the clause and append the final break statement if necessary
+            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;
+        }
+        // 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
+        const start = clauses.findIndex(c => ts.isDefaultClause(c));
+        if (start >= 0) {
+            // Find the last clause that we can fallthrough to
+            const end = clauses.findIndex((clause, index) => index >= start && containsBreakOrReturn(clause.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) {
+                statements.push(lua.createDoStatement(defaultStatements));
+            }
         }
-        // If the clause condition holds, go to the correct label
-        const condition = lua.createBinaryExpression(switchVariable, context.transformExpression(clause.expression), lua.SyntaxKind.EqualityOperator);
-        const goto = lua.createGotoStatement(`${switchName}_case_${index}`);
-        return lua.createIfStatement(condition, lua.createBlock([goto]), previousCondition);
-    }, undefined);
-    if (concatenatedIf) {
-        statements.push(concatenatedIf);
     }
-    const hasDefaultCase = statement.caseBlock.clauses.some(ts.isDefaultClause);
-    statements.push(lua.createGotoStatement(`${switchName}_${hasDefaultCase ? "case_default" : "end"}`));
-    for (const [index, clause] of statement.caseBlock.clauses.entries()) {
-        const labelName = `${switchName}_case_${ts.isCaseClause(clause) ? index : "default"}`;
-        statements.push(lua.createLabelStatement(labelName));
-        statements.push(lua.createDoStatement(context.transformStatements(clause.statements)));
+    // Hoist the variable, function, and import statements to the top of the switch
+    statements.unshift(...hoistedStatements);
+    if (hoistedIdentifiers.length > 0) {
+        statements.unshift(lua.createVariableDeclarationStatement(hoistedIdentifiers));
     }
-    statements.push(lua.createLabelStatement(`${switchName}_end`));
-    statements = scope_1.performHoisting(context, statements);
-    scope_1.popScope(context);
+    (0, scope_1.popScope)(context);
+    // Add the switch expression after hoisting
     const expression = context.transformExpression(statement.expression);
     statements.unshift(lua.createVariableDeclarationStatement(switchVariable, expression));
-    return statements;
+    // Wrap the statements in a repeat until true statement to facilitate dynamic break/returns
+    return lua.createRepeatStatement(lua.createBlock(statements), lua.createBooleanLiteral(true));
 };
 exports.transformSwitchStatement = transformSwitchStatement;
 //# sourceMappingURL=switch.js.map

package/dist/transformation/visitors/template.js

@@ -24,11 +24,11 @@ const transformTemplateExpression = (node, context) => {
     for (const span of node.templateSpans) {
         const expression = context.transformExpression(span.expression);
         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 +65,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);
 };

package/dist/transformation/visitors/typeof.js

@@ -8,7 +8,7 @@ const lualib_1 = require("../utils/lualib");
 const binary_expression_1 = require("./binary-expression");
 const transformTypeOfExpression = (node, context) => {
     const innerExpression = context.transformExpression(node.expression);
-    return lualib_1.transformLuaLibFunction(context, LuaLib_1.LuaLibFeature.TypeOf, node, innerExpression);
+    return (0, lualib_1.transformLuaLibFunction)(context, LuaLib_1.LuaLibFeature.TypeOf, node, innerExpression);
 };
 exports.transformTypeOfExpression = transformTypeOfExpression;
 function transformTypeOfBinaryExpression(context, node) {
@@ -43,7 +43,7 @@ function transformTypeOfBinaryExpression(context, node) {
     }
     const innerExpression = context.transformExpression(typeOfExpression.expression);
     const typeCall = lua.createCallExpression(lua.createIdentifier("type"), [innerExpression], typeOfExpression);
-    return binary_expression_1.transformBinaryOperation(context, typeCall, comparedExpression, operator, node);
+    return (0, binary_expression_1.transformBinaryOperation)(context, typeCall, comparedExpression, operator, node);
 }
 exports.transformTypeOfBinaryExpression = transformTypeOfBinaryExpression;
 //# sourceMappingURL=typeof.js.map

package/dist/transformation/visitors/typescript.js

@@ -5,7 +5,7 @@ const ts = require("typescript");
 const assignment_validation_1 = require("../utils/assignment-validation");
 const transformAssertionExpression = (expression, context) => {
     if (!ts.isConstTypeReference(expression.type)) {
-        assignment_validation_1.validateAssignment(context, expression, context.checker.getTypeAtLocation(expression.expression), context.checker.getTypeAtLocation(expression.type));
+        (0, assignment_validation_1.validateAssignment)(context, expression, context.checker.getTypeAtLocation(expression.expression), context.checker.getTypeAtLocation(expression.type));
     }
     return context.transformExpression(expression.expression);
 };

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

@@ -12,32 +12,32 @@ function transformUnaryExpressionStatement(context, node) {
         (expression.operator === ts.SyntaxKind.PlusPlusToken || expression.operator === ts.SyntaxKind.MinusMinusToken)) {
         // ++i, --i
         const replacementOperator = expression.operator === ts.SyntaxKind.PlusPlusToken ? ts.SyntaxKind.PlusToken : ts.SyntaxKind.MinusToken;
-        return compound_1.transformCompoundAssignmentStatement(context, expression, expression.operand, ts.factory.createNumericLiteral(1), replacementOperator);
+        return (0, compound_1.transformCompoundAssignmentStatement)(context, expression, expression.operand, ts.factory.createNumericLiteral(1), replacementOperator);
     }
     else if (ts.isPostfixUnaryExpression(expression)) {
         // i++, i--
         const replacementOperator = expression.operator === ts.SyntaxKind.PlusPlusToken ? ts.SyntaxKind.PlusToken : ts.SyntaxKind.MinusToken;
-        return compound_1.transformCompoundAssignmentStatement(context, expression, expression.operand, ts.factory.createNumericLiteral(1), replacementOperator);
+        return (0, compound_1.transformCompoundAssignmentStatement)(context, expression, expression.operand, ts.factory.createNumericLiteral(1), replacementOperator);
     }
 }
 exports.transformUnaryExpressionStatement = transformUnaryExpressionStatement;
 const transformPostfixUnaryExpression = (expression, context) => {
     switch (expression.operator) {
         case ts.SyntaxKind.PlusPlusToken:
-            return compound_1.transformCompoundAssignmentExpression(context, expression, expression.operand, ts.factory.createNumericLiteral(1), ts.SyntaxKind.PlusToken, true);
+            return (0, compound_1.transformCompoundAssignmentExpression)(context, expression, expression.operand, ts.factory.createNumericLiteral(1), ts.SyntaxKind.PlusToken, true);
         case ts.SyntaxKind.MinusMinusToken:
-            return compound_1.transformCompoundAssignmentExpression(context, expression, expression.operand, ts.factory.createNumericLiteral(1), ts.SyntaxKind.MinusToken, true);
+            return (0, compound_1.transformCompoundAssignmentExpression)(context, expression, expression.operand, ts.factory.createNumericLiteral(1), ts.SyntaxKind.MinusToken, true);
         default:
-            utils_1.assertNever(expression.operator);
+            (0, utils_1.assertNever)(expression.operator);
     }
 };
 exports.transformPostfixUnaryExpression = transformPostfixUnaryExpression;
 const transformPrefixUnaryExpression = (expression, context) => {
     switch (expression.operator) {
         case ts.SyntaxKind.PlusPlusToken:
-            return compound_1.transformCompoundAssignmentExpression(context, expression, expression.operand, ts.factory.createNumericLiteral(1), ts.SyntaxKind.PlusToken, false);
+            return (0, compound_1.transformCompoundAssignmentExpression)(context, expression, expression.operand, ts.factory.createNumericLiteral(1), ts.SyntaxKind.PlusToken, false);
         case ts.SyntaxKind.MinusMinusToken:
-            return compound_1.transformCompoundAssignmentExpression(context, expression, expression.operand, ts.factory.createNumericLiteral(1), ts.SyntaxKind.MinusToken, false);
+            return (0, compound_1.transformCompoundAssignmentExpression)(context, expression, expression.operand, ts.factory.createNumericLiteral(1), ts.SyntaxKind.MinusToken, false);
         case ts.SyntaxKind.PlusToken:
             // TODO: Wrap with `Number`
             return context.transformExpression(expression.operand);
@@ -46,9 +46,9 @@ const transformPrefixUnaryExpression = (expression, context) => {
         case ts.SyntaxKind.ExclamationToken:
             return lua.createUnaryExpression(context.transformExpression(expression.operand), lua.SyntaxKind.NotOperator);
         case ts.SyntaxKind.TildeToken:
-            return bit_1.transformUnaryBitOperation(context, expression, context.transformExpression(expression.operand), lua.SyntaxKind.BitwiseNotOperator);
+            return (0, bit_1.transformUnaryBitOperation)(context, expression, context.transformExpression(expression.operand), lua.SyntaxKind.BitwiseNotOperator);
         default:
-            utils_1.assertNever(expression.operator);
+            (0, utils_1.assertNever)(expression.operator);
     }
 };
 exports.transformPrefixUnaryExpression = transformPrefixUnaryExpression;