Try just the fetching change in checker.

Author: DanielRosenwasser

src/compiler/binder.ts

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

src/compiler/checker.ts

@@ -3887,9 +3887,10 @@ namespace ts {
 
         function getAlternativeContainingModules(symbol: Symbol, enclosingDeclaration: Node): Symbol[] {
             const containingFile = getSourceFileOfNode(enclosingDeclaration);
+            const id = getNodeId(containingFile);
             const links = getSymbolLinks(symbol);
             let results: Symbol[] | undefined;
-            if (links.extendedContainersByFile && (results = links.extendedContainersByFile.get(containingFile))) {
+            if (links.extendedContainersByFile && (results = links.extendedContainersByFile.get(id))) {
                 return results;
             }
             if (containingFile && containingFile.imports) {
@@ -3903,7 +3904,7 @@ namespace ts {
                     results = append(results, resolvedModule);
                 }
                 if (length(results)) {
-                    (links.extendedContainersByFile ||= new Map()).set(containingFile, results!);
+                    (links.extendedContainersByFile || (links.extendedContainersByFile = new Map())).set(id, results!);
                     return results!;
                 }
             }
@@ -33795,7 +33796,7 @@ namespace ts {
             const type = checkExpression(node);
             // If control flow analysis was required to determine the type, it is worth caching.
             if (flowInvocationCount !== startInvocationCount) {
-                const cache = (flowTypeCache ||= []);
+                const cache = flowTypeCache || (flowTypeCache = []);
                 cache[getNodeId(node)] = type;
                 setNodeFlags(node, node.flags | NodeFlags.TypeCached);
             }
@@ -40317,8 +40318,9 @@ namespace ts {
             const enclosingFile = getSourceFileOfNode(node);
             const links = getNodeLinks(enclosingFile);
             if (!(links.flags & NodeCheckFlags.TypeChecked)) {
-                links.deferredNodes ||= new Set();
-                links.deferredNodes.add(node);
+                links.deferredNodes = links.deferredNodes || new Map();
+                const id = getNodeId(node);
+                links.deferredNodes.set(id, node);
             }
         }
 

src/compiler/emitter.ts

@@ -869,7 +869,7 @@ namespace ts {
         const bundledHelpers = new Map<string, boolean>();
 
         let currentSourceFile: SourceFile | undefined;
-        let nodeToGeneratedName: ESMap<Node, string>; // Map of generated names for specific nodes.
+        let nodeIdToGeneratedName: 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() {
-            nodeToGeneratedName = new Map<Node, string>();
+            nodeIdToGeneratedName = [];
             autoGeneratedIdToGeneratedName = [];
             generatedNames = new Set();
             tempFlagsStack = [];
@@ -5008,11 +5008,8 @@ namespace ts {
         }
 
         function generateNameCached(node: Node, flags?: GeneratedIdentifierFlags) {
-            let result = nodeToGeneratedName.get(node);
-            if (result === undefined) {
-                nodeToGeneratedName.set(node, result = generateNameForNode(node, flags));
-            }
-            return result;
+            const nodeId = getNodeId(node);
+            return nodeIdToGeneratedName[nodeId] || (nodeIdToGeneratedName[nodeId] = generateNameForNode(node, flags));
         }
 
         /**

src/compiler/factory/nodeFactory.ts

@@ -5339,7 +5339,7 @@ namespace ts {
         }
 
         function flattenCommaElements(node: Expression): Expression | readonly Expression[] {
-            if (nodeIsSynthesized(node) && !isParseTreeNode(node) && !node.original && !node.emitNode) {
+            if (nodeIsSynthesized(node) && !isParseTreeNode(node) && !node.original && !node.emitNode && !node.id) {
                 if (isCommaListExpression(node)) {
                     return node.elements;
                 }

src/compiler/transformers/classFields.ts

@@ -147,7 +147,7 @@ namespace ts {
 
         let enabledSubstitutions: ClassPropertySubstitutionFlags;
 
-        let classAliases: ESMap<Node, Identifier>;
+        let classAliases: Identifier[];
 
         /**
          * Tracks what computed name expressions originating from elided names must be inlined
@@ -162,7 +162,7 @@ namespace ts {
         let pendingStatements: Statement[] | undefined;
 
         const classLexicalEnvironmentStack: (ClassLexicalEnvironment | undefined)[] = [];
-        const classLexicalEnvironmentMap = new WeakMap<Node, ClassLexicalEnvironment>();
+        const classLexicalEnvironmentMap = new Map<number, ClassLexicalEnvironment>();
         let currentClassLexicalEnvironment: ClassLexicalEnvironment | undefined;
         let currentComputedPropertyNameClassLexicalEnvironment: ClassLexicalEnvironment | undefined;
         let currentStaticPropertyDeclarationOrStaticBlock: PropertyDeclaration | ClassStaticBlockDeclaration | undefined;
@@ -738,7 +738,7 @@ namespace ts {
         function transformClassStaticBlockDeclaration(node: ClassStaticBlockDeclaration) {
             if (shouldTransformPrivateElementsOrClassStaticBlocks) {
                 if (currentClassLexicalEnvironment) {
-                    classLexicalEnvironmentMap.set(getOriginalNode(node), currentClassLexicalEnvironment);
+                    classLexicalEnvironmentMap.set(getOriginalNodeId(node), currentClassLexicalEnvironment);
                 }
 
                 startLexicalEnvironment();
@@ -1128,7 +1128,7 @@ namespace ts {
                         enableSubstitutionForClassAliases();
                         const alias = factory.cloneNode(temp) as GeneratedIdentifier;
                         alias.autoGenerateFlags &= ~GeneratedIdentifierFlags.ReservedInNestedScopes;
-                        classAliases.set(getOriginalNode(node), alias);
+                        classAliases[getOriginalNodeId(node)] = alias;
                     }
 
                     // To preserve the behavior of the old emitter, we explicitly indent
@@ -1375,7 +1375,7 @@ namespace ts {
                 // capture the lexical environment for the member
                 setOriginalNode(transformed, property);
                 addEmitFlags(transformed, EmitFlags.AdviseOnEmitNode);
-                classLexicalEnvironmentMap.set(getOriginalNode(transformed), currentClassLexicalEnvironment);
+                classLexicalEnvironmentMap.set(getOriginalNodeId(transformed), currentClassLexicalEnvironment);
             }
             currentStaticPropertyDeclarationOrStaticBlock = savedCurrentStaticPropertyDeclarationOrStaticBlock;
             return transformed;
@@ -1453,7 +1453,7 @@ namespace ts {
                 context.enableSubstitution(SyntaxKind.Identifier);
 
                 // Keep track of class aliases.
-                classAliases = new Map<Node, Identifier>();
+                classAliases = [];
             }
         }
 
@@ -1516,16 +1516,18 @@ namespace ts {
 
         function onEmitNode(hint: EmitHint, node: Node, emitCallback: (hint: EmitHint, node: Node) => void) {
             const original = getOriginalNode(node);
-            const classLexicalEnvironment = classLexicalEnvironmentMap.get(original);
-            if (classLexicalEnvironment) {
-                const savedClassLexicalEnvironment = currentClassLexicalEnvironment;
-                const savedCurrentComputedPropertyNameClassLexicalEnvironment = currentComputedPropertyNameClassLexicalEnvironment;
-                currentClassLexicalEnvironment = classLexicalEnvironment;
-                currentComputedPropertyNameClassLexicalEnvironment = classLexicalEnvironment;
-                previousOnEmitNode(hint, node, emitCallback);
-                currentClassLexicalEnvironment = savedClassLexicalEnvironment;
-                currentComputedPropertyNameClassLexicalEnvironment = savedCurrentComputedPropertyNameClassLexicalEnvironment;
-                return;
+            if (original.id) {
+                const classLexicalEnvironment = classLexicalEnvironmentMap.get(original.id);
+                if (classLexicalEnvironment) {
+                    const savedClassLexicalEnvironment = currentClassLexicalEnvironment;
+                    const savedCurrentComputedPropertyNameClassLexicalEnvironment = currentComputedPropertyNameClassLexicalEnvironment;
+                    currentClassLexicalEnvironment = classLexicalEnvironment;
+                    currentComputedPropertyNameClassLexicalEnvironment = classLexicalEnvironment;
+                    previousOnEmitNode(hint, node, emitCallback);
+                    currentClassLexicalEnvironment = savedClassLexicalEnvironment;
+                    currentComputedPropertyNameClassLexicalEnvironment = savedCurrentComputedPropertyNameClassLexicalEnvironment;
+                    return;
+                }
             }
 
             switch (node.kind) {
@@ -1631,7 +1633,7 @@ namespace ts {
                     // constructor references in static property initializers.
                     const declaration = resolver.getReferencedValueDeclaration(node);
                     if (declaration) {
-                        const classAlias = classAliases.get(declaration);
+                        const classAlias = classAliases[declaration.id!]; // TODO: GH#18217
                         if (classAlias) {
                             const clone = factory.cloneNode(classAlias);
                             setSourceMapRange(clone, node);

src/compiler/transformers/declarations.ts

@@ -60,7 +60,7 @@ namespace ts {
         let enclosingDeclaration: Node;
         let necessaryTypeReferences: Set<string> | undefined;
         let lateMarkedStatements: LateVisibilityPaintedStatement[] | undefined;
-        let lateStatementReplacementMap: ESMap<Node, VisitResult<LateVisibilityPaintedStatement | ExportAssignment>>;
+        let lateStatementReplacementMap: ESMap<NodeId, VisitResult<LateVisibilityPaintedStatement | ExportAssignment>>;
         let suppressNewDiagnosticContexts: boolean;
         let exportedModulesFromDeclarationEmit: Symbol[] | undefined;
 
@@ -84,7 +84,7 @@ namespace ts {
         let errorFallbackNode: Declaration | undefined;
 
         let currentSourceFile: SourceFile;
-        let refs: ESMap<Node, SourceFile>;
+        let refs: ESMap<NodeId, SourceFile>;
         let libs: ESMap<string, boolean>;
         let emittedImports: readonly AnyImportSyntax[] | undefined; // must be declared in container so it can be `undefined` while transformer's first pass
         const resolver = context.getEmitResolver();
@@ -110,7 +110,7 @@ namespace ts {
             }
             // Otherwise we should emit a path-based reference
             const container = getSourceFileOfNode(node);
-            refs.set(getOriginalNode(container), container);
+            refs.set(getOriginalNodeId(container), container);
         }
 
         function handleSymbolAccessibilityError(symbolAccessibilityResult: SymbolAccessibilityResult) {
@@ -426,12 +426,12 @@ namespace ts {
             }
         }
 
-        function collectReferences(sourceFile: SourceFile | UnparsedSource, ret: ESMap<Node, SourceFile>) {
+        function collectReferences(sourceFile: SourceFile | UnparsedSource, ret: ESMap<NodeId, SourceFile>) {
             if (noResolve || (!isUnparsedSource(sourceFile) && isSourceFileJS(sourceFile))) return ret;
             forEach(sourceFile.referencedFiles, f => {
                 const elem = host.getSourceFileFromReference(sourceFile, f);
                 if (elem) {
-                    ret.set(getOriginalNode(elem), elem);
+                    ret.set(getOriginalNodeId(elem), elem);
                 }
             });
             return ret;
@@ -812,7 +812,7 @@ namespace ts {
                 needsDeclare = i.parent && isSourceFile(i.parent) && !(isExternalModule(i.parent) && isBundledEmit);
                 const result = transformTopLevelDeclaration(i);
                 needsDeclare = priorNeedsDeclare;
-                lateStatementReplacementMap.set(getOriginalNode(i), result);
+                lateStatementReplacementMap.set(getOriginalNodeId(i), result);
             }
 
             // And lastly, we need to get the final form of all those indetermine import declarations from before and add them to the output list
@@ -821,10 +821,10 @@ namespace ts {
 
             function visitLateVisibilityMarkedStatements(statement: Statement) {
                 if (isLateVisibilityPaintedStatement(statement)) {
-                    const originalNode = getOriginalNode(statement);
-                    if (lateStatementReplacementMap.has(originalNode)) {
-                        const result = lateStatementReplacementMap.get(originalNode);
-                        lateStatementReplacementMap.delete(originalNode);
+                    const key = getOriginalNodeId(statement);
+                    if (lateStatementReplacementMap.has(key)) {
+                        const result = lateStatementReplacementMap.get(key);
+                        lateStatementReplacementMap.delete(key);
                         if (result) {
                             if (isArray(result) ? some(result, needsScopeMarker) : needsScopeMarker(result)) {
                                 // Top-level declarations in .d.ts files are always considered exported even without a modifier unless there's an export assignment or specifier
@@ -1146,7 +1146,7 @@ namespace ts {
 
             const result = transformTopLevelDeclaration(input);
             // Don't actually transform yet; just leave as original node - will be elided/swapped by late pass
-            lateStatementReplacementMap.set(getOriginalNode(input), result);
+            lateStatementReplacementMap.set(getOriginalNodeId(input), result);
             return input;
         }
 
@@ -1348,9 +1348,9 @@ namespace ts {
                         needsDeclare = false;
                         visitNode(inner, visitDeclarationStatements);
                         // eagerly transform nested namespaces (the nesting doesn't need any elision or painting done)
-                        const originalNode = getOriginalNode(inner!); // TODO: GH#18217
-                        const body = lateStatementReplacementMap.get(originalNode);
-                        lateStatementReplacementMap.delete(originalNode);
+                        const id = getOriginalNodeId(inner!); // TODO: GH#18217
+                        const body = lateStatementReplacementMap.get(id);
+                        lateStatementReplacementMap.delete(id);
                         return cleanup(factory.updateModuleDeclaration(
                             input,
                             /*decorators*/ undefined,

src/compiler/transformers/es2017.ts

@@ -46,7 +46,7 @@ namespace ts {
         /** Whether the async function contains an element access on super (`super[x]`). */
         let hasSuperElementAccess: boolean;
         /** A set of node IDs for generated super accessors (variable statements). */
-        const substitutedSuperAccessors = new Set<Node>();
+        const substitutedSuperAccessors: boolean[] = [];
 
         let contextFlags: ContextFlags = 0;
 
@@ -503,7 +503,7 @@ namespace ts {
                     enableSubstitutionForAsyncMethodsWithSuper();
                     if (capturedSuperProperties.size) {
                         const variableStatement = createSuperAccessVariableStatement(factory, resolver, node, capturedSuperProperties);
-                        substitutedSuperAccessors.add(variableStatement);
+                        substitutedSuperAccessors[getNodeId(variableStatement)] = true;
                         insertStatementsAfterStandardPrologue(statements, [variableStatement]);
                     }
                 }
@@ -613,7 +613,7 @@ namespace ts {
                 }
             }
             // Disable substitution in the generated super accessor itself.
-            else if (enabledSubstitutions && substitutedSuperAccessors.has(node)) {
+            else if (enabledSubstitutions && substitutedSuperAccessors[getNodeId(node)]) {
                 const savedEnclosingSuperContainerFlags = enclosingSuperContainerFlags;
                 enclosingSuperContainerFlags = 0;
                 previousOnEmitNode(hint, node, emitCallback);