From 57d94ce0904e8a5a3e7a00ebf23373a6e41d4339 Mon Sep 17 00:00:00 2001
From: Sheetal Nandi <shkamat@microsoft.com>
Date: Tue, 5 Apr 2022 16:35:46 -0700
Subject: [PATCH 1/2] Revert "Avoid no-op export map updates (#45238)"

This reverts commit 0f6e6efde08385916602e254f406f1703907b2a5.
---
 src/compiler/builderState.ts | 36 +-----------------------------------
 1 file changed, 1 insertion(+), 35 deletions(-)

diff --git a/src/compiler/builderState.ts b/src/compiler/builderState.ts
index a64a6c13ed1e8..0a0957885a2c7 100644
--- a/src/compiler/builderState.ts
+++ b/src/compiler/builderState.ts
@@ -48,11 +48,6 @@ namespace ts {
          */
         readonly exportedModulesMap: BuilderState.ManyToManyPathMap | undefined;
 
-        previousCache?: {
-            id: number,
-            version: number,
-        };
-
         /**
          * true if file version is used as signature
          * This helps in delaying the calculation of the d.ts hash as version for the file till reasonable time
@@ -86,7 +81,6 @@ namespace ts {
         }
 
         export interface ReadonlyManyToManyPathMap {
-            readonly id: number;
             clone(): ManyToManyPathMap;
             forEach(action: (v: ReadonlySet<Path>, k: Path) => void): void;
             getKeys(v: Path): ReadonlySet<Path> | undefined;
@@ -103,18 +97,13 @@ namespace ts {
         }
 
         export interface ManyToManyPathMap extends ReadonlyManyToManyPathMap {
-            version(): number; // Incremented each time the contents are changed
             deleteKey(k: Path): boolean;
             set(k: Path, v: ReadonlySet<Path>): void;
         }
 
-        let manyToManyPathMapCount = 0;
         export function createManyToManyPathMap(): ManyToManyPathMap {
             function create(forward: ESMap<Path, ReadonlySet<Path>>, reverse: ESMap<Path, Set<Path>>, deleted: Set<Path> | undefined): ManyToManyPathMap {
-                let version = 0;
                 const map: ManyToManyPathMap = {
-                    id: manyToManyPathMapCount++,
-                    version: () => version,
                     clone: () => create(new Map(forward), new Map(reverse), deleted && new Set(deleted)),
                     forEach: fn => forward.forEach(fn),
                     getKeys: v => reverse.get(v),
@@ -133,33 +122,26 @@ namespace ts {
 
                         set.forEach(v => deleteFromMultimap(reverse, v, k));
                         forward.delete(k);
-                        version++;
                         return true;
                     },
                     set: (k, vSet) => {
-                        let changed = !!deleted?.delete(k);
+                        deleted?.delete(k);
 
                         const existingVSet = forward.get(k);
                         forward.set(k, vSet);
 
                         existingVSet?.forEach(v => {
                             if (!vSet.has(v)) {
-                                changed = true;
                                 deleteFromMultimap(reverse, v, k);
                             }
                         });
 
                         vSet.forEach(v => {
                             if (!existingVSet?.has(v)) {
-                                changed = true;
                                 addToMultimap(reverse, v, k);
                             }
                         });
 
-                        if (changed) {
-                            version++;
-                        }
-
                         return map;
                     },
                 };
@@ -494,22 +476,6 @@ namespace ts {
         export function updateExportedFilesMapFromCache(state: BuilderState, exportedModulesMapCache: ManyToManyPathMap | undefined) {
             if (exportedModulesMapCache) {
                 Debug.assert(!!state.exportedModulesMap);
-
-                const cacheId = exportedModulesMapCache.id;
-                const cacheVersion = exportedModulesMapCache.version();
-                if (state.previousCache) {
-                    if (state.previousCache.id === cacheId && state.previousCache.version === cacheVersion) {
-                        // If this is the same cache at the same version as last time this BuilderState
-                        // was updated, there's no need to update again
-                        return;
-                    }
-                    state.previousCache.id = cacheId;
-                    state.previousCache.version = cacheVersion;
-                }
-                else {
-                    state.previousCache = { id: cacheId, version: cacheVersion };
-                }
-
                 exportedModulesMapCache.deletedKeys()?.forEach(path => state.exportedModulesMap!.deleteKey(path));
                 exportedModulesMapCache.forEach((exportedModules, path) => state.exportedModulesMap!.set(path, exportedModules));
             }

From 3ac922671dd73a042205d3b1d4dad5eea558d9e3 Mon Sep 17 00:00:00 2001
From: Sheetal Nandi <shkamat@microsoft.com>
Date: Tue, 5 Apr 2022 16:39:05 -0700
Subject: [PATCH 2/2] Need to reset currentAffectedFilesExportedModulesMap
 after commiting to final exports map

---
 src/compiler/builder.ts      |  1 +
 src/compiler/builderState.ts | 10 ++++++++--
 2 files changed, 9 insertions(+), 2 deletions(-)

diff --git a/src/compiler/builder.ts b/src/compiler/builder.ts
index aec8cae3cea12..10ede0d5e7d7c 100644
--- a/src/compiler/builder.ts
+++ b/src/compiler/builder.ts
@@ -372,6 +372,7 @@ namespace ts {
                 BuilderState.updateSignaturesFromCache(state, state.currentAffectedFilesSignatures!);
                 state.currentAffectedFilesSignatures!.clear();
                 BuilderState.updateExportedFilesMapFromCache(state, state.currentAffectedFilesExportedModulesMap);
+                state.currentAffectedFilesExportedModulesMap?.clear();
                 state.affectedFiles = undefined;
             }
 
diff --git a/src/compiler/builderState.ts b/src/compiler/builderState.ts
index 0a0957885a2c7..1446832eb5827 100644
--- a/src/compiler/builderState.ts
+++ b/src/compiler/builderState.ts
@@ -99,6 +99,7 @@ namespace ts {
         export interface ManyToManyPathMap extends ReadonlyManyToManyPathMap {
             deleteKey(k: Path): boolean;
             set(k: Path, v: ReadonlySet<Path>): void;
+            clear(): void;
         }
 
         export function createManyToManyPathMap(): ManyToManyPathMap {
@@ -144,6 +145,11 @@ namespace ts {
 
                         return map;
                     },
+                    clear: () => {
+                        forward.clear();
+                        reverse.clear();
+                        deleted?.clear();
+                    }
                 };
 
                 return map;
@@ -161,11 +167,11 @@ namespace ts {
             set.add(v);
         }
 
-        function deleteFromMultimap<K, V>(map: ESMap<K, Set<V>>, k: K, v: V, removeEmpty = true): boolean {
+        function deleteFromMultimap<K, V>(map: ESMap<K, Set<V>>, k: K, v: V): boolean {
             const set = map.get(k);
 
             if (set?.delete(v)) {
-                if (removeEmpty && !set.size) {
+                if (!set.size) {
                     map.delete(k);
                 }
                 return true;