Use getNodeId() less, specifically for NodeLinks.

Author: DanielRosenwasser

src/compiler/binder.ts

@@ -15,7 +15,7 @@ namespace ts {
         referenced: boolean;
     }
 
-    export function getModuleInstanceState(node: ModuleDeclaration, visited?: ESMap<number, ModuleInstanceState | undefined>): ModuleInstanceState {
+    export function getModuleInstanceState(node: ModuleDeclaration, visited?: ESMap<Node, ModuleInstanceState | undefined>): ModuleInstanceState {
         if (node.body && !node.body.parent) {
             // getModuleInstanceStateForAliasTarget needs to walk up the parent chain, so parent pointers must be set on this tree already
             setParent(node.body, node);
@@ -24,18 +24,17 @@ namespace ts {
         return node.body ? getModuleInstanceStateCached(node.body, visited) : ModuleInstanceState.Instantiated;
     }
 
-    function getModuleInstanceStateCached(node: Node, visited = new Map<number, ModuleInstanceState | undefined>()) {
-        const nodeId = getNodeId(node);
-        if (visited.has(nodeId)) {
-            return visited.get(nodeId) || ModuleInstanceState.NonInstantiated;
+    function getModuleInstanceStateCached(node: Node, visited = new Map<Node, ModuleInstanceState | undefined>()) {
+        if (visited.has(node)) {
+            return visited.get(node) || ModuleInstanceState.NonInstantiated;
         }
-        visited.set(nodeId, undefined);
+        visited.set(node, undefined);
         const result = getModuleInstanceStateWorker(node, visited);
-        visited.set(nodeId, result);
+        visited.set(node, result);
         return result;
     }
 
-    function getModuleInstanceStateWorker(node: Node, visited: ESMap<number, ModuleInstanceState | undefined>): ModuleInstanceState {
+    function getModuleInstanceStateWorker(node: Node, visited: ESMap<Node, ModuleInstanceState | undefined>): ModuleInstanceState {
         // A module is uninstantiated if it contains only
         switch (node.kind) {
             // 1. interface declarations, type alias declarations
@@ -107,7 +106,7 @@ namespace ts {
         return ModuleInstanceState.Instantiated;
     }
 
-    function getModuleInstanceStateForAliasTarget(specifier: ExportSpecifier, visited: ESMap<number, ModuleInstanceState | undefined>) {
+    function getModuleInstanceStateForAliasTarget(specifier: ExportSpecifier, visited: ESMap<Node, ModuleInstanceState | undefined>) {
         const name = specifier.propertyName || specifier.name;
         let p: Node | undefined = specifier.parent;
         while (p) {
@@ -2984,7 +2983,7 @@ namespace ts {
 
         function addLateBoundAssignmentDeclarationToSymbol(node: BinaryExpression | DynamicNamedDeclaration, symbol: Symbol | undefined) {
             if (symbol) {
-                (symbol.assignmentDeclarationMembers || (symbol.assignmentDeclarationMembers = new Map())).set(getNodeId(node), node);
+                (symbol.assignmentDeclarationMembers ||= new Set()).add(node);
             }
         }
 

src/compiler/checker.ts

@@ -974,7 +974,7 @@ namespace ts {
         const maximumSuggestionCount = 10;
         const mergedSymbols: Symbol[] = [];
         const symbolLinks: SymbolLinks[] = [];
-        const nodeLinks: NodeLinks[] = [];
+        const nodeLinks: ESMap<Node, NodeLinks> = new Map();
         const flowLoopCaches: ESMap<string, Type>[] = [];
         const flowLoopNodes: FlowNode[] = [];
         const flowLoopKeys: string[] = [];
@@ -1463,8 +1463,11 @@ namespace ts {
         }
 
         function getNodeLinks(node: Node): NodeLinks {
-            const nodeId = getNodeId(node);
-            return nodeLinks[nodeId] || (nodeLinks[nodeId] = new (NodeLinks as any)());
+            let result = nodeLinks.get(node);
+            if (!result) {
+                nodeLinks.set(node, result = new (NodeLinks as any)() as NodeLinks);
+            }
+            return result;
         }
 
         function isGlobalSourceFile(node: Node) {
@@ -40316,9 +40319,8 @@ namespace ts {
             const enclosingFile = getSourceFileOfNode(node);
             const links = getNodeLinks(enclosingFile);
             if (!(links.flags & NodeCheckFlags.TypeChecked)) {
-                links.deferredNodes = links.deferredNodes || new Map();
-                const id = getNodeId(node);
-                links.deferredNodes.set(id, node);
+                links.deferredNodes = links.deferredNodes || new Set();
+                links.deferredNodes.add(node);
             }
         }
 
@@ -41599,9 +41601,7 @@ namespace ts {
         }
 
         function getNodeCheckFlags(node: Node): NodeCheckFlags {
-            const nodeId = node.id || 0;
-            if (nodeId < 0 || nodeId >= nodeLinks.length) return 0;
-            return nodeLinks[nodeId]?.flags || 0;
+            return nodeLinks.get(node)?.flags || 0;
         }
 
         function getEnumMemberValue(node: EnumMember): string | number | undefined {

src/compiler/emitter.ts

@@ -869,7 +869,7 @@ namespace ts {
         const bundledHelpers = new Map<string, boolean>();
 
         let currentSourceFile: SourceFile | undefined;
-        let nodeIdToGeneratedName: string[]; // Map of generated names for specific nodes.
+        let nodeToGeneratedName: ESMap<Node, string>; // Map of generated names for specific nodes.
         let autoGeneratedIdToGeneratedName: string[]; // Map of generated names for temp and loop variables.
         let generatedNames: Set<string>; // Set of names generated by the NameGenerator.
         let tempFlagsStack: TempFlags[]; // Stack of enclosing name generation scopes.
@@ -1154,7 +1154,7 @@ namespace ts {
         }
 
         function reset() {
-            nodeIdToGeneratedName = [];
+            nodeToGeneratedName = new Map<Node, string>();
             autoGeneratedIdToGeneratedName = [];
             generatedNames = new Set();
             tempFlagsStack = [];
@@ -5008,8 +5008,11 @@ namespace ts {
         }
 
         function generateNameCached(node: Node, flags?: GeneratedIdentifierFlags) {
-            const nodeId = getNodeId(node);
-            return nodeIdToGeneratedName[nodeId] || (nodeIdToGeneratedName[nodeId] = generateNameForNode(node, flags));
+            let result = nodeToGeneratedName.get(node);
+            if (result === undefined) {
+                nodeToGeneratedName.set(node, result = generateNameForNode(node, flags));
+            }
+            return result;
         }
 
         /**

src/compiler/types.ts

@@ -4908,7 +4908,7 @@ namespace ts {
         /* @internal */ isReferenced?: SymbolFlags; // True if the symbol is referenced elsewhere. Keeps track of the meaning of a reference in case a symbol is both a type parameter and parameter.
         /* @internal */ isReplaceableByMethod?: boolean; // Can this Javascript class property be replaced by a method symbol?
         /* @internal */ isAssigned?: boolean;   // True if the symbol is a parameter with assignments
-        /* @internal */ assignmentDeclarationMembers?: ESMap<number, Declaration>; // detected late-bound assignment declarations associated with the symbol
+        /* @internal */ assignmentDeclarationMembers?: Set<Declaration>; // detected late-bound assignment declarations associated with the symbol
     }
 
     /* @internal */
@@ -5106,7 +5106,7 @@ namespace ts {
         jsxNamespace?: Symbol | false;      // Resolved jsx namespace symbol for this node
         jsxImplicitImportContainer?: Symbol | false; // Resolved module symbol the implicit jsx import of this file should refer to
         contextFreeType?: Type;             // Cached context-free type used by the first pass of inference; used when a function's return is partially contextually sensitive
-        deferredNodes?: ESMap<NodeId, Node>; // Set of nodes whose checking has been deferred
+        deferredNodes?: Set<Node>;          // Set of nodes whose checking has been deferred
         capturedBlockScopeBindings?: Symbol[]; // Block-scoped bindings captured beneath this part of an IterationStatement
         outerTypeParameters?: TypeParameter[]; // Outer type parameters of anonymous object type
         isExhaustive?: boolean;             // Is node an exhaustive switch statement