typescript-to-lua 0.42.0 → 1.1.1

package/dist/transformation/utils/lua-ast.js

@@ -10,7 +10,7 @@ const scope_1 = require("./scope");
 const lualib_1 = require("./lualib");
 const LuaLib_1 = require("../../LuaLib");
 function unwrapVisitorResult(result) {
-    return result === undefined ? [] : utils_1.castArray(result);
+    return result === undefined ? [] : (0, utils_1.castArray)(result);
 }
 exports.unwrapVisitorResult = unwrapVisitorResult;
 function createSelfIdentifier(tsOriginal) {
@@ -58,7 +58,7 @@ exports.getNumberLiteralValue = getNumberLiteralValue;
 // Prefer use of transformToImmediatelyInvokedFunctionExpression to maintain correct scope. If you use this directly,
 // ensure you push/pop a function scope appropriately to avoid incorrect vararg optimization.
 function createImmediatelyInvokedFunctionExpression(statements, result, tsOriginal) {
-    const body = [...statements, lua.createReturnStatement(utils_1.castArray(result))];
+    const body = [...statements, lua.createReturnStatement((0, utils_1.castArray)(result))];
     const flags = statements.length === 0 ? lua.FunctionExpressionFlags.Inline : lua.FunctionExpressionFlags.None;
     const iife = lua.createFunctionExpression(lua.createBlock(body), undefined, undefined, flags);
     return lua.createCallExpression(iife, [], tsOriginal);
@@ -66,7 +66,7 @@ function createImmediatelyInvokedFunctionExpression(statements, result, tsOrigin
 exports.createImmediatelyInvokedFunctionExpression = createImmediatelyInvokedFunctionExpression;
 function createUnpackCall(context, expression, tsOriginal) {
     if (context.luaTarget === CompilerOptions_1.LuaTarget.Universal) {
-        return lualib_1.transformLuaLibFunction(context, LuaLib_1.LuaLibFeature.Unpack, tsOriginal, expression);
+        return (0, lualib_1.transformLuaLibFunction)(context, LuaLib_1.LuaLibFeature.Unpack, tsOriginal, expression);
     }
     const unpack = context.luaTarget === CompilerOptions_1.LuaTarget.Lua51 || context.luaTarget === CompilerOptions_1.LuaTarget.LuaJIT
         ? lua.createIdentifier("unpack")
@@ -91,8 +91,8 @@ exports.wrapInToStringForConcat = wrapInToStringForConcat;
 function createHoistableVariableDeclarationStatement(context, identifier, initializer, tsOriginal) {
     const declaration = lua.createVariableDeclarationStatement(identifier, initializer, tsOriginal);
     if (identifier.symbolId !== undefined) {
-        const scope = scope_1.peekScope(context);
-        utils_1.assert(scope.type !== scope_1.ScopeType.Switch);
+        const scope = (0, scope_1.peekScope)(context);
+        (0, utils_1.assert)(scope.type !== scope_1.ScopeType.Switch);
         if (!scope.variableDeclarations) {
             scope.variableDeclarations = [];
         }
@@ -106,32 +106,32 @@ function hasMultipleReferences(scope, identifiers) {
     if (!scopeSymbols) {
         return false;
     }
-    const referenceLists = utils_1.castArray(identifiers).map(i => i.symbolId && scopeSymbols.get(i.symbolId));
+    const referenceLists = (0, utils_1.castArray)(identifiers).map(i => i.symbolId && scopeSymbols.get(i.symbolId));
     return referenceLists.some(symbolRefs => symbolRefs && symbolRefs.length > 1);
 }
 function createLocalOrExportedOrGlobalDeclaration(context, lhs, rhs, tsOriginal, overrideExportScope) {
     let declaration;
     let assignment;
     const isFunctionDeclaration = tsOriginal !== undefined && ts.isFunctionDeclaration(tsOriginal);
-    const identifiers = utils_1.castArray(lhs);
+    const identifiers = (0, utils_1.castArray)(lhs);
     if (identifiers.length === 0) {
         return [];
     }
-    const exportScope = overrideExportScope !== null && overrideExportScope !== void 0 ? overrideExportScope : export_1.getIdentifierExportScope(context, identifiers[0]);
+    const exportScope = overrideExportScope !== null && overrideExportScope !== void 0 ? overrideExportScope : (0, export_1.getIdentifierExportScope)(context, identifiers[0]);
     if (exportScope) {
         // exported
         if (!rhs) {
             return [];
         }
         else {
-            assignment = lua.createAssignmentStatement(identifiers.map(identifier => export_1.createExportedIdentifier(context, identifier, exportScope)), rhs, tsOriginal);
+            assignment = lua.createAssignmentStatement(identifiers.map(identifier => (0, export_1.createExportedIdentifier)(context, identifier, exportScope)), rhs, tsOriginal);
         }
     }
     else {
-        const scope = scope_1.peekScope(context);
+        const scope = (0, scope_1.peekScope)(context);
         const isTopLevelVariable = scope.type === scope_1.ScopeType.File;
         if (context.isModule || !isTopLevelVariable) {
-            if (scope.type === scope_1.ScopeType.Switch || (!isFunctionDeclaration && hasMultipleReferences(scope, lhs))) {
+            if (!isFunctionDeclaration && hasMultipleReferences(scope, lhs)) {
                 // Split declaration and assignment of identifiers that reference themselves in their declaration
                 declaration = lua.createVariableDeclarationStatement(lhs, undefined, tsOriginal);
                 if (rhs) {
@@ -141,13 +141,12 @@ function createLocalOrExportedOrGlobalDeclaration(context, lhs, rhs, tsOriginal,
             else {
                 declaration = lua.createVariableDeclarationStatement(lhs, rhs, tsOriginal);
             }
-            // Remember local variable declarations for hoisting later
-            if (!scope.variableDeclarations) {
-                scope.variableDeclarations = [];
-            }
-            scope.variableDeclarations.push(declaration);
-            if (scope.type === scope_1.ScopeType.Switch) {
-                declaration = undefined;
+            if (!isFunctionDeclaration) {
+                // Remember local variable declarations for hoisting later
+                if (!scope.variableDeclarations) {
+                    scope.variableDeclarations = [];
+                }
+                scope.variableDeclarations.push(declaration);
             }
         }
         else if (rhs) {
@@ -161,7 +160,7 @@ function createLocalOrExportedOrGlobalDeclaration(context, lhs, rhs, tsOriginal,
     if (isFunctionDeclaration) {
         // Remember function definitions for hoisting later
         const functionSymbolId = lhs.symbolId;
-        const scope = scope_1.peekScope(context);
+        const scope = (0, scope_1.peekScope)(context);
         if (functionSymbolId && scope.functionDefinitions) {
             const definitions = scope.functionDefinitions.get(functionSymbolId);
             if (definitions) {

package/dist/transformation/utils/lualib.js

@@ -7,7 +7,7 @@ Object.defineProperty(exports, "LuaLibFeature", { enumerable: true, get: functio
 const utils_1 = require("../../utils");
 const luaLibFeatures = new WeakMap();
 function getUsedLuaLibFeatures(context) {
-    return utils_1.getOrUpdate(luaLibFeatures, context, () => new Set());
+    return (0, utils_1.getOrUpdate)(luaLibFeatures, context, () => new Set());
 }
 exports.getUsedLuaLibFeatures = getUsedLuaLibFeatures;
 function importLuaLibFeature(context, feature) {

package/dist/transformation/utils/safe-names.js

@@ -51,27 +51,27 @@ const luaBuiltins = new Set([
     "type",
     "unpack",
 ]);
-const isUnsafeName = (name) => !exports.isValidLuaIdentifier(name) || luaBuiltins.has(name);
+const isUnsafeName = (name) => !(0, exports.isValidLuaIdentifier)(name) || luaBuiltins.has(name);
 exports.isUnsafeName = isUnsafeName;
 function checkName(context, name, node) {
-    const isInvalid = !exports.isValidLuaIdentifier(name);
+    const isInvalid = !(0, exports.isValidLuaIdentifier)(name);
     if (isInvalid) {
         // Empty identifier is a TypeScript error
         if (name !== "") {
-            context.diagnostics.push(diagnostics_1.invalidAmbientIdentifierName(node, name));
+            context.diagnostics.push((0, diagnostics_1.invalidAmbientIdentifierName)(node, name));
         }
     }
     return isInvalid;
 }
 function hasUnsafeSymbolName(context, symbol, tsOriginal) {
     var _a, _b;
-    const isAmbient = (_b = (_a = symbol.declarations) === null || _a === void 0 ? void 0 : _a.some(d => typescript_1.isAmbientNode(d))) !== null && _b !== void 0 ? _b : false;
+    const isAmbient = (_b = (_a = symbol.declarations) === null || _a === void 0 ? void 0 : _a.some(d => (0, typescript_1.isAmbientNode)(d))) !== null && _b !== void 0 ? _b : false;
     // Catch ambient declarations of identifiers with bad names
     if (isAmbient && checkName(context, symbol.name, tsOriginal)) {
         return true;
     }
     // only unsafe when non-ambient and not exported
-    return exports.isUnsafeName(symbol.name) && !isAmbient && !export_1.isSymbolExported(context, symbol);
+    return (0, exports.isUnsafeName)(symbol.name) && !isAmbient && !(0, export_1.isSymbolExported)(context, symbol);
 }
 exports.hasUnsafeSymbolName = hasUnsafeSymbolName;
 function hasUnsafeIdentifierName(context, identifier, checkSymbol = true) {

package/dist/transformation/utils/scope.d.ts

@@ -26,6 +26,11 @@ export interface Scope {
     loopContinued?: boolean;
     functionReturned?: boolean;
 }
+export interface HoistingResult {
+    statements: lua.Statement[];
+    hoistedStatements: lua.Statement[];
+    hoistedIdentifiers: lua.Identifier[];
+}
 export declare function walkScopesUp(context: TransformationContext): IterableIterator<Scope>;
 export declare function markSymbolAsReferencedInCurrentScopes(context: TransformationContext, symbolId: lua.SymbolId, identifier: ts.Identifier): void;
 export declare function peekScope(context: TransformationContext): Scope;
@@ -37,5 +42,6 @@ export declare function hasReferencedSymbol(context: TransformationContext, scop
 export declare function isFunctionScopeWithDefinition(scope: Scope): scope is Scope & {
     node: ts.SignatureDeclaration;
 };
+export declare function separateHoistedStatements(context: TransformationContext, statements: lua.Statement[]): HoistingResult;
 export declare function performHoisting(context: TransformationContext, statements: lua.Statement[]): lua.Statement[];
 export {};

package/dist/transformation/utils/scope.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.performHoisting = exports.isFunctionScopeWithDefinition = exports.hasReferencedSymbol = exports.hasReferencedUndefinedLocalFunction = exports.popScope = exports.pushScope = exports.findScope = exports.peekScope = exports.markSymbolAsReferencedInCurrentScopes = exports.walkScopesUp = exports.ScopeType = void 0;
+exports.performHoisting = exports.separateHoistedStatements = exports.isFunctionScopeWithDefinition = exports.hasReferencedSymbol = exports.hasReferencedUndefinedLocalFunction = exports.popScope = exports.pushScope = exports.findScope = exports.peekScope = exports.markSymbolAsReferencedInCurrentScopes = exports.walkScopesUp = exports.ScopeType = void 0;
 const ts = require("typescript");
 const lua = require("../../LuaAST");
 const utils_1 = require("../../utils");
@@ -19,7 +19,7 @@ var ScopeType;
 })(ScopeType = exports.ScopeType || (exports.ScopeType = {}));
 const scopeStacks = new WeakMap();
 function getScopeStack(context) {
-    return utils_1.getOrUpdate(scopeStacks, context, () => []);
+    return (0, utils_1.getOrUpdate)(scopeStacks, context, () => []);
 }
 function* walkScopesUp(context) {
     const scopeStack = getScopeStack(context);
@@ -34,7 +34,7 @@ function markSymbolAsReferencedInCurrentScopes(context, symbolId, identifier) {
         if (!scope.referencedSymbols) {
             scope.referencedSymbols = new Map();
         }
-        const references = utils_1.getOrUpdate(scope.referencedSymbols, symbolId, () => []);
+        const references = (0, utils_1.getOrUpdate)(scope.referencedSymbols, symbolId, () => []);
         references.push(identifier);
     }
 }
@@ -42,7 +42,7 @@ exports.markSymbolAsReferencedInCurrentScopes = markSymbolAsReferencedInCurrentS
 function peekScope(context) {
     const scopeStack = getScopeStack(context);
     const scope = scopeStack[scopeStack.length - 1];
-    utils_1.assert(scope);
+    (0, utils_1.assert)(scope);
     return scope;
 }
 exports.peekScope = peekScope;
@@ -64,13 +64,13 @@ exports.pushScope = pushScope;
 function popScope(context) {
     const scopeStack = getScopeStack(context);
     const scope = scopeStack.pop();
-    utils_1.assert(scope);
+    (0, utils_1.assert)(scope);
     return scope;
 }
 exports.popScope = popScope;
 function isHoistableFunctionDeclaredInScope(symbol, scopeNode) {
     var _a;
-    return (_a = symbol === null || symbol === void 0 ? void 0 : symbol.declarations) === null || _a === void 0 ? void 0 : _a.some(d => ts.isFunctionDeclaration(d) && typescript_1.findFirstNodeAbove(d, (n) => n === scopeNode));
+    return (_a = symbol === null || symbol === void 0 ? void 0 : symbol.declarations) === null || _a === void 0 ? void 0 : _a.some(d => ts.isFunctionDeclaration(d) && (0, typescript_1.findFirstNodeAbove)(d, (n) => n === scopeNode));
 }
 // Checks for references to local functions which haven't been defined yet,
 // and thus will be hoisted above the current position.
@@ -106,21 +106,43 @@ function isFunctionScopeWithDefinition(scope) {
     return scope.node !== undefined && ts.isFunctionLike(scope.node);
 }
 exports.isFunctionScopeWithDefinition = isFunctionScopeWithDefinition;
-function performHoisting(context, statements) {
+function separateHoistedStatements(context, statements) {
     const scope = peekScope(context);
-    let result = statements;
-    result = hoistFunctionDefinitions(context, scope, result);
-    result = hoistVariableDeclarations(context, scope, result);
-    result = hoistImportStatements(scope, result);
-    return result;
+    const allHoistedStatments = [];
+    const allHoistedIdentifiers = [];
+    let { unhoistedStatements, hoistedStatements, hoistedIdentifiers } = hoistFunctionDefinitions(context, scope, statements);
+    allHoistedStatments.push(...hoistedStatements);
+    allHoistedIdentifiers.push(...hoistedIdentifiers);
+    ({ unhoistedStatements, hoistedIdentifiers } = hoistVariableDeclarations(context, scope, unhoistedStatements));
+    allHoistedIdentifiers.push(...hoistedIdentifiers);
+    ({ unhoistedStatements, hoistedStatements } = hoistImportStatements(scope, unhoistedStatements));
+    allHoistedStatments.unshift(...hoistedStatements);
+    return {
+        statements: unhoistedStatements,
+        hoistedStatements: allHoistedStatments,
+        hoistedIdentifiers: allHoistedIdentifiers,
+    };
+}
+exports.separateHoistedStatements = separateHoistedStatements;
+function performHoisting(context, statements) {
+    const result = separateHoistedStatements(context, statements);
+    const modifiedStatements = [...result.hoistedStatements, ...result.statements];
+    if (result.hoistedIdentifiers.length > 0) {
+        modifiedStatements.unshift(lua.createVariableDeclarationStatement(result.hoistedIdentifiers));
+    }
+    return modifiedStatements;
 }
 exports.performHoisting = performHoisting;
 function shouldHoistSymbol(context, symbolId, scope) {
-    const symbolInfo = symbols_1.getSymbolInfo(context, symbolId);
+    // Always hoist in top-level of switch statements
+    if (scope.type === ScopeType.Switch) {
+        return true;
+    }
+    const symbolInfo = (0, symbols_1.getSymbolInfo)(context, symbolId);
     if (!symbolInfo) {
         return false;
     }
-    const declaration = typescript_1.getFirstDeclarationInFile(symbolInfo.symbol, context.sourceFile);
+    const declaration = (0, typescript_1.getFirstDeclarationInFile)(symbolInfo.symbol, context.sourceFile);
     if (!declaration) {
         return false;
     }
@@ -129,7 +151,7 @@ function shouldHoistSymbol(context, symbolId, scope) {
     }
     if (scope.functionDefinitions) {
         for (const [functionSymbolId, functionDefinition] of scope.functionDefinitions) {
-            utils_1.assert(functionDefinition.definition);
+            (0, utils_1.assert)(functionDefinition.definition);
             const { line, column } = lua.getOriginalPos(functionDefinition.definition);
             if (line !== undefined && column !== undefined) {
                 const definitionPos = ts.getPositionOfLineAndCharacter(context.sourceFile, line, column);
@@ -146,52 +168,60 @@ function shouldHoistSymbol(context, symbolId, scope) {
 }
 function hoistVariableDeclarations(context, scope, statements) {
     if (!scope.variableDeclarations) {
-        return statements;
+        return { unhoistedStatements: statements, hoistedIdentifiers: [] };
     }
-    const result = [...statements];
-    const hoistedLocals = [];
+    const unhoistedStatements = [...statements];
+    const hoistedIdentifiers = [];
     for (const declaration of scope.variableDeclarations) {
         const symbols = declaration.left.map(i => i.symbolId).filter(utils_1.isNonNull);
         if (symbols.some(s => shouldHoistSymbol(context, s, scope))) {
-            const index = result.indexOf(declaration);
-            utils_1.assert(index > -1);
+            const index = unhoistedStatements.indexOf(declaration);
+            if (index < 0) {
+                continue; // statements array may not contain all statements in the scope (switch-case)
+            }
             if (declaration.right) {
                 const assignment = lua.createAssignmentStatement(declaration.left, declaration.right);
                 lua.setNodePosition(assignment, declaration); // Preserve position info for sourcemap
-                result.splice(index, 1, assignment);
+                unhoistedStatements.splice(index, 1, assignment);
             }
             else {
-                result.splice(index, 1);
+                unhoistedStatements.splice(index, 1);
             }
-            hoistedLocals.push(...declaration.left);
-        }
-        else if (scope.type === ScopeType.Switch) {
-            utils_1.assert(!declaration.right);
-            hoistedLocals.push(...declaration.left);
+            hoistedIdentifiers.push(...declaration.left);
         }
     }
-    if (hoistedLocals.length > 0) {
-        result.unshift(lua.createVariableDeclarationStatement(hoistedLocals));
-    }
-    return result;
+    return { unhoistedStatements, hoistedIdentifiers };
 }
 function hoistFunctionDefinitions(context, scope, statements) {
     if (!scope.functionDefinitions) {
-        return statements;
+        return { unhoistedStatements: statements, hoistedStatements: [], hoistedIdentifiers: [] };
     }
-    const result = [...statements];
-    const hoistedFunctions = [];
+    const unhoistedStatements = [...statements];
+    const hoistedStatements = [];
+    const hoistedIdentifiers = [];
     for (const [functionSymbolId, functionDefinition] of scope.functionDefinitions) {
-        utils_1.assert(functionDefinition.definition);
+        (0, utils_1.assert)(functionDefinition.definition);
         if (shouldHoistSymbol(context, functionSymbolId, scope)) {
-            const index = result.indexOf(functionDefinition.definition);
-            result.splice(index, 1);
-            hoistedFunctions.push(functionDefinition.definition);
+            const index = unhoistedStatements.indexOf(functionDefinition.definition);
+            if (index < 0) {
+                continue; // statements array may not contain all statements in the scope (switch-case)
+            }
+            unhoistedStatements.splice(index, 1);
+            if (lua.isVariableDeclarationStatement(functionDefinition.definition)) {
+                // Separate function definition and variable declaration
+                (0, utils_1.assert)(functionDefinition.definition.right);
+                hoistedIdentifiers.push(...functionDefinition.definition.left);
+                hoistedStatements.push(lua.createAssignmentStatement(functionDefinition.definition.left, functionDefinition.definition.right));
+            }
+            else {
+                hoistedStatements.push(functionDefinition.definition);
+            }
         }
     }
-    return [...hoistedFunctions, ...result];
+    return { unhoistedStatements, hoistedStatements, hoistedIdentifiers };
 }
 function hoistImportStatements(scope, statements) {
-    return scope.importStatements ? [...scope.importStatements, ...statements] : statements;
+    var _a;
+    return { unhoistedStatements: statements, hoistedStatements: (_a = scope.importStatements) !== null && _a !== void 0 ? _a : [] };
 }
 //# sourceMappingURL=scope.js.map

package/dist/transformation/utils/symbols.js

@@ -14,27 +14,27 @@ function nextSymbolId(context) {
 const symbolInfoMap = new WeakMap();
 const symbolIdMaps = new WeakMap();
 function getSymbolInfo(context, symbolId) {
-    return utils_1.getOrUpdate(symbolInfoMap, context, () => new Map()).get(symbolId);
+    return (0, utils_1.getOrUpdate)(symbolInfoMap, context, () => new Map()).get(symbolId);
 }
 exports.getSymbolInfo = getSymbolInfo;
 function getSymbolIdOfSymbol(context, symbol) {
-    return utils_1.getOrUpdate(symbolIdMaps, context, () => new Map()).get(symbol);
+    return (0, utils_1.getOrUpdate)(symbolIdMaps, context, () => new Map()).get(symbol);
 }
 exports.getSymbolIdOfSymbol = getSymbolIdOfSymbol;
 function trackSymbolReference(context, symbol, identifier) {
-    const symbolIds = utils_1.getOrUpdate(symbolIdMaps, context, () => new Map());
+    const symbolIds = (0, utils_1.getOrUpdate)(symbolIdMaps, context, () => new Map());
     // Track first time symbols are seen
     let symbolId = symbolIds.get(symbol);
     if (symbolId === undefined) {
         symbolId = nextSymbolId(context);
         symbolIds.set(symbol, symbolId);
-        const symbolInfo = utils_1.getOrUpdate(symbolInfoMap, context, () => new Map());
+        const symbolInfo = (0, utils_1.getOrUpdate)(symbolInfoMap, context, () => new Map());
         symbolInfo.set(symbolId, { symbol, firstSeenAtPos: identifier.pos });
     }
     // If isOptimizedVarArgSpread returns true, the identifier will not appear in the resulting Lua.
     // Only the optimized ellipses (...) will be used.
-    if (!spread_1.isOptimizedVarArgSpread(context, symbol, identifier)) {
-        scope_1.markSymbolAsReferencedInCurrentScopes(context, symbolId, identifier);
+    if (!(0, spread_1.isOptimizedVarArgSpread)(context, symbol, identifier)) {
+        (0, scope_1.markSymbolAsReferencedInCurrentScopes)(context, symbolId, identifier);
     }
     return symbolId;
 }

package/dist/transformation/utils/transform.js

@@ -5,10 +5,10 @@ const utils_1 = require("../../utils");
 const lua_ast_1 = require("./lua-ast");
 const scope_1 = require("./scope");
 function transformToImmediatelyInvokedFunctionExpression(context, transformFunction, tsOriginal) {
-    scope_1.pushScope(context, scope_1.ScopeType.Function);
+    (0, scope_1.pushScope)(context, scope_1.ScopeType.Function);
     const { statements, result } = transformFunction();
-    scope_1.popScope(context);
-    return lua_ast_1.createImmediatelyInvokedFunctionExpression(utils_1.castArray(statements), result, tsOriginal);
+    (0, scope_1.popScope)(context);
+    return (0, lua_ast_1.createImmediatelyInvokedFunctionExpression)((0, utils_1.castArray)(statements), result, tsOriginal);
 }
 exports.transformToImmediatelyInvokedFunctionExpression = transformToImmediatelyInvokedFunctionExpression;
 //# sourceMappingURL=transform.js.map

package/dist/transformation/utils/typescript/nodes.d.ts

@@ -4,6 +4,8 @@ export declare function isAssignmentPattern(node: ts.Node): node is ts.Assignmen
 export declare function isDestructuringAssignment(node: ts.Node): node is ts.DestructuringAssignment;
 export declare function isAmbientNode(node: ts.Declaration): boolean;
 export declare function isInDestructingAssignment(node: ts.Node): boolean;
+export declare function isInAsyncFunction(node: ts.Node): boolean;
+export declare function isInGeneratorFunction(node: ts.Node): boolean;
 /**
  * Quite hacky, avoid unless absolutely necessary!
  */

package/dist/transformation/utils/typescript/nodes.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isFirstDeclaration = exports.getSymbolOfNode = exports.isInDestructingAssignment = exports.isAmbientNode = exports.isDestructuringAssignment = exports.isAssignmentPattern = void 0;
+exports.isFirstDeclaration = exports.getSymbolOfNode = exports.isInGeneratorFunction = exports.isInAsyncFunction = exports.isInDestructingAssignment = exports.isAmbientNode = exports.isDestructuringAssignment = exports.isAssignmentPattern = void 0;
 const ts = require("typescript");
+const _1 = require(".");
 function isAssignmentPattern(node) {
     return ts.isObjectLiteralExpression(node) || ts.isArrayLiteralExpression(node);
 }
@@ -22,6 +23,25 @@ function isInDestructingAssignment(node) {
             (ts.isBinaryExpression(node.parent) && ts.isArrayLiteralExpression(node.parent.left))));
 }
 exports.isInDestructingAssignment = isInDestructingAssignment;
+function isInAsyncFunction(node) {
+    var _a, _b;
+    // Check if node is in function declaration with `async`
+    const declaration = (0, _1.findFirstNodeAbove)(node, ts.isFunctionLike);
+    if (!declaration) {
+        return false;
+    }
+    return (_b = (_a = declaration.modifiers) === null || _a === void 0 ? void 0 : _a.some(m => m.kind === ts.SyntaxKind.AsyncKeyword)) !== null && _b !== void 0 ? _b : false;
+}
+exports.isInAsyncFunction = isInAsyncFunction;
+function isInGeneratorFunction(node) {
+    // Check if node is in function declaration with `async`
+    const declaration = (0, _1.findFirstNodeAbove)(node, ts.isFunctionDeclaration);
+    if (!declaration) {
+        return false;
+    }
+    return declaration.asteriskToken !== undefined;
+}
+exports.isInGeneratorFunction = isInGeneratorFunction;
 /**
  * Quite hacky, avoid unless absolutely necessary!
  */

package/dist/transformation/visitors/access.js

@@ -15,29 +15,29 @@ function transformElementAccessArgument(context, node) {
     const index = context.transformExpression(node.argumentExpression);
     const type = context.checker.getTypeAtLocation(node.expression);
     const argumentType = context.checker.getTypeAtLocation(node.argumentExpression);
-    if (typescript_1.isArrayType(context, type) && typescript_1.isNumberType(context, argumentType)) {
-        return lua_ast_1.addToNumericExpression(index, 1);
+    if ((0, typescript_1.isArrayType)(context, type) && (0, typescript_1.isNumberType)(context, argumentType)) {
+        return (0, lua_ast_1.addToNumericExpression)(index, 1);
     }
     return index;
 }
 exports.transformElementAccessArgument = transformElementAccessArgument;
 const transformElementAccessExpression = (node, context) => {
-    const constEnumValue = enum_1.tryGetConstEnumValue(context, node);
+    const constEnumValue = (0, enum_1.tryGetConstEnumValue)(context, node);
     if (constEnumValue) {
         return constEnumValue;
     }
     const table = context.transformExpression(node.expression);
     const type = context.checker.getTypeAtLocation(node.expression);
     const argumentType = context.checker.getTypeAtLocation(node.argumentExpression);
-    if (typescript_1.isStringType(context, type) && typescript_1.isNumberType(context, argumentType)) {
+    if ((0, typescript_1.isStringType)(context, type) && (0, typescript_1.isNumberType)(context, argumentType)) {
         const index = context.transformExpression(node.argumentExpression);
-        return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.StringAccess, node, table, index);
+        return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.StringAccess, node, table, index);
     }
     const accessExpression = transformElementAccessArgument(context, node);
-    if (multi_1.isMultiReturnCall(context, node.expression)) {
+    if ((0, multi_1.isMultiReturnCall)(context, node.expression)) {
         const accessType = context.checker.getTypeAtLocation(node.argumentExpression);
-        if (!typescript_1.isNumberType(context, accessType)) {
-            context.diagnostics.push(diagnostics_1.invalidMultiReturnAccess(node));
+        if (!(0, typescript_1.isNumberType)(context, accessType)) {
+            context.diagnostics.push((0, diagnostics_1.invalidMultiReturnAccess)(node));
         }
         // When selecting the first element, we can shortcut
         if (ts.isNumericLiteral(node.argumentExpression) && node.argumentExpression.text === "0") {
@@ -50,7 +50,7 @@ const transformElementAccessExpression = (node, context) => {
         }
     }
     if (ts.isOptionalChain(node)) {
-        return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.OptionalChainAccess, node, table, accessExpression);
+        return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.OptionalChainAccess, node, table, accessExpression);
     }
     return lua.createTableIndexExpression(table, accessExpression, node);
 };
@@ -58,20 +58,20 @@ exports.transformElementAccessExpression = transformElementAccessExpression;
 const transformPropertyAccessExpression = (node, context) => {
     const property = node.name.text;
     const type = context.checker.getTypeAtLocation(node.expression);
-    const annotations = annotations_1.getTypeAnnotations(type);
+    const annotations = (0, annotations_1.getTypeAnnotations)(type);
     if (annotations.has(annotations_1.AnnotationKind.LuaTable)) {
-        context.diagnostics.push(diagnostics_1.annotationRemoved(node, annotations_1.AnnotationKind.LuaTable));
+        context.diagnostics.push((0, diagnostics_1.annotationRemoved)(node, annotations_1.AnnotationKind.LuaTable));
     }
-    const constEnumValue = enum_1.tryGetConstEnumValue(context, node);
+    const constEnumValue = (0, enum_1.tryGetConstEnumValue)(context, node);
     if (constEnumValue) {
         return constEnumValue;
     }
-    const builtinResult = builtins_1.transformBuiltinPropertyAccessExpression(context, node);
+    const builtinResult = (0, builtins_1.transformBuiltinPropertyAccessExpression)(context, node);
     if (builtinResult) {
         return builtinResult;
     }
-    if (ts.isCallExpression(node.expression) && multi_1.returnsMultiType(context, node.expression)) {
-        context.diagnostics.push(diagnostics_1.invalidMultiReturnAccess(node));
+    if (ts.isCallExpression(node.expression) && (0, multi_1.returnsMultiType)(context, node.expression)) {
+        context.diagnostics.push((0, diagnostics_1.invalidMultiReturnAccess)(node));
     }
     // Do not output path for member only enums
     if (annotations.has(annotations_1.AnnotationKind.CompileMembersOnly)) {
@@ -94,7 +94,7 @@ exports.transformPropertyAccessExpression = transformPropertyAccessExpression;
 function transformOptionalChain(context, node) {
     const left = context.transformExpression(node.expression);
     const right = lua.createStringLiteral(node.name.text, node.name);
-    return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.OptionalChainAccess, node, left, right);
+    return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.OptionalChainAccess, node, left, right);
 }
 const transformQualifiedName = (node, context) => {
     const right = lua.createStringLiteral(node.right.text, node.right);

package/dist/transformation/visitors/async-await.d.ts

@@ -0,0 +1,6 @@
+import * as ts from "typescript";
+import * as lua from "../../LuaAST";
+import { FunctionVisitor, TransformationContext } from "../context";
+export declare const transformAwaitExpression: FunctionVisitor<ts.AwaitExpression>;
+export declare function isAsyncFunction(declaration: ts.FunctionLikeDeclaration): boolean;
+export declare function wrapInAsyncAwaiter(context: TransformationContext, statements: lua.Statement[]): lua.Statement[];

package/dist/transformation/visitors/async-await.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapInAsyncAwaiter = exports.isAsyncFunction = exports.transformAwaitExpression = void 0;
+const ts = require("typescript");
+const lua = require("../../LuaAST");
+const diagnostics_1 = require("../utils/diagnostics");
+const lualib_1 = require("../utils/lualib");
+const typescript_1 = require("../utils/typescript");
+const transformAwaitExpression = (node, context) => {
+    var _a;
+    // Check if await is inside an async function, it is not allowed at top level or in non-async functions
+    const containingFunction = (0, typescript_1.findFirstNodeAbove)(node, ts.isFunctionLike);
+    if (containingFunction === undefined ||
+        !((_a = containingFunction.modifiers) === null || _a === void 0 ? void 0 : _a.some(m => m.kind === ts.SyntaxKind.AsyncKeyword))) {
+        context.diagnostics.push((0, diagnostics_1.awaitMustBeInAsyncFunction)(node));
+    }
+    const expression = context.transformExpression(node.expression);
+    const catchIdentifier = lua.createIdentifier("____catch");
+    return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.Await, node, catchIdentifier, expression);
+};
+exports.transformAwaitExpression = transformAwaitExpression;
+function isAsyncFunction(declaration) {
+    var _a, _b;
+    return (_b = (_a = declaration.modifiers) === null || _a === void 0 ? void 0 : _a.some(m => m.kind === ts.SyntaxKind.AsyncKeyword)) !== null && _b !== void 0 ? _b : false;
+}
+exports.isAsyncFunction = isAsyncFunction;
+function wrapInAsyncAwaiter(context, statements) {
+    (0, lualib_1.importLuaLibFeature)(context, lualib_1.LuaLibFeature.Await);
+    return [
+        lua.createReturnStatement([
+            lua.createCallExpression(lua.createIdentifier("__TS__AsyncAwaiter"), [
+                lua.createFunctionExpression(lua.createBlock(statements)),
+            ]),
+        ]),
+    ];
+}
+exports.wrapInAsyncAwaiter = wrapInAsyncAwaiter;
+//# sourceMappingURL=async-await.js.map