Reparse top-level 'await' in modules

Author: rbuckton

src/compiler/checker.ts

@@ -33511,7 +33511,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

@@ -10,6 +10,7 @@ namespace ts {
         NoNodeConverters = 1 << 1,
         // Ensures new `PropertyAccessExpression` nodes are created with the `NoIndentation` emit flag set.
         NoIndentationOnFreshPropertyAccess = 1 << 2,
+        NoOriginalNode = 1 << 3,
     }
 
     /**
@@ -22,6 +23,7 @@ namespace ts {
         // Lazily load the parenthesizer, node converters, and some factory methods until they are used.
         const parenthesizerRules = memoize(() => flags & NodeFactoryFlags.NoParenthesizerRules ? nullParenthesizerRules : createParenthesizerRules(factory));
         const converters = memoize(() => flags & NodeFactoryFlags.NoNodeConverters ? nullNodeConverters : createNodeConverters(factory));
+        const update = flags & NodeFactoryFlags.NoOriginalNode ? updateWithoutOriginal : updateWithOriginal;
 
         // lazy initializaton of common operator factories
         const getBinaryCreateFunction = memoizeOne((operator: BinaryOperator) => (left: Expression, right: Expression) => createBinaryExpression(left, operator, right));
@@ -553,7 +555,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;
         }
 
@@ -820,6 +828,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;
         }
 
@@ -2090,7 +2101,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
@@ -4754,7 +4765,7 @@ namespace ts {
             hasNoDefaultLib: boolean,
             libReferences: readonly FileReference[]
         ) {
-            const node = createBaseNode<SourceFile>(SyntaxKind.SourceFile);
+            const node = baseFactory.createBaseSourceFileNode(SyntaxKind.SourceFile) as Mutable<SourceFile>;
             for (const p in source) {
                 if (p === "emitNode" || hasProperty(node, p) || !hasProperty(source, p)) continue;
                 (node as any)[p] = (source as any)[p];
@@ -5681,7 +5692,15 @@ namespace ts {
         }
     }
 
-    function update<T extends Node>(updated: T, original: T): T {
+    function updateWithoutOriginal<T extends Node>(updated: T, original: T): T {
+        if (updated !== original) {
+            setOriginalNode(updated, original);
+            setTextRange(updated, original);
+        }
+        return updated;
+    }
+
+    function updateWithOriginal<T extends Node>(updated: T, original: T): T {
         if (updated !== original) {
             setOriginalNode(updated, original);
             setTextRange(updated, original);
@@ -5766,14 +5785,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 {