Merge pull request microsoft#8196 from zhengbli/fileWatcherBackToPolling

Change file watching back to polling.

Author: zhengbli

src/compiler/sys.ts

@@ -3,6 +3,11 @@
 namespace ts {
     export type FileWatcherCallback = (fileName: string, removed?: boolean) => void;
     export type DirectoryWatcherCallback = (directoryName: string) => void;
+    export interface WatchedFile {
+        fileName: string;
+        callback: FileWatcherCallback;
+        mtime?: Date;
+    }
 
     export interface System {
         args: string[];
@@ -26,12 +31,6 @@ namespace ts {
         exit(exitCode?: number): void;
     }
 
-    interface WatchedFile {
-        fileName: string;
-        callback: FileWatcherCallback;
-        mtime?: Date;
-    }
-
     export interface FileWatcher {
         close(): void;
     }
@@ -230,83 +229,7 @@ namespace ts {
             const _os = require("os");
             const _crypto = require("crypto");
 
-            // average async stat takes about 30 microseconds
-            // set chunk size to do 30 files in < 1 millisecond
-            function createPollingWatchedFileSet(interval = 2500, chunkSize = 30) {
-                let watchedFiles: WatchedFile[] = [];
-                let nextFileToCheck = 0;
-                let watchTimer: any;
-
-                function getModifiedTime(fileName: string): Date {
-                    return _fs.statSync(fileName).mtime;
-                }
-
-                function poll(checkedIndex: number) {
-                    const watchedFile = watchedFiles[checkedIndex];
-                    if (!watchedFile) {
-                        return;
-                    }
-
-                    _fs.stat(watchedFile.fileName, (err: any, stats: any) => {
-                        if (err) {
-                            watchedFile.callback(watchedFile.fileName);
-                        }
-                        else if (watchedFile.mtime.getTime() !== stats.mtime.getTime()) {
-                            watchedFile.mtime = getModifiedTime(watchedFile.fileName);
-                            watchedFile.callback(watchedFile.fileName, watchedFile.mtime.getTime() === 0);
-                        }
-                    });
-                }
-
-                // this implementation uses polling and
-                // stat due to inconsistencies of fs.watch
-                // and efficiency of stat on modern filesystems
-                function startWatchTimer() {
-                    watchTimer = setInterval(() => {
-                        let count = 0;
-                        let nextToCheck = nextFileToCheck;
-                        let firstCheck = -1;
-                        while ((count < chunkSize) && (nextToCheck !== firstCheck)) {
-                            poll(nextToCheck);
-                            if (firstCheck < 0) {
-                                firstCheck = nextToCheck;
-                            }
-                            nextToCheck++;
-                            if (nextToCheck === watchedFiles.length) {
-                                nextToCheck = 0;
-                            }
-                            count++;
-                        }
-                        nextFileToCheck = nextToCheck;
-                    }, interval);
-                }
-
-                function addFile(fileName: string, callback: FileWatcherCallback): WatchedFile {
-                    const file: WatchedFile = {
-                        fileName,
-                        callback,
-                        mtime: getModifiedTime(fileName)
-                    };
-
-                    watchedFiles.push(file);
-                    if (watchedFiles.length === 1) {
-                        startWatchTimer();
-                    }
-                    return file;
-                }
-
-                function removeFile(file: WatchedFile) {
-                    watchedFiles = copyListRemovingItem(file, watchedFiles);
-                }
-
-                return {
-                    getModifiedTime: getModifiedTime,
-                    poll: poll,
-                    startWatchTimer: startWatchTimer,
-                    addFile: addFile,
-                    removeFile: removeFile
-                };
-            }
+            const useNonPollingWatchers = process.env["TSC_NONPOLLING_WATCHER"];
 
             function createWatchedFileSet() {
                 const dirWatchers: Map<DirectoryWatcher> = {};
@@ -389,26 +312,11 @@ namespace ts {
                     }
                 }
             }
-
-            // REVIEW: for now this implementation uses polling.
-            // The advantage of polling is that it works reliably
-            // on all os and with network mounted files.
-            // For 90 referenced files, the average time to detect
-            // changes is 2*msInterval (by default 5 seconds).
-            // The overhead of this is .04 percent (1/2500) with
-            // average pause of < 1 millisecond (and max
-            // pause less than 1.5 milliseconds); question is
-            // do we anticipate reference sets in the 100s and
-            // do we care about waiting 10-20 seconds to detect
-            // 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;
-             }
+                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
@@ -501,7 +409,7 @@ namespace ts {
                     const files = _fs.readdirSync(path || ".").sort();
                     const directories: string[] = [];
                     for (const current of files) {
-                        // This is necessary because on some file system node fails to exclude 
+                        // This is necessary because on some file system node fails to exclude
                         // "." and "..". See https://github.com/nodejs/node/issues/4002
                         if (current === "." || current === "..") {
                             continue;
@@ -535,15 +443,26 @@ namespace ts {
                 readFile,
                 writeFile,
                 watchFile: (fileName, callback) => {
-                    // Node 4.0 stabilized 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 watchSet = isNode4OrLater() ? watchedFileSet : pollingWatchedFileSet;
-                    const watchedFile =  watchSet.addFile(fileName, callback);
-                    return {
-                        close: () => watchSet.removeFile(watchedFile)
-                    };
+                    if (useNonPollingWatchers) {
+                        const watchedFile = watchedFileSet.addFile(fileName, callback);
+                        return {
+                            close: () => watchedFileSet.removeFile(watchedFile)
+                        };
+                    }
+                    else {
+                        _fs.watchFile(fileName, { persistent: true, interval: 250 }, fileChanged);
+                        return {
+                            close: () => _fs.unwatchFile(fileName, fileChanged)
+                        };
+                    }
+
+                    function fileChanged(curr: any, prev: any) {
+                        if (+curr.mtime <= +prev.mtime) {
+                            return;
+                        }
+
+                        callback(fileName);
+                    }
                 },
                 watchDirectory: (directoryName, callback, recursive) => {
                     // Node 4.0 `fs.watch` function supports the "recursive" option on both OSX and Windows

src/compiler/types.ts

@@ -2126,7 +2126,7 @@ namespace ts {
         jsxFlags?: JsxFlags;              // flags for knowing what kind of element/attributes we're dealing with
         resolvedJsxType?: Type;           // resolved element attributes type of a JSX openinglike element
         hasSuperCall?: boolean;           // recorded result when we try to find super-call. We only try to find one if this flag is undefined, indicating that we haven't made an attempt.
-        superCall?: ExpressionStatement;  // Cached first super-call found in the constructor. Used in checking whether super is called before this-accessing 
+        superCall?: ExpressionStatement;  // Cached first super-call found in the constructor. Used in checking whether super is called before this-accessing
     }
 
     export const enum TypeFlags {
@@ -2507,7 +2507,7 @@ namespace ts {
         // When options come from a config file, its path is recorded here
         configFilePath?: string;
         /* @internal */
-        // Path used to used to compute primary search locations 
+        // Path used to used to compute primary search locations
         typesRoot?: string;
         types?: string[];
 
@@ -2824,7 +2824,7 @@ namespace ts {
          */
         resolveModuleNames?(moduleNames: string[], containingFile: string): ResolvedModule[];
         /**
-         * This method is a companion for 'resolveModuleNames' and is used to resolve 'types' references to actual type declaration files 
+         * This method is a companion for 'resolveModuleNames' and is used to resolve 'types' references to actual type declaration files
          */
         resolveTypeReferenceDirectives?(typeReferenceDirectiveNames: string[], containingFile: string): ResolvedTypeReferenceDirective[];
     }

src/server/server.ts

@@ -153,6 +153,98 @@ namespace ts.server {
     // This places log file in the directory containing editorServices.js
     // TODO: check that this location is writable
 
+    // average async stat takes about 30 microseconds
+    // set chunk size to do 30 files in < 1 millisecond
+    function createPollingWatchedFileSet(interval = 2500, chunkSize = 30) {
+        let watchedFiles: WatchedFile[] = [];
+        let nextFileToCheck = 0;
+        let watchTimer: any;
+
+        function getModifiedTime(fileName: string): Date {
+            return fs.statSync(fileName).mtime;
+        }
+
+        function poll(checkedIndex: number) {
+            const watchedFile = watchedFiles[checkedIndex];
+            if (!watchedFile) {
+                return;
+            }
+
+            fs.stat(watchedFile.fileName, (err: any, stats: any) => {
+                if (err) {
+                    watchedFile.callback(watchedFile.fileName);
+                }
+                else if (watchedFile.mtime.getTime() !== stats.mtime.getTime()) {
+                    watchedFile.mtime = getModifiedTime(watchedFile.fileName);
+                    watchedFile.callback(watchedFile.fileName, watchedFile.mtime.getTime() === 0);
+                }
+            });
+        }
+
+        // this implementation uses polling and
+        // stat due to inconsistencies of fs.watch
+        // and efficiency of stat on modern filesystems
+        function startWatchTimer() {
+            watchTimer = setInterval(() => {
+                let count = 0;
+                let nextToCheck = nextFileToCheck;
+                let firstCheck = -1;
+                while ((count < chunkSize) && (nextToCheck !== firstCheck)) {
+                    poll(nextToCheck);
+                    if (firstCheck < 0) {
+                        firstCheck = nextToCheck;
+                    }
+                    nextToCheck++;
+                    if (nextToCheck === watchedFiles.length) {
+                        nextToCheck = 0;
+                    }
+                    count++;
+                }
+                nextFileToCheck = nextToCheck;
+            }, interval);
+        }
+
+        function addFile(fileName: string, callback: FileWatcherCallback): WatchedFile {
+            const file: WatchedFile = {
+                fileName,
+                callback,
+                mtime: getModifiedTime(fileName)
+            };
+
+            watchedFiles.push(file);
+            if (watchedFiles.length === 1) {
+                startWatchTimer();
+            }
+            return file;
+        }
+
+        function removeFile(file: WatchedFile) {
+            watchedFiles = copyListRemovingItem(file, watchedFiles);
+        }
+
+        return {
+            getModifiedTime: getModifiedTime,
+            poll: poll,
+            startWatchTimer: startWatchTimer,
+            addFile: addFile,
+            removeFile: removeFile
+        };
+    }
+
+    // REVIEW: for now this implementation uses polling.
+    // The advantage of polling is that it works reliably
+    // on all os and with network mounted files.
+    // For 90 referenced files, the average time to detect
+    // changes is 2*msInterval (by default 5 seconds).
+    // The overhead of this is .04 percent (1/2500) with
+    // average pause of < 1 millisecond (and max
+    // pause less than 1.5 milliseconds); question is
+    // do we anticipate reference sets in the 100s and
+    // do we care about waiting 10-20 seconds to detect
+    // 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 logger = createLoggerFromEnv();
 
     const pending: string[] = [];
@@ -176,6 +268,12 @@ namespace ts.server {
 
     // Override sys.write because fs.writeSync is not reliable on Node 4
     ts.sys.write = (s: string) => writeMessage(s);
+    ts.sys.watchFile = (fileName, callback) => {
+        const watchedFile = pollingWatchedFileSet.addFile(fileName, callback);
+        return {
+            close: () => pollingWatchedFileSet.removeFile(watchedFile)
+        };
+    };
 
     const ioSession = new IOSession(ts.sys, logger);
     process.on("uncaughtException", function(err: Error) {