typescript-to-lua 1.0.1 → 1.1.0

package/dist/transformation/visitors/literal.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.literalVisitors = exports.transformJsxAttributes = exports.createShorthandIdentifier = exports.transformPropertyName = void 0;
+exports.literalVisitors = exports.createShorthandIdentifier = exports.transformPropertyName = void 0;
 const ts = require("typescript");
 const lua = require("../../LuaAST");
 const utils_1 = require("../../utils");
@@ -13,7 +13,6 @@ const typescript_1 = require("../utils/typescript");
 const function_1 = require("./function");
 const call_1 = require("./call");
 const multi_1 = require("./language-extensions/multi");
-const jsx_1 = require("./jsx/jsx");
 // TODO: Move to object-literal.ts?
 function transformPropertyName(context, node) {
     if (ts.isComputedPropertyName(node)) {
@@ -33,16 +32,16 @@ exports.transformPropertyName = transformPropertyName;
 function createShorthandIdentifier(context, valueSymbol, propertyIdentifier) {
     const propertyName = propertyIdentifier.text;
     const isUnsafeName = valueSymbol
-        ? safe_names_1.hasUnsafeSymbolName(context, valueSymbol, propertyIdentifier)
-        : safe_names_1.hasUnsafeIdentifierName(context, propertyIdentifier, false);
-    const name = isUnsafeName ? safe_names_1.createSafeName(propertyName) : propertyName;
+        ? (0, safe_names_1.hasUnsafeSymbolName)(context, valueSymbol, propertyIdentifier)
+        : (0, safe_names_1.hasUnsafeIdentifierName)(context, propertyIdentifier, false);
+    const name = isUnsafeName ? (0, safe_names_1.createSafeName)(propertyName) : propertyName;
     let identifier = context.transformExpression(ts.factory.createIdentifier(name));
     lua.setNodeOriginal(identifier, propertyIdentifier);
     if (valueSymbol !== undefined && lua.isIdentifier(identifier)) {
-        identifier.symbolId = symbols_1.getSymbolIdOfSymbol(context, valueSymbol);
-        const exportScope = export_1.getSymbolExportScope(context, valueSymbol);
+        identifier.symbolId = (0, symbols_1.getSymbolIdOfSymbol)(context, valueSymbol);
+        const exportScope = (0, export_1.getSymbolExportScope)(context, valueSymbol);
         if (exportScope) {
-            identifier = export_1.createExportedIdentifier(context, identifier, exportScope);
+            identifier = (0, export_1.createExportedIdentifier)(context, identifier, exportScope);
         }
     }
     return identifier;
@@ -56,10 +55,10 @@ const transformNumericLiteralExpression = expression => {
     }
     return lua.createNumericLiteral(Number(expression.text), expression);
 };
-const transformObjectLiteralExpressionOrJsxAttributes = (expression, context) => {
-    const violations = multi_1.findMultiAssignmentViolations(context, expression);
+const transformObjectLiteralExpression = (expression, context) => {
+    const violations = (0, multi_1.findMultiAssignmentViolations)(context, expression);
     if (violations.length > 0) {
-        context.diagnostics.push(...violations.map(e => diagnostics_1.invalidMultiFunctionUse(e)));
+        context.diagnostics.push(...violations.map(e => (0, diagnostics_1.invalidMultiFunctionUse)(e)));
         return lua.createNilLiteral(expression);
     }
     let properties = [];
@@ -70,39 +69,19 @@ const transformObjectLiteralExpressionOrJsxAttributes = (expression, context) =>
             const expression = context.transformExpression(element.initializer);
             properties.push(lua.createTableFieldExpression(expression, name, element));
         }
-        else if (ts.isJsxAttribute(element)) {
-            const initializer = element.initializer;
-            let expression;
-            if (initializer === undefined) {
-                expression = lua.createBooleanLiteral(true);
-            }
-            else if (ts.isStringLiteral(initializer)) {
-                const text = jsx_1.formatJSXStringValueLiteral(initializer.text);
-                expression = lua.createStringLiteral(text, initializer);
-            }
-            else if (ts.isJsxExpression(initializer)) {
-                expression = initializer.expression
-                    ? context.transformExpression(initializer.expression)
-                    : lua.createBooleanLiteral(true);
-            }
-            else {
-                utils_1.assertNever(initializer);
-            }
-            properties.push(lua.createTableFieldExpression(expression, name, element));
-        }
         else if (ts.isShorthandPropertyAssignment(element)) {
             const valueSymbol = context.checker.getShorthandAssignmentValueSymbol(element);
             if (valueSymbol) {
-                symbols_1.trackSymbolReference(context, valueSymbol, element.name);
+                (0, symbols_1.trackSymbolReference)(context, valueSymbol, element.name);
             }
             const identifier = createShorthandIdentifier(context, valueSymbol, element.name);
             properties.push(lua.createTableFieldExpression(identifier, name, element));
         }
         else if (ts.isMethodDeclaration(element)) {
-            const expression = function_1.transformFunctionLikeDeclaration(element, context);
+            const expression = (0, function_1.transformFunctionLikeDeclaration)(element, context);
             properties.push(lua.createTableFieldExpression(expression, name, element));
         }
-        else if (ts.isSpreadAssignment(element) || ts.isJsxSpreadAttribute(element)) {
+        else if (ts.isSpreadAssignment(element)) {
             // Create a table for preceding properties to preserve property order
             // { x: 0, ...{ y: 2 }, y: 1, z: 2 } --> __TS__ObjectAssign({x = 0}, {y = 2}, {y = 1, z = 2})
             if (properties.length > 0) {
@@ -112,8 +91,8 @@ const transformObjectLiteralExpressionOrJsxAttributes = (expression, context) =>
             }
             const type = context.checker.getTypeAtLocation(element.expression);
             let tableExpression;
-            if (typescript_1.isArrayType(context, type)) {
-                tableExpression = lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.ArrayToObject, element.expression, context.transformExpression(element.expression));
+            if ((0, typescript_1.isArrayType)(context, type)) {
+                tableExpression = (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ArrayToObject, element.expression, context.transformExpression(element.expression));
             }
             else {
                 tableExpression = context.transformExpression(element.expression);
@@ -121,10 +100,10 @@ const transformObjectLiteralExpressionOrJsxAttributes = (expression, context) =>
             tableExpressions.push(tableExpression);
         }
         else if (ts.isAccessor(element)) {
-            context.diagnostics.push(diagnostics_1.unsupportedAccessorInObjectLiteral(element));
+            context.diagnostics.push((0, diagnostics_1.unsupportedAccessorInObjectLiteral)(element));
         }
         else {
-            utils_1.assertNever(element);
+            (0, utils_1.assertNever)(element);
         }
     }
     if (tableExpressions.length === 0) {
@@ -138,14 +117,12 @@ const transformObjectLiteralExpressionOrJsxAttributes = (expression, context) =>
         if (tableExpressions[0].kind !== lua.SyntaxKind.TableExpression) {
             tableExpressions.unshift(lua.createTableExpression(undefined, expression));
         }
-        return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.ObjectAssign, expression, ...tableExpressions);
+        return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ObjectAssign, expression, ...tableExpressions);
     }
 };
-const transformObjectLiteralExpression = transformObjectLiteralExpressionOrJsxAttributes;
-exports.transformJsxAttributes = transformObjectLiteralExpressionOrJsxAttributes;
 const transformArrayLiteralExpression = (expression, context) => {
     const filteredElements = expression.elements.map(e => ts.isOmittedExpression(e) ? ts.factory.createIdentifier("undefined") : e);
-    const values = call_1.flattenSpreadExpressions(context, filteredElements).map(e => lua.createTableFieldExpression(e));
+    const values = (0, call_1.flattenSpreadExpressions)(context, filteredElements).map(e => lua.createTableFieldExpression(e));
     return lua.createTableExpression(values, expression);
 };
 exports.literalVisitors = {

package/dist/transformation/visitors/loops/do-while.js

@@ -3,10 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.transformDoStatement = exports.transformWhileStatement = void 0;
 const lua = require("../../../LuaAST");
 const utils_1 = require("./utils");
-const transformWhileStatement = (statement, context) => lua.createWhileStatement(lua.createBlock(utils_1.transformLoopBody(context, statement)), context.transformExpression(statement.expression), statement);
+const transformWhileStatement = (statement, context) => lua.createWhileStatement(lua.createBlock((0, utils_1.transformLoopBody)(context, statement)), context.transformExpression(statement.expression), statement);
 exports.transformWhileStatement = transformWhileStatement;
 const transformDoStatement = (statement, context) => {
-    const body = lua.createDoStatement(utils_1.transformLoopBody(context, statement));
+    const body = lua.createDoStatement((0, utils_1.transformLoopBody)(context, statement));
     let condition = context.transformExpression(statement.expression);
     if (lua.isUnaryExpression(condition) && condition.operator === lua.SyntaxKind.NotOperator) {
         condition = condition.operand;

package/dist/transformation/visitors/loops/for-in.js

@@ -6,15 +6,15 @@ const diagnostics_1 = require("../../utils/diagnostics");
 const typescript_1 = require("../../utils/typescript");
 const utils_1 = require("./utils");
 const transformForInStatement = (statement, context) => {
-    if (typescript_1.isArrayType(context, context.checker.getTypeAtLocation(statement.expression))) {
-        context.diagnostics.push(diagnostics_1.forbiddenForIn(statement));
+    if ((0, typescript_1.isArrayType)(context, context.checker.getTypeAtLocation(statement.expression))) {
+        context.diagnostics.push((0, diagnostics_1.forbiddenForIn)(statement));
     }
     // Transpile expression
     const pairsIdentifier = lua.createIdentifier("pairs");
     const expression = context.transformExpression(statement.expression);
     const pairsCall = lua.createCallExpression(pairsIdentifier, [expression]);
-    const body = lua.createBlock(utils_1.transformLoopBody(context, statement));
-    const valueVariable = utils_1.transformForInitializer(context, statement.initializer, body);
+    const body = lua.createBlock((0, utils_1.transformLoopBody)(context, statement));
+    const valueVariable = (0, utils_1.transformForInitializer)(context, statement.initializer, body);
     return lua.createForInStatement(body, [valueVariable], [pairsCall], statement);
 };
 exports.transformForInStatement = transformForInStatement;

package/dist/transformation/visitors/loops/for-of.js

@@ -11,32 +11,32 @@ const iterable_1 = require("../language-extensions/iterable");
 const range_1 = require("../language-extensions/range");
 const utils_1 = require("./utils");
 function transformForOfArrayStatement(context, statement, block) {
-    const valueVariable = utils_1.transformForInitializer(context, statement.initializer, block);
+    const valueVariable = (0, utils_1.transformForInitializer)(context, statement.initializer, block);
     const ipairsCall = lua.createCallExpression(lua.createIdentifier("ipairs"), [
         context.transformExpression(statement.expression),
     ]);
     return lua.createForInStatement(block, [lua.createAnonymousIdentifier(), valueVariable], [ipairsCall], statement);
 }
 function transformForOfIteratorStatement(context, statement, block) {
-    const valueVariable = utils_1.transformForInitializer(context, statement.initializer, block);
-    const iterable = lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.Iterator, statement.expression, context.transformExpression(statement.expression));
+    const valueVariable = (0, utils_1.transformForInitializer)(context, statement.initializer, block);
+    const iterable = (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.Iterator, statement.expression, context.transformExpression(statement.expression));
     return lua.createForInStatement(block, [lua.createAnonymousIdentifier(), valueVariable], [iterable], statement);
 }
 const transformForOfStatement = (node, context) => {
-    const body = lua.createBlock(utils_1.transformLoopBody(context, node));
-    if (ts.isCallExpression(node.expression) && range_1.isRangeFunction(context, node.expression)) {
-        return range_1.transformRangeStatement(context, node, body);
+    const body = lua.createBlock((0, utils_1.transformLoopBody)(context, node));
+    if (ts.isCallExpression(node.expression) && (0, range_1.isRangeFunction)(context, node.expression)) {
+        return (0, range_1.transformRangeStatement)(context, node, body);
     }
-    else if (ts.isCallExpression(node.expression) && annotations_1.isForRangeType(context, node.expression.expression)) {
-        context.diagnostics.push(diagnostics_1.annotationRemoved(node.expression, annotations_1.AnnotationKind.ForRange));
+    else if (ts.isCallExpression(node.expression) && (0, annotations_1.isForRangeType)(context, node.expression.expression)) {
+        context.diagnostics.push((0, diagnostics_1.annotationRemoved)(node.expression, annotations_1.AnnotationKind.ForRange));
     }
-    else if (iterable_1.isIterableExpression(context, node.expression)) {
-        return iterable_1.transformForOfIterableStatement(context, node, body);
+    else if ((0, iterable_1.isIterableExpression)(context, node.expression)) {
+        return (0, iterable_1.transformForOfIterableStatement)(context, node, body);
     }
-    else if (annotations_1.isLuaIteratorType(context, node.expression)) {
-        context.diagnostics.push(diagnostics_1.annotationRemoved(node.expression, annotations_1.AnnotationKind.LuaIterator));
+    else if ((0, annotations_1.isLuaIteratorType)(context, node.expression)) {
+        context.diagnostics.push((0, diagnostics_1.annotationRemoved)(node.expression, annotations_1.AnnotationKind.LuaIterator));
     }
-    else if (typescript_1.isArrayType(context, context.checker.getTypeAtLocation(node.expression))) {
+    else if ((0, typescript_1.isArrayType)(context, context.checker.getTypeAtLocation(node.expression))) {
         return transformForOfArrayStatement(context, node, body);
     }
     else {

package/dist/transformation/visitors/loops/for.js

@@ -9,9 +9,9 @@ const transformForStatement = (statement, context) => {
     const result = [];
     if (statement.initializer) {
         if (ts.isVariableDeclarationList(statement.initializer)) {
-            variable_declaration_1.checkVariableDeclarationList(context, statement.initializer);
+            (0, variable_declaration_1.checkVariableDeclarationList)(context, statement.initializer);
             // local initializer = value
-            result.push(...statement.initializer.declarations.flatMap(d => variable_declaration_1.transformVariableDeclaration(context, d)));
+            result.push(...statement.initializer.declarations.flatMap(d => (0, variable_declaration_1.transformVariableDeclaration)(context, d)));
         }
         else {
             result.push(...context.transformStatements(ts.factory.createExpressionStatement(statement.initializer)));
@@ -21,7 +21,7 @@ const transformForStatement = (statement, context) => {
         ? context.transformExpression(statement.condition)
         : lua.createBooleanLiteral(true);
     // Add body
-    const body = utils_1.transformLoopBody(context, statement);
+    const body = (0, utils_1.transformLoopBody)(context, statement);
     if (statement.incrementor) {
         body.push(...context.transformStatements(ts.factory.createExpressionStatement(statement.incrementor)));
     }

package/dist/transformation/visitors/loops/utils.js

@@ -11,9 +11,9 @@ const block_1 = require("../block");
 const identifier_1 = require("../identifier");
 const variable_declaration_1 = require("../variable-declaration");
 function transformLoopBody(context, loop) {
-    scope_1.pushScope(context, scope_1.ScopeType.Loop);
-    const body = scope_1.performHoisting(context, block_1.transformBlockOrStatement(context, loop.statement));
-    const scope = scope_1.popScope(context);
+    (0, scope_1.pushScope)(context, scope_1.ScopeType.Loop);
+    const body = (0, scope_1.performHoisting)(context, (0, block_1.transformBlockOrStatement)(context, loop.statement));
+    const scope = (0, scope_1.popScope)(context);
     const scopeId = scope.id;
     if (!scope.loopContinued) {
         return body;
@@ -25,7 +25,7 @@ function transformLoopBody(context, loop) {
 }
 exports.transformLoopBody = transformLoopBody;
 function getVariableDeclarationBinding(context, node) {
-    variable_declaration_1.checkVariableDeclarationList(context, node);
+    (0, variable_declaration_1.checkVariableDeclarationList)(context, node);
     if (node.declarations.length === 0) {
         return ts.factory.createIdentifier("____");
     }
@@ -38,18 +38,18 @@ function transformForInitializer(context, initializer, block) {
         // Declaration of new variable
         const binding = getVariableDeclarationBinding(context, initializer);
         if (ts.isArrayBindingPattern(binding) || ts.isObjectBindingPattern(binding)) {
-            block.statements.unshift(...variable_declaration_1.transformBindingPattern(context, binding, valueVariable));
+            block.statements.unshift(...(0, variable_declaration_1.transformBindingPattern)(context, binding, valueVariable));
         }
         else {
             // Single variable declared in for loop
-            return identifier_1.transformIdentifier(context, binding);
+            return (0, identifier_1.transformIdentifier)(context, binding);
         }
     }
     else {
         // Assignment to existing variable(s)
-        block.statements.unshift(...(typescript_1.isAssignmentPattern(initializer)
-            ? destructuring_assignments_1.transformAssignmentPattern(context, initializer, valueVariable)
-            : assignments_1.transformAssignment(context, initializer, valueVariable)));
+        block.statements.unshift(...((0, typescript_1.isAssignmentPattern)(initializer)
+            ? (0, destructuring_assignments_1.transformAssignmentPattern)(context, initializer, valueVariable)
+            : (0, assignments_1.transformAssignment)(context, initializer, valueVariable)));
     }
     return valueVariable;
 }

package/dist/transformation/visitors/modules/export.js

@@ -19,25 +19,25 @@ const transformExportAssignment = (node, context) => {
     // export = [expression];
     // ____exports = [expression];
     if (node.isExportEquals) {
-        return lua.createVariableDeclarationStatement(lua_ast_1.createExportsIdentifier(), exportedValue, node);
+        return lua.createVariableDeclarationStatement((0, lua_ast_1.createExportsIdentifier)(), exportedValue, node);
     }
     else {
         // export default [expression];
         // ____exports.default = [expression];
-        return lua.createAssignmentStatement(lua.createTableIndexExpression(lua_ast_1.createExportsIdentifier(), export_1.createDefaultExportStringLiteral(node)), exportedValue, node);
+        return lua.createAssignmentStatement(lua.createTableIndexExpression((0, lua_ast_1.createExportsIdentifier)(), (0, export_1.createDefaultExportStringLiteral)(node)), exportedValue, node);
     }
 };
 exports.transformExportAssignment = transformExportAssignment;
 function transformExportAll(context, node) {
-    utils_1.assert(node.moduleSpecifier);
+    (0, utils_1.assert)(node.moduleSpecifier);
     if (!context.resolver.moduleExportsSomeValue(node.moduleSpecifier)) {
         return undefined;
     }
-    const moduleRequire = import_1.createModuleRequire(context, node.moduleSpecifier);
+    const moduleRequire = (0, import_1.createModuleRequire)(context, node.moduleSpecifier);
     // export * as ns from "...";
     // exports.ns = require(...)
     if (node.exportClause && ts.isNamespaceExport(node.exportClause)) {
-        const assignToExports = lua.createAssignmentStatement(lua.createTableIndexExpression(lua_ast_1.createExportsIdentifier(), lua.createStringLiteral(node.exportClause.name.text)), moduleRequire);
+        const assignToExports = lua.createAssignmentStatement(lua.createTableIndexExpression((0, lua_ast_1.createExportsIdentifier)(), lua.createStringLiteral(node.exportClause.name.text)), moduleRequire);
         return assignToExports;
     }
     // export * from "...";
@@ -50,7 +50,7 @@ function transformExportAll(context, node) {
     // ____exports[____exportKey] = ____exportValue
     const forKey = lua.createIdentifier("____exportKey");
     const forValue = lua.createIdentifier("____exportValue");
-    const leftAssignment = lua.createAssignmentStatement(lua.createTableIndexExpression(lua_ast_1.createExportsIdentifier(), forKey), forValue);
+    const leftAssignment = lua.createAssignmentStatement(lua.createTableIndexExpression((0, lua_ast_1.createExportsIdentifier)(), forKey), forValue);
     // if key ~= "default" then
     //  -- export the value, do not export "default" values
     // end
@@ -70,12 +70,12 @@ const isDefaultExportSpecifier = (node) => (node.name && node.name.originalKeywo
 function transformExportSpecifier(context, node) {
     const exportedSymbol = context.checker.getExportSpecifierLocalTargetSymbol(node);
     const exportedIdentifier = node.propertyName ? node.propertyName : node.name;
-    const exportedExpression = literal_1.createShorthandIdentifier(context, exportedSymbol, exportedIdentifier);
+    const exportedExpression = (0, literal_1.createShorthandIdentifier)(context, exportedSymbol, exportedIdentifier);
     const isDefault = isDefaultExportSpecifier(node);
     const identifierToExport = isDefault
-        ? export_1.createDefaultExportIdentifier(node)
-        : identifier_1.transformIdentifier(context, node.name);
-    const exportAssignmentLeftHandSide = export_1.createExportedIdentifier(context, identifierToExport);
+        ? (0, export_1.createDefaultExportIdentifier)(node)
+        : (0, identifier_1.transformIdentifier)(context, node.name);
+    const exportAssignmentLeftHandSide = (0, export_1.createExportedIdentifier)(context, identifierToExport);
     return lua.createAssignmentStatement(exportAssignmentLeftHandSide, exportedExpression, node);
 }
 function transformExportSpecifiersFrom(context, statement, moduleSpecifier, exportSpecifiers) {
@@ -83,11 +83,11 @@ function transformExportSpecifiersFrom(context, statement, moduleSpecifier, expo
     const importClause = ts.factory.createImportClause(false, undefined, ts.factory.createNamedImports(exportSpecifiers.map(s => ts.factory.createImportSpecifier(s.propertyName, s.name))));
     const importDeclaration = ts.factory.createImportDeclaration(statement.decorators, statement.modifiers, importClause, moduleSpecifier);
     // Wrap in block to prevent imports from hoisting out of `do` statement
-    const [block] = block_1.transformScopeBlock(context, ts.factory.createBlock([importDeclaration]), scope_1.ScopeType.Block);
+    const [block] = (0, block_1.transformScopeBlock)(context, ts.factory.createBlock([importDeclaration]), scope_1.ScopeType.Block);
     const result = block.statements;
     // Now the module is imported, add the imports to the export table
     for (const specifier of exportSpecifiers) {
-        result.push(lua.createAssignmentStatement(export_1.createExportedIdentifier(context, identifier_1.transformIdentifier(context, specifier.name)), identifier_1.transformIdentifier(context, specifier.name)));
+        result.push(lua.createAssignmentStatement((0, export_1.createExportedIdentifier)(context, (0, identifier_1.transformIdentifier)(context, specifier.name)), (0, identifier_1.transformIdentifier)(context, specifier.name)));
     }
     // Wrap this in a DoStatement to prevent polluting the scope.
     return lua.createDoStatement(result, statement);
@@ -106,7 +106,7 @@ const transformExportDeclaration = (node, context) => {
         // export * as ns from "...";
         return transformExportAll(context, node);
     }
-    const exportSpecifiers = exports.getExported(context, node.exportClause);
+    const exportSpecifiers = (0, exports.getExported)(context, node.exportClause);
     // export { ... };
     if (!node.moduleSpecifier) {
         return exportSpecifiers.map(exportSpecifier => transformExportSpecifier(context, exportSpecifier));

package/dist/transformation/visitors/modules/import.js

@@ -15,7 +15,7 @@ function isNoResolutionPath(context, moduleSpecifier) {
     const moduleOwnerSymbol = context.checker.getSymbolAtLocation(moduleSpecifier);
     if (!moduleOwnerSymbol)
         return false;
-    const annotations = annotations_1.getSymbolAnnotations(moduleOwnerSymbol);
+    const annotations = (0, annotations_1.getSymbolAnnotations)(moduleOwnerSymbol);
     return annotations.has(annotations_1.AnnotationKind.NoResolution);
 }
 function createModuleRequire(context, moduleSpecifier, tsOriginal = moduleSpecifier) {
@@ -33,12 +33,12 @@ function shouldBeImported(context, importNode) {
     return context.resolver.isReferencedAliasDeclaration(importNode);
 }
 function transformImportSpecifier(context, importSpecifier, moduleTableName) {
-    const leftIdentifier = identifier_1.transformIdentifier(context, importSpecifier.name);
-    const propertyName = literal_1.transformPropertyName(context, importSpecifier.propertyName ? importSpecifier.propertyName : importSpecifier.name);
+    const leftIdentifier = (0, identifier_1.transformIdentifier)(context, importSpecifier.name);
+    const propertyName = (0, literal_1.transformPropertyName)(context, importSpecifier.propertyName ? importSpecifier.propertyName : importSpecifier.name);
     return lua.createVariableDeclarationStatement(leftIdentifier, lua.createTableIndexExpression(moduleTableName, propertyName), importSpecifier);
 }
 const transformImportDeclaration = (statement, context) => {
-    const scope = scope_1.peekScope(context);
+    const scope = (0, scope_1.peekScope)(context);
     if (!scope.importStatements) {
         scope.importStatements = [];
     }
@@ -61,14 +61,14 @@ const transformImportDeclaration = (statement, context) => {
         : "module";
     // Create the require statement to extract values.
     // local ____module = require("module")
-    const importUniqueName = lua.createIdentifier(safe_names_1.createSafeName(path.basename(importPath)));
+    const importUniqueName = lua.createIdentifier((0, safe_names_1.createSafeName)(path.basename(importPath)));
     let usingRequireStatement = false;
     // import defaultValue from "./module";
     // local defaultValue = __module.default
     if (statement.importClause.name) {
         if (shouldBeImported(context, statement.importClause)) {
-            const propertyName = export_1.createDefaultExportStringLiteral(statement.importClause.name);
-            const defaultImportAssignmentStatement = lua.createVariableDeclarationStatement(identifier_1.transformIdentifier(context, statement.importClause.name), lua.createTableIndexExpression(importUniqueName, propertyName), statement.importClause.name);
+            const propertyName = (0, export_1.createDefaultExportStringLiteral)(statement.importClause.name);
+            const defaultImportAssignmentStatement = lua.createVariableDeclarationStatement((0, identifier_1.transformIdentifier)(context, statement.importClause.name), lua.createTableIndexExpression(importUniqueName, propertyName), statement.importClause.name);
             result.push(defaultImportAssignmentStatement);
             usingRequireStatement = true;
         }
@@ -77,7 +77,7 @@ const transformImportDeclaration = (statement, context) => {
     // local module = require("module")
     if (statement.importClause.namedBindings && ts.isNamespaceImport(statement.importClause.namedBindings)) {
         if (context.resolver.isReferencedAliasDeclaration(statement.importClause.namedBindings)) {
-            const requireStatement = lua.createVariableDeclarationStatement(identifier_1.transformIdentifier(context, statement.importClause.namedBindings.name), requireCall, statement);
+            const requireStatement = lua.createVariableDeclarationStatement((0, identifier_1.transformIdentifier)(context, statement.importClause.namedBindings.name), requireCall, statement);
             result.push(requireStatement);
         }
     }
@@ -118,9 +118,9 @@ const transformImportEqualsDeclaration = (node, context) => {
             !context.resolver.isTopLevelValueImportEqualsWithEntityName(node))) {
         return undefined;
     }
-    const name = identifier_1.transformIdentifier(context, node.name);
+    const name = (0, identifier_1.transformIdentifier)(context, node.name);
     const expression = context.transformExpression(node.moduleReference);
-    return lua_ast_1.createHoistableVariableDeclarationStatement(context, name, expression, node);
+    return (0, lua_ast_1.createHoistableVariableDeclarationStatement)(context, name, expression, node);
 };
 exports.transformImportEqualsDeclaration = transformImportEqualsDeclaration;
 //# sourceMappingURL=import.js.map

package/dist/transformation/visitors/namespace.js

@@ -13,11 +13,11 @@ const symbols_1 = require("../utils/symbols");
 const identifier_1 = require("./identifier");
 function createModuleLocalNameIdentifier(context, declaration) {
     const moduleSymbol = context.checker.getSymbolAtLocation(declaration.name);
-    if (moduleSymbol !== undefined && safe_names_1.isUnsafeName(moduleSymbol.name)) {
-        return lua.createIdentifier(safe_names_1.createSafeName(declaration.name.text), declaration.name, moduleSymbol && symbols_1.getSymbolIdOfSymbol(context, moduleSymbol), declaration.name.text);
+    if (moduleSymbol !== undefined && (0, safe_names_1.isUnsafeName)(moduleSymbol.name)) {
+        return lua.createIdentifier((0, safe_names_1.createSafeName)(declaration.name.text), declaration.name, moduleSymbol && (0, symbols_1.getSymbolIdOfSymbol)(context, moduleSymbol), declaration.name.text);
     }
     // TODO: Should synthetic name nodes be escaped as well?
-    return identifier_1.transformIdentifier(context, declaration.name);
+    return (0, identifier_1.transformIdentifier)(context, declaration.name);
 }
 exports.createModuleLocalNameIdentifier = createModuleLocalNameIdentifier;
 // TODO: Do it based on transform result?
@@ -37,17 +37,17 @@ function moduleHasEmittedBody(node) {
 const currentNamespaces = new WeakMap();
 const transformModuleDeclaration = (node, context) => {
     var _a, _b;
-    const annotations = annotations_1.getTypeAnnotations(context.checker.getTypeAtLocation(node));
+    const annotations = (0, annotations_1.getTypeAnnotations)(context.checker.getTypeAtLocation(node));
     // If phantom namespace elide the declaration and return the body
     if (annotations.has(annotations_1.AnnotationKind.Phantom)) {
-        context.diagnostics.push(diagnostics_1.annotationRemoved(node, annotations_1.AnnotationKind.Phantom));
+        context.diagnostics.push((0, diagnostics_1.annotationRemoved)(node, annotations_1.AnnotationKind.Phantom));
     }
     const currentNamespace = currentNamespaces.get(context);
     const result = [];
     const symbol = context.checker.getSymbolAtLocation(node.name);
     const hasExports = symbol !== undefined && context.checker.getExportsOfModule(symbol).length > 0;
-    const nameIdentifier = identifier_1.transformIdentifier(context, node.name);
-    const exportScope = export_1.getIdentifierExportScope(context, nameIdentifier);
+    const nameIdentifier = (0, identifier_1.transformIdentifier)(context, node.name);
+    const exportScope = (0, export_1.getIdentifierExportScope)(context, nameIdentifier);
     // Non-module namespace could be merged if:
     // - is top level
     // - is nested and exported
@@ -60,17 +60,17 @@ const transformModuleDeclaration = (node, context) => {
             ts.getOriginalNode(node) === ((_b = symbol.declarations) === null || _b === void 0 ? void 0 : _b.find(ts.isModuleDeclaration)));
     if (isNonModuleMergeable) {
         // 'local NS = NS or {}' or 'exportTable.NS = exportTable.NS or {}'
-        const localDeclaration = lua_ast_1.createLocalOrExportedOrGlobalDeclaration(context, nameIdentifier, lua.createBinaryExpression(export_1.addExportToIdentifier(context, nameIdentifier), lua.createTableExpression(), lua.SyntaxKind.OrOperator));
+        const localDeclaration = (0, lua_ast_1.createLocalOrExportedOrGlobalDeclaration)(context, nameIdentifier, lua.createBinaryExpression((0, export_1.addExportToIdentifier)(context, nameIdentifier), lua.createTableExpression(), lua.SyntaxKind.OrOperator));
         result.push(...localDeclaration);
     }
     else if (isFirstDeclaration) {
         // local NS = {} or exportTable.NS = {}
-        const localDeclaration = lua_ast_1.createLocalOrExportedOrGlobalDeclaration(context, nameIdentifier, lua.createTableExpression());
+        const localDeclaration = (0, lua_ast_1.createLocalOrExportedOrGlobalDeclaration)(context, nameIdentifier, lua.createTableExpression());
         result.push(...localDeclaration);
     }
     if ((isNonModuleMergeable || isFirstDeclaration) && exportScope && hasExports && moduleHasEmittedBody(node)) {
         // local NS = exportTable.NS
-        const localDeclaration = lua_ast_1.createHoistableVariableDeclarationStatement(context, createModuleLocalNameIdentifier(context, node), export_1.createExportedIdentifier(context, nameIdentifier, exportScope));
+        const localDeclaration = (0, lua_ast_1.createHoistableVariableDeclarationStatement)(context, createModuleLocalNameIdentifier(context, node), (0, export_1.createExportedIdentifier)(context, nameIdentifier, exportScope));
         result.push(localDeclaration);
     }
     // Set current namespace for nested NS
@@ -78,9 +78,9 @@ const transformModuleDeclaration = (node, context) => {
     currentNamespaces.set(context, node);
     // Transform moduleblock to block and visit it
     if (moduleHasEmittedBody(node)) {
-        scope_1.pushScope(context, scope_1.ScopeType.Block);
-        const statements = scope_1.performHoisting(context, context.transformStatements(ts.isModuleBlock(node.body) ? node.body.statements : node.body));
-        scope_1.popScope(context);
+        (0, scope_1.pushScope)(context, scope_1.ScopeType.Block);
+        const statements = (0, scope_1.performHoisting)(context, context.transformStatements(ts.isModuleBlock(node.body) ? node.body.statements : node.body));
+        (0, scope_1.popScope)(context);
         result.push(lua.createDoStatement(statements));
     }
     currentNamespaces.set(context, currentNamespace);

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

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

package/dist/transformation/visitors/return.js

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