typescript-to-lua 1.0.0 → 1.2.0

package/dist/transformation/visitors/switch.js

@@ -2,46 +2,168 @@
 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 preceding_statements_1 = require("../utils/preceding-statements");
 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 binary_expression_1 = require("./binary-expression");
+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 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 scope = scope_1.pushScope(context, scope_1.ScopeType.Switch);
-    // Give the switch a unique name to prevent nested switches from acting up.
+};
+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 createOrExpression(context, condition, comparison, precedingStatements);
+    }
+    // Next condition
+    return [[...conditionPrecedingStatements, ...precedingStatements], comparison];
+};
+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;
+        let conditionPrecedingStatements = [];
+        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)) {
+                [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
+                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(...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) {
+                        [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 { 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
+        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

@@ -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);
 };

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,9 @@ 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);
+    const [precedingStatements, result] = (0, binary_expression_1.transformBinaryOperation)(context, typeCall, comparedExpression, [], operator, node);
+    context.addPrecedingStatements(precedingStatements);
+    return result;
 }
 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;

package/dist/transformation/visitors/variable-declaration.js

@@ -9,6 +9,7 @@ const diagnostics_1 = require("../utils/diagnostics");
 const export_1 = require("../utils/export");
 const lua_ast_1 = require("../utils/lua-ast");
 const lualib_1 = require("../utils/lualib");
+const preceding_statements_1 = require("../utils/preceding-statements");
 const identifier_1 = require("./identifier");
 const multi_1 = require("./language-extensions/multi");
 const literal_1 = require("./literal");
@@ -17,16 +18,21 @@ function transformArrayBindingElement(context, name) {
         return lua.createAnonymousIdentifier(name);
     }
     else if (ts.isIdentifier(name)) {
-        return identifier_1.transformIdentifier(context, name);
+        return (0, identifier_1.transformIdentifier)(context, name);
     }
     else if (ts.isBindingElement(name)) {
-        // TODO: It should always be true when called from `transformVariableDeclaration`,
-        // but could be false from `transformForOfLuaIteratorStatement`.
-        utils_1.assert(ts.isIdentifier(name.name));
-        return identifier_1.transformIdentifier(context, name.name);
+        if (ts.isIdentifier(name.name)) {
+            return (0, identifier_1.transformIdentifier)(context, name.name);
+        }
+        else {
+            // ts.isBindingPattern(name.name)
+            const tempName = context.createTempNameForNode(name.name);
+            context.addPrecedingStatements(transformBindingPattern(context, name.name, tempName));
+            return tempName;
+        }
     }
     else {
-        utils_1.assertNever(name);
+        (0, utils_1.assertNever)(name);
     }
 }
 exports.transformArrayBindingElement = transformArrayBindingElement;
@@ -48,11 +54,13 @@ function transformBindingPattern(context, pattern, table, propertyAccessStack =
             continue;
         }
         // Build the path to the table
-        const tableExpression = propertyAccessStack.reduce((path, property) => lua.createTableIndexExpression(path, literal_1.transformPropertyName(context, property)), table);
+        const tableExpression = propertyAccessStack.reduce((path, property) => lua.createTableIndexExpression(path, (0, literal_1.transformPropertyName)(context, property)), table);
         // The identifier of the new variable
-        const variableName = identifier_1.transformIdentifier(context, element.name);
+        const variableName = (0, identifier_1.transformIdentifier)(context, element.name);
         // The field to extract
-        const propertyName = literal_1.transformPropertyName(context, (_a = element.propertyName) !== null && _a !== void 0 ? _a : element.name);
+        const elementName = (_a = element.propertyName) !== null && _a !== void 0 ? _a : element.name;
+        const [precedingStatements, propertyName] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => (0, literal_1.transformPropertyName)(context, elementName));
+        result.push(...precedingStatements); // Keep property's preceding statements in order
         let expression;
         if (element.dotDotDotToken) {
             if (index !== pattern.elements.length - 1) {
@@ -78,20 +86,23 @@ function transformBindingPattern(context, pattern, table, propertyAccessStack =
                     }
                 }
                 const excludedPropertiesTable = excludedProperties.map(e => lua.createTableFieldExpression(lua.createBooleanLiteral(true), lua.createStringLiteral(e.text, e)));
-                expression = lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.ObjectRest, undefined, tableExpression, lua.createTableExpression(excludedPropertiesTable));
+                expression = (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ObjectRest, undefined, tableExpression, lua.createTableExpression(excludedPropertiesTable));
             }
             else {
-                expression = lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.ArraySlice, undefined, tableExpression, lua.createNumericLiteral(index));
+                expression = (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ArraySlice, undefined, tableExpression, lua.createNumericLiteral(index));
             }
         }
         else {
             expression = lua.createTableIndexExpression(tableExpression, ts.isObjectBindingPattern(pattern) ? propertyName : lua.createNumericLiteral(index + 1));
         }
-        result.push(...lua_ast_1.createLocalOrExportedOrGlobalDeclaration(context, variableName, expression));
+        result.push(...(0, lua_ast_1.createLocalOrExportedOrGlobalDeclaration)(context, variableName, expression));
         if (element.initializer) {
-            const identifier = export_1.addExportToIdentifier(context, variableName);
+            const identifier = (0, export_1.addExportToIdentifier)(context, variableName);
+            const tsInitializer = element.initializer;
+            const [initializerPrecedingStatements, initializer] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(tsInitializer));
             result.push(lua.createIfStatement(lua.createBinaryExpression(identifier, lua.createNilLiteral(), lua.SyntaxKind.EqualityOperator), lua.createBlock([
-                lua.createAssignmentStatement(identifier, context.transformExpression(element.initializer)),
+                ...initializerPrecedingStatements,
+                lua.createAssignmentStatement(identifier, initializer),
             ])));
         }
     }
@@ -106,18 +117,21 @@ function transformBindingVariableDeclaration(context, bindingPattern, initialize
     if (ts.isObjectBindingPattern(bindingPattern) || bindingPattern.elements.some(isComplexBindingElement)) {
         let table;
         if (initializer !== undefined && ts.isIdentifier(initializer)) {
-            table = identifier_1.transformIdentifier(context, initializer);
+            table = (0, identifier_1.transformIdentifier)(context, initializer);
         }
         else {
             // Contain the expression in a temporary variable
-            table = lua.createAnonymousIdentifier();
             if (initializer) {
+                table = context.createTempNameForNode(initializer);
                 let expression = context.transformExpression(initializer);
-                if (multi_1.isMultiReturnCall(context, initializer)) {
-                    expression = lua_ast_1.wrapInTable(expression);
+                if ((0, multi_1.isMultiReturnCall)(context, initializer)) {
+                    expression = (0, lua_ast_1.wrapInTable)(expression);
                 }
                 statements.push(lua.createVariableDeclarationStatement(table, expression));
             }
+            else {
+                table = lua.createAnonymousIdentifier();
+            }
         }
         statements.push(...transformBindingPattern(context, bindingPattern, table));
         return statements;
@@ -126,30 +140,30 @@ function transformBindingVariableDeclaration(context, bindingPattern, initialize
         ? bindingPattern.elements.map(e => transformArrayBindingElement(context, e))
         : lua.createAnonymousIdentifier();
     if (initializer) {
-        if (multi_1.isMultiReturnCall(context, initializer)) {
+        if ((0, multi_1.isMultiReturnCall)(context, initializer)) {
             // Don't unpack LuaMultiReturn functions
-            statements.push(...lua_ast_1.createLocalOrExportedOrGlobalDeclaration(context, vars, context.transformExpression(initializer), initializer));
+            statements.push(...(0, lua_ast_1.createLocalOrExportedOrGlobalDeclaration)(context, vars, context.transformExpression(initializer), initializer));
         }
         else if (ts.isArrayLiteralExpression(initializer)) {
             // Don't unpack array literals
             const values = initializer.elements.length > 0
                 ? initializer.elements.map(e => context.transformExpression(e))
                 : lua.createNilLiteral();
-            statements.push(...lua_ast_1.createLocalOrExportedOrGlobalDeclaration(context, vars, values, initializer));
+            statements.push(...(0, lua_ast_1.createLocalOrExportedOrGlobalDeclaration)(context, vars, values, initializer));
         }
         else {
             // local vars = this.transpileDestructingAssignmentValue(node.initializer);
-            const unpackedInitializer = lua_ast_1.createUnpackCall(context, context.transformExpression(initializer), initializer);
-            statements.push(...lua_ast_1.createLocalOrExportedOrGlobalDeclaration(context, vars, unpackedInitializer, initializer));
+            const unpackedInitializer = (0, lua_ast_1.createUnpackCall)(context, context.transformExpression(initializer), initializer);
+            statements.push(...(0, lua_ast_1.createLocalOrExportedOrGlobalDeclaration)(context, vars, unpackedInitializer, initializer));
         }
     }
     else {
-        statements.push(...lua_ast_1.createLocalOrExportedOrGlobalDeclaration(context, vars, lua.createNilLiteral(), initializer));
+        statements.push(...(0, lua_ast_1.createLocalOrExportedOrGlobalDeclaration)(context, vars, lua.createNilLiteral(), initializer));
     }
     for (const element of bindingPattern.elements) {
         if (!ts.isOmittedExpression(element) && element.initializer) {
-            const variableName = identifier_1.transformIdentifier(context, element.name);
-            const identifier = export_1.addExportToIdentifier(context, variableName);
+            const variableName = (0, identifier_1.transformIdentifier)(context, element.name);
+            const identifier = (0, export_1.addExportToIdentifier)(context, variableName);
             statements.push(lua.createIfStatement(lua.createBinaryExpression(identifier, lua.createNilLiteral(), lua.SyntaxKind.EqualityOperator), lua.createBlock([
                 lua.createAssignmentStatement(identifier, context.transformExpression(element.initializer)),
             ])));
@@ -163,27 +177,27 @@ function transformVariableDeclaration(context, statement) {
     if (statement.initializer && statement.type) {
         const initializerType = context.checker.getTypeAtLocation(statement.initializer);
         const varType = context.checker.getTypeFromTypeNode(statement.type);
-        assignment_validation_1.validateAssignment(context, statement.initializer, initializerType, varType);
+        (0, assignment_validation_1.validateAssignment)(context, statement.initializer, initializerType, varType);
     }
     if (ts.isIdentifier(statement.name)) {
         // Find variable identifier
-        const identifierName = identifier_1.transformIdentifier(context, statement.name);
+        const identifierName = (0, identifier_1.transformIdentifier)(context, statement.name);
         const value = statement.initializer && context.transformExpression(statement.initializer);
-        return lua_ast_1.createLocalOrExportedOrGlobalDeclaration(context, identifierName, value, statement);
+        return (0, lua_ast_1.createLocalOrExportedOrGlobalDeclaration)(context, identifierName, value, statement);
     }
     else if (ts.isArrayBindingPattern(statement.name) || ts.isObjectBindingPattern(statement.name)) {
         return transformBindingVariableDeclaration(context, statement.name, statement.initializer);
     }
     else {
-        return utils_1.assertNever(statement.name);
+        return (0, utils_1.assertNever)(statement.name);
     }
 }
 exports.transformVariableDeclaration = transformVariableDeclaration;
 function checkVariableDeclarationList(context, node) {
     if ((node.flags & (ts.NodeFlags.Let | ts.NodeFlags.Const)) === 0) {
         const token = node.getFirstToken();
-        utils_1.assert(token);
-        context.diagnostics.push(diagnostics_1.unsupportedVarDeclaration(token));
+        (0, utils_1.assert)(token);
+        context.diagnostics.push((0, diagnostics_1.unsupportedVarDeclaration)(token));
     }
 }
 exports.checkVariableDeclarationList = checkVariableDeclarationList;

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

@@ -0,0 +1,6 @@
+import * as ts from "typescript";
+import * as lua from "../../LuaAST";
+import { TransformationContext } from "../context";
+import { FunctionVisitor } from "../context/visitors";
+export declare const transformVoidExpression: FunctionVisitor<ts.VoidExpression>;
+export declare const transformVoidExpressionStatement: (node: ts.VoidExpression, context: TransformationContext) => lua.VariableDeclarationStatement;

package/dist/transformation/visitors/void.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformVoidExpressionStatement = exports.transformVoidExpression = void 0;
+const ts = require("typescript");
+const lua = require("../../LuaAST");
+// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/void
+const transformVoidExpression = (node, context) => {
+    // If content is a literal it is safe to replace the entire expression with nil
+    if (!ts.isLiteralExpression(node.expression)) {
+        // local ____ = <expression>
+        context.addPrecedingStatements(lua.createVariableDeclarationStatement(lua.createAnonymousIdentifier(), context.transformExpression(node.expression)));
+    }
+    return lua.createNilLiteral(node);
+};
+exports.transformVoidExpression = transformVoidExpression;
+const transformVoidExpressionStatement = (node, context) => 
+// In case of a void expression statement we can omit the IIFE
+lua.createVariableDeclarationStatement(lua.createAnonymousIdentifier(), context.transformExpression(node.expression), node);
+exports.transformVoidExpressionStatement = transformVoidExpressionStatement;
+//# sourceMappingURL=void.js.map

package/dist/transpilation/bundle.d.ts

@@ -1,3 +1,6 @@
+import { SourceNode } from "source-map";
 import * as ts from "typescript";
 import { EmitFile, ProcessedFile } from "./utils";
+export declare const sourceMapTracebackBundlePlaceholder = "{#SourceMapTracebackBundle}";
+export declare function printStackTraceBundleOverride(rootNode: SourceNode): string;
 export declare function getBundleResult(program: ts.Program, files: ProcessedFile[]): [ts.Diagnostic[], EmitFile];