Reduce number of watches for failed lookup locations as part of module resolution

sheetalkamat · sheetalkamat · commit 5aafd3f06c2c · 2017-08-31T09:13:59.000-07:00
diff --git a/src/compiler/resolutionCache.ts b/src/compiler/resolutionCache.ts
@@ -14,7 +14,7 @@ namespace ts {
         resolveTypeReferenceDirectives(typeDirectiveNames: string[], containingFile: string): ResolvedTypeReferenceDirective[];
 
         invalidateResolutionOfFile(filePath: Path): void;
-        invalidateResolutionOfChangedFailedLookupLocation(failedLookupLocationPath: Path): void;
+        onFileAddOrRemoveInDirectoryOfFailedLookup(fileOrFolder: Path): boolean;
 
         createHasInvalidatedResolution(): HasInvalidatedResolution;
 
@@ -26,15 +26,17 @@ namespace ts {
         isInvalidated?: boolean;
     }
 
-    interface FailedLookupLocationsWatcher {
+    interface DirectoryWatchesOfFailedLookup {
+        /** watcher for the directory of failed lookup */
         watcher: FileWatcher;
-        refCount: number;
+        /** map with key being the failed lookup location path and value being the actual location */
+        mapLocations: MultiMap<string>;
     }
 
     export function createResolutionCache(
         toPath: (fileName: string) => Path,
         getCompilerOptions: () => CompilerOptions,
-        watchForFailedLookupLocation: (failedLookupLocation: string, failedLookupLocationPath: Path) => FileWatcher,
+        watchDirectoryOfFailedLookupLocation: (directory: string) => FileWatcher,
         log: (s: string) => void,
         projectName?: string,
         getGlobalCache?: () => string | undefined): ResolutionCache {
@@ -49,7 +51,7 @@ namespace ts {
         const resolvedModuleNames = createMap<Map<ResolvedModuleWithFailedLookupLocations>>();
         const resolvedTypeReferenceDirectives = createMap<Map<ResolvedTypeReferenceDirectiveWithFailedLookupLocations>>();
 
-        const failedLookupLocationsWatches = createMap<FailedLookupLocationsWatcher>();
+        const directoryWatchesOfFailedLookups = createMap<DirectoryWatchesOfFailedLookup>();
 
         return {
             setModuleResolutionHost,
@@ -58,7 +60,7 @@ namespace ts {
             resolveModuleNames,
             resolveTypeReferenceDirectives,
             invalidateResolutionOfFile,
-            invalidateResolutionOfChangedFailedLookupLocation,
+            onFileAddOrRemoveInDirectoryOfFailedLookup,
             createHasInvalidatedResolution,
             clear
         };
@@ -69,7 +71,7 @@ namespace ts {
 
         function clear() {
             // Close all the watches for failed lookup locations, irrespective of refcounts for them since this is to clear the cache
-            clearMap(failedLookupLocationsWatches, closeFileWatcherOf);
+            clearMap(directoryWatchesOfFailedLookups, closeFileWatcherOf);
             resolvedModuleNames.clear();
             resolvedTypeReferenceDirectives.clear();
         }
@@ -203,43 +205,51 @@ namespace ts {
         }
 
         function watchFailedLookupLocation(failedLookupLocation: string, failedLookupLocationPath: Path) {
-            const failedLookupLocationWatcher = failedLookupLocationsWatches.get(failedLookupLocationPath);
-            if (failedLookupLocationWatcher) {
-                failedLookupLocationWatcher.refCount++;
-                log(`Watcher: FailedLookupLocations: Status: Using existing watcher: Location: ${failedLookupLocation}`);
+            const dirPath = getDirectoryPath(failedLookupLocationPath);
+            const watches = directoryWatchesOfFailedLookups.get(dirPath);
+            if (watches) {
+                watches.mapLocations.add(failedLookupLocationPath, failedLookupLocation);
             }
             else {
-                const watcher = watchForFailedLookupLocation(failedLookupLocation, failedLookupLocationPath);
-                failedLookupLocationsWatches.set(failedLookupLocationPath, { watcher, refCount: 1 });
+                const mapLocations = createMultiMap<string>();
+                mapLocations.add(failedLookupLocationPath, failedLookupLocation);
+                directoryWatchesOfFailedLookups.set(dirPath, {
+                    watcher: watchDirectoryOfFailedLookupLocation(getDirectoryPath(failedLookupLocation)),
+                    mapLocations
+                });
             }
         }
 
         function closeFailedLookupLocationWatcher(failedLookupLocation: string, failedLookupLocationPath: Path) {
-            const failedLookupLocationWatcher = failedLookupLocationsWatches.get(failedLookupLocationPath);
-            Debug.assert(!!failedLookupLocationWatcher);
-            failedLookupLocationWatcher.refCount--;
-            if (failedLookupLocationWatcher.refCount) {
-                log(`Watcher: FailedLookupLocations: Status: Removing existing watcher: Location: ${failedLookupLocation}`);
-            }
-            else {
-                failedLookupLocationWatcher.watcher.close();
-                failedLookupLocationsWatches.delete(failedLookupLocationPath);
+            const dirPath = getDirectoryPath(failedLookupLocationPath);
+            const watches = directoryWatchesOfFailedLookups.get(dirPath);
+            watches.mapLocations.remove(failedLookupLocationPath, failedLookupLocation);
+            if (watches.mapLocations.size === 0) {
+                watches.watcher.close();
+                directoryWatchesOfFailedLookups.delete(dirPath);
             }
         }
 
         type FailedLookupLocationAction = (failedLookupLocation: string, failedLookupLocationPath: Path) => void;
-        function withFailedLookupLocations(failedLookupLocations: ReadonlyArray<string> | undefined, fn: FailedLookupLocationAction) {
-            forEach(failedLookupLocations, failedLookupLocation => {
-                fn(failedLookupLocation, toPath(failedLookupLocation));
-            });
+        function withFailedLookupLocations(failedLookupLocations: ReadonlyArray<string> | undefined, fn: FailedLookupLocationAction, startIndex?: number) {
+            if (failedLookupLocations) {
+                for (let i = startIndex || 0; i < failedLookupLocations.length; i++) {
+                    fn(failedLookupLocations[i], toPath(failedLookupLocations[i]));
+                }
+            }
         }
 
         function updateFailedLookupLocationWatches(failedLookupLocations: ReadonlyArray<string> | undefined, existingFailedLookupLocations: ReadonlyArray<string> | undefined) {
+            log(`Resolution cache: Updating...`);
+            const index = existingFailedLookupLocations && failedLookupLocations ?
+                findDiffIndex(failedLookupLocations, existingFailedLookupLocations) :
+                0;
+
             // Watch all the failed lookup locations
-            withFailedLookupLocations(failedLookupLocations, watchFailedLookupLocation);
+            withFailedLookupLocations(failedLookupLocations, watchFailedLookupLocation, index);
 
             // Close existing watches for the failed locations
-            withFailedLookupLocations(existingFailedLookupLocations, closeFailedLookupLocationWatcher);
+            withFailedLookupLocations(existingFailedLookupLocations, closeFailedLookupLocationWatcher, index);
         }
 
         function invalidateResolutionCacheOfDeletedFile<T extends NameResolutionWithFailedLookupLocations, R>(
@@ -291,9 +301,15 @@ namespace ts {
             invalidateResolutionCacheOfDeletedFile(filePath, resolvedTypeReferenceDirectives, m => m.resolvedTypeReferenceDirective, r => r.resolvedFileName);
         }
 
-        function invalidateResolutionOfChangedFailedLookupLocation(failedLookupLocationPath: Path) {
-             invalidateResolutionCacheOfChangedFailedLookupLocation(failedLookupLocationPath, resolvedModuleNames);
-             invalidateResolutionCacheOfChangedFailedLookupLocation(failedLookupLocationPath, resolvedTypeReferenceDirectives);
+        function onFileAddOrRemoveInDirectoryOfFailedLookup(fileOrFolder: Path) {
+            const dirPath = getDirectoryPath(fileOrFolder);
+            const watches = directoryWatchesOfFailedLookups.get(dirPath);
+            const isFailedLookupFile = watches.mapLocations.has(fileOrFolder);
+            if (isFailedLookupFile) {
+                invalidateResolutionCacheOfChangedFailedLookupLocation(fileOrFolder, resolvedModuleNames);
+                invalidateResolutionCacheOfChangedFailedLookupLocation(fileOrFolder, resolvedTypeReferenceDirectives);
+            }
+            return isFailedLookupFile;
         }
     }
 }
diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts
@@ -3543,6 +3543,18 @@ namespace ts {
         }
     }
 
+    /**
+     * Find the index where arrayA and arrayB differ
+     */
+    export function findDiffIndex<T>(arrayA: ReadonlyArray<T>, arrayB: ReadonlyArray<T>) {
+        for (let i = 0; i < arrayA.length; i++) {
+            if (i === arrayB.length || arrayA[i] !== arrayB[i]) {
+                return i;
+            }
+        }
+        return arrayA.length;
+    }
+
     export function addFileWatcher(host: System, file: string, cb: FileWatcherCallback): FileWatcher {
         return host.watchFile(file, cb);
     }
diff --git a/src/compiler/watchedProgram.ts b/src/compiler/watchedProgram.ts
@@ -268,7 +268,7 @@ namespace ts {
         const resolutionCache = createResolutionCache(
             fileName => toPath(fileName),
             () => compilerOptions,
-            watchFailedLookupLocation,
+            watchDirectoryOfFailedLookupLocation,
             writeLog
         );
 
@@ -552,14 +552,22 @@ namespace ts {
             }
         }
 
-        function watchFailedLookupLocation(failedLookupLocation: string, failedLookupLocationPath: Path) {
-            return watchFilePath(system, failedLookupLocation, onFailedLookupLocationChange, failedLookupLocationPath, writeLog);
+        function watchDirectoryOfFailedLookupLocation(directory: string) {
+            return watchDirectory(system, directory, onFileAddOrRemoveInDirectoryOfFailedLookup, WatchDirectoryFlags.None, writeLog);
         }
 
-        function onFailedLookupLocationChange(fileName: string, eventKind: FileWatcherEventKind, failedLookupLocationPath: Path) {
-            updateCachedSystemWithFile(fileName, failedLookupLocationPath, eventKind);
-            resolutionCache.invalidateResolutionOfChangedFailedLookupLocation(failedLookupLocationPath);
-            scheduleProgramUpdate();
+        function onFileAddOrRemoveInDirectoryOfFailedLookup(fileOrFolder: string) {
+            const fileOrFolderPath = toPath(fileOrFolder);
+
+            if (configFileName) {
+                // Since the file existance changed, update the sourceFiles cache
+                (host as CachedPartialSystem).addOrDeleteFileOrFolder(fileOrFolder, fileOrFolderPath);
+            }
+
+            // If the location results in update to failed lookup, schedule program update
+            if (resolutionCache.onFileAddOrRemoveInDirectoryOfFailedLookup(fileOrFolderPath)) {
+                scheduleProgramUpdate();
+            }
         }
 
         function watchMissingFilePath(missingFilePath: Path) {
diff --git a/src/server/editorServices.ts b/src/server/editorServices.ts
@@ -432,8 +432,8 @@ namespace ts.server {
             return s => this.logger.info(s + detailedInfo);
         }
 
-        toPath(fileName: string, basePath = this.currentDirectory) {
-            return toPath(fileName, basePath, this.toCanonicalFileName);
+        toPath(fileName: string) {
+            return toPath(fileName, this.currentDirectory, this.toCanonicalFileName);
         }
 
         /* @internal */
diff --git a/src/server/project.ts b/src/server/project.ts
@@ -216,7 +216,7 @@ namespace ts.server {
             this.resolutionCache = createResolutionCache(
                 fileName => this.projectService.toPath(fileName),
                 () => this.compilerOptions,
-                (failedLookupLocation, failedLookupLocationPath) => this.watchFailedLookupLocation(failedLookupLocation, failedLookupLocationPath),
+                directory => this.watchDirectoryOfFailedLookup(directory),
                 s => this.projectService.logger.info(s),
                 this.getProjectName(),
                 () => this.getTypeAcquisition().enable ? this.projectService.typingsInstaller.globalTypingsCacheLocation : undefined
@@ -233,24 +233,30 @@ namespace ts.server {
             this.markAsDirty();
         }
 
-        private watchFailedLookupLocation(failedLookupLocation: string, failedLookupLocationPath: Path) {
-            return this.projectService.watchFile(
+        private watchDirectoryOfFailedLookup(directory: string) {
+            return this.projectService.watchDirectory(
                 this.projectService.host,
-                failedLookupLocation,
-                (fileName, eventKind) => this.onFailedLookupLocationChanged(fileName, eventKind, failedLookupLocationPath),
+                directory,
+                fileOrFolder => this.onFileAddOrRemoveInDirectoryOfFailedLookup(fileOrFolder),
+                WatchDirectoryFlags.None,
                 WatchType.FailedLookupLocation,
                 this
             );
         }
 
-        private onFailedLookupLocationChanged(fileName: string, eventKind: FileWatcherEventKind, failedLookupLocationPath: Path) {
+        private onFileAddOrRemoveInDirectoryOfFailedLookup(fileOrFolder: string) {
+            const fileOrFolderPath = this.projectService.toPath(fileOrFolder);
+
             // There is some kind of change in the failed lookup location, update the program
             if (this.projectKind === ProjectKind.Configured) {
-                (this.lsHost.host as CachedPartialSystem).addOrDeleteFile(fileName, failedLookupLocationPath, eventKind);
+                (this.lsHost.host as CachedPartialSystem).addOrDeleteFileOrFolder(fileOrFolder, fileOrFolderPath);
+            }
+
+            // If the location results in update to failed lookup, schedule program update
+            if (this.resolutionCache.onFileAddOrRemoveInDirectoryOfFailedLookup(fileOrFolderPath)) {
+                this.markAsDirty();
+                this.projectService.delayUpdateProjectGraphAndInferredProjectsRefresh(this);
             }
-            this.resolutionCache.invalidateResolutionOfChangedFailedLookupLocation(failedLookupLocationPath);
-            this.markAsDirty();
-            this.projectService.delayUpdateProjectGraphAndInferredProjectsRefresh(this);
         }
 
         private setInternalCompilerOptionsForEmittingJsFiles() {

Original file line number	Diff line number	Diff line change
`@@ -3543,6 +3543,18 @@ namespace ts {`
`3543`	`3543`	`}`
`3544`	`3544`	`}`
`3545`	`3545`
	`3546`	`+ /**`
	`3547`	`+ * Find the index where arrayA and arrayB differ`
	`3548`	`+ */`
	`3549`	`+ export function findDiffIndex<T>(arrayA: ReadonlyArray<T>, arrayB: ReadonlyArray<T>) {`
	`3550`	`+ for (let i = 0; i < arrayA.length; i++) {`
	`3551`	`+ if (i === arrayB.length \|\| arrayA[i] !== arrayB[i]) {`
	`3552`	`+ return i;`
	`3553`	`+ }`
	`3554`	`+ }`
	`3555`	`+ return arrayA.length;`
	`3556`	`+ }`
	`3557`	`+`
`3546`	`3558`	`export function addFileWatcher(host: System, file: string, cb: FileWatcherCallback): FileWatcher {`
`3547`	`3559`	`return host.watchFile(file, cb);`
`3548`	`3560`	`}`
Original file line number	Diff line number	Diff line change
`@@ -432,8 +432,8 @@ namespace ts.server {`
`432`	`432`	`return s => this.logger.info(s + detailedInfo);`
`433`	`433`	`}`
`434`	`434`
`435`		`- toPath(fileName: string, basePath = this.currentDirectory) {`
`436`		`- return toPath(fileName, basePath, this.toCanonicalFileName);`
	`435`	`+ toPath(fileName: string) {`
	`436`	`+ return toPath(fileName, this.currentDirectory, this.toCanonicalFileName);`
`437`	`437`	`}`
`438`	`438`
`439`	`439`	`/* @internal */`