Remove originalKeywordKind from Identifier nodes.

DanielRosenwasser · DanielRosenwasser · commit 38402e6141b8 · 2022-12-14T00:24:28.000Z
diff --git a/src/compiler/binder.ts b/src/compiler/binder.ts
@@ -283,6 +283,7 @@ import {
     SpreadElement,
     Statement,
     StringLiteral,
+    stringToToken,
     SuperExpression,
     SwitchStatement,
     Symbol,
@@ -2419,14 +2420,20 @@ function createBinder(): (file: SourceFile, options: CompilerOptions) => void {
             !(node.flags & NodeFlags.JSDoc) &&
             !isIdentifierName(node)) {
 
+
+            const originalKeywordKind = stringToToken(node.escapedText as string);
+            if (originalKeywordKind === undefined) {
+                return;
+            }
+
             // strict mode identifiers
             if (inStrictMode &&
-                node.originalKeywordKind! >= SyntaxKind.FirstFutureReservedWord &&
-                node.originalKeywordKind! <= SyntaxKind.LastFutureReservedWord) {
+                originalKeywordKind >= SyntaxKind.FirstFutureReservedWord &&
+                originalKeywordKind <= SyntaxKind.LastFutureReservedWord) {
                 file.bindDiagnostics.push(createDiagnosticForNode(node,
                     getStrictModeIdentifierMessage(node), declarationNameToString(node)));
             }
-            else if (node.originalKeywordKind === SyntaxKind.AwaitKeyword) {
+            else if (originalKeywordKind === SyntaxKind.AwaitKeyword) {
                 if (isExternalModule(file) && isInTopLevelContext(node)) {
                     file.bindDiagnostics.push(createDiagnosticForNode(node,
                         Diagnostics.Identifier_expected_0_is_a_reserved_word_at_the_top_level_of_a_module,
@@ -2438,7 +2445,7 @@ function createBinder(): (file: SourceFile, options: CompilerOptions) => void {
                         declarationNameToString(node)));
                 }
             }
-            else if (node.originalKeywordKind === SyntaxKind.YieldKeyword && node.flags & NodeFlags.YieldContext) {
+            else if (originalKeywordKind === SyntaxKind.YieldKeyword && node.flags & NodeFlags.YieldContext) {
                 file.bindDiagnostics.push(createDiagnosticForNode(node,
                     Diagnostics.Identifier_expected_0_is_a_reserved_word_that_cannot_be_used_here,
                     declarationNameToString(node)));
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
@@ -923,6 +923,7 @@ import {
     StringLiteralLike,
     StringLiteralType,
     StringMappingType,
+    stringToToken,
     stripQuotes,
     StructuredType,
     SubstitutionType,
@@ -23117,11 +23118,12 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                 break;
             case SyntaxKind.Parameter:
                 const param = declaration as ParameterDeclaration;
+                let keywordKind: SyntaxKind | undefined;
                 if (isIdentifier(param.name) &&
-                    (isCallSignatureDeclaration(param.parent) || isMethodSignature(param.parent) || isFunctionTypeNode(param.parent)) &&
-                    param.parent.parameters.indexOf(param) > -1 &&
-                    (resolveName(param, param.name.escapedText, SymbolFlags.Type, undefined, param.name.escapedText, /*isUse*/ true) ||
-                    param.name.originalKeywordKind && isTypeNodeKind(param.name.originalKeywordKind))) {
+                        (isCallSignatureDeclaration(param.parent) || isMethodSignature(param.parent) || isFunctionTypeNode(param.parent)) &&
+                        param.parent.parameters.indexOf(param) > -1 &&
+                        (resolveName(param, param.name.escapedText, SymbolFlags.Type, undefined, param.name.escapedText, /*isUse*/ true) ||
+                        (keywordKind = stringToToken(param.name.escapedText as string)) && isTypeNodeKind(keywordKind))) {
                     const newName = "arg" + param.parent.parameters.indexOf(param);
                     const typeName = declarationNameToString(param.name) + (param.dotDotDotToken ? "[]" : "");
                     errorOrSuggestion(noImplicitAny, declaration, Diagnostics.Parameter_has_a_name_but_no_type_Did_you_mean_0_Colon_1, newName, typeName);
@@ -46687,7 +46689,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
 
     function checkGrammarNameInLetOrConstDeclarations(name: Identifier | BindingPattern): boolean {
         if (name.kind === SyntaxKind.Identifier) {
-            if (name.originalKeywordKind === SyntaxKind.LetKeyword) {
+            if (name.escapedText === "let") {
                 return grammarErrorOnNode(name, Diagnostics.let_is_not_allowed_to_be_used_as_a_name_in_let_or_const_declarations);
             }
         }
diff --git a/src/compiler/factory/nodeFactory.ts b/src/compiler/factory/nodeFactory.ts
@@ -407,7 +407,6 @@ import {
     startsWith,
     Statement,
     StringLiteral,
-    stringToToken,
     SuperExpression,
     SwitchStatement,
     SyntaxKind,
@@ -1150,16 +1149,15 @@ export function createNodeFactory(flags: NodeFactoryFlags, baseFactory: BaseNode
     // Identifiers
     //
 
-    function createBaseIdentifier(escapedText: __String, originalKeywordKind: SyntaxKind | undefined) {
+    function createBaseIdentifier(escapedText: __String) {
         const node = baseFactory.createBaseIdentifierNode(SyntaxKind.Identifier) as Mutable<Identifier>;
-        node.originalKeywordKind = originalKeywordKind;
         node.escapedText = escapedText;
         node.autoGenerateFlags = GeneratedIdentifierFlags.None;
         return node;
     }
 
     function createBaseGeneratedIdentifier(text: string, autoGenerateFlags: GeneratedIdentifierFlags, prefix: string | GeneratedNamePart | undefined, suffix: string | undefined) {
-        const node = createBaseIdentifier(escapeLeadingUnderscores(text), /*originalKeywordKind*/ undefined) as Mutable<GeneratedIdentifier>;
+        const node = createBaseIdentifier(escapeLeadingUnderscores(text)) as Mutable<GeneratedIdentifier>;
         node.autoGenerateFlags = autoGenerateFlags;
         node.autoGenerateId = nextAutoGenerateId;
         node.autoGeneratePrefix = prefix;
@@ -1168,16 +1166,17 @@ export function createNodeFactory(flags: NodeFactoryFlags, baseFactory: BaseNode
         return node;
     }
 
-    // @api
-    function createIdentifier(text: string, typeArguments?: readonly (TypeNode | TypeParameterDeclaration)[], originalKeywordKind?: SyntaxKind, hasExtendedUnicodeEscape?: boolean): Identifier {
-        if (originalKeywordKind === undefined && text) {
-            originalKeywordKind = stringToToken(text);
-        }
-        if (originalKeywordKind === SyntaxKind.Identifier) {
-            originalKeywordKind = undefined;
-        }
-
-        const node = createBaseIdentifier(escapeLeadingUnderscores(text), originalKeywordKind);
+    /**
+     * 
+     * @param text 
+     * @param typeArguments 
+     * @param originalKeywordKind ONLY provided by the parser.
+     * @param hasExtendedUnicodeEscape ONLY provided by the parser.
+     * @returns 
+    */
+   // @api
+   function createIdentifier(text: string, typeArguments?: readonly (TypeNode | TypeParameterDeclaration)[], originalKeywordKind?: SyntaxKind, hasExtendedUnicodeEscape?: boolean): Identifier {
+        const node = createBaseIdentifier(escapeLeadingUnderscores(text));
         node.typeArguments = asNodeArray(typeArguments);
         node.hasExtendedUnicodeEscape = hasExtendedUnicodeEscape;
         node.jsDoc = undefined; // initialized by parser (JsDocContainer)
@@ -1186,7 +1185,7 @@ export function createNodeFactory(flags: NodeFactoryFlags, baseFactory: BaseNode
         node.symbol = undefined!; // initialized by checker
 
         // NOTE: we do not include transform flags of typeArguments in an identifier as they do not contribute to transformations
-        if (node.originalKeywordKind === SyntaxKind.AwaitKeyword) {
+        if (originalKeywordKind === SyntaxKind.AwaitKeyword) {
             node.transformFlags |= TransformFlags.ContainsPossibleTopLevelAwait;
         }
         if (node.hasExtendedUnicodeEscape) {
@@ -6372,7 +6371,7 @@ export function createNodeFactory(flags: NodeFactoryFlags, baseFactory: BaseNode
     }
 
     function cloneGeneratedIdentifier(node: GeneratedIdentifier): GeneratedIdentifier {
-        const clone = createBaseIdentifier(node.escapedText, /*originalKeywordKind*/ undefined) as Mutable<GeneratedIdentifier>;
+        const clone = createBaseIdentifier(node.escapedText) as Mutable<GeneratedIdentifier>;
         clone.flags |= node.flags & ~NodeFlags.Synthesized;
         clone.autoGenerateFlags = node.autoGenerateFlags;
         clone.autoGenerateId = node.autoGenerateId;
@@ -6384,7 +6383,7 @@ export function createNodeFactory(flags: NodeFactoryFlags, baseFactory: BaseNode
     }
 
     function cloneIdentifier(node: Identifier): Identifier {
-        const clone = createBaseIdentifier(node.escapedText, node.originalKeywordKind);
+        const clone = createBaseIdentifier(node.escapedText);
         clone.flags |= node.flags & ~NodeFlags.Synthesized;
         clone.typeArguments = node.typeArguments;
         clone.hasExtendedUnicodeEscape = node.hasExtendedUnicodeEscape;
diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts
@@ -3194,7 +3194,7 @@ namespace Parser {
                     // into an actual .ConstructorDeclaration.
                     const methodDeclaration = node as MethodDeclaration;
                     const nameIsConstructor = methodDeclaration.name.kind === SyntaxKind.Identifier &&
-                        methodDeclaration.name.originalKeywordKind === SyntaxKind.ConstructorKeyword;
+                        methodDeclaration.name.escapedText === "constructor";
 
                     return !nameIsConstructor;
             }
diff --git a/src/compiler/transformers/es2015.ts b/src/compiler/transformers/es2015.ts
@@ -105,7 +105,7 @@ import {
     isHoistedFunction,
     isHoistedVariableStatement,
     isIdentifier,
-    isIdentifierANonContextualKeyword,
+    isStringANonContextualKeyword,
     isIfStatement,
     isInternalName,
     isIterationStatement,
@@ -1074,7 +1074,7 @@ export function transformES2015(context: TransformationContext): (x: SourceFile
     function transformClassBody(node: ClassExpression | ClassDeclaration, extendsClauseElement: ExpressionWithTypeArguments | undefined): Block {
         const statements: Statement[] = [];
         const name = factory.getInternalName(node);
-        const constructorLikeName = isIdentifierANonContextualKeyword(name) ? factory.getGeneratedNameForNode(name) : name;
+        const constructorLikeName = isStringANonContextualKeyword(idText(name)) ? factory.getGeneratedNameForNode(name) : name;
         startLexicalEnvironment();
         addExtendsHelperIfNeeded(statements, node, extendsClauseElement);
         addConstructor(statements, node, constructorLikeName, extendsClauseElement);
diff --git a/src/compiler/transformers/es5.ts b/src/compiler/transformers/es5.ts
@@ -5,7 +5,6 @@ import {
     Expression,
     getOriginalNodeId,
     Identifier,
-    idText,
     isIdentifier,
     isPrivateIdentifier,
     isPropertyAccessExpression,
@@ -15,7 +14,6 @@ import {
     JsxOpeningElement,
     JsxSelfClosingElement,
     Node,
-    nodeIsSynthesized,
     PropertyAccessExpression,
     PropertyAssignment,
     setTextRange,
@@ -139,7 +137,7 @@ export function transformES5(context: TransformationContext): (x: SourceFile | B
      * @param name An Identifier
      */
     function trySubstituteReservedName(name: Identifier) {
-        const token = name.originalKeywordKind || (nodeIsSynthesized(name) ? stringToToken(idText(name)) : undefined);
+        const token = stringToToken(name.escapedText as string);
         if (token !== undefined && token >= SyntaxKind.FirstReservedWord && token <= SyntaxKind.LastReservedWord) {
             return setTextRange(factory.createStringLiteralFromNode(name), name);
         }
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
@@ -1677,7 +1677,6 @@ export interface Identifier extends PrimaryExpression, Declaration, JSDocContain
      * Text of identifier, but if the identifier begins with two underscores, this will begin with three.
      */
     readonly escapedText: __String;
-    readonly originalKeywordKind?: SyntaxKind;                // Original syntaxKind which get set so that we can report an error later
     /** @internal */ readonly autoGenerateFlags?: GeneratedIdentifierFlags; // Specifies whether to auto-generate the text for an identifier.
     /** @internal */ readonly autoGenerateId?: number;           // Ensures unique generated identifiers get unique names, but clones get the same name.
     /** @internal */ readonly autoGeneratePrefix?: string | GeneratedNamePart;
diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts
@@ -4340,11 +4340,6 @@ export function isStringAKeyword(name: string) {
     return token !== undefined && isKeyword(token);
 }
 
-/** @internal */
-export function isIdentifierANonContextualKeyword({ originalKeywordKind }: Identifier): boolean {
-    return !!originalKeywordKind && !isContextualKeyword(originalKeywordKind);
-}
-
 /** @internal */
 export function isTrivia(token: SyntaxKind): token is TriviaSyntaxKind {
     return SyntaxKind.FirstTriviaToken <= token && token <= SyntaxKind.LastTriviaToken;
@@ -5709,7 +5704,7 @@ export function isThisInTypeQuery(node: Node): boolean {
 
 /** @internal */
 export function identifierIsThisKeyword(id: Identifier): boolean {
-    return id.originalKeywordKind === SyntaxKind.ThisKeyword;
+    return id.escapedText === "this";
 }
 
 /** @internal */
diff --git a/src/harness/harnessUtils.ts b/src/harness/harnessUtils.ts
@@ -206,15 +206,10 @@ export function sourceFileToJSON(file: ts.Node): string {
                     break;
 
                 case "hasExtendedUnicodeEscape":
-                    if ((n as any).hasExtendedUnicodeEscape) {
+                    if ((n as ts.Identifier).hasExtendedUnicodeEscape) {
                         o.hasExtendedUnicodeEscape = true;
                     }
                     break;
-
-                case "originalKeywordKind":
-                    o[propertyName] = getKindName((n as any)[propertyName]);
-                    break;
-
                 case "flags":
                     // Clear the flags that are produced by aggregating child values. That is ephemeral
                     // data we don't care about in the dump. We only care what the parser set directly
diff --git a/src/services/codefixes/convertToEsModule.ts b/src/services/codefixes/convertToEsModule.ts
@@ -75,6 +75,7 @@ import {
     SourceFile,
     Statement,
     StringLiteralLike,
+    stringToToken,
     SymbolFlags,
     SyntaxKind,
     textChanges,
@@ -161,8 +162,9 @@ type ExportRenames = ReadonlyMap<string, string>;
 function collectExportRenames(sourceFile: SourceFile, checker: TypeChecker, identifiers: Identifiers): ExportRenames {
     const res = new Map<string, string>();
     forEachExportReference(sourceFile, node => {
-        const { text, originalKeywordKind } = node.name;
-        if (!res.has(text) && (originalKeywordKind !== undefined && isNonContextualKeyword(originalKeywordKind)
+        const text = node.name.text;
+        const keywordKind = stringToToken(text);
+        if (!res.has(text) && (keywordKind !== undefined && isNonContextualKeyword(keywordKind)
             || checker.resolveName(text, node, SymbolFlags.Value, /*excludeGlobals*/ true))) {
             // Unconditionally add an underscore in case `text` is a keyword.
             res.set(text, makeUniqueName(`_${text}`, identifiers));
diff --git a/src/services/completions.ts b/src/services/completions.ts
@@ -1690,8 +1690,11 @@ function isModifierLike(node: Node): ModifierSyntaxKind | undefined {
     if (isModifier(node)) {
         return node.kind;
     }
-    if (isIdentifier(node) && node.originalKeywordKind && isModifierKind(node.originalKeywordKind)) {
-        return node.originalKeywordKind;
+    if (isIdentifier(node)) {
+        const keywordKind = stringToToken(node.text);
+        if (keywordKind && isModifierKind(keywordKind)) {
+            return keywordKind;
+        }
     }
     return undefined;
 }
@@ -4720,7 +4723,7 @@ function isFunctionLikeBodyKeyword(kind: SyntaxKind) {
 }
 
 function keywordForNode(node: Node): SyntaxKind {
-    return isIdentifier(node) ? node.originalKeywordKind || SyntaxKind.Unknown : node.kind;
+    return isIdentifier(node) ? stringToToken(node.text) ?? SyntaxKind.Unknown : node.kind;
 }
 
 function getContextualKeywords(
@@ -4824,7 +4827,7 @@ function tryGetObjectTypeDeclarationCompletionContainer(sourceFile: SourceFile,
             }
             break;
        case SyntaxKind.Identifier: {
-            const originalKeywordKind = (location as Identifier).originalKeywordKind;
+            const originalKeywordKind = stringToToken((location as Identifier).text);
             if (originalKeywordKind && isKeyword(originalKeywordKind)) {
                 return undefined;
             }
diff --git a/src/services/findAllReferences.ts b/src/services/findAllReferences.ts
@@ -1940,8 +1940,8 @@ export namespace Core {
 
         // For `export { foo as bar }`, rename `foo`, but not `bar`.
         if (!isForRenameWithPrefixAndSuffixText(state.options) || alwaysGetReferences) {
-            const isDefaultExport = referenceLocation.originalKeywordKind === SyntaxKind.DefaultKeyword
-                || exportSpecifier.name.originalKeywordKind === SyntaxKind.DefaultKeyword;
+            const isDefaultExport = referenceLocation.text === "default"
+                || exportSpecifier.name.text === "default";
             const exportKind = isDefaultExport ? ExportKind.Default : ExportKind.Named;
             const exportSymbol = Debug.checkDefined(exportSpecifier.symbol);
             const exportInfo = getExportInfo(exportSymbol, exportKind, state.checker);
diff --git a/src/services/refactors/extractSymbol.ts b/src/services/refactors/extractSymbol.ts
@@ -87,7 +87,6 @@ import {
     isJsxElement,
     isJsxFragment,
     isJsxSelfClosingElement,
-    isKeyword,
     isModuleBlock,
     isParenthesizedTypeNode,
     isPartOfTypeNode,
@@ -100,6 +99,7 @@ import {
     isSourceFile,
     isStatement,
     isStatic,
+    isStringAKeyword,
     isStringLiteral,
     isSwitchStatement,
     isThis,
@@ -1351,7 +1351,7 @@ function extractConstantInScope(
 
     // Make a unique name for the extracted variable
     const file = scope.getSourceFile();
-    const localNameText = isPropertyAccessExpression(node) && !isClassLike(scope) && !checker.resolveName(node.name.text, node, SymbolFlags.Value, /*excludeGlobals*/ false) && !isPrivateIdentifier(node.name) && !isKeyword(node.name.originalKeywordKind!)
+    const localNameText = isPropertyAccessExpression(node) && !isClassLike(scope) && !checker.resolveName(node.name.text, node, SymbolFlags.Value, /*excludeGlobals*/ false) && !isPrivateIdentifier(node.name) && !isStringAKeyword(node.name.text)
         ? node.name.text
         : getUniqueName(isClassLike(scope) ? "newProperty" : "newLocal", file);
     const isJS = isInJSFile(scope);
diff --git a/src/services/rename.ts b/src/services/rename.ts
@@ -97,7 +97,7 @@ function getRenameInfoForNode(
     }
 
     // Cannot rename `default` as in `import { default as foo } from "./someModule";
-    if (isIdentifier(node) && node.originalKeywordKind === SyntaxKind.DefaultKeyword && symbol.parent && symbol.parent.flags & SymbolFlags.Module) {
+    if (isIdentifier(node) && node.escapedText === "default" && symbol.parent && symbol.parent.flags & SymbolFlags.Module) {
         return undefined;
     }
 

Original file line number	Diff line number	Diff line change
`@@ -3194,7 +3194,7 @@ namespace Parser {`
`3194`	`3194`	`// into an actual .ConstructorDeclaration.`
`3195`	`3195`	`const methodDeclaration = node as MethodDeclaration;`
`3196`	`3196`	`const nameIsConstructor = methodDeclaration.name.kind === SyntaxKind.Identifier &&`
`3197`		`- methodDeclaration.name.originalKeywordKind === SyntaxKind.ConstructorKeyword;`
	`3197`	`+ methodDeclaration.name.escapedText === "constructor";`
`3198`	`3198`
`3199`	`3199`	`return !nameIsConstructor;`
`3200`	`3200`	`}`