Allow await in a simple unary expression

src/compiler/parser.ts

@@ -3400,6 +3400,8 @@ namespace ts {
                     return parseTypeOfExpression();
                 case SyntaxKind.VoidKeyword:
                     return parseVoidExpression();
+                case SyntaxKind.AwaitKeyword:
+                    return parseAwaitExpression();
                 case SyntaxKind.LessThanToken:
                     // This is modified UnaryExpression grammar in TypeScript
                     //  UnaryExpression (modified):

tests/baselines/reference/castOfAwait.js

@@ -0,0 +1,20 @@
+//// [castOfAwait.ts]
+async function f() {
+    return <number> await 0;
+}
+
+
+//// [castOfAwait.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());
+    });
+};
+function f() {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield 0;
+    });
+}

tests/baselines/reference/castOfAwait.symbols

@@ -0,0 +1,7 @@
+=== tests/cases/compiler/castOfAwait.ts ===
+async function f() {
+>f : Symbol(f, Decl(castOfAwait.ts, 0, 0))
+
+    return <number> await 0;
+}
+

tests/baselines/reference/castOfAwait.types

@@ -0,0 +1,10 @@
+=== tests/cases/compiler/castOfAwait.ts ===
+async function f() {
+>f : () => Promise<number>
+
+    return <number> await 0;
+><number> await 0 : number
+>await 0 : number
+>0 : number
+}
+

tests/cases/compiler/castOfAwait.ts

@@ -0,0 +1,4 @@
+// @target: es6
+async function f() {
+    return <number> await 0;
+}