Add multiMapRemove helper

src/compiler/core.ts

@@ -581,6 +581,21 @@ namespace ts {
         }
     }
 
+    /**
+     * Removes a value from an array of values associated with the key.
+     * Does not preserve the order of those values.
+     * Does nothing if `key` is not in `map`, or `value` is not in `map[key]`.
+     */
+    export function multiMapRemove<V>(map: Map<V[]>, key: string, value: V): void {
+        const values = map[key];
+        if (values) {
+            unorderedRemoveItem(values, value);
+            if (!values.length) {
+                delete map[key];
+            }
+        }
+    }
+
     /**
      * Tests whether a value is an array.
      */

src/compiler/sys.ts

@@ -283,13 +283,7 @@ namespace ts {
                 }
 
                 function removeFileWatcherCallback(filePath: string, callback: FileWatcherCallback) {
-                    const callbacks = fileWatcherCallbacks[filePath];
-                    if (callbacks) {
-                        unorderedRemoveItem(callbacks, callback);
-                        if (callbacks.length === 0) {
-                            delete fileWatcherCallbacks[filePath];
-                        }
-                    }
+                    multiMapRemove(fileWatcherCallbacks, filePath, callback);
                 }
 
                 function fileEventHandler(eventName: string, relativeFileName: string, baseDirPath: string) {

src/harness/unittests/tsserverProjectSystem.ts

@@ -199,16 +199,11 @@ namespace ts {
         watchDirectory(directoryName: string, callback: DirectoryWatcherCallback, recursive: boolean): DirectoryWatcher {
             const path = this.toPath(directoryName);
             const cbWithRecursive = { cb: callback, recursive };
-            const callbacks = multiMapAdd(this.watchedDirectories, path, cbWithRecursive);
+            multiMapAdd(this.watchedDirectories, path, cbWithRecursive);
             return {
                 referenceCount: 0,
                 directoryName,
-                close: () => {
-                    unorderedRemoveItem(callbacks, cbWithRecursive);
-                    if (!callbacks.length) {
-                        delete this.watchedDirectories[path];
-                    }
-                }
+                close: () => multiMapRemove(this.watchedDirectories, path, cbWithRecursive)
             };
         }
 
@@ -234,15 +229,8 @@ namespace ts {
 
         watchFile(fileName: string, callback: FileWatcherCallback) {
             const path = this.toPath(fileName);
-            const callbacks = multiMapAdd(this.watchedFiles, path, callback);
-            return {
-                close: () => {
-                    unorderedRemoveItem(callbacks, callback);
-                    if (!callbacks.length) {
-                        delete this.watchedFiles[path];
-                    }
-                }
-            };
+            multiMapAdd(this.watchedFiles, path, callback);
+            return { close: () => multiMapRemove(this.watchedFiles, path, callback) };
         }
 
         // TOOD: record and invoke callbacks to simulate timer events