Share extended config watchers across projects in server

New shared watcher map in ProjectService that stores callbacks per project to be invoked when the file watcher is triggered. The FileWatcher is created with the watch options of the first Project to watch the extended config.
microsoft · Nov 14, 2020 · 588bee3 · 588bee3
1 parent 60aa8b1
commit 588bee3
Show file tree

Hide file tree

Showing 4 changed files with 74 additions and 21 deletions.
diff --git a/src/compiler/watchPublic.ts b/src/compiler/watchPublic.ts
@@ -792,7 +792,7 @@ namespace ts {
         }
 
         function watchExtendedConfigFiles() {
-            const configFile = builderProgram.getCompilerOptions().configFile;
+            const { configFile } = builderProgram.getCompilerOptions();
             if (configFile) {
                 updateExtendedConfigFilesWatch(
                     configFile,

diff --git a/src/compiler/watchUtilities.ts b/src/compiler/watchUtilities.ts
@@ -282,6 +282,64 @@ namespace ts {
         );
     }
 
+    export interface SharedExtendedConfigFileWatcher<P> {
+        watcher: FileWatcher;
+        callbacks: ESMap<P, FileWatcherCallback>;
+    }
+
+    export function updateSharedExtendedConfigFilesWatch<P>(
+        project: P,
+        configFile: TsConfigSourceFile,
+        sharedExtendedConfigFilesMap: ESMap<string, SharedExtendedConfigFileWatcher<P>>,
+        watchExtendedConfigFile: (extendedConfigPath: string, callback: FileWatcherCallback) => FileWatcher,
+        projectCallback: FileWatcherCallback
+    ) {
+        const extendedSourceFiles = configFile.extendedSourceFiles || emptyArray;
+        const newSharedExtendedConfigFilesMap = arrayToMap(extendedSourceFiles, identity, returnTrue);
+
+        sharedExtendedConfigFilesMap.forEach((existingWatcher, key) => {
+            if (newSharedExtendedConfigFilesMap.has(key)) {
+                existingWatcher.callbacks.set(project, projectCallback);
+            }
+            else {
+                existingWatcher.callbacks.delete(project);
+                if (existingWatcher.callbacks.size === 0) {
+                    sharedExtendedConfigFilesMap.delete(key);
+                    closeFileWatcherOf(existingWatcher);
+                }
+            }
+        });
+
+        newSharedExtendedConfigFilesMap.forEach((_true, extendedConfigPath) => {
+            if (!sharedExtendedConfigFilesMap.has(extendedConfigPath)) {
+                const newWatcher = createSharedExtendedConfigFileWatcher(extendedConfigPath);
+                sharedExtendedConfigFilesMap.set(extendedConfigPath, newWatcher);
+            }
+        });
+
+        function createSharedExtendedConfigFileWatcher(extendedConfigPath: string) {
+            const callbacks = new Map<P, FileWatcherCallback>();
+            callbacks.set(project, projectCallback);
+            const watcher = watchExtendedConfigFile(extendedConfigPath, (...args) => {
+                callbacks.forEach((callback) => callback(...args));
+            });
+            return { watcher, callbacks };
+        }
+    }
+
+    export function removeProjectFromSharedExtendedConfigFilesWatch<P>(
+        project: P,
+        sharedExtendedConfigFilesMap: ESMap<string, SharedExtendedConfigFileWatcher<P>>
+    ) {
+        sharedExtendedConfigFilesMap.forEach((existingWatcher, key) => {
+            existingWatcher.callbacks.delete(project);
+            if (existingWatcher.callbacks.size === 0) {
+                sharedExtendedConfigFilesMap.delete(key);
+                closeFileWatcherOf(existingWatcher);
+            }
+        });
+    }
+
     /**
      * Updates the existing missing file watches with the new set of missing files after new program is created
      */

diff --git a/src/server/editorServices.ts b/src/server/editorServices.ts
@@ -756,6 +756,9 @@ namespace ts.server {
         /*@internal*/
         readonly watchFactory: WatchFactory<WatchType, Project>;
 
+        /*@internal*/
+        private sharedExtendedConfigFilesMap = new Map<string, SharedExtendedConfigFileWatcher<Project>>();
+
         /*@internal*/
         readonly packageJsonCache: PackageJsonCache;
         /*@internal*/
@@ -1384,6 +1387,7 @@ namespace ts.server {
             project.print(/*writeProjectFileNames*/ true);
 
             project.close();
+            removeProjectFromSharedExtendedConfigFilesWatch(project, this.sharedExtendedConfigFilesMap);
             if (Debug.shouldAssert(AssertionLevel.Normal)) {
                 this.filenameToScriptInfo.forEach(info => Debug.assert(
                     !info.isAttached(project),
@@ -2156,14 +2160,14 @@ namespace ts.server {
             const lastFileExceededProgramSize = this.getFilenameForExceededTotalSizeLimitForNonTsFiles(project.canonicalConfigFilePath, compilerOptions, parsedCommandLine.fileNames, fileNamePropertyReader);
             if (lastFileExceededProgramSize) {
                 project.disableLanguageService(lastFileExceededProgramSize);
-                project.stopWatchingExtendedConfigFiles();
+                removeProjectFromSharedExtendedConfigFilesWatch(project, this.sharedExtendedConfigFilesMap);
                 project.stopWatchingWildCards();
             }
             else {
                 project.setCompilerOptions(compilerOptions);
                 project.setWatchOptions(parsedCommandLine.watchOptions);
                 project.enableLanguageService();
-                project.watchExtendedConfigFiles();
+                project.watchExtendedConfigFiles(this.sharedExtendedConfigFilesMap);
                 project.watchWildcards(new Map(getEntries(parsedCommandLine.wildcardDirectories!))); // TODO: GH#18217
             }
             project.enablePluginsWithOptions(compilerOptions, this.currentPluginConfigOverrides);

diff --git a/src/server/project.ts b/src/server/project.ts
@@ -2046,8 +2046,6 @@ namespace ts.server {
     export class ConfiguredProject extends Project {
         /* @internal */
         configFileWatcher: FileWatcher | undefined;
-        /* @internal */
-        private extendedConfigFileWatchers: ESMap<string, FileWatcher> | undefined;
         private directoriesWatchedForWildcards: ESMap<string, WildcardDirectoryWatcher> | undefined;
         readonly canonicalConfigFilePath: NormalizedPath;
 
@@ -2262,10 +2260,10 @@ namespace ts.server {
         }
 
         /* @internal */
-        createExtendedConfigFileWatcher(extendedConfigFile: string): FileWatcher {
+        createExtendedConfigFileWatcher(extendedConfigFile: string, callback: FileWatcherCallback): FileWatcher {
             return this.projectService.watchFactory.watchFile(
                 extendedConfigFile,
-                (fileName) => this.projectService.onExtendedConfigChangedForConfiguredProject(this, fileName),
+                callback,
                 PollingInterval.High,
                 this.projectService.getWatchOptions(this),
                 WatchType.ExtendedConfigFile,
@@ -2274,25 +2272,19 @@ namespace ts.server {
         }
 
         /* @internal */
-        watchExtendedConfigFiles() {
-            const configFile = this.getCompilerOptions().configFile;
+        watchExtendedConfigFiles(sharedExtendedConfigFilesMap: ESMap<string, SharedExtendedConfigFileWatcher<Project>>) {
+            const { configFile } = this.getCompilerOptions();
             if (configFile) {
-                updateExtendedConfigFilesWatch(
+                updateSharedExtendedConfigFilesWatch(
+                    this,
                     configFile,
-                    this.extendedConfigFileWatchers || (this.extendedConfigFileWatchers = new Map()),
-                    (extendedConfigFile) => this.createExtendedConfigFileWatcher(extendedConfigFile),
+                    sharedExtendedConfigFilesMap,
+                    (extendedConfigFile, callback) => this.createExtendedConfigFileWatcher(extendedConfigFile, callback),
+                    (fileName) => this.projectService.onExtendedConfigChangedForConfiguredProject(this, fileName),
                 );
             }
         }
 
-        /* @internal */
-        stopWatchingExtendedConfigFiles() {
-            if (this.extendedConfigFileWatchers) {
-                clearMap(this.extendedConfigFileWatchers, closeFileWatcher);
-                this.extendedConfigFileWatchers = undefined;
-            }
-        }
-
         /*@internal*/
         watchWildcards(wildcardDirectories: ESMap<string, WatchDirectoryFlags>) {
             updateWatchingWildcardDirectories(
@@ -2317,7 +2309,6 @@ namespace ts.server {
                 this.configFileWatcher = undefined;
             }
 
-            this.stopWatchingExtendedConfigFiles();
             this.stopWatchingWildCards();
             this.configFileSpecs = undefined;
             this.openFileWatchTriggered.clear();