Add more tests and additional diagnostics

Author: rbuckton

src/compiler/checker.ts

@@ -28210,7 +28210,7 @@ namespace ts {
             return undefinedWideningType;
         }
 
-        function isTopLevelAwait(node: AwaitExpression) {
+        function isInTopLevelContext(node: Node) {
             const container = getThisContainer(node, /*includeArrowFunctions*/ true);
             return isSourceFile(container);
         }
@@ -28219,7 +28219,7 @@ namespace ts {
             // Grammar checking
             if (produceDiagnostics) {
                 if (!(node.flags & NodeFlags.AwaitContext)) {
-                    if (isTopLevelAwait(node)) {
+                    if (isInTopLevelContext(node)) {
                         const sourceFile = getSourceFileOfNode(node);
                         if (!hasParseDiagnostics(sourceFile)) {
                             let span: TextSpan | undefined;
@@ -34802,6 +34802,7 @@ namespace ts {
         }
 
         function checkImportBinding(node: ImportEqualsDeclaration | ImportClause | NamespaceImport | ImportSpecifier) {
+            checkGrammarAwaitIdentifier(node.name);
             checkCollisionWithRequireExportsInGeneratedCode(node, node.name!);
             checkCollisionWithGlobalPromiseInGeneratedCode(node, node.name!);
             checkAliasSymbol(node);
@@ -37545,17 +37546,32 @@ namespace ts {
             return false;
         }
 
+        function checkGrammarAwaitIdentifier(name: Identifier | undefined): boolean {
+            if (name && isIdentifier(name) && name.originalKeywordKind === SyntaxKind.AwaitKeyword && isInTopLevelContext(name.parent)) {
+                const file = getSourceFileOfNode(name);
+                if (!file.isDeclarationFile && isExternalModule(file)) {
+                    return grammarErrorOnNode(name, Diagnostics.Identifier_expected_0_is_a_reserved_word_at_the_top_level_of_a_module, idText(name));
+                }
+            }
+            return false;
+        }
+
         function checkGrammarFunctionLikeDeclaration(node: FunctionLikeDeclaration | MethodSignature): boolean {
             // Prevent cascading error by short-circuit
             const file = getSourceFileOfNode(node);
-            return checkGrammarDecoratorsAndModifiers(node) || checkGrammarTypeParameterList(node.typeParameters, file) ||
-                checkGrammarParameterList(node.parameters) || checkGrammarArrowFunction(node, file) ||
+            return checkGrammarDecoratorsAndModifiers(node) ||
+                checkGrammarTypeParameterList(node.typeParameters, file) ||
+                (isFunctionDeclaration(node) && checkGrammarAwaitIdentifier(node.name)) ||
+                checkGrammarParameterList(node.parameters) ||
+                checkGrammarArrowFunction(node, file) ||
                 (isFunctionLikeDeclaration(node) && checkGrammarForUseStrictSimpleParameterList(node));
         }
 
         function checkGrammarClassLikeDeclaration(node: ClassLikeDeclaration): boolean {
             const file = getSourceFileOfNode(node);
-            return checkGrammarClassDeclarationHeritageClauses(node) || checkGrammarTypeParameterList(node.typeParameters, file);
+            return (isClassDeclaration(node) && checkGrammarAwaitIdentifier(node.name)) ||
+                checkGrammarClassDeclarationHeritageClauses(node) ||
+                checkGrammarTypeParameterList(node.typeParameters, file);
         }
 
         function checkGrammarArrowFunction(node: Node, file: SourceFile): boolean {
@@ -38195,11 +38211,15 @@ namespace ts {
                 if (node.propertyName) {
                     return grammarErrorOnNode(node.name, Diagnostics.A_rest_element_cannot_have_a_property_name);
                 }
+            }
 
-                if (node.initializer) {
-                    // Error on equals token which immediately precedes the initializer
-                    return grammarErrorAtPos(node, node.initializer.pos - 1, 1, Diagnostics.A_rest_element_cannot_have_an_initializer);
-                }
+            if (isIdentifier(node.name) && checkGrammarAwaitIdentifier(node.name)) {
+                return true;
+            }
+
+            if (node.dotDotDotToken && node.initializer) {
+                // Error on equals token which immediately precedes the initializer
+                return grammarErrorAtPos(node, node.initializer.pos - 1, 1, Diagnostics.A_rest_element_cannot_have_an_initializer);
             }
         }
 
@@ -38260,6 +38280,9 @@ namespace ts {
                     }
                 }
             }
+            if (isIdentifier(node.name) && checkGrammarAwaitIdentifier(node.name)) {
+                return true;
+            }
 
             if (node.exclamationToken && (node.parent.parent.kind !== SyntaxKind.VariableStatement || !node.type || node.initializer || node.flags & NodeFlags.Ambient)) {
                 return grammarErrorOnNode(node.exclamationToken, Diagnostics.Definite_assignment_assertions_can_only_be_used_along_with_a_type_annotation);

src/compiler/diagnosticMessages.json

@@ -867,6 +867,11 @@
         "category": "Error",
         "code": 1261
     },
+    "Identifier expected. '{0}' is a reserved word at the top-level of a module.": {
+        "category": "Error",
+        "code": 1262
+    },
+
     "'with' statements are not allowed in an async function block.": {
         "category": "Error",
         "code": 1300

src/compiler/factory/nodeFactory.ts

@@ -556,14 +556,29 @@ namespace ts {
                 decorators,
                 modifiers
             );
-            node.name = asName(name);
-            node.transformFlags |=
-                kind === SyntaxKind.MethodDeclaration ||
-                kind === SyntaxKind.GetAccessor ||
-                kind === SyntaxKind.SetAccessor ||
-                kind === SyntaxKind.PropertyDeclaration ?
-                propagatePropertyNameFlags(node.name) :
-                propagateChildFlags(node.name) ;
+            name = asName(name);
+            node.name = name;
+
+            // The PropertyName of a member is allowed to be `await`.
+            // We don't need to exclude `await` for type signatures since types
+            // don't propagate child flags.
+            if (name) {
+                switch (node.kind) {
+                    case SyntaxKind.MethodDeclaration:
+                    case SyntaxKind.GetAccessor:
+                    case SyntaxKind.SetAccessor:
+                    case SyntaxKind.PropertyDeclaration:
+                    case SyntaxKind.PropertyAssignment:
+                        if (isIdentifier(name)) {
+                            node.transformFlags |= propagateIdentifierNameFlags(name);
+                            break;
+                        }
+                        // fall through
+                    default:
+                        node.transformFlags |= propagateChildFlags(name);
+                        break;
+                }
+            }
             return node;
         }
 
@@ -637,7 +652,7 @@ namespace ts {
                 type
             );
             node.body = body;
-            node.transformFlags |= propagateChildFlags(node.body);
+            node.transformFlags |= propagateChildFlags(node.body) & ~TransformFlags.ContainsPossibleTopLevelAwait;
             if (!body) node.transformFlags |= TransformFlags.ContainsTypeScript;
             return node;
         }
@@ -1022,7 +1037,7 @@ namespace ts {
             node.right = asName(right);
             node.transformFlags |=
                 propagateChildFlags(node.left) |
-                propagateChildFlags(node.right);
+                propagateIdentifierNameFlags(node.right);
             return node;
         }
 
@@ -2037,9 +2052,13 @@ namespace ts {
             node.propertyName = asName(propertyName);
             node.dotDotDotToken = dotDotDotToken;
             node.transformFlags |=
-                propagateChildFlags(node.propertyName) |
                 propagateChildFlags(node.dotDotDotToken) |
                 TransformFlags.ContainsES2015;
+            if (node.propertyName) {
+                node.transformFlags |= isIdentifier(node.propertyName) ?
+                    propagateIdentifierNameFlags(node.propertyName) :
+                    propagateChildFlags(node.propertyName);
+            }
             if (dotDotDotToken) node.transformFlags |= TransformFlags.ContainsRestOrSpread;
             return node;
         }
@@ -2103,7 +2122,9 @@ namespace ts {
             node.name = asName(name);
             node.transformFlags =
                 propagateChildFlags(node.expression) |
-                propagatePropertyNameFlags(node.name);
+                (isIdentifier(node.name) ?
+                    propagateIdentifierNameFlags(node.name) :
+                    propagateChildFlags(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
@@ -2133,10 +2154,12 @@ namespace ts {
             node.questionDotToken = questionDotToken;
             node.name = asName(name);
             node.transformFlags |=
+                TransformFlags.ContainsES2020 |
                 propagateChildFlags(node.expression) |
                 propagateChildFlags(node.questionDotToken) |
-                propagateChildFlags(node.name) |
-                TransformFlags.ContainsES2020;
+                (isIdentifier(node.name) ?
+                    propagateIdentifierNameFlags(node.name) :
+                    propagateChildFlags(node.name));
             return node;
         }
 
@@ -3565,6 +3588,7 @@ namespace ts {
             node.transformFlags |=
                 propagateChildrenFlags(node.members) |
                 TransformFlags.ContainsTypeScript;
+            node.transformFlags &= ~TransformFlags.ContainsPossibleTopLevelAwait; // Enum declarations cannot contain `await`
             return node;
         }
 
@@ -3608,6 +3632,7 @@ namespace ts {
                     propagateChildFlags(node.body) |
                     TransformFlags.ContainsTypeScript;
             }
+            node.transformFlags &= ~TransformFlags.ContainsPossibleTopLevelAwait; // Module declarations cannot contain `await`.
             return node;
         }
 
@@ -3692,6 +3717,7 @@ namespace ts {
             node.moduleReference = moduleReference;
             node.transformFlags |= propagateChildFlags(node.moduleReference);
             if (!isExternalModuleReference(node.moduleReference)) node.transformFlags |= TransformFlags.ContainsTypeScript;
+            node.transformFlags &= ~TransformFlags.ContainsPossibleTopLevelAwait; // Import= declaration is always parsed in an Await context
             return node;
         }
 
@@ -3728,6 +3754,7 @@ namespace ts {
             node.transformFlags |=
                 propagateChildFlags(node.importClause) |
                 propagateChildFlags(node.moduleSpecifier);
+            node.transformFlags &= ~TransformFlags.ContainsPossibleTopLevelAwait; // always parsed in an Await context
             return node;
         }
 
@@ -3759,6 +3786,7 @@ namespace ts {
             if (isTypeOnly) {
                 node.transformFlags |= TransformFlags.ContainsTypeScript;
             }
+            node.transformFlags &= ~TransformFlags.ContainsPossibleTopLevelAwait; // always parsed in an Await context
             return node;
         }
 
@@ -3776,6 +3804,7 @@ namespace ts {
             const node = createBaseNode<NamespaceImport>(SyntaxKind.NamespaceImport);
             node.name = name;
             node.transformFlags |= propagateChildFlags(node.name);
+            node.transformFlags &= ~TransformFlags.ContainsPossibleTopLevelAwait; // always parsed in an Await context
             return node;
         }
 
@@ -3793,6 +3822,7 @@ namespace ts {
             node.transformFlags |=
                 propagateChildFlags(node.name) |
                 TransformFlags.ContainsESNext;
+            node.transformFlags &= ~TransformFlags.ContainsPossibleTopLevelAwait; // always parsed in an Await context
             return node;
         }
 
@@ -3808,6 +3838,7 @@ namespace ts {
             const node = createBaseNode<NamedImports>(SyntaxKind.NamedImports);
             node.elements = createNodeArray(elements);
             node.transformFlags |= propagateChildrenFlags(node.elements);
+            node.transformFlags &= ~TransformFlags.ContainsPossibleTopLevelAwait; // always parsed in an Await context
             return node;
         }
 
@@ -3826,6 +3857,7 @@ namespace ts {
             node.transformFlags |=
                 propagateChildFlags(node.propertyName) |
                 propagateChildFlags(node.name);
+            node.transformFlags &= ~TransformFlags.ContainsPossibleTopLevelAwait; // always parsed in an Await context
             return node;
         }
 
@@ -3854,6 +3886,7 @@ namespace ts {
                 ? parenthesizerRules().parenthesizeRightSideOfBinary(SyntaxKind.EqualsToken, /*leftSide*/ undefined, expression)
                 : parenthesizerRules().parenthesizeExpressionOfExportDefault(expression);
             node.transformFlags |= propagateChildFlags(node.expression);
+            node.transformFlags &= ~TransformFlags.ContainsPossibleTopLevelAwait; // always parsed in an Await context
             return node;
         }
 
@@ -3890,6 +3923,7 @@ namespace ts {
             node.transformFlags |=
                 propagateChildFlags(node.exportClause) |
                 propagateChildFlags(node.moduleSpecifier);
+            node.transformFlags &= ~TransformFlags.ContainsPossibleTopLevelAwait; // always parsed in an Await context
             return node;
         }
 
@@ -3916,6 +3950,7 @@ namespace ts {
             const node = createBaseNode<NamedExports>(SyntaxKind.NamedExports);
             node.elements = createNodeArray(elements);
             node.transformFlags |= propagateChildrenFlags(node.elements);
+            node.transformFlags &= ~TransformFlags.ContainsPossibleTopLevelAwait; // always parsed in an Await context
             return node;
         }
 
@@ -3934,6 +3969,7 @@ namespace ts {
             node.transformFlags |=
                 propagateChildFlags(node.propertyName) |
                 propagateChildFlags(node.name);
+            node.transformFlags &= ~TransformFlags.ContainsPossibleTopLevelAwait; // always parsed in an Await context
             return node;
         }
 
@@ -3964,6 +4000,7 @@ namespace ts {
             const node = createBaseNode<ExternalModuleReference>(SyntaxKind.ExternalModuleReference);
             node.expression = expression;
             node.transformFlags |= propagateChildFlags(node.expression);
+            node.transformFlags &= ~TransformFlags.ContainsPossibleTopLevelAwait; // always parsed in an Await context
             return node;
         }
 
@@ -5786,13 +5823,9 @@ namespace ts {
         return tokenValue;
     }
 
-    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 propagateIdentifierNameFlags(node: Identifier) {
+        // An IdentifierName is allowed to be `await`
+        return propagateChildFlags(node) & ~TransformFlags.ContainsPossibleTopLevelAwait;
     }
 
     function propagatePropertyNameFlagsOfChild(node: PropertyName, transformFlags: TransformFlags) {

src/compiler/factory/utilities.ts

@@ -811,6 +811,11 @@ namespace ts {
             || kind === SyntaxKind.ExportDeclaration;
     }
 
+    /* @internal */
+    export function isExportModifier(node: Modifier): node is ExportKeyword {
+        return node.kind === SyntaxKind.ExportKeyword;
+    }
+
     /* @internal */
     export function isAsyncModifier(node: Modifier): node is AsyncKeyword {
         return node.kind === SyntaxKind.AsyncKeyword;