Reparse top level 'await' in modules

src/compiler/checker.ts

@@ -33533,7 +33533,7 @@ namespace ts {
         function checkThrowStatement(node: ThrowStatement) {
             // Grammar checking
             if (!checkGrammarStatementInAmbientContext(node)) {
-                if (node.expression === undefined) {
+                if (isIdentifier(node.expression) && !node.expression.escapedText) {
                     grammarErrorAfterFirstToken(node, Diagnostics.Line_break_not_permitted_here);
                 }
             }

src/compiler/factory/nodeFactory.ts

@@ -557,7 +557,13 @@ namespace ts {
                 modifiers
             );
             node.name = asName(name);
-            node.transformFlags |= propagateChildFlags(node.name);
+            node.transformFlags |=
+                kind === SyntaxKind.MethodDeclaration ||
+                kind === SyntaxKind.GetAccessor ||
+                kind === SyntaxKind.SetAccessor ||
+                kind === SyntaxKind.PropertyDeclaration ?
+                propagatePropertyNameFlags(node.name) :
+                propagateChildFlags(node.name) ;
             return node;
         }
 
@@ -824,6 +830,9 @@ namespace ts {
                 // NOTE: we do not use `setChildren` here because typeArguments in an identifier do not contribute to transformations
                 node.typeArguments = createNodeArray(typeArguments);
             }
+            if (node.originalKeywordKind === SyntaxKind.AwaitKeyword) {
+                node.transformFlags |= TransformFlags.ContainsPossibleTopLevelAwait;
+            }
             return node;
         }
 
@@ -2094,7 +2103,7 @@ namespace ts {
             node.name = asName(name);
             node.transformFlags =
                 propagateChildFlags(node.expression) |
-                propagateChildFlags(node.name);
+                propagatePropertyNameFlags(node.name);
             if (isSuperKeyword(expression)) {
                 // super method calls require a lexical 'this'
                 // super method calls require 'super' hoisting in ES2017 and ES2018 async functions and async generators
@@ -5777,14 +5786,23 @@ namespace ts {
         return tokenValue;
     }
 
-    function propagatePropertyNameFlags(node: PropertyName, transformFlags: TransformFlags) {
+    function propagatePropertyNameFlags(node: Node | undefined) {
+        if (!node) return TransformFlags.None;
+        // `await` in a property name should not be considered a possible top-level await keyword
+        const transformFlags = propagateChildFlags(node);
+        return isIdentifier(node) ?
+            transformFlags & ~TransformFlags.ContainsPossibleTopLevelAwait :
+            transformFlags;
+    }
+
+    function propagatePropertyNameFlagsOfChild(node: PropertyName, transformFlags: TransformFlags) {
         return transformFlags | (node.transformFlags & TransformFlags.PropertyNamePropagatingFlags);
     }
 
     function propagateChildFlags(child: Node | undefined): TransformFlags {
         if (!child) return TransformFlags.None;
         const childFlags = child.transformFlags & ~getTransformFlagsSubtreeExclusions(child.kind);
-        return isNamedDeclaration(child) && isPropertyName(child.name) ? propagatePropertyNameFlags(child.name, childFlags) : childFlags;
+        return isNamedDeclaration(child) && isPropertyName(child.name) ? propagatePropertyNameFlagsOfChild(child.name, childFlags) : childFlags;
     }
 
     function propagateChildrenFlags(children: NodeArray<Node> | undefined): TransformFlags {

src/compiler/types.ts

@@ -2722,7 +2722,7 @@ namespace ts {
 
     export interface ThrowStatement extends Statement {
         readonly kind: SyntaxKind.ThrowStatement;
-        readonly expression?: Expression;
+        readonly expression: Expression;
     }
 
     export interface TryStatement extends Statement {
@@ -6242,6 +6242,7 @@ namespace ts {
         ContainsHoistedDeclarationOrCompletion = 1 << 20,
         ContainsDynamicImport = 1 << 21,
         ContainsClassFields = 1 << 22,
+        ContainsPossibleTopLevelAwait = 1 << 23,
 
         // Please leave this as 1 << 29.
         // It is the maximum bit we can set before we outgrow the size of a v8 small integer (SMI) on an x86 system.
@@ -6268,13 +6269,13 @@ namespace ts {
         OuterExpressionExcludes = HasComputedFlags,
         PropertyAccessExcludes = OuterExpressionExcludes,
         NodeExcludes = PropertyAccessExcludes,
-        ArrowFunctionExcludes = NodeExcludes | ContainsTypeScriptClassSyntax | ContainsBlockScopedBinding | ContainsYield | ContainsAwait | ContainsHoistedDeclarationOrCompletion | ContainsBindingPattern | ContainsObjectRestOrSpread,
-        FunctionExcludes = NodeExcludes | ContainsTypeScriptClassSyntax | ContainsLexicalThis | ContainsBlockScopedBinding | ContainsYield | ContainsAwait | ContainsHoistedDeclarationOrCompletion | ContainsBindingPattern | ContainsObjectRestOrSpread,
-        ConstructorExcludes = NodeExcludes | ContainsLexicalThis | ContainsBlockScopedBinding | ContainsYield | ContainsAwait | ContainsHoistedDeclarationOrCompletion | ContainsBindingPattern | ContainsObjectRestOrSpread,
-        MethodOrAccessorExcludes = NodeExcludes | ContainsLexicalThis | ContainsBlockScopedBinding | ContainsYield | ContainsAwait | ContainsHoistedDeclarationOrCompletion | ContainsBindingPattern | ContainsObjectRestOrSpread,
-        PropertyExcludes = NodeExcludes | ContainsLexicalThis,
+        ArrowFunctionExcludes = NodeExcludes | ContainsTypeScriptClassSyntax | ContainsBlockScopedBinding | ContainsYield | ContainsAwait | ContainsHoistedDeclarationOrCompletion | ContainsBindingPattern | ContainsObjectRestOrSpread | ContainsPossibleTopLevelAwait,
+        FunctionExcludes = NodeExcludes | ContainsTypeScriptClassSyntax | ContainsLexicalThis | ContainsBlockScopedBinding | ContainsYield | ContainsAwait | ContainsHoistedDeclarationOrCompletion | ContainsBindingPattern | ContainsObjectRestOrSpread | ContainsPossibleTopLevelAwait,
+        ConstructorExcludes = NodeExcludes | ContainsLexicalThis | ContainsBlockScopedBinding | ContainsYield | ContainsAwait | ContainsHoistedDeclarationOrCompletion | ContainsBindingPattern | ContainsObjectRestOrSpread | ContainsPossibleTopLevelAwait,
+        MethodOrAccessorExcludes = NodeExcludes | ContainsLexicalThis | ContainsBlockScopedBinding | ContainsYield | ContainsAwait | ContainsHoistedDeclarationOrCompletion | ContainsBindingPattern | ContainsObjectRestOrSpread | ContainsPossibleTopLevelAwait,
+        PropertyExcludes = NodeExcludes | ContainsLexicalThis | ContainsPossibleTopLevelAwait,
         ClassExcludes = NodeExcludes | ContainsTypeScriptClassSyntax | ContainsComputedPropertyName,
-        ModuleExcludes = NodeExcludes | ContainsTypeScriptClassSyntax | ContainsLexicalThis | ContainsBlockScopedBinding | ContainsHoistedDeclarationOrCompletion,
+        ModuleExcludes = NodeExcludes | ContainsTypeScriptClassSyntax | ContainsLexicalThis | ContainsBlockScopedBinding | ContainsHoistedDeclarationOrCompletion | ContainsPossibleTopLevelAwait,
         TypeExcludes = ~ContainsTypeScript,
         ObjectLiteralExcludes = NodeExcludes | ContainsTypeScriptClassSyntax | ContainsComputedPropertyName | ContainsObjectRestOrSpread,
         ArrayLiteralOrCallOrNewExcludes = NodeExcludes | ContainsRestOrSpread,

src/compiler/visitorPublic.ts

@@ -838,7 +838,7 @@ namespace ts {
 
             case SyntaxKind.ThrowStatement:
                 return factory.updateThrowStatement(<ThrowStatement>node,
-                    nodeVisitor((<ThrowStatement>node).expression!, visitor, isExpression)); // expression could be `undefined` due to invalid parse.
+                    nodeVisitor((<ThrowStatement>node).expression, visitor, isExpression));
 
             case SyntaxKind.TryStatement:
                 return factory.updateTryStatement(<TryStatement>node,

tests/baselines/reference/api/tsserverlibrary.d.ts

@@ -1445,7 +1445,7 @@ declare namespace ts {
     }
     export interface ThrowStatement extends Statement {
         readonly kind: SyntaxKind.ThrowStatement;
-        readonly expression?: Expression;
+        readonly expression: Expression;
     }
     export interface TryStatement extends Statement {
         readonly kind: SyntaxKind.TryStatement;

tests/baselines/reference/api/typescript.d.ts

@@ -1445,7 +1445,7 @@ declare namespace ts {
     }
     export interface ThrowStatement extends Statement {
         readonly kind: SyntaxKind.ThrowStatement;
-        readonly expression?: Expression;
+        readonly expression: Expression;
     }
     export interface TryStatement extends Statement {
         readonly kind: SyntaxKind.TryStatement;

tests/baselines/reference/throwWithoutNewLine2.js

@@ -3,5 +3,5 @@ throw
 a;
 
 //// [throwWithoutNewLine2.js]
-throw;
+throw ;
 a;

tests/baselines/reference/throwWithoutNewLine2.types

@@ -1,5 +1,6 @@
 === tests/cases/compiler/throwWithoutNewLine2.ts ===
 throw
 a;
+> : any
 >a : any
 

tests/baselines/reference/topLevelAwait(module=esnext,target=es2015).errors.txt

@@ -6,4 +6,43 @@ tests/cases/conformance/externalModules/topLevelAwait.ts(2,1): error TS1378: Top
     await x;
     ~~~~~
 !!! error TS1378: Top-level 'await' expressions are only allowed when the 'module' option is set to 'esnext' or 'system', and the 'target' option is set to 'es2017' or higher.
-
+
+    // reparse element access as await
+    await [x];
+    await [x, x];
+
+    // reparse call as await
+    declare function f(): number;
+    await (x);
+    await (f(), x);
+    await <number>(x);
+    await <number>(f(), x);
+
+    // reparse tagged template as await
+    await ``;
+    await <string> ``;
+
+    // member names should be ok
+    class C1 {
+        await() {}
+    }
+    class C2 {
+        get await() { return 1; }
+        set await(value) { }
+    }
+    class C3 {
+        await = 1;
+    }
+    ({
+        await() {}
+    });
+    ({
+        get await() { return 1 },
+        set await(value) { }
+    });
+    ({
+        await: 1
+    });
+
+    // property access name should be ok
+    C1.prototype.await;

tests/baselines/reference/topLevelAwait(module=esnext,target=es2015).js

@@ -1,8 +1,82 @@
 //// [topLevelAwait.ts]
 export const x = 1;
 await x;
-
+
+// reparse element access as await
+await [x];
+await [x, x];
+
+// reparse call as await
+declare function f(): number;
+await (x);
+await (f(), x);
+await <number>(x);
+await <number>(f(), x);
+
+// reparse tagged template as await
+await ``;
+await <string> ``;
+
+// member names should be ok
+class C1 {
+    await() {}
+}
+class C2 {
+    get await() { return 1; }
+    set await(value) { }
+}
+class C3 {
+    await = 1;
+}
+({
+    await() {}
+});
+({
+    get await() { return 1 },
+    set await(value) { }
+});
+({
+    await: 1
+});
+
+// property access name should be ok
+C1.prototype.await;
 
 //// [topLevelAwait.js]
 export const x = 1;
 await x;
+// reparse element access as await
+await [x];
+await [x, x];
+await (x);
+await (f(), x);
+await (x);
+await (f(), x);
+// reparse tagged template as await
+await ``;
+await ``;
+// member names should be ok
+class C1 {
+    await() { }
+}
+class C2 {
+    get await() { return 1; }
+    set await(value) { }
+}
+class C3 {
+    constructor() {
+        this.await = 1;
+    }
+}
+({
+    await() { }
+});
+({
+    get await() { return 1; },
+    set await(value) { }
+});
+({
+    await: 1
+});
+// property access name should be ok
+C1.prototype.await;

tests/baselines/reference/topLevelAwait(module=esnext,target=es2015).symbols

@@ -5,3 +5,84 @@ export const x = 1;
 await x;
 >x : Symbol(x, Decl(topLevelAwait.ts, 0, 12))
 
+// reparse element access as await
+await [x];
+>x : Symbol(x, Decl(topLevelAwait.ts, 0, 12))
+
+await [x, x];
+>x : Symbol(x, Decl(topLevelAwait.ts, 0, 12))
+>x : Symbol(x, Decl(topLevelAwait.ts, 0, 12))
+
+// reparse call as await
+declare function f(): number;
+>f : Symbol(f, Decl(topLevelAwait.ts, 5, 13))
+
+await (x);
+>x : Symbol(x, Decl(topLevelAwait.ts, 0, 12))
+
+await (f(), x);
+>f : Symbol(f, Decl(topLevelAwait.ts, 5, 13))
+>x : Symbol(x, Decl(topLevelAwait.ts, 0, 12))
+
+await <number>(x);
+>x : Symbol(x, Decl(topLevelAwait.ts, 0, 12))
+
+await <number>(f(), x);
+>f : Symbol(f, Decl(topLevelAwait.ts, 5, 13))
+>x : Symbol(x, Decl(topLevelAwait.ts, 0, 12))
+
+// reparse tagged template as await
+await ``;
+await <string> ``;
+
+// member names should be ok
+class C1 {
+>C1 : Symbol(C1, Decl(topLevelAwait.ts, 16, 18))
+
+    await() {}
+>await : Symbol(C1.await, Decl(topLevelAwait.ts, 19, 10))
+}
+class C2 {
+>C2 : Symbol(C2, Decl(topLevelAwait.ts, 21, 1))
+
+    get await() { return 1; }
+>await : Symbol(C2.await, Decl(topLevelAwait.ts, 22, 10), Decl(topLevelAwait.ts, 23, 29))
+
+    set await(value) { }
+>await : Symbol(C2.await, Decl(topLevelAwait.ts, 22, 10), Decl(topLevelAwait.ts, 23, 29))
+>value : Symbol(value, Decl(topLevelAwait.ts, 24, 14))
+}
+class C3 {
+>C3 : Symbol(C3, Decl(topLevelAwait.ts, 25, 1))
+
+    await = 1;
+>await : Symbol(C3.await, Decl(topLevelAwait.ts, 26, 10))
+}
+({
+    await() {}
+>await : Symbol(await, Decl(topLevelAwait.ts, 29, 2))
+
+});
+({
+    get await() { return 1 },
+>await : Symbol(await, Decl(topLevelAwait.ts, 32, 2), Decl(topLevelAwait.ts, 33, 29))
+
+    set await(value) { }
+>await : Symbol(await, Decl(topLevelAwait.ts, 32, 2), Decl(topLevelAwait.ts, 33, 29))
+>value : Symbol(value, Decl(topLevelAwait.ts, 34, 14))
+
+});
+({
+    await: 1
+>await : Symbol(await, Decl(topLevelAwait.ts, 36, 2))
+
+});
+
+// property access name should be ok
+C1.prototype.await;
+>C1.prototype.await : Symbol(C1.await, Decl(topLevelAwait.ts, 19, 10))
+>C1.prototype : Symbol(C1.prototype)
+>C1 : Symbol(C1, Decl(topLevelAwait.ts, 16, 18))
+>prototype : Symbol(C1.prototype)
+>await : Symbol(C1.await, Decl(topLevelAwait.ts, 19, 10))
+