typescript-to-lua 0.41.2 → 1.1.0

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,36 +15,42 @@ 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 (ts.isCallExpression(node.expression) && multi_1.returnsMultiType(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") {
+            return table;
+        }
+        else {
+            const selectIdentifier = lua.createIdentifier("select");
+            const selectCall = lua.createCallExpression(selectIdentifier, [accessExpression, table]);
+            return selectCall;
         }
-        const selectIdentifier = lua.createIdentifier("select");
-        const selectCall = lua.createCallExpression(selectIdentifier, [accessExpression, table]);
-        return selectCall;
     }
     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);
 };
@@ -52,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)) {
@@ -88,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

package/dist/transformation/visitors/binary-expression/assignments.js

@@ -4,7 +4,6 @@ exports.transformAssignmentStatement = exports.transformAssignmentExpression = e
 const ts = require("typescript");
 const lua = require("../../../LuaAST");
 const utils_1 = require("../../../utils");
-const annotations_1 = require("../../utils/annotations");
 const assignment_validation_1 = require("../../utils/assignment-validation");
 const export_1 = require("../../utils/export");
 const lua_ast_1 = require("../../utils/lua-ast");
@@ -19,33 +18,33 @@ const diagnostics_1 = require("../../utils/diagnostics");
 function transformAssignmentLeftHandSideExpression(context, node) {
     const symbol = context.checker.getSymbolAtLocation(node);
     const left = context.transformExpression(node);
-    return lua.isIdentifier(left) && symbol && export_1.isSymbolExported(context, symbol)
-        ? export_1.createExportedIdentifier(context, left)
-        : utils_1.cast(left, lua.isAssignmentLeftHandSideExpression);
+    return lua.isIdentifier(left) && symbol && (0, export_1.isSymbolExported)(context, symbol)
+        ? (0, export_1.createExportedIdentifier)(context, left)
+        : (0, utils_1.cast)(left, lua.isAssignmentLeftHandSideExpression);
 }
 exports.transformAssignmentLeftHandSideExpression = transformAssignmentLeftHandSideExpression;
 function transformAssignment(context, 
 // TODO: Change type to ts.LeftHandSideExpression?
 lhs, right, parent) {
     if (ts.isOptionalChain(lhs)) {
-        context.diagnostics.push(diagnostics_1.notAllowedOptionalAssignment(lhs));
+        context.diagnostics.push((0, diagnostics_1.notAllowedOptionalAssignment)(lhs));
         return [];
     }
-    if (destructuring_assignments_1.isArrayLength(context, lhs)) {
-        const arrayLengthAssignment = lua.createExpressionStatement(lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.ArraySetLength, parent, context.transformExpression(lhs.expression), right));
+    if ((0, destructuring_assignments_1.isArrayLength)(context, lhs)) {
+        const arrayLengthAssignment = lua.createExpressionStatement((0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ArraySetLength, parent, context.transformExpression(lhs.expression), right));
         return [arrayLengthAssignment];
     }
     const symbol = ts.isShorthandPropertyAssignment(lhs.parent)
         ? context.checker.getShorthandAssignmentValueSymbol(lhs.parent)
         : context.checker.getSymbolAtLocation(lhs);
-    const dependentSymbols = symbol ? export_1.getDependenciesOfSymbol(context, symbol) : [];
+    const dependentSymbols = symbol ? (0, export_1.getDependenciesOfSymbol)(context, symbol) : [];
     const left = transformAssignmentLeftHandSideExpression(context, lhs);
     const rootAssignment = lua.createAssignmentStatement(left, right, lhs.parent);
     return [
         rootAssignment,
         ...dependentSymbols.map(symbol => {
             const [left] = rootAssignment.left;
-            const identifierToAssign = export_1.createExportedIdentifier(context, lua.createIdentifier(symbol.name));
+            const identifierToAssign = (0, export_1.createExportedIdentifier)(context, lua.createIdentifier(symbol.name));
             return lua.createAssignmentStatement(identifierToAssign, left);
         }),
     ];
@@ -54,12 +53,12 @@ exports.transformAssignment = transformAssignment;
 function transformDestructuredAssignmentExpression(context, expression) {
     const rootIdentifier = lua.createAnonymousIdentifier(expression.left);
     let right = context.transformExpression(expression.right);
-    if (annotations_1.isTupleReturnCall(context, expression.right) || multi_1.isMultiReturnCall(context, expression.right)) {
-        right = lua_ast_1.wrapInTable(right);
+    if ((0, multi_1.isMultiReturnCall)(context, expression.right)) {
+        right = (0, lua_ast_1.wrapInTable)(right);
     }
     const statements = [
         lua.createVariableDeclarationStatement(rootIdentifier, right),
-        ...destructuring_assignments_1.transformDestructuringAssignment(context, expression, rootIdentifier),
+        ...(0, destructuring_assignments_1.transformDestructuringAssignment)(context, expression, rootIdentifier),
     ];
     return { statements, result: rootIdentifier };
 }
@@ -67,13 +66,13 @@ function transformAssignmentExpression(context, expression) {
     // Validate assignment
     const rightType = context.checker.getTypeAtLocation(expression.right);
     const leftType = context.checker.getTypeAtLocation(expression.left);
-    assignment_validation_1.validateAssignment(context, expression.right, rightType, leftType);
-    if (destructuring_assignments_1.isArrayLength(context, expression.left)) {
+    (0, assignment_validation_1.validateAssignment)(context, expression.right, rightType, leftType);
+    if ((0, destructuring_assignments_1.isArrayLength)(context, expression.left)) {
         // array.length = x
-        return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.ArraySetLength, expression, context.transformExpression(expression.left.expression), context.transformExpression(expression.right));
+        return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ArraySetLength, expression, context.transformExpression(expression.left.expression), context.transformExpression(expression.right));
     }
-    if (typescript_1.isDestructuringAssignment(expression)) {
-        return transform_1.transformToImmediatelyInvokedFunctionExpression(context, () => transformDestructuredAssignmentExpression(context, expression), expression);
+    if ((0, typescript_1.isDestructuringAssignment)(expression)) {
+        return (0, transform_1.transformToImmediatelyInvokedFunctionExpression)(context, () => transformDestructuredAssignmentExpression(context, expression), expression);
     }
     if (ts.isPropertyAccessExpression(expression.left) || ts.isElementAccessExpression(expression.left)) {
         // Left is property/element access: cache result while maintaining order of evaluation
@@ -91,7 +90,7 @@ function transformAssignmentExpression(context, expression) {
             indexParameter,
             valueParameter,
         ]);
-        scope_1.pushScope(context, scope_1.ScopeType.Function);
+        (0, scope_1.pushScope)(context, scope_1.ScopeType.Function);
         const objExpression = context.transformExpression(expression.left.expression);
         let indexExpression;
         if (ts.isPropertyAccessExpression(expression.left)) {
@@ -100,14 +99,14 @@ function transformAssignmentExpression(context, expression) {
         }
         else {
             // Element access
-            indexExpression = access_1.transformElementAccessArgument(context, expression.left);
+            indexExpression = (0, access_1.transformElementAccessArgument)(context, expression.left);
         }
         const args = [objExpression, indexExpression, context.transformExpression(expression.right)];
-        scope_1.popScope(context);
+        (0, scope_1.popScope)(context);
         return lua.createCallExpression(iife, args, expression);
     }
     else {
-        return transform_1.transformToImmediatelyInvokedFunctionExpression(context, () => {
+        return (0, transform_1.transformToImmediatelyInvokedFunctionExpression)(context, () => {
             // Simple assignment
             // (function() ${left} = ${right}; return ${left} end)()
             const left = context.transformExpression(expression.left);
@@ -120,7 +119,7 @@ function transformAssignmentExpression(context, expression) {
 exports.transformAssignmentExpression = transformAssignmentExpression;
 const canBeTransformedToLuaAssignmentStatement = (context, node) => ts.isArrayLiteralExpression(node.left) &&
     node.left.elements.every(element => {
-        if (destructuring_assignments_1.isArrayLength(context, element)) {
+        if ((0, destructuring_assignments_1.isArrayLength)(context, element)) {
             return false;
         }
         if (ts.isPropertyAccessExpression(element) || ts.isElementAccessExpression(element)) {
@@ -129,7 +128,7 @@ const canBeTransformedToLuaAssignmentStatement = (context, node) => ts.isArrayLi
         if (ts.isIdentifier(element)) {
             const symbol = context.checker.getSymbolAtLocation(element);
             if (symbol) {
-                const aliases = export_1.getDependenciesOfSymbol(context, symbol);
+                const aliases = (0, export_1.getDependenciesOfSymbol)(context, symbol);
                 return aliases.length === 0;
             }
         }
@@ -138,26 +137,28 @@ function transformAssignmentStatement(context, expression) {
     // Validate assignment
     const rightType = context.checker.getTypeAtLocation(expression.right);
     const leftType = context.checker.getTypeAtLocation(expression.left);
-    assignment_validation_1.validateAssignment(context, expression.right, rightType, leftType);
-    if (typescript_1.isDestructuringAssignment(expression)) {
+    (0, assignment_validation_1.validateAssignment)(context, expression.right, rightType, leftType);
+    if ((0, typescript_1.isDestructuringAssignment)(expression)) {
         if (canBeTransformedToLuaAssignmentStatement(context, expression)) {
             const rightType = context.checker.getTypeAtLocation(expression.right);
             let right = context.transformExpression(expression.right);
-            if (!(annotations_1.isTupleReturnCall(context, expression.right) || multi_1.isMultiReturnCall(context, expression.right)) &&
-                typescript_1.isArrayType(context, rightType)) {
-                right = lua_ast_1.createUnpackCall(context, right, expression.right);
+            if (ts.isArrayLiteralExpression(expression.right)) {
+                right = expression.right.elements.map(e => context.transformExpression(e));
+            }
+            else if (!(0, multi_1.isMultiReturnCall)(context, expression.right) && (0, typescript_1.isArrayType)(context, rightType)) {
+                right = (0, lua_ast_1.createUnpackCall)(context, right, expression.right);
             }
             const left = expression.left.elements.map(e => transformAssignmentLeftHandSideExpression(context, e));
             return [lua.createAssignmentStatement(left, right, expression)];
         }
         let right = context.transformExpression(expression.right);
-        if (annotations_1.isTupleReturnCall(context, expression.right) || multi_1.isMultiReturnCall(context, expression.right)) {
-            right = lua_ast_1.wrapInTable(right);
+        if ((0, multi_1.isMultiReturnCall)(context, expression.right)) {
+            right = (0, lua_ast_1.wrapInTable)(right);
         }
         const rootIdentifier = lua.createAnonymousIdentifier(expression.left);
         return [
             lua.createVariableDeclarationStatement(rootIdentifier, right),
-            ...destructuring_assignments_1.transformDestructuringAssignment(context, expression, rootIdentifier),
+            ...(0, destructuring_assignments_1.transformDestructuringAssignment)(context, expression, rootIdentifier),
         ];
     }
     else {