TypeScriptToLua · Perryvw · Aug 20, 2021 · Jul 5, 2021 · Jul 8, 2021 · Jul 11, 2021
diff --git a/src/LuaLib.ts b/src/LuaLib.ts
@@ -28,6 +28,7 @@ export enum LuaLibFeature {
     ArrayFlat = "ArrayFlat",
     ArrayFlatMap = "ArrayFlatMap",
     ArraySetLength = "ArraySetLength",
+    Await = "Await",
     Class = "Class",
     ClassExtends = "ClassExtends",
     CloneDescriptor = "CloneDescriptor",
@@ -101,6 +102,7 @@ const luaLibDependencies: Partial<Record<LuaLibFeature, LuaLibFeature[]>> = {
     ArrayConcat: [LuaLibFeature.ArrayIsArray],
     ArrayFlat: [LuaLibFeature.ArrayConcat, LuaLibFeature.ArrayIsArray],
     ArrayFlatMap: [LuaLibFeature.ArrayConcat, LuaLibFeature.ArrayIsArray],
+    Await: [LuaLibFeature.InstanceOf, LuaLibFeature.New],
     Decorate: [LuaLibFeature.ObjectGetOwnPropertyDescriptor, LuaLibFeature.SetDescriptor, LuaLibFeature.ObjectAssign],
     DelegatedYield: [LuaLibFeature.StringAccess],
     Delete: [LuaLibFeature.ObjectGetOwnPropertyDescriptors],

diff --git a/src/lualib/Await.ts b/src/lualib/Await.ts
@@ -0,0 +1,52 @@
+// The following is a translation of the TypeScript async awaiter which uses generators and yields.
+// For Lua we use coroutines instead.
+//
+// Source:
+//
+// var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+//     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+//     return new (P || (P = Promise))(function (resolve, reject) {
+//         function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+//         function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+//         function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+//         step((generator = generator.apply(thisArg, _arguments || [])).next());
+//     });
+// };
+//
+
+// eslint-disable-next-line @typescript-eslint/promise-function-async
+function __TS__AsyncAwaiter(this: void, generator: (this: void) => void) {
+    return new Promise((resolve, reject) => {
+        const asyncCoroutine = coroutine.create(generator);
+
+        // eslint-disable-next-line @typescript-eslint/promise-function-async
+        function adopt(value: unknown) {
+            return value instanceof __TS__Promise ? value : Promise.resolve(value);
+        }
+        function fulfilled(value) {
+            const [success, resultOrError] = coroutine.resume(asyncCoroutine, value);
+            if (success) {
+                step(resultOrError);
+            } else {
+                reject(resultOrError);
+            }
+        }
+        function step(result: unknown) {
+            if (coroutine.status(asyncCoroutine) === "dead") {
+                resolve(result);
+            } else {
+                adopt(result).then(fulfilled, reason => reject(reason));
+            }
+        }
+        const [success, resultOrError] = coroutine.resume(asyncCoroutine);
+        if (success) {
+            step(resultOrError);
+        } else {
+            reject(resultOrError);
+        }
+    });
+}
+
+function __TS__Await(this: void, thing: unknown) {
+    return coroutine.yield(thing);
+}
diff --git a/src/transformation/utils/diagnostics.ts b/src/transformation/utils/diagnostics.ts
@@ -147,3 +147,7 @@ export const annotationDeprecated = createWarningDiagnosticFactory(
 export const notAllowedOptionalAssignment = createErrorDiagnosticFactory(
     "The left-hand side of an assignment expression may not be an optional property access."
 );
+
+export const awaitMustBeInAsyncFunction = createErrorDiagnosticFactory(
+    "Await can only be used inside async functions."
+);
diff --git a/src/transformation/visitors/async-await.ts b/src/transformation/visitors/async-await.ts
@@ -0,0 +1,36 @@
+import * as ts from "typescript";
+import * as lua from "../../LuaAST";
+import { FunctionVisitor, TransformationContext } from "../context";
+import { awaitMustBeInAsyncFunction } from "../utils/diagnostics";
+import { importLuaLibFeature, LuaLibFeature, transformLuaLibFunction } from "../utils/lualib";
+import { findFirstNodeAbove } from "../utils/typescript";
+
+export const transformAwaitExpression: FunctionVisitor<ts.AwaitExpression> = (node, context) => {
+    // Check if await is inside an async function, it is not allowed at top level or in non-async functions
+    const containingFunction = findFirstNodeAbove(node, ts.isFunctionLike);
+    if (
+        containingFunction === undefined ||
+        !containingFunction.modifiers?.some(m => m.kind === ts.SyntaxKind.AsyncKeyword)
+    ) {
+        context.diagnostics.push(awaitMustBeInAsyncFunction(node));
+    }
+
+    const expression = context.transformExpression(node.expression);
+    return transformLuaLibFunction(context, LuaLibFeature.Await, node, expression);
+};
+
+export function isAsyncFunction(declaration: ts.FunctionLikeDeclaration): boolean {
+    return declaration.modifiers?.some(m => m.kind === ts.SyntaxKind.AsyncKeyword) ?? false;
+}
+
+export function wrapInAsyncAwaiter(context: TransformationContext, statements: lua.Statement[]): lua.Statement[] {
+    importLuaLibFeature(context, LuaLibFeature.Await);
+
+    return [
+        lua.createReturnStatement([
+            lua.createCallExpression(lua.createIdentifier("__TS__AsyncAwaiter"), [
+                lua.createFunctionExpression(lua.createBlock(statements)),
+            ]),
+        ]),
+    ];
+}
diff --git a/src/transformation/visitors/function.ts b/src/transformation/visitors/function.ts
@@ -13,6 +13,7 @@ import {
 } from "../utils/lua-ast";
 import { LuaLibFeature, transformLuaLibFunction } from "../utils/lualib";
 import { peekScope, performHoisting, popScope, pushScope, Scope, ScopeType } from "../utils/scope";
+import { isAsyncFunction, wrapInAsyncAwaiter } from "./async-await";
 import { transformIdentifier } from "./identifier";
 import { transformExpressionBodyToReturnStatement } from "./return";
 import { transformBindingPattern } from "./variable-declaration";
@@ -114,7 +115,10 @@ export function transformFunctionBody(
 ): [lua.Statement[], Scope] {
     const scope = pushScope(context, ScopeType.Function);
     scope.node = node;
-    const bodyStatements = transformFunctionBodyContent(context, body);
+    let bodyStatements = transformFunctionBodyContent(context, body);
+    if (node && isAsyncFunction(node)) {
+        bodyStatements = wrapInAsyncAwaiter(context, bodyStatements);
+    }
     const headerStatements = transformFunctionBodyHeader(context, scope, parameters, spreadIdentifier);
     popScope(context);
     return [[...headerStatements, ...bodyStatements], scope];
@@ -195,6 +199,7 @@ export function transformFunctionToExpression(
         spreadIdentifier,
         node
     );
+
     const functionExpression = lua.createFunctionExpression(
         lua.createBlock(transformedBody),
         paramNames,

diff --git a/src/transformation/visitors/index.ts b/src/transformation/visitors/index.ts
@@ -41,6 +41,7 @@ import { typescriptVisitors } from "./typescript";
 import { transformPostfixUnaryExpression, transformPrefixUnaryExpression } from "./unary-expression";
 import { transformVariableStatement } from "./variable-declaration";
 import { jsxVisitors } from "./jsx/jsx";
+import { transformAwaitExpression } from "./async-await";
 
 const transformEmptyStatement: FunctionVisitor<ts.EmptyStatement> = () => undefined;
 const transformParenthesizedExpression: FunctionVisitor<ts.ParenthesizedExpression> = (node, context) =>
@@ -51,6 +52,7 @@ export const standardVisitors: Visitors = {
     ...typescriptVisitors,
     ...jsxVisitors,
     [ts.SyntaxKind.ArrowFunction]: transformFunctionLikeDeclaration,
+    [ts.SyntaxKind.AwaitExpression]: transformAwaitExpression,
     [ts.SyntaxKind.BinaryExpression]: transformBinaryExpression,
     [ts.SyntaxKind.Block]: transformBlock,
     [ts.SyntaxKind.BreakStatement]: transformBreakStatement,

diff --git a/src/transformation/visitors/sourceFile.ts b/src/transformation/visitors/sourceFile.ts
@@ -23,6 +23,7 @@ export const transformSourceFileNode: FunctionVisitor<ts.SourceFile> = (node, co
         }
     } else {
         pushScope(context, ScopeType.File);
+
         statements = performHoisting(context, context.transformStatements(node.statements));
         popScope(context);
 

diff --git a/src/transformation/visitors/spread.ts b/src/transformation/visitors/spread.ts
@@ -37,6 +37,11 @@ export function isOptimizedVarArgSpread(context: TransformationContext, symbol:
         return false;
     }
 
+    // Scope cannot be an async function
+    if (scope.node.modifiers?.some(m => m.kind === ts.SyntaxKind.AsyncKeyword)) {
+        return false;
+    }
+
     // Identifier must be a vararg in the local function scope's parameters
     const isSpreadParameter = (p: ts.ParameterDeclaration) =>
         p.dotDotDotToken && ts.isIdentifier(p.name) && context.checker.getSymbolAtLocation(p.name) === symbol;