Always recreate the file watcher when rename event occurs

src/testRunner/unittests/tsbuildWatch/noEmit.ts

@@ -6,11 +6,10 @@ namespace ts.tscWatch {
             commandLineArgs: ["-b", "-w", "-verbose"],
             sys: () => createWatchedSystem(
                 [
-                    libFile,
+                    { path: libFile.path, content: libContent },
                     { path: `${projectRoot}/a.js`, content: "" },
                     { path: `${projectRoot}/b.ts`, content: "" },
                     { path: `${projectRoot}/tsconfig.json`, content: JSON.stringify({ compilerOptions: { allowJs: true, noEmit: true } }) },
-                    { path: libFile.path, content: libContent }
                 ],
                 { currentDirectory: projectRoot }
             ),

src/testRunner/unittests/tscWatch/emit.ts

@@ -6,21 +6,12 @@ namespace ts.tscWatch {
                 scenario,
                 subScenario: `emit with outFile or out setting/${subScenario}`,
                 commandLineArgs: ["--w", "-p", "/a/tsconfig.json"],
-                sys: () => {
-                    const config: File = {
-                        path: "/a/tsconfig.json",
-                        content: JSON.stringify({ compilerOptions: { out, outFile } })
-                    };
-                    const f1: File = {
-                        path: "/a/a.ts",
-                        content: "let x = 1"
-                    };
-                    const f2: File = {
-                        path: "/a/b.ts",
-                        content: "let y = 1"
-                    };
-                    return createWatchedSystem([f1, f2, config, libFile]);
-                },
+                sys: () => createWatchedSystem({
+                    "/a/a.ts": "let x = 1",
+                    "/a/b.ts": "let y = 1",
+                    "/a/tsconfig.json": JSON.stringify({ compilerOptions: { out, outFile } }),
+                    [libFile.path]: libFile.content,
+                }),
                 changes: [
                     {
                         caption: "Make change in the file",

src/testRunner/unittests/tscWatch/forceConsistentCasingInFileNames.ts

@@ -20,7 +20,7 @@ namespace ts.tscWatch {
                 scenario: "forceConsistentCasingInFileNames",
                 subScenario,
                 commandLineArgs: ["--w", "--p", tsconfig.path],
-                sys: () => createWatchedSystem([loggerFile, anotherFile, tsconfig, libFile, tsconfig]),
+                sys: () => createWatchedSystem([loggerFile, anotherFile, tsconfig, libFile]),
                 changes
             });
         }

src/testRunner/unittests/tscWatch/helpers.ts

@@ -7,10 +7,6 @@ namespace ts.tscWatch {
     export import libFile = TestFSWithWatch.libFile;
     export import createWatchedSystem = TestFSWithWatch.createWatchedSystem;
     export import checkArray = TestFSWithWatch.checkArray;
-    export import checkWatchedFiles = TestFSWithWatch.checkWatchedFiles;
-    export import checkWatchedFilesDetailed = TestFSWithWatch.checkWatchedFilesDetailed;
-    export import checkWatchedDirectories = TestFSWithWatch.checkWatchedDirectories;
-    export import checkWatchedDirectoriesDetailed = TestFSWithWatch.checkWatchedDirectoriesDetailed;
     export import checkOutputContains = TestFSWithWatch.checkOutputContains;
     export import checkOutputDoesNotContain = TestFSWithWatch.checkOutputDoesNotContain;
 
@@ -436,7 +432,7 @@ namespace ts.tscWatch {
         return sys;
     }
 
-    export function createSystemWithSolutionBuild(solutionRoots: readonly string[], files: readonly TestFSWithWatch.FileOrFolderOrSymLink[], params?: TestFSWithWatch.TestServerHostCreationParameters) {
+    export function createSystemWithSolutionBuild(solutionRoots: readonly string[], files: TestFSWithWatch.FileOrFolderOrSymLinkMap | readonly TestFSWithWatch.FileOrFolderOrSymLink[], params?: TestFSWithWatch.TestServerHostCreationParameters) {
         return solutionBuildWithBaseline(createWatchedSystem(files, params), solutionRoots);
     }
 }

src/testRunner/unittests/tscWatch/watchEnvironment.ts

@@ -581,5 +581,141 @@ namespace ts.tscWatch {
                 verifyWorker("-extendedDiagnostics");
             });
         });
+
+        verifyTscWatch({
+            scenario,
+            subScenario: `fsWatch/when using file watching thats when rename occurs when file is still on the disk`,
+            commandLineArgs: ["-w", "--extendedDiagnostics"],
+            sys: () => createWatchedSystem(
+                {
+                    [libFile.path]: libFile.content,
+                    [`${projectRoot}/main.ts`]: `import { foo } from "./foo"; foo();`,
+                    [`${projectRoot}/foo.ts`]: `export declare function foo(): string;`,
+                    [`${projectRoot}/tsconfig.json`]: JSON.stringify({
+                        watchOptions: { watchFile: "useFsEvents" },
+                        files: ["foo.ts", "main.ts"]
+                    }),
+                },
+                { currentDirectory: projectRoot, }
+            ),
+            changes: [
+                {
+                    caption: "Introduce error such that when callback happens file is already appeared",
+                    // vm's wq generates this kind of event
+                    // Skip delete event so inode changes but when the create's rename occurs file is on disk
+                    change: sys => sys.modifyFile(`${projectRoot}/foo.ts`, `export declare function foo2(): string;`, {
+                        invokeFileDeleteCreateAsPartInsteadOfChange: true,
+                        ignoreDelete: true,
+                    }),
+                    timeouts: sys => sys.checkTimeoutQueueLengthAndRun(1),
+                },
+                {
+                    caption: "Replace file with rename event that fixes error",
+                    change: sys => sys.modifyFile(`${projectRoot}/foo.ts`, `export declare function foo(): string;`, { invokeFileDeleteCreateAsPartInsteadOfChange: true, }),
+                    timeouts: sys => sys.checkTimeoutQueueLengthAndRun(1),
+                },
+            ]
+        });
+
+        describe("with fsWatch on inodes", () => {
+            verifyTscWatch({
+                scenario,
+                subScenario: `fsWatch/when using file watching thats on inode`,
+                commandLineArgs: ["-w", "--extendedDiagnostics"],
+                sys: () => createWatchedSystem(
+                    {
+                        [libFile.path]: libFile.content,
+                        [`${projectRoot}/main.ts`]: `import { foo } from "./foo"; foo();`,
+                        [`${projectRoot}/foo.d.ts`]: `export function foo(): string;`,
+                        [`${projectRoot}/tsconfig.json`]: JSON.stringify({ watchOptions: { watchFile: "useFsEvents" }, files: ["foo.d.ts", "main.ts"] }),
+                    },
+                    {
+                        currentDirectory: projectRoot,
+                        inodeWatching: true
+                    }
+                ),
+                changes: [
+                    {
+                        caption: "Replace file with rename event that introduces error",
+                        change: sys => sys.modifyFile(`${projectRoot}/foo.d.ts`, `export function foo2(): string;`, { invokeFileDeleteCreateAsPartInsteadOfChange: true }),
+                        timeouts: sys => sys.checkTimeoutQueueLengthAndRun(2),
+                    },
+                    {
+                        caption: "Replace file with rename event that fixes error",
+                        change: sys => sys.modifyFile(`${projectRoot}/foo.d.ts`, `export function foo(): string;`, { invokeFileDeleteCreateAsPartInsteadOfChange: true }),
+                        timeouts: sys => sys.checkTimeoutQueueLengthAndRun(2),
+                    },
+                ]
+            });
+
+            verifyTscWatch({
+                scenario,
+                subScenario: `fsWatch/when using file watching thats on inode when rename event ends with tilde`,
+                commandLineArgs: ["-w", "--extendedDiagnostics"],
+                sys: () => createWatchedSystem(
+                    {
+                        [libFile.path]: libFile.content,
+                        [`${projectRoot}/main.ts`]: `import { foo } from "./foo"; foo();`,
+                        [`${projectRoot}/foo.d.ts`]: `export function foo(): string;`,
+                        [`${projectRoot}/tsconfig.json`]: JSON.stringify({ watchOptions: { watchFile: "useFsEvents" }, files: ["foo.d.ts", "main.ts"] }),
+                    },
+                    {
+                        currentDirectory: projectRoot,
+                        inodeWatching: true
+                    }
+                ),
+                changes: [
+                    {
+                        caption: "Replace file with rename event that introduces error",
+                        change: sys => sys.modifyFile(`${projectRoot}/foo.d.ts`, `export function foo2(): string;`, { invokeFileDeleteCreateAsPartInsteadOfChange: true, useTildeAsSuffixInRenameEventFileName: true }),
+                        timeouts: sys => sys.checkTimeoutQueueLengthAndRun(2),
+                    },
+                    {
+                        caption: "Replace file with rename event that fixes error",
+                        change: sys => sys.modifyFile(`${projectRoot}/foo.d.ts`, `export function foo(): string;`, { invokeFileDeleteCreateAsPartInsteadOfChange: true, useTildeAsSuffixInRenameEventFileName: true }),
+                        timeouts: sys => sys.checkTimeoutQueueLengthAndRun(2),
+                    },
+                ]
+            });
+
+            verifyTscWatch({
+                scenario,
+                subScenario: `fsWatch/when using file watching thats on inode when rename occurs when file is still on the disk`,
+                commandLineArgs: ["-w", "--extendedDiagnostics"],
+                sys: () => createWatchedSystem(
+                    {
+                        [libFile.path]: libFile.content,
+                        [`${projectRoot}/main.ts`]: `import { foo } from "./foo"; foo();`,
+                        [`${projectRoot}/foo.ts`]: `export declare function foo(): string;`,
+                        [`${projectRoot}/tsconfig.json`]: JSON.stringify({
+                            watchOptions: { watchFile: "useFsEvents" },
+                            files: ["foo.ts", "main.ts"]
+                        }),
+                    },
+                    {
+                        currentDirectory: projectRoot,
+                        inodeWatching: true,
+                    }
+                ),
+                changes: [
+                    {
+                        caption: "Introduce error such that when callback happens file is already appeared",
+                        // vm's wq generates this kind of event
+                        // Skip delete event so inode changes but when the create's rename occurs file is on disk
+                        change: sys => sys.modifyFile(`${projectRoot}/foo.ts`, `export declare function foo2(): string;`, {
+                            invokeFileDeleteCreateAsPartInsteadOfChange: true,
+                            ignoreDelete: true,
+                            skipInodeCheckOnCreate: true
+                        }),
+                        timeouts: sys => sys.checkTimeoutQueueLengthAndRun(1),
+                    },
+                    {
+                        caption: "Replace file with rename event that fixes error",
+                        change: sys => sys.modifyFile(`${projectRoot}/foo.ts`, `export declare function foo(): string;`, { invokeFileDeleteCreateAsPartInsteadOfChange: true, }),
+                        timeouts: sys => sys.checkTimeoutQueueLengthAndRun(1),
+                    },
+                ]
+            });
+        });
     });
 }