Use refcounts on the resolution so we arent going through failed lookup locations when resolutions are cached.

sheetalkamat · sheetalkamat · commit 9569b1317421 · 2018-02-22T16:04:00.000-08:00
diff --git a/src/compiler/resolutionCache.ts b/src/compiler/resolutionCache.ts
@@ -28,6 +28,7 @@ namespace ts {
     interface ResolutionWithFailedLookupLocations {
         readonly failedLookupLocations: ReadonlyArray<string>;
         isInvalidated?: boolean;
+        refCount?: number;
     }
 
     interface ResolutionWithResolvedFileName {
@@ -257,17 +258,11 @@ namespace ts {
                         perDirectoryResolution.set(name, resolution);
                     }
                     resolutionsInFile.set(name, resolution);
-                    if (resolution.failedLookupLocations) {
-                        if (existingResolution && existingResolution.failedLookupLocations) {
-                            watchAndStopWatchDiffFailedLookupLocations(resolution, existingResolution);
-                        }
-                        else {
-                            watchFailedLookupLocationOfResolution(resolution, 0);
-                        }
-                    }
-                    else if (existingResolution) {
+                    watchFailedLookupLocationOfResolution(resolution);
+                    if (existingResolution) {
                         stopWatchFailedLookupLocationOfResolution(existingResolution);
                     }
+
                     if (logChanges && filesWithChangedSetOfUnresolvedImports && !resolutionIsEqualTo(existingResolution, resolution)) {
                         filesWithChangedSetOfUnresolvedImports.push(path);
                         // reset log changes to avoid recording the same file multiple times
@@ -399,80 +394,98 @@ namespace ts {
             return fileExtensionIsOneOf(path, failedLookupDefaultExtensions);
         }
 
-        function watchAndStopWatchDiffFailedLookupLocations(resolution: ResolutionWithFailedLookupLocations, existingResolution: ResolutionWithFailedLookupLocations) {
-            const failedLookupLocations = resolution.failedLookupLocations;
-            const existingFailedLookupLocations = existingResolution.failedLookupLocations;
-            for (let index = 0; index < failedLookupLocations.length; index++) {
-                if (index === existingFailedLookupLocations.length) {
-                    // Additional failed lookup locations, watch from this index
-                    watchFailedLookupLocationOfResolution(resolution, index);
-                    return;
-                }
-                else if (failedLookupLocations[index] !== existingFailedLookupLocations[index]) {
-                    // Different failed lookup locations,
-                    // Watch new resolution failed lookup locations from this index and
-                    // stop watching existing resolutions from this index
-                    watchFailedLookupLocationOfResolution(resolution, index);
-                    stopWatchFailedLookupLocationOfResolutionFrom(existingResolution, index);
-                    return;
-                }
+        function watchFailedLookupLocationOfResolution(resolution: ResolutionWithFailedLookupLocations) {
+            // No need to set the resolution refCount
+            if (!resolution.failedLookupLocations || !resolution.failedLookupLocations.length) {
+                return;
             }
 
-            // All new failed lookup locations are already watched (and are same),
-            // Stop watching failed lookup locations of existing resolution after failed lookup locations length
-            stopWatchFailedLookupLocationOfResolutionFrom(existingResolution, failedLookupLocations.length);
-        }
+            if (resolution.refCount !== undefined) {
+                resolution.refCount++;
+                return;
+            }
 
-        function watchFailedLookupLocationOfResolution({ failedLookupLocations }: ResolutionWithFailedLookupLocations, startIndex: number) {
-            for (let i = startIndex; i < failedLookupLocations.length; i++) {
-                const failedLookupLocation = failedLookupLocations[i];
+            resolution.refCount = 1;
+            const { failedLookupLocations } = resolution;
+            let setAtRoot = false;
+            for (const failedLookupLocation of failedLookupLocations) {
                 const failedLookupLocationPath = resolutionHost.toPath(failedLookupLocation);
-                // If the failed lookup location path is not one of the supported extensions,
-                // store it in the custom path
-                if (!isPathWithDefaultFailedLookupExtension(failedLookupLocationPath)) {
-                    const refCount = customFailedLookupPaths.get(failedLookupLocationPath) || 0;
-                    customFailedLookupPaths.set(failedLookupLocationPath, refCount + 1);
-                }
                 const { dir, dirPath, ignore } = getDirectoryToWatchFailedLookupLocation(failedLookupLocation, failedLookupLocationPath);
                 if (!ignore) {
-                    const dirWatcher = directoryWatchesOfFailedLookups.get(dirPath);
-                    if (dirWatcher) {
-                        dirWatcher.refCount++;
+                    // If the failed lookup location path is not one of the supported extensions,
+                    // store it in the custom path
+                    if (!isPathWithDefaultFailedLookupExtension(failedLookupLocationPath)) {
+                        const refCount = customFailedLookupPaths.get(failedLookupLocationPath) || 0;
+                        customFailedLookupPaths.set(failedLookupLocationPath, refCount + 1);
+                    }
+                    if (dirPath === rootPath) {
+                        setAtRoot = true;
                     }
                     else {
-                        directoryWatchesOfFailedLookups.set(dirPath, { watcher: createDirectoryWatcher(dir, dirPath), refCount: 1 });
+                        setDirectoryWatcher(dir, dirPath);
                     }
                 }
             }
+
+            if (setAtRoot) {
+                setDirectoryWatcher(rootDir, rootPath);
+            }
         }
 
-        function stopWatchFailedLookupLocationOfResolution(resolution: ResolutionWithFailedLookupLocations) {
-            if (resolution.failedLookupLocations) {
-                stopWatchFailedLookupLocationOfResolutionFrom(resolution, 0);
+        function setDirectoryWatcher(dir: string, dirPath: Path) {
+            const dirWatcher = directoryWatchesOfFailedLookups.get(dirPath);
+            if (dirWatcher) {
+                dirWatcher.refCount++;
+            }
+            else {
+                directoryWatchesOfFailedLookups.set(dirPath, { watcher: createDirectoryWatcher(dir, dirPath), refCount: 1 });
             }
         }
 
-        function stopWatchFailedLookupLocationOfResolutionFrom({ failedLookupLocations }: ResolutionWithFailedLookupLocations, startIndex: number) {
-            for (let i = startIndex; i < failedLookupLocations.length; i++) {
-                const failedLookupLocation = failedLookupLocations[i];
+        function stopWatchFailedLookupLocationOfResolution(resolution: ResolutionWithFailedLookupLocations) {
+            if (!resolution.failedLookupLocations || !resolution.failedLookupLocations.length) {
+                return;
+            }
+
+            resolution.refCount!--;
+            if (resolution.refCount) {
+                return;
+            }
+
+            const { failedLookupLocations } = resolution;
+            let removeAtRoot = false;
+            for (const failedLookupLocation of failedLookupLocations) {
                 const failedLookupLocationPath = resolutionHost.toPath(failedLookupLocation);
-                const refCount = customFailedLookupPaths.get(failedLookupLocationPath);
-                if (refCount) {
-                    if (refCount === 1) {
-                        customFailedLookupPaths.delete(failedLookupLocationPath);
+                const { dirPath, ignore } = getDirectoryToWatchFailedLookupLocation(failedLookupLocation, failedLookupLocationPath);
+                if (!ignore) {
+                    const refCount = customFailedLookupPaths.get(failedLookupLocationPath);
+                    if (refCount) {
+                        if (refCount === 1) {
+                            customFailedLookupPaths.delete(failedLookupLocationPath);
+                        }
+                        else {
+                            Debug.assert(refCount > 1);
+                            customFailedLookupPaths.set(failedLookupLocationPath, refCount - 1);
+                        }
+                    }
+
+                    if (dirPath === rootPath) {
+                        removeAtRoot = true;
                     }
                     else {
-                        Debug.assert(refCount > 1);
-                        customFailedLookupPaths.set(failedLookupLocationPath, refCount - 1);
+                        removeDirectoryWatcher(dirPath);
                     }
                 }
-                const { dirPath, ignore } = getDirectoryToWatchFailedLookupLocation(failedLookupLocation, failedLookupLocationPath);
-                if (!ignore) {
-                    const dirWatcher = directoryWatchesOfFailedLookups.get(dirPath);
-                    // Do not close the watcher yet since it might be needed by other failed lookup locations.
-                    dirWatcher.refCount--;
-                }
             }
+            if (removeAtRoot) {
+                removeDirectoryWatcher(rootPath);
+            }
+        }
+
+        function removeDirectoryWatcher(dirPath: string) {
+            const dirWatcher = directoryWatchesOfFailedLookups.get(dirPath);
+            // Do not close the watcher yet since it might be needed by other failed lookup locations.
+            dirWatcher.refCount--;
         }
 
         function createDirectoryWatcher(directory: string, dirPath: Path) {
