Remove Identifier.hasExtendedUnicodeEscape

Author: rbuckton

Diff for: src/compiler/binder.ts

@@ -1030,6 +1030,7 @@ function createBinder(): (file: SourceFile, options: CompilerOptions) => void {
         else if (containerFlags & ContainerFlags.IsInterface) {
             seenThisKeyword = false;
             bindChildren(node);
+            Debug.assertNotNode(node, isIdentifier); // ContainsThis cannot overlap with HasExtendedUnicodeEscape on Identifier
             node.flags = seenThisKeyword ? node.flags | NodeFlags.ContainsThis : node.flags & ~NodeFlags.ContainsThis;
         }
         else {

Diff for: src/compiler/factory/nodeFactory.ts

@@ -1156,7 +1156,6 @@ export function createNodeFactory(flags: NodeFactoryFlags, baseFactory: BaseNode
         node.originalKeywordKind = originalKeywordKind;
         node.escapedText = escapedText;
         node.autoGenerate = undefined;
-        node.hasExtendedUnicodeEscape = undefined;
         node.jsDoc = undefined; // initialized by parser (JsDocContainer)
         node.jsDocCache = undefined; // initialized by parser (JsDocContainer)
         node.flowNode = undefined; // initialized by binder (FlowContainer)
@@ -1186,13 +1185,13 @@ export function createNodeFactory(flags: NodeFactoryFlags, baseFactory: BaseNode
         }
 
         const node = createBaseIdentifier(escapeLeadingUnderscores(text), originalKeywordKind);
-        node.hasExtendedUnicodeEscape = hasExtendedUnicodeEscape;
+        if (hasExtendedUnicodeEscape) node.flags |= NodeFlags.HasExtendedUnicodeEscape;
 
         // NOTE: we do not include transform flags of typeArguments in an identifier as they do not contribute to transformations
         if (node.originalKeywordKind === SyntaxKind.AwaitKeyword) {
             node.transformFlags |= TransformFlags.ContainsPossibleTopLevelAwait;
         }
-        if (node.hasExtendedUnicodeEscape) {
+        if (node.flags & NodeFlags.HasExtendedUnicodeEscape) {
             node.transformFlags |= TransformFlags.ContainsES2015;
         }
 
@@ -6381,7 +6380,6 @@ export function createNodeFactory(flags: NodeFactoryFlags, baseFactory: BaseNode
     function cloneIdentifier(node: Identifier): Identifier {
         const clone = createBaseIdentifier(node.escapedText, node.originalKeywordKind);
         clone.flags |= node.flags & ~NodeFlags.Synthesized;
-        clone.hasExtendedUnicodeEscape = node.hasExtendedUnicodeEscape;
         clone.jsDoc = node.jsDoc;
         clone.jsDocCache = node.jsDocCache;
         clone.flowNode = node.flowNode;

Diff for: src/compiler/transformers/es2015.ts

@@ -856,7 +856,7 @@ export function transformES2015(context: TransformationContext): (x: SourceFile
                 return convertedLoopState.argumentsName || (convertedLoopState.argumentsName = factory.createUniqueName("arguments"));
             }
         }
-        if (node.hasExtendedUnicodeEscape) {
+        if (node.flags & NodeFlags.HasExtendedUnicodeEscape) {
             return setOriginalNode(setTextRange(
                 factory.createIdentifier(unescapeLeadingUnderscores(node.escapedText)),
                 node

Diff for: src/compiler/types.ts

@@ -831,6 +831,8 @@ export const enum NodeFlags {
     // never cleared on SourceFiles which get re-used in between incremental parses.
     // See the comment above on `PossiblyContainsDynamicImport` and `PossiblyContainsImportMeta`.
     /** @internal */ PermanentlySetIncrementalFlags = PossiblyContainsDynamicImport | PossiblyContainsImportMeta,
+
+    /** @internal */ HasExtendedUnicodeEscape = ContainsThis, // Reuses ContainsThis value with a different meaning on Identifiers
 }
 
 export const enum ModifierFlags {
@@ -1682,7 +1684,6 @@ export interface Identifier extends PrimaryExpression, Declaration, JSDocContain
     /** @internal */ generatedImportReference?: ImportSpecifier; // Reference to the generated import specifier this identifier refers to
     isInJSDocNamespace?: boolean;                             // if the node is a member in a JSDoc namespace
     /** @internal */ jsdocDotPos?: number;                       // Identifier occurs in JSDoc-style generic: Id.<T>
-    /** @internal */ hasExtendedUnicodeEscape?: boolean;
 }
 
 // Transient identifier node (marked by id === -1)

Diff for: src/harness/harnessUtils.ts

@@ -1,5 +1,6 @@
 import * as ts from "./_namespaces/ts";
 import * as Harness from "./_namespaces/Harness";
+import { isIdentifier } from "./_namespaces/ts";
 
 export function encodeString(s: string): string {
     return ts.sys.bufferFrom!(s).toString("utf8");
@@ -189,7 +190,7 @@ export function sourceFileToJSON(file: ts.Node): string {
             o.containsParseError = true;
         }
 
-        for (const propertyName of Object.getOwnPropertyNames(n) as readonly (keyof ts.SourceFile | keyof ts.Identifier)[]) {
+        for (const propertyName of Object.getOwnPropertyNames(n) as readonly (keyof ts.SourceFile | keyof ts.Identifier | keyof ts.StringLiteral)[]) {
             switch (propertyName) {
                 case "parent":
                 case "symbol":
@@ -219,7 +220,13 @@ export function sourceFileToJSON(file: ts.Node): string {
                     // 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
                     // on the AST.
-                    const flags = n.flags & ~(ts.NodeFlags.JavaScriptFile | ts.NodeFlags.HasAggregatedChildData);
+                    let flags = n.flags & ~(ts.NodeFlags.JavaScriptFile | ts.NodeFlags.HasAggregatedChildData);
+                    if (isIdentifier(n)) {
+                        if (flags & ts.NodeFlags.HasExtendedUnicodeEscape) {
+                            o.hasExtendedUnicodeEscape = true;
+                            flags &= ~ts.NodeFlags.HasExtendedUnicodeEscape;
+                        }
+                    }
                     if (flags) {
                         o[propertyName] = getNodeFlagName(flags);
                     }