typescript-to-lua 1.0.1 → 1.1.0

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

@@ -17,16 +17,16 @@ function isOptimizedVarArgSpread(context, symbol, identifier) {
         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 +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;
@@ -52,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)) {
@@ -61,13 +61,13 @@ const transformSpreadElement = (node, context) => {
         }
     }
     const innerExpression = context.transformExpression(node.expression);
-    if (multi_1.isMultiReturnCall(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

@@ -27,7 +27,7 @@ const coalesceCondition = (condition, switchVariable, expression, context) => {
     return lua.createBinaryExpression(switchVariable, context.transformExpression(expression), lua.SyntaxKind.EqualityOperator);
 };
 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,16 +35,22 @@ 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;
         for (let i = 0; i < clauses.length; i++) {
@@ -86,10 +92,16 @@ const transformSwitchStatement = (statement, context) => {
                 }
             }
             // 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
@@ -101,11 +113,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 +134,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

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

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

@@ -17,16 +17,16 @@ 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);
+        (0, utils_1.assert)(ts.isIdentifier(name.name));
+        return (0, identifier_1.transformIdentifier)(context, name.name);
     }
     else {
-        utils_1.assertNever(name);
+        (0, utils_1.assertNever)(name);
     }
 }
 exports.transformArrayBindingElement = transformArrayBindingElement;
@@ -48,11 +48,11 @@ 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 propertyName = (0, literal_1.transformPropertyName)(context, (_a = element.propertyName) !== null && _a !== void 0 ? _a : element.name);
         let expression;
         if (element.dotDotDotToken) {
             if (index !== pattern.elements.length - 1) {
@@ -78,18 +78,18 @@ 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);
             result.push(lua.createIfStatement(lua.createBinaryExpression(identifier, lua.createNilLiteral(), lua.SyntaxKind.EqualityOperator), lua.createBlock([
                 lua.createAssignmentStatement(identifier, context.transformExpression(element.initializer)),
             ])));
@@ -106,15 +106,15 @@ 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) {
                 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));
             }
@@ -126,30 +126,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 +163,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,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformVoidExpressionStatement = exports.transformVoidExpression = void 0;
+const ts = require("typescript");
+const lua = require("../../LuaAST");
+const lua_ast_1 = require("../utils/lua-ast");
+// 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)) {
+        return lua.createNilLiteral(node);
+    }
+    // (function() local ____ = <expression> end)()
+    return (0, lua_ast_1.createImmediatelyInvokedFunctionExpression)([
+        lua.createVariableDeclarationStatement(lua.createAnonymousIdentifier(), context.transformExpression(node.expression)),
+    ], [], 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];

package/dist/transpilation/bundle.js

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getBundleResult = void 0;
+exports.getBundleResult = exports.printStackTraceBundleOverride = exports.sourceMapTracebackBundlePlaceholder = void 0;
 const path = require("path");
 const source_map_1 = require("source-map");
 const LuaPrinter_1 = require("../LuaPrinter");
 const utils_1 = require("../utils");
 const diagnostics_1 = require("./diagnostics");
 const transpiler_1 = require("./transpiler");
-const createModulePath = (pathToResolve, program) => LuaPrinter_1.escapeString(utils_1.formatPathToLuaPath(utils_1.trimExtension(transpiler_1.getEmitPathRelativeToOutDir(pathToResolve, program))));
+const createModulePath = (pathToResolve, program) => (0, LuaPrinter_1.escapeString)((0, utils_1.formatPathToLuaPath)((0, utils_1.trimExtension)((0, transpiler_1.getEmitPathRelativeToOutDir)(pathToResolve, program))));
 // Override `require` to read from ____modules table.
 const requireOverride = `
 local ____modules = {}
@@ -30,16 +30,51 @@ local function require(file, ...)
     end
 end
 `;
+exports.sourceMapTracebackBundlePlaceholder = "{#SourceMapTracebackBundle}";
+function printStackTraceBundleOverride(rootNode) {
+    const map = {};
+    const getLineNumber = (line, fallback) => {
+        const data = map[line];
+        if (data === undefined) {
+            return fallback;
+        }
+        if (typeof data === "number") {
+            return data;
+        }
+        return data.line;
+    };
+    const transformLineData = (data) => {
+        if (typeof data === "number") {
+            return data;
+        }
+        return `{line = ${data.line}, file = "${data.file}"}`;
+    };
+    let currentLine = 1;
+    rootNode.walk((chunk, mappedPosition) => {
+        if (mappedPosition.line !== undefined && mappedPosition.line > 0) {
+            const line = getLineNumber(currentLine, mappedPosition.line);
+            map[currentLine] = {
+                line,
+                file: path.basename(mappedPosition.source),
+            };
+        }
+        currentLine += chunk.split("\n").length - 1;
+    });
+    const mapItems = Object.entries(map).map(([line, original]) => `["${line}"] = ${transformLineData(original)}`);
+    const mapString = "{" + mapItems.join(",") + "}";
+    return `__TS__SourceMapTraceBack(debug.getinfo(1).short_src, ${mapString});`;
+}
+exports.printStackTraceBundleOverride = printStackTraceBundleOverride;
 function getBundleResult(program, files) {
     const diagnostics = [];
     const options = program.getCompilerOptions();
-    const bundleFile = utils_1.cast(options.luaBundle, utils_1.isNonNull);
-    const entryModule = utils_1.cast(options.luaBundleEntry, utils_1.isNonNull);
+    const bundleFile = (0, utils_1.cast)(options.luaBundle, utils_1.isNonNull);
+    const entryModule = (0, utils_1.cast)(options.luaBundleEntry, utils_1.isNonNull);
     // Resolve project settings relative to project file.
-    const resolvedEntryModule = path.resolve(transpiler_1.getSourceDir(program), entryModule);
-    const outputPath = path.resolve(transpiler_1.getEmitOutDir(program), bundleFile);
+    const resolvedEntryModule = path.resolve((0, transpiler_1.getSourceDir)(program), entryModule);
+    const outputPath = path.resolve((0, transpiler_1.getEmitOutDir)(program), bundleFile);
     if (program.getSourceFile(resolvedEntryModule) === undefined && program.getSourceFile(entryModule) === undefined) {
-        diagnostics.push(diagnostics_1.couldNotFindBundleEntryPoint(entryModule));
+        diagnostics.push((0, diagnostics_1.couldNotFindBundleEntryPoint)(entryModule));
     }
     // For each file: ["<module path>"] = function() <lua content> end,
     const moduleTableEntries = files.map(f => moduleSourceNode(f, createModulePath(f.fileName, program)));
@@ -47,12 +82,19 @@ function getBundleResult(program, files) {
     const moduleTable = createModuleTableNode(moduleTableEntries);
     // return require("<entry module path>")
     const entryPoint = `return require(${createModulePath(entryModule, program)}, ...)\n`;
-    const sourceChunks = [requireOverride, moduleTable, entryPoint];
+    const footers = [];
+    if (options.sourceMapTraceback) {
+        // Generates SourceMapTraceback for the entire file
+        footers.push('require("lualib_bundle")\n');
+        footers.push(`${exports.sourceMapTracebackBundlePlaceholder}\n`);
+    }
+    const sourceChunks = [requireOverride, moduleTable, ...footers, entryPoint];
     if (!options.noHeader) {
         sourceChunks.unshift(LuaPrinter_1.tstlHeader);
     }
     const bundleNode = joinSourceChunks(sourceChunks);
-    const { code, map } = bundleNode.toStringWithSourceMap();
+    let { code, map } = bundleNode.toStringWithSourceMap();
+    code = code.replace(exports.sourceMapTracebackBundlePlaceholder, printStackTraceBundleOverride(bundleNode));
     return [
         diagnostics,
         {
@@ -65,7 +107,7 @@ function getBundleResult(program, files) {
 }
 exports.getBundleResult = getBundleResult;
 function moduleSourceNode({ code, sourceMapNode }, modulePath) {
-    const tableEntryHead = `[${modulePath}] = function(...) `;
+    const tableEntryHead = `[${modulePath}] = function(...) \n`;
     const tableEntryTail = " end,\n";
     return joinSourceChunks([tableEntryHead, sourceMapNode !== null && sourceMapNode !== void 0 ? sourceMapNode : code, tableEntryTail]);
 }

package/dist/transpilation/diagnostics.js

@@ -3,8 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.unsupportedJsxEmit = exports.cannotBundleLibrary = exports.usingLuaBundleWithInlineMightGenerateDuplicateCode = exports.luaBundleEntryIsRequired = exports.couldNotFindBundleEntryPoint = exports.transformerShouldBeATsTransformerFactory = exports.shouldHaveAExport = exports.couldNotResolveFrom = exports.toLoadItShouldBeTranspiled = exports.couldNotReadDependency = exports.couldNotResolveRequire = void 0;
 const ts = require("typescript");
 const utils_1 = require("../utils");
-const createDiagnosticFactory = (getMessage, category = ts.DiagnosticCategory.Error) => utils_1.createSerialDiagnosticFactory((...args) => ({ messageText: getMessage(...args), category }));
-exports.couldNotResolveRequire = createDiagnosticFactory((requirePath, containingFile) => `Could not resolve require path '${requirePath}' in file ${containingFile}.`);
+const createDiagnosticFactory = (getMessage, category = ts.DiagnosticCategory.Error) => (0, utils_1.createSerialDiagnosticFactory)((...args) => ({ messageText: getMessage(...args), category }));
+exports.couldNotResolveRequire = createDiagnosticFactory((requirePath, containingFile) => `Could not resolve lua source files for require path '${requirePath}' in file ${containingFile}.`);
 exports.couldNotReadDependency = createDiagnosticFactory((dependency) => `Could not read content of resolved dependency ${dependency}.`);
 exports.toLoadItShouldBeTranspiled = createDiagnosticFactory((kind, transform) => `To load "${transform}" ${kind} it should be transpiled or "ts-node" should be installed.`);
 exports.couldNotResolveFrom = createDiagnosticFactory((kind, transform, base) => `Could not resolve "${transform}" ${kind} from "${base}".`);
@@ -12,7 +12,7 @@ exports.shouldHaveAExport = createDiagnosticFactory((kind, transform, importName
 exports.transformerShouldBeATsTransformerFactory = createDiagnosticFactory((transform) => `"${transform}" transformer should be a ts.TransformerFactory or an object with ts.TransformerFactory values.`);
 exports.couldNotFindBundleEntryPoint = createDiagnosticFactory((entryPoint) => `Could not find bundle entry point '${entryPoint}'. It should be a file in the project.`);
 exports.luaBundleEntryIsRequired = createDiagnosticFactory(() => "'luaBundleEntry' is required when 'luaBundle' is enabled.");
-exports.usingLuaBundleWithInlineMightGenerateDuplicateCode = utils_1.createSerialDiagnosticFactory(() => ({
+exports.usingLuaBundleWithInlineMightGenerateDuplicateCode = (0, utils_1.createSerialDiagnosticFactory)(() => ({
     category: ts.DiagnosticCategory.Warning,
     messageText: "Using 'luaBundle' with 'luaLibImport: \"inline\"' might generate duplicate code. " +
         "It is recommended to use 'luaLibImport: \"require\"'.",