From 4195eb3670cfe784995828e97758d93a600838cd Mon Sep 17 00:00:00 2001
From: Andy Hanson <anhans@microsoft.com>
Date: Wed, 29 Jun 2016 13:29:54 -0700
Subject: [PATCH] Parse `export default async function` as a declaration

---
 src/compiler/parser.ts                         | 10 +++++-----
 src/compiler/types.ts                          |  2 +-
 .../reference/exportDefaultAsyncFunction.js    | 18 ++++++++++++++++++
 .../exportDefaultAsyncFunction.symbols         |  8 ++++++++
 .../reference/exportDefaultAsyncFunction.types |  9 +++++++++
 .../compiler/exportDefaultAsyncFunction.ts     |  3 +++
 6 files changed, 44 insertions(+), 6 deletions(-)
 create mode 100644 tests/baselines/reference/exportDefaultAsyncFunction.js
 create mode 100644 tests/baselines/reference/exportDefaultAsyncFunction.symbols
 create mode 100644 tests/baselines/reference/exportDefaultAsyncFunction.types
 create mode 100644 tests/cases/compiler/exportDefaultAsyncFunction.ts

diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts
index 9f02e8c2926e1..d720cd0648f9d 100644
--- a/src/compiler/parser.ts
+++ b/src/compiler/parser.ts
@@ -1155,12 +1155,12 @@ namespace ts {
             if (token === SyntaxKind.ExportKeyword) {
                 nextToken();
                 if (token === SyntaxKind.DefaultKeyword) {
-                    return lookAhead(nextTokenIsClassOrFunction);
+                    return lookAhead(nextTokenIsClassOrFunctionOrAsync);
                 }
                 return token !== SyntaxKind.AsteriskToken && token !== SyntaxKind.AsKeyword && token !== SyntaxKind.OpenBraceToken && canFollowModifier();
             }
             if (token === SyntaxKind.DefaultKeyword) {
-                return nextTokenIsClassOrFunction();
+                return nextTokenIsClassOrFunctionOrAsync();
             }
             if (token === SyntaxKind.StaticKeyword) {
                 nextToken();
@@ -1182,9 +1182,9 @@ namespace ts {
                 || isLiteralPropertyName();
         }
 
-        function nextTokenIsClassOrFunction(): boolean {
+        function nextTokenIsClassOrFunctionOrAsync(): boolean {
             nextToken();
-            return token === SyntaxKind.ClassKeyword || token === SyntaxKind.FunctionKeyword;
+            return token === SyntaxKind.ClassKeyword || token === SyntaxKind.FunctionKeyword || token === SyntaxKind.AsyncKeyword;
         }
 
         // True if positioned at the start of a list element
@@ -5070,7 +5070,7 @@ namespace ts {
          * In such situations, 'permitInvalidConstAsModifier' should be set to true.
          */
         function parseModifiers(permitInvalidConstAsModifier?: boolean): ModifiersArray {
-            let flags = 0;
+            let flags: NodeFlags = 0;
             let modifiers: ModifiersArray;
             while (true) {
                 const modifierStart = scanner.getStartPos();
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
index 56029fd316cdb..0110fda4e4195 100644
--- a/src/compiler/types.ts
+++ b/src/compiler/types.ts
@@ -469,7 +469,7 @@ namespace ts {
     }
 
     export interface ModifiersArray extends NodeArray<Modifier> {
-        flags: number;
+        flags: NodeFlags;
     }
 
     // @kind(SyntaxKind.AbstractKeyword)
diff --git a/tests/baselines/reference/exportDefaultAsyncFunction.js b/tests/baselines/reference/exportDefaultAsyncFunction.js
new file mode 100644
index 0000000000000..a06b41b5e7396
--- /dev/null
+++ b/tests/baselines/reference/exportDefaultAsyncFunction.js
@@ -0,0 +1,18 @@
+//// [exportDefaultAsyncFunction.ts]
+export default async function foo(): Promise<void> {}
+foo();
+
+
+//// [exportDefaultAsyncFunction.js]
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    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) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments)).next());
+    });
+};
+export default function foo() {
+    return __awaiter(this, void 0, void 0, function* () { });
+}
+foo();
diff --git a/tests/baselines/reference/exportDefaultAsyncFunction.symbols b/tests/baselines/reference/exportDefaultAsyncFunction.symbols
new file mode 100644
index 0000000000000..47178519558f3
--- /dev/null
+++ b/tests/baselines/reference/exportDefaultAsyncFunction.symbols
@@ -0,0 +1,8 @@
+=== tests/cases/compiler/exportDefaultAsyncFunction.ts ===
+export default async function foo(): Promise<void> {}
+>foo : Symbol(foo, Decl(exportDefaultAsyncFunction.ts, 0, 0))
+>Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+
+foo();
+>foo : Symbol(foo, Decl(exportDefaultAsyncFunction.ts, 0, 0))
+
diff --git a/tests/baselines/reference/exportDefaultAsyncFunction.types b/tests/baselines/reference/exportDefaultAsyncFunction.types
new file mode 100644
index 0000000000000..7258c6fcf0c28
--- /dev/null
+++ b/tests/baselines/reference/exportDefaultAsyncFunction.types
@@ -0,0 +1,9 @@
+=== tests/cases/compiler/exportDefaultAsyncFunction.ts ===
+export default async function foo(): Promise<void> {}
+>foo : () => Promise<void>
+>Promise : Promise<T>
+
+foo();
+>foo() : Promise<void>
+>foo : () => Promise<void>
+
diff --git a/tests/cases/compiler/exportDefaultAsyncFunction.ts b/tests/cases/compiler/exportDefaultAsyncFunction.ts
new file mode 100644
index 0000000000000..c05296711ec8b
--- /dev/null
+++ b/tests/cases/compiler/exportDefaultAsyncFunction.ts
@@ -0,0 +1,3 @@
+// @target: es6
+export default async function foo(): Promise<void> {}
+foo();