Make useFsEvents as default strategy for the watching (#50366)

* Remove unnecessary parameter

* Dont store name unnecessarily in the watchers

* Polled watches and not files

* Use fs events as default watching

* Some refactoring

* Make single per directory native watchers now that we are using it as default

* Rename

* Comment

Author: sheetalkamat

src/compiler/sys.ts

@@ -35,8 +35,7 @@ namespace ts {
 
     export type FileWatcherCallback = (fileName: string, eventKind: FileWatcherEventKind, modifiedTime?: Date) => void;
     export type DirectoryWatcherCallback = (fileName: string) => void;
-    /*@internal*/
-    export interface WatchedFile {
+    interface WatchedFile {
         readonly fileName: string;
         readonly callback: FileWatcherCallback;
         mtime: Date;
@@ -81,8 +80,7 @@ namespace ts {
     /* @internal */
     export let unchangedPollThresholds = createPollingIntervalBasedLevels(defaultChunkLevels);
 
-    /* @internal */
-    export function setCustomPollingValues(system: System) {
+    function setCustomPollingValues(system: System) {
         if (!system.getEnvironmentVariable) {
             return;
         }
@@ -189,31 +187,28 @@ namespace ts {
         }
     }
 
-    /* @internal */
-    export function createDynamicPriorityPollingWatchFile(host: {
+    interface WatchedFileWithUnchangedPolls extends WatchedFileWithIsClosed {
+        unchangedPolls: number;
+    }
+    function createDynamicPriorityPollingWatchFile(host: {
         getModifiedTime: NonNullable<System["getModifiedTime"]>;
         setTimeout: NonNullable<System["setTimeout"]>;
     }): HostWatchFile {
-        interface WatchedFile extends ts.WatchedFile {
-            isClosed?: boolean;
-            unchangedPolls: number;
-        }
-
-        interface PollingIntervalQueue extends Array<WatchedFile> {
+        interface PollingIntervalQueue extends Array<WatchedFileWithUnchangedPolls> {
             pollingInterval: PollingInterval;
             pollIndex: number;
             pollScheduled: boolean;
         }
 
-        const watchedFiles: WatchedFile[] = [];
-        const changedFilesInLastPoll: WatchedFile[] = [];
+        const watchedFiles: WatchedFileWithUnchangedPolls[] = [];
+        const changedFilesInLastPoll: WatchedFileWithUnchangedPolls[] = [];
         const lowPollingIntervalQueue = createPollingIntervalQueue(PollingInterval.Low);
         const mediumPollingIntervalQueue = createPollingIntervalQueue(PollingInterval.Medium);
         const highPollingIntervalQueue = createPollingIntervalQueue(PollingInterval.High);
         return watchFile;
 
         function watchFile(fileName: string, callback: FileWatcherCallback, defaultPollingInterval: PollingInterval): FileWatcher {
-            const file: WatchedFile = {
+            const file: WatchedFileWithUnchangedPolls = {
                 fileName,
                 callback,
                 unchangedPolls: 0,
@@ -233,7 +228,7 @@ namespace ts {
         }
 
         function createPollingIntervalQueue(pollingInterval: PollingInterval): PollingIntervalQueue {
-            const queue = [] as WatchedFile[] as PollingIntervalQueue;
+            const queue = [] as WatchedFileWithUnchangedPolls[] as PollingIntervalQueue;
             queue.pollingInterval = pollingInterval;
             queue.pollIndex = 0;
             queue.pollScheduled = false;
@@ -265,7 +260,7 @@ namespace ts {
             }
         }
 
-        function pollQueue(queue: (WatchedFile | undefined)[], pollingInterval: PollingInterval, pollIndex: number, chunkSize: number) {
+        function pollQueue(queue: (WatchedFileWithUnchangedPolls | undefined)[], pollingInterval: PollingInterval, pollIndex: number, chunkSize: number) {
             return pollWatchedFileQueue(
                 host,
                 queue,
@@ -274,7 +269,7 @@ namespace ts {
                 onWatchFileStat
             );
 
-            function onWatchFileStat(watchedFile: WatchedFile, pollIndex: number, fileChanged: boolean) {
+            function onWatchFileStat(watchedFile: WatchedFileWithUnchangedPolls, pollIndex: number, fileChanged: boolean) {
                 if (fileChanged) {
                     watchedFile.unchangedPolls = 0;
                     // Changed files go to changedFilesInLastPoll queue
@@ -311,12 +306,12 @@ namespace ts {
             }
         }
 
-        function addToPollingIntervalQueue(file: WatchedFile, pollingInterval: PollingInterval) {
+        function addToPollingIntervalQueue(file: WatchedFileWithUnchangedPolls, pollingInterval: PollingInterval) {
             pollingIntervalQueue(pollingInterval).push(file);
             scheduleNextPollIfNotAlreadyScheduled(pollingInterval);
         }
 
-        function addChangedFileToLowPollingIntervalQueue(file: WatchedFile) {
+        function addChangedFileToLowPollingIntervalQueue(file: WatchedFileWithUnchangedPolls) {
             changedFilesInLastPoll.push(file);
             scheduleNextPollIfNotAlreadyScheduled(PollingInterval.Low);
         }
@@ -423,59 +418,50 @@ namespace ts {
         }
     }
 
-    /* @internal */
-    export function createSingleFileWatcherPerName(
-        watchFile: HostWatchFile,
-        useCaseSensitiveFileNames: boolean
-    ): HostWatchFile {
-        interface SingleFileWatcher {
-            watcher: FileWatcher;
-            refCount: number;
-        }
-        const cache = new Map<string, SingleFileWatcher>();
-        const callbacksCache = createMultiMap<FileWatcherCallback>();
+    interface SingleFileWatcher<T extends FileWatcherCallback | FsWatchCallback>{
+        watcher: FileWatcher;
+        callbacks: T[];
+    }
+    function createSingleWatcherPerName<T extends FileWatcherCallback | FsWatchCallback>(
+        cache: Map<SingleFileWatcher<T>>,
+        useCaseSensitiveFileNames: boolean,
+        name: string,
+        callback: T,
+        createWatcher: (callback: T) => FileWatcher,
+    ): FileWatcher {
         const toCanonicalFileName = createGetCanonicalFileName(useCaseSensitiveFileNames);
+        const path = toCanonicalFileName(name);
+        const existing = cache.get(path);
+        if (existing) {
+            existing.callbacks.push(callback);
+        }
+        else {
+            cache.set(path, {
+                watcher: createWatcher((
+                    // Cant infer types correctly so lets satisfy checker
+                    (param1: any, param2: never, param3: any) => cache.get(path)?.callbacks.slice().forEach(cb => cb(param1, param2, param3))
+                ) as T),
+                callbacks: [callback]
+            });
+        }
 
-        return (fileName, callback, pollingInterval, options) => {
-            const path = toCanonicalFileName(fileName);
-            const existing = cache.get(path);
-            if (existing) {
-                existing.refCount++;
-            }
-            else {
-                cache.set(path, {
-                    watcher: watchFile(
-                        fileName,
-                        (fileName, eventKind, modifiedTime) => forEach(
-                            callbacksCache.get(path),
-                            cb => cb(fileName, eventKind, modifiedTime)
-                        ),
-                        pollingInterval,
-                        options
-                    ),
-                    refCount: 1
-                });
+        return {
+            close: () => {
+                const watcher = cache.get(path);
+                // Watcher is not expected to be undefined, but if it is normally its because
+                // exception was thrown somewhere else and watch state is not what it should be
+                if (!watcher) return;
+                if (!orderedRemoveItem(watcher.callbacks, callback) || watcher.callbacks.length) return;
+                cache.delete(path);
+                closeFileWatcherOf(watcher);
             }
-            callbacksCache.add(path, callback);
-
-            return {
-                close: () => {
-                    const watcher = Debug.checkDefined(cache.get(path));
-                    callbacksCache.remove(path, callback);
-                    watcher.refCount--;
-                    if (watcher.refCount) return;
-                    cache.delete(path);
-                    closeFileWatcherOf(watcher);
-                }
-            };
         };
     }
 
     /**
      * Returns true if file status changed
      */
-    /*@internal*/
-    export function onWatchedFileStat(watchedFile: WatchedFile, modifiedTime: Date): boolean {
+    function onWatchedFileStat(watchedFile: WatchedFile, modifiedTime: Date): boolean {
         const oldTime = watchedFile.mtime.getTime();
         const newTime = modifiedTime.getTime();
         if (oldTime !== newTime) {
@@ -512,8 +498,7 @@ namespace ts {
         curSysLog = logger;
     }
 
-    /*@internal*/
-    export interface RecursiveDirectoryWatcherHost {
+    interface RecursiveDirectoryWatcherHost {
         watchDirectory: HostWatchDirectory;
         useCaseSensitiveFileNames: boolean;
         getCurrentDirectory: System["getCurrentDirectory"];
@@ -529,8 +514,7 @@ namespace ts {
      * that means if this is recursive watcher, watch the children directories as well
      * (eg on OS that dont support recursive watch using fs.watch use fs.watchFile)
      */
-    /*@internal*/
-    export function createDirectoryWatcherSupportingRecursive({
+    function createDirectoryWatcherSupportingRecursive({
         watchDirectory,
         useCaseSensitiveFileNames,
         getCurrentDirectory,
@@ -792,8 +776,7 @@ namespace ts {
         Directory,
     }
 
-    /*@internal*/
-    export function createFileWatcherCallback(callback: FsWatchCallback): FileWatcherCallback {
+    function createFileWatcherCallback(callback: FsWatchCallback): FileWatcherCallback {
         return (_fileName, eventKind, modifiedTime) => callback(eventKind === FileWatcherEventKind.Changed ? "change" : "rename", "", modifiedTime);
     }
 
@@ -854,7 +837,7 @@ namespace ts {
     /*@internal*/
     export interface CreateSystemWatchFunctions {
         // Polling watch file
-        pollingWatchFile: HostWatchFile;
+        pollingWatchFileWorker: HostWatchFile;
         // For dynamic polling watch file
         getModifiedTime: NonNullable<System["getModifiedTime"]>;
         setTimeout: NonNullable<System["setTimeout"]>;
@@ -878,7 +861,7 @@ namespace ts {
 
     /*@internal*/
     export function createSystemWatchFunctions({
-        pollingWatchFile,
+        pollingWatchFileWorker,
         getModifiedTime,
         setTimeout,
         clearTimeout,
@@ -896,6 +879,9 @@ namespace ts {
         inodeWatching,
         sysLog,
     }: CreateSystemWatchFunctions): { watchFile: HostWatchFile; watchDirectory: HostWatchDirectory; } {
+        const pollingWatches = new Map<string, SingleFileWatcher<FileWatcherCallback>>();
+        const fsWatches = new Map<string, SingleFileWatcher<FsWatchCallback>>();
+        const fsWatchesRecursive = new Map<string, SingleFileWatcher<FsWatchCallback>>();
         let dynamicPollingWatchFile: HostWatchFile | undefined;
         let fixedChunkSizePollingWatchFile: HostWatchFile | undefined;
         let nonPollingWatchFile: HostWatchFile | undefined;
@@ -968,7 +954,7 @@ namespace ts {
                         // Use notifications from FS to watch with falling back to fs.watchFile
                         generateWatchFileOptions(WatchFileKind.UseFsEventsOnParentDirectory, PollingWatchKind.PriorityInterval, options) :
                         // Default to do not use fixed polling interval
-                        { watchFile: defaultWatchFileKind?.() || WatchFileKind.FixedPollingInterval };
+                        { watchFile: defaultWatchFileKind?.() || WatchFileKind.UseFsEvents };
             }
         }
 
@@ -1073,13 +1059,39 @@ namespace ts {
             }
         }
 
+        function pollingWatchFile(fileName: string, callback: FileWatcherCallback, pollingInterval: PollingInterval, options: WatchOptions | undefined) {
+            return createSingleWatcherPerName(
+                pollingWatches,
+                useCaseSensitiveFileNames,
+                fileName,
+                callback,
+                cb => pollingWatchFileWorker(fileName, cb, pollingInterval, options),
+            );
+        }
         function fsWatch(
             fileOrDirectory: string,
             entryKind: FileSystemEntryKind,
             callback: FsWatchCallback,
             recursive: boolean,
             fallbackPollingInterval: PollingInterval,
             fallbackOptions: WatchOptions | undefined
+        ): FileWatcher {
+            return createSingleWatcherPerName(
+                recursive ? fsWatchesRecursive : fsWatches,
+                useCaseSensitiveFileNames,
+                fileOrDirectory,
+                callback,
+                cb => fsWatchHandlingExistenceOnHost(fileOrDirectory, entryKind, cb, recursive, fallbackPollingInterval, fallbackOptions),
+            );
+        }
+
+        function fsWatchHandlingExistenceOnHost(
+            fileOrDirectory: string,
+            entryKind: FileSystemEntryKind,
+            callback: FsWatchCallback,
+            recursive: boolean,
+            fallbackPollingInterval: PollingInterval,
+            fallbackOptions: WatchOptions | undefined
         ): FileWatcher {
             let lastDirectoryPartWithDirectorySeparator: string | undefined;
             let lastDirectoryPart: string | undefined;
@@ -1445,7 +1457,7 @@ namespace ts {
             const fsSupportsRecursiveFsWatch = isNode4OrLater && (process.platform === "win32" || process.platform === "darwin");
             const getCurrentDirectory = memoize(() => process.cwd());
             const { watchFile, watchDirectory } = createSystemWatchFunctions({
-                pollingWatchFile: createSingleFileWatcherPerName(fsWatchFileWorker, useCaseSensitiveFileNames),
+                pollingWatchFileWorker: fsWatchFileWorker,
                 getModifiedTime,
                 setTimeout,
                 clearTimeout,