Limit node flag to expressions to not mess up incremental parsing

andrewbranch · andrewbranch · commit a0691dabe62e · 2020-01-15T14:49:51.000-08:00
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
@@ -1865,7 +1865,7 @@ namespace ts {
         }
 
         function checkSymbolUsageInExpressionContext(symbol: Symbol, name: __String, useSite: Node) {
-            if (!(useSite.flags & (NodeFlags.Ambient | NodeFlags.InNonEmittingNode)) && useSite.parent.kind !== SyntaxKind.ExportSpecifier) {
+            if (!(useSite.flags & (NodeFlags.Ambient | NodeFlags.InNonEmittingExpression)) && useSite.parent.kind !== SyntaxKind.ExportSpecifier) {
                 const typeOnlyDeclaration = getTypeOnlyAliasDeclaration(symbol);
                 if (typeOnlyDeclaration) {
                     const message = typeOnlyDeclaration.kind === SyntaxKind.ExportSpecifier
diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts
@@ -1444,13 +1444,16 @@ namespace ts {
                 token() === SyntaxKind.NumericLiteral;
         }
 
-        function parsePropertyNameWorker(allowComputedPropertyNames: boolean): PropertyName {
+        function parsePropertyNameWorker(allowComputedPropertyNames: boolean, computedNameIsNonEmitting: boolean): PropertyName {
             if (token() === SyntaxKind.StringLiteral || token() === SyntaxKind.NumericLiteral) {
                 const node = <StringLiteral | NumericLiteral>parseLiteralNode();
                 node.text = internIdentifier(node.text);
                 return node;
             }
             if (allowComputedPropertyNames && token() === SyntaxKind.OpenBracketToken) {
+                if (computedNameIsNonEmitting) {
+                    return doInsideOfContext(NodeFlags.InNonEmittingExpression, parseComputedPropertyName);
+                }
                 return parseComputedPropertyName();
             }
             if (token() === SyntaxKind.PrivateIdentifier) {
@@ -1459,8 +1462,8 @@ namespace ts {
             return parseIdentifierName();
         }
 
-        function parsePropertyName(): PropertyName {
-            return parsePropertyNameWorker(/*allowComputedPropertyNames*/ true);
+        function parsePropertyName(computedNameIsNonEmitting: boolean): PropertyName {
+            return parsePropertyNameWorker(/*allowComputedPropertyNames*/ true, computedNameIsNonEmitting);
         }
 
         function parseComputedPropertyName(): ComputedPropertyName {
@@ -2563,7 +2566,7 @@ namespace ts {
         function parseTypeQuery(): TypeQueryNode {
             const node = <TypeQueryNode>createNode(SyntaxKind.TypeQuery);
             parseExpected(SyntaxKind.TypeOfKeyword);
-            node.exprName = parseEntityName(/*allowReservedWords*/ true);
+            node.exprName = doInsideOfContext(NodeFlags.InNonEmittingExpression, () => parseEntityName(/*allowReservedWords*/ true));
             return finishNode(node);
         }
 
@@ -2814,7 +2817,7 @@ namespace ts {
         }
 
         function parsePropertyOrMethodSignature(node: PropertySignature | MethodSignature): PropertySignature | MethodSignature {
-            node.name = parsePropertyName();
+            node.name = parsePropertyName(/*computedNameIsNonEmitting*/ true);
             node.questionToken = parseOptionalToken(SyntaxKind.QuestionToken);
             if (token() === SyntaxKind.OpenParenToken || token() === SyntaxKind.LessThanToken) {
                 node.kind = SyntaxKind.MethodSignature;
@@ -3362,10 +3365,7 @@ namespace ts {
         function parseType(): TypeNode {
             // The rules about 'yield' only apply to actual code/expression contexts.  They don't
             // apply to 'type' contexts.  So we disable these parameters here before moving on.
-            return doOutsideOfContext(
-                NodeFlags.TypeExcludesFlags,
-                () => doInsideOfContext(NodeFlags.InNonEmittingNode, parseTypeWorker)
-            );
+            return doOutsideOfContext(NodeFlags.TypeExcludesFlags, parseTypeWorker);
         }
 
         function parseTypeWorker(noConditionalTypes?: boolean): TypeNode {
@@ -5002,7 +5002,7 @@ namespace ts {
 
             const asteriskToken = parseOptionalToken(SyntaxKind.AsteriskToken);
             const tokenIsIdentifier = isIdentifier();
-            node.name = parsePropertyName();
+            node.name = parsePropertyName(/*computedNameIsNonEmitting*/ false);
             // Disallowing of optional property assignments and definite assignment assertion happens in the grammar checker.
             (<MethodDeclaration>node).questionToken = parseOptionalToken(SyntaxKind.QuestionToken);
             (<MethodDeclaration>node).exclamationToken = parseOptionalToken(SyntaxKind.ExclamationToken);
@@ -5712,9 +5712,9 @@ namespace ts {
                 case SyntaxKind.ClassKeyword:
                     return parseClassDeclaration(<ClassDeclaration>node);
                 case SyntaxKind.InterfaceKeyword:
-                    return doInsideOfContext(NodeFlags.InNonEmittingNode, () => parseInterfaceDeclaration(<InterfaceDeclaration>node));
+                    return parseInterfaceDeclaration(<InterfaceDeclaration>node);
                 case SyntaxKind.TypeKeyword:
-                    return doInsideOfContext(NodeFlags.InNonEmittingNode, () => parseTypeAliasDeclaration(<TypeAliasDeclaration>node));
+                    return parseTypeAliasDeclaration(<TypeAliasDeclaration>node);
                 case SyntaxKind.EnumKeyword:
                     return parseEnumDeclaration(<EnumDeclaration>node);
                 case SyntaxKind.GlobalKeyword:
@@ -5779,7 +5779,7 @@ namespace ts {
             const node = <BindingElement>createNode(SyntaxKind.BindingElement);
             node.dotDotDotToken = parseOptionalToken(SyntaxKind.DotDotDotToken);
             const tokenIsIdentifier = isIdentifier();
-            const propertyName = parsePropertyName();
+            const propertyName = parsePropertyName(/*computedNameIsNonEmitting*/ false);
             if (tokenIsIdentifier && token() !== SyntaxKind.ColonToken) {
                 node.name = <Identifier>propertyName;
             }
@@ -5953,12 +5953,8 @@ namespace ts {
 
         function parsePropertyOrMethodDeclaration(node: PropertyDeclaration | MethodDeclaration): PropertyDeclaration | MethodDeclaration {
             const asteriskToken = parseOptionalToken(SyntaxKind.AsteriskToken);
-            if (node.modifiers && some(node.modifiers, isAbstractModifier)) {
-                node.name = doInsideOfContext(NodeFlags.InNonEmittingNode, parsePropertyName);
-            }
-            else {
-                node.name = parsePropertyName();
-            }
+            const isAbstract = !!node.modifiers && some(node.modifiers, isAbstractModifier);
+            node.name = parsePropertyName(isAbstract);
 
             // Note: this is not legal as per the grammar.  But we allow it in the parser and
             // report an error in the grammar checker.
@@ -5971,7 +5967,7 @@ namespace ts {
 
         function parseAccessorDeclaration(node: AccessorDeclaration, kind: AccessorDeclaration["kind"]): AccessorDeclaration {
             node.kind = kind;
-            node.name = parsePropertyName();
+            node.name = parsePropertyName(/*computedNameIsNonEmitting*/ false);
             fillSignature(SyntaxKind.ColonToken, SignatureFlags.None, node);
             node.body = parseFunctionBlockOrSemicolon(SignatureFlags.None);
             return finishNode(node);
@@ -6277,7 +6273,7 @@ namespace ts {
         // or any time an integer literal initializer is encountered.
         function parseEnumMember(): EnumMember {
             const node = <EnumMember>createNodeWithJSDoc(SyntaxKind.EnumMember);
-            node.name = parsePropertyName();
+            node.name = parsePropertyName(/*computedNameIsNonEmitting*/ false);
             node.initializer = allowInAnd(parseInitializer);
             return finishNode(node);
         }
@@ -6396,35 +6392,23 @@ namespace ts {
                 (isIdentifier() || tokenAfterImportDefinitelyProducesImportDeclaration())
             ) {
                 isTypeOnly = true;
-                identifier = isIdentifier() ? doInsideOfContext(NodeFlags.InNonEmittingNode, parseIdentifier) : undefined;
-                node.flags |= NodeFlags.InNonEmittingNode;
+                identifier = isIdentifier() ? parseIdentifier() : undefined;
             }
 
             if (identifier && !tokenAfterImportedIdentifierDefinitelyProducesImportDeclaration()) {
                 return parseImportEqualsDeclaration(<ImportEqualsDeclaration>node, identifier, isTypeOnly);
             }
 
             // Import statement
-            if (isTypeOnly) {
-                return doInsideOfContext(
-                    NodeFlags.InNonEmittingNode,
-                    () => parseImportDeclarationRest(node as ImportDeclaration, afterImportPos, identifier, isTypeOnly)
-                );
-            }
-
-            return parseImportDeclarationRest(node as ImportDeclaration, afterImportPos, identifier, isTypeOnly);
-        }
-
-        function parseImportDeclarationRest(node: ImportDeclaration, afterImportPos: number, name: Identifier | undefined, isTypeOnly: boolean): ImportDeclaration {
             node.kind = SyntaxKind.ImportDeclaration;
             // ImportDeclaration:
             //  import ImportClause from ModuleSpecifier ;
             //  import ModuleSpecifier;
-            if (name || // import id
+            if (identifier || // import id
                 token() === SyntaxKind.AsteriskToken ||  // import *
                 token() === SyntaxKind.OpenBraceToken    // import {
             ) {
-                (<ImportDeclaration>node).importClause = parseImportClause(name, afterImportPos, isTypeOnly);
+                (<ImportDeclaration>node).importClause = parseImportClause(identifier, afterImportPos, isTypeOnly);
                 parseExpected(SyntaxKind.FromKeyword);
             }
 
@@ -6587,9 +6571,6 @@ namespace ts {
         function parseExportDeclaration(node: ExportDeclaration): ExportDeclaration {
             node.kind = SyntaxKind.ExportDeclaration;
             node.isTypeOnly = parseOptional(SyntaxKind.TypeKeyword);
-            if (node.isTypeOnly) {
-                return doInsideOfContext(NodeFlags.InNonEmittingNode, () => parseExportDeclarationWorker(node));
-            }
             return parseExportDeclarationWorker(node);
         }
 
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
@@ -574,15 +574,15 @@ namespace ts {
         /* @internal */ InWithStatement               = 1 << 24, // If any ancestor of node was the `statement` of a WithStatement (not the `expression`)
         JsonFile                                      = 1 << 25, // If node was parsed in a Json
         /* @internal */ TypeCached                    = 1 << 26, // If a type was cached for node at any point
-        /* @internal */ InNonEmittingNode             = 1 << 27, // If a node was in a context where expressions are never emitted: type queries, abstract members, computed property names of types.
+        /* @internal */ InNonEmittingExpression       = 1 << 27, // If a node was in a context where expressions are never emitted: type queries, abstract members, computed property names of types.
 
         BlockScoped = Let | Const,
 
         ReachabilityCheckFlags = HasImplicitReturn | HasExplicitReturn,
         ReachabilityAndEmitFlags = ReachabilityCheckFlags | HasAsyncFunctions,
 
         // Parsing context flags
-        ContextFlags = DisallowInContext | YieldContext | DecoratorContext | AwaitContext | JavaScriptFile | InWithStatement | Ambient,
+        ContextFlags = DisallowInContext | YieldContext | DecoratorContext | AwaitContext | JavaScriptFile | InWithStatement | Ambient | InNonEmittingExpression,
 
         // Exclude these flags when parsing a Type
         TypeExcludesFlags = YieldContext | AwaitContext,

Original file line number	Diff line number	Diff line change
`@@ -1865,7 +1865,7 @@ namespace ts {`
`1865`	`1865`	`}`
`1866`	`1866`
`1867`	`1867`	`function checkSymbolUsageInExpressionContext(symbol: Symbol, name: __String, useSite: Node) {`
`1868`		`- if (!(useSite.flags & (NodeFlags.Ambient \| NodeFlags.InNonEmittingNode)) && useSite.parent.kind !== SyntaxKind.ExportSpecifier) {`
	`1868`	`+ if (!(useSite.flags & (NodeFlags.Ambient \| NodeFlags.InNonEmittingExpression)) && useSite.parent.kind !== SyntaxKind.ExportSpecifier) {`
`1869`	`1869`	`const typeOnlyDeclaration = getTypeOnlyAliasDeclaration(symbol);`
`1870`	`1870`	`if (typeOnlyDeclaration) {`
`1871`	`1871`	`const message = typeOnlyDeclaration.kind === SyntaxKind.ExportSpecifier`