Fix too many watcher instances issue

src/compiler/core.ts

@@ -612,7 +612,9 @@ namespace ts {
         return path.substr(0, rootLength) + normalized.join(directorySeparator);
     }
 
-    export function getDirectoryPath(path: string) {
+    export function getDirectoryPath(path: Path): Path;
+    export function getDirectoryPath(path: string): string;
+    export function getDirectoryPath(path: string): any {
         return path.substr(0, Math.max(getRootLength(path), path.lastIndexOf(directorySeparator)));
     }
 
@@ -870,4 +872,11 @@ namespace ts {
         }
         return copiedList;
     }
+
+    export function createGetCanonicalFileName(useCaseSensitivefileNames: boolean): (fileName: string) => string {
+        return useCaseSensitivefileNames
+            ? ((fileName) => fileName)
+            : ((fileName) => fileName.toLowerCase());
+    }
+
 }

src/compiler/sys.ts

@@ -1,15 +1,18 @@
 /// <reference path="core.ts"/>
 
 namespace ts {
+    export type FileWatcherCallback = (path: string, removed?: boolean) => void;
+    export type DirectoryWatcherCallback = (path: string) => void;
+
     export interface System {
         args: string[];
         newLine: string;
         useCaseSensitiveFileNames: boolean;
         write(s: string): void;
         readFile(path: string, encoding?: string): string;
         writeFile(path: string, data: string, writeByteOrderMark?: boolean): void;
-        watchFile?(path: string, callback: (path: string, removed?: boolean) => void): FileWatcher;
-        watchDirectory?(path: string, callback: (path: string) => void, recursive?: boolean): FileWatcher;
+        watchFile?(path: Path, callback: FileWatcherCallback): FileWatcher;
+        watchDirectory?(path: string, callback: DirectoryWatcherCallback, recursive?: boolean): FileWatcher;
         resolvePath(path: string): string;
         fileExists(path: string): boolean;
         directoryExists(path: string): boolean;
@@ -22,15 +25,20 @@ namespace ts {
     }
 
     interface WatchedFile {
-        fileName: string;
-        callback: (fileName: string, removed?: boolean) => void;
-        mtime: Date;
+        filePath: Path;
+        callback: FileWatcherCallback;
+        mtime?: Date;
     }
 
     export interface FileWatcher {
         close(): void;
     }
 
+    export interface DirectoryWatcher extends FileWatcher {
+        directoryPath: Path;
+        referenceCount: number;
+    }
+
     declare var require: any;
     declare var module: any;
     declare var process: any;
@@ -62,8 +70,8 @@ namespace ts {
         readFile(path: string): string;
         writeFile(path: string, contents: string): void;
         readDirectory(path: string, extension?: string, exclude?: string[]): string[];
-        watchFile?(path: string, callback: (path: string, removed?: boolean) => void): FileWatcher;
-        watchDirectory?(path: string, callback: (path: string) => void, recursive?: boolean): FileWatcher;
+        watchFile?(path: string, callback: FileWatcherCallback): FileWatcher;
+        watchDirectory?(path: string, callback: DirectoryWatcherCallback, recursive?: boolean): FileWatcher;
     };
 
     export var sys: System = (function () {
@@ -221,7 +229,7 @@ namespace ts {
 
             // average async stat takes about 30 microseconds
             // set chunk size to do 30 files in < 1 millisecond
-            function createWatchedFileSet(interval = 2500, chunkSize = 30) {
+            function createPollingWatchedFileSet(interval = 2500, chunkSize = 30) {
                 let watchedFiles: WatchedFile[] = [];
                 let nextFileToCheck = 0;
                 let watchTimer: any;
@@ -236,13 +244,13 @@ namespace ts {
                         return;
                     }
 
-                    _fs.stat(watchedFile.fileName, (err: any, stats: any) => {
+                    _fs.stat(watchedFile.filePath, (err: any, stats: any) => {
                         if (err) {
-                            watchedFile.callback(watchedFile.fileName);
+                            watchedFile.callback(watchedFile.filePath);
                         }
                         else if (watchedFile.mtime.getTime() !== stats.mtime.getTime()) {
-                            watchedFile.mtime = getModifiedTime(watchedFile.fileName);
-                            watchedFile.callback(watchedFile.fileName, watchedFile.mtime.getTime() === 0);
+                            watchedFile.mtime = getModifiedTime(watchedFile.filePath);
+                            watchedFile.callback(watchedFile.filePath, watchedFile.mtime.getTime() === 0);
                         }
                     });
                 }
@@ -270,11 +278,11 @@ namespace ts {
                     }, interval);
                 }
 
-                function addFile(fileName: string, callback: (fileName: string, removed?: boolean) => void): WatchedFile {
+                function addFile(filePath: Path, callback: FileWatcherCallback): WatchedFile {
                     const file: WatchedFile = {
-                        fileName,
+                        filePath,
                         callback,
-                        mtime: getModifiedTime(fileName)
+                        mtime: getModifiedTime(filePath)
                     };
 
                     watchedFiles.push(file);
@@ -297,6 +305,88 @@ namespace ts {
                 };
             }
 
+            function createWatchedFileSet() {
+                const dirWatchers = createFileMap<DirectoryWatcher>();
+                // One file can have multiple watchers
+                const fileWatcherCallbacks = createFileMap<FileWatcherCallback[]>();
+                return { addFile, removeFile };
+
+                function reduceDirWatcherRefCountForFile(filePath: Path) {
+                    const dirPath = getDirectoryPath(filePath);
+                    if (dirWatchers.contains(dirPath)) {
+                        const watcher = dirWatchers.get(dirPath);
+                        watcher.referenceCount -= 1;
+                        if (watcher.referenceCount <= 0) {
+                            watcher.close();
+                            dirWatchers.remove(dirPath);
+                        }
+                    }
+                }
+
+                function addDirWatcher(dirPath: Path): void {
+                    if (dirWatchers.contains(dirPath)) {
+                        const watcher = dirWatchers.get(dirPath);
+                        watcher.referenceCount += 1;
+                        return;
+                    }
+
+                    const watcher: DirectoryWatcher = _fs.watch(
+                        dirPath,
+                        { persistent: true },
+                        (eventName: string, relativeFileName: string) => fileEventHandler(eventName, relativeFileName, dirPath)
+                    );
+                    watcher.referenceCount = 1;
+                    dirWatchers.set(dirPath, watcher);
+                    return;
+                }
+
+                function addFileWatcherCallback(filePath: Path, callback: FileWatcherCallback): void {
+                    if (fileWatcherCallbacks.contains(filePath)) {
+                        fileWatcherCallbacks.get(filePath).push(callback);
+                    }
+                    else {
+                        fileWatcherCallbacks.set(filePath, [callback]);
+                    }
+                }
+
+                function addFile(filePath: Path, callback: FileWatcherCallback): WatchedFile {
+                    addFileWatcherCallback(filePath, callback);
+                    addDirWatcher(getDirectoryPath(filePath));
+
+                    return { filePath, callback };
+                }
+
+                function removeFile(watchedFile: WatchedFile) {
+                    removeFileWatcherCallback(watchedFile.filePath, watchedFile.callback);
+                    reduceDirWatcherRefCountForFile(watchedFile.filePath);
+                }
+
+                function removeFileWatcherCallback(filePath: Path, callback: FileWatcherCallback) {
+                    if (fileWatcherCallbacks.contains(filePath)) {
+                        const newCallbacks = copyListRemovingItem(callback, fileWatcherCallbacks.get(filePath));
+                        if (newCallbacks.length === 0) {
+                            fileWatcherCallbacks.remove(filePath);
+                        }
+                        else {
+                            fileWatcherCallbacks.set(filePath, newCallbacks);
+                        }
+                    }
+                }
+
+                /**
+                 * @param watcherPath is the path from which the watcher is triggered.
+                 */
+                function fileEventHandler(eventName: string, relativefileName: string, baseDirPath: Path) {
+                    // When files are deleted from disk, the triggered "rename" event would have a relativefileName of "undefined"
+                    const filePath = relativefileName === undefined ? undefined : toPath(relativefileName, baseDirPath, getCanonicalPath);
+                    if (eventName === "change" && fileWatcherCallbacks.contains(filePath)) {
+                        for (const fileCallback of fileWatcherCallbacks.get(filePath)) {
+                            fileCallback(filePath);
+                        }
+                    }
+                }
+            }
+
             // REVIEW: for now this implementation uses polling.
             // The advantage of polling is that it works reliably
             // on all os and with network mounted files.
@@ -310,8 +400,13 @@ namespace ts {
             // changes for large reference sets? If so, do we want
             // to increase the chunk size or decrease the interval
             // time dynamically to match the large reference set?
+            const pollingWatchedFileSet = createPollingWatchedFileSet();
             const watchedFileSet = createWatchedFileSet();
 
+            function isNode4OrLater(): boolean {
+                 return parseInt(process.version.charAt(1)) >= 4;
+             }
+
             const platform: string = _os.platform();
             // win32\win64 are case insensitive platforms, MacOS (darwin) by default is also case insensitive
             const useCaseSensitiveFileNames = platform !== "win32" && platform !== "win64" && platform !== "darwin";
@@ -405,29 +500,38 @@ namespace ts {
                 },
                 readFile,
                 writeFile,
-                watchFile: (fileName, callback) => {
+                watchFile: (filePath, callback) => {
                     // Node 4.0 stablized the `fs.watch` function on Windows which avoids polling
                     // and is more efficient than `fs.watchFile` (ref: https://github.com/nodejs/node/pull/2649
                     // and https://github.com/Microsoft/TypeScript/issues/4643), therefore
                     // if the current node.js version is newer than 4, use `fs.watch` instead.
-                    const watchedFile = watchedFileSet.addFile(fileName, callback);
+                    const watchSet = isNode4OrLater() ? watchedFileSet : pollingWatchedFileSet;
+                    const watchedFile =  watchSet.addFile(filePath, callback);
                     return {
-                        close: () => watchedFileSet.removeFile(watchedFile)
+                        close: () => watchSet.removeFile(watchedFile)
                     };
                 },
                 watchDirectory: (path, callback, recursive) => {
                     // Node 4.0 `fs.watch` function supports the "recursive" option on both OSX and Windows
                     // (ref: https://github.com/nodejs/node/pull/2649 and https://github.com/Microsoft/TypeScript/issues/4643)
+                    let options: any;
+                    if (isNode4OrLater() && (process.platform === "win32" || process.platform === "darwin")) {
+                        options = { persistent: true, recursive: !!recursive };
+                    }
+                    else {
+                        options = { persistent: true };
+                    }
+
                     return _fs.watch(
                         path,
-                        { persistent: true, recursive: !!recursive },
+                        options,
                         (eventName: string, relativeFileName: string) => {
                             // In watchDirectory we only care about adding and removing files (when event name is
                             // "rename"); changes made within files are handled by corresponding fileWatchers (when
                             // event name is "change")
                             if (eventName === "rename") {
                                 // When deleting a file, the passed baseFileName is null
-                                callback(!relativeFileName ? relativeFileName : normalizePath(ts.combinePaths(path, relativeFileName)));
+                                callback(!relativeFileName ? relativeFileName : normalizePath(combinePaths(path, relativeFileName)));
                             };
                         }
                     );
@@ -511,5 +615,3 @@ namespace ts {
         }
     })();
 }
-
-

src/compiler/tsc.ts

@@ -334,7 +334,8 @@ namespace ts {
                 return sys.exit(ExitStatus.DiagnosticsPresent_OutputsSkipped);
             }
             if (configFileName) {
-                configFileWatcher = sys.watchFile(configFileName, configFileChanged);
+                const configFilePath = toPath(configFileName, sys.getCurrentDirectory(), createGetCanonicalFileName(sys.useCaseSensitiveFileNames));
+                configFileWatcher = sys.watchFile(configFilePath, configFileChanged);
             }
             if (sys.watchDirectory && configFileName) {
                 const directory = ts.getDirectoryPath(configFileName);
@@ -442,7 +443,8 @@ namespace ts {
             const sourceFile = hostGetSourceFile(fileName, languageVersion, onError);
             if (sourceFile && compilerOptions.watch) {
                 // Attach a file watcher
-                sourceFile.fileWatcher = sys.watchFile(sourceFile.fileName, (fileName: string, removed?: boolean) => sourceFileChanged(sourceFile, removed));
+                const filePath = toPath(sourceFile.fileName, sys.getCurrentDirectory(), createGetCanonicalFileName(sys.useCaseSensitiveFileNames));
+                sourceFile.fileWatcher = sys.watchFile(filePath, (fileName: string, removed?: boolean) => sourceFileChanged(sourceFile, removed));
             }
             return sourceFile;
         }

src/server/editorServices.ts

@@ -1000,7 +1000,7 @@ namespace ts.server {
                     info.setFormatOptions(this.getFormatCodeOptions());
                     this.filenameToScriptInfo[fileName] = info;
                     if (!info.isOpen) {
-                        info.fileWatcher = this.host.watchFile(fileName, _ => { this.watchedFileChanged(fileName); });
+                        info.fileWatcher = this.host.watchFile(<Path>fileName, _ => { this.watchedFileChanged(fileName); });
                     }
                 }
             }
@@ -1213,7 +1213,7 @@ namespace ts.server {
                     }
                 }
                 project.finishGraph();
-                project.projectFileWatcher = this.host.watchFile(configFilename, _ => this.watchedProjectConfigFileChanged(project));
+                project.projectFileWatcher = this.host.watchFile(<Path>configFilename, _ => this.watchedProjectConfigFileChanged(project));
                 this.log("Add recursive watcher for: " + ts.getDirectoryPath(configFilename));
                 project.directoryWatcher = this.host.watchDirectory(
                     ts.getDirectoryPath(configFilename),

src/services/services.ts

@@ -2008,13 +2008,6 @@ namespace ts {
         return createLanguageServiceSourceFile(sourceFile.fileName, scriptSnapshot, sourceFile.languageVersion, version, /*setNodeParents*/ true);
     }
 
-    export function createGetCanonicalFileName(useCaseSensitivefileNames: boolean): (fileName: string) => string {
-        return useCaseSensitivefileNames
-            ? ((fileName) => fileName)
-            : ((fileName) => fileName.toLowerCase());
-    }
-
-
     export function createDocumentRegistry(useCaseSensitiveFileNames?: boolean, currentDirectory = ""): DocumentRegistry {
         // Maps from compiler setting target (ES3, ES5, etc.) to all the cached documents we have
         // for those settings.