microsoft
diff --git a/‎src/compiler/sys.ts
Copy file name to clipboard
+179-145Lines changed: 179 additions & 145 deletions b/‎src/compiler/sys.ts
Copy file name to clipboard
+179-145Lines changed: 179 additions & 145 deletions
diff --git a/‎src/harness/virtualFileSystemWithWatch.ts
Copy file name to clipboard
+159-234Lines changed: 159 additions & 234 deletions b/‎src/harness/virtualFileSystemWithWatch.ts
Copy file name to clipboard
+159-234Lines changed: 159 additions & 234 deletions
diff --git a/‎src/testRunner/unittests/tsbuildWatch/noEmit.ts
Copy file name to clipboard
+1-2Lines changed: 1 addition & 2 deletions b/‎src/testRunner/unittests/tsbuildWatch/noEmit.ts
Copy file name to clipboard
+1-2Lines changed: 1 addition & 2 deletions
diff --git a/‎src/testRunner/unittests/tscWatch/emit.ts
Copy file name to clipboard
+6-15Lines changed: 6 additions & 15 deletions b/‎src/testRunner/unittests/tscWatch/emit.ts
Copy file name to clipboard
+6-15Lines changed: 6 additions & 15 deletions
diff --git a/‎src/testRunner/unittests/tscWatch/forceConsistentCasingInFileNames.ts
Copy file name to clipboard
+1-1Lines changed: 1 addition & 1 deletion b/‎src/testRunner/unittests/tscWatch/forceConsistentCasingInFileNames.ts
Copy file name to clipboard
+1-1Lines changed: 1 addition & 1 deletion
diff --git a/‎src/testRunner/unittests/tscWatch/helpers.ts
Copy file name to clipboard
+1-5Lines changed: 1 addition & 5 deletions b/‎src/testRunner/unittests/tscWatch/helpers.ts
Copy file name to clipboard
+1-5Lines changed: 1 addition & 5 deletions
diff --git a/‎src/testRunner/unittests/tscWatch/watchEnvironment.ts
Copy file name to clipboard
+136Lines changed: 136 additions & 0 deletions b/‎src/testRunner/unittests/tscWatch/watchEnvironment.ts
Copy file name to clipboard
+136Lines changed: 136 additions & 0 deletions
@@ -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 }
             ),
 
@@ -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",
 
@@ -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
             });
         }
 
@@ -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);
     }
 }
@@ -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),
+                    },
+                ]
+            });
+        });
     });
 }
Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,7 @@ namespace ts.tscWatch {`
`20`	`20`	`scenario: "forceConsistentCasingInFileNames",`
`21`	`21`	`subScenario,`
`22`	`22`	`commandLineArgs: ["--w", "--p", tsconfig.path],`
`23`		`- sys: () => createWatchedSystem([loggerFile, anotherFile, tsconfig, libFile, tsconfig]),`
	`23`	`+ sys: () => createWatchedSystem([loggerFile, anotherFile, tsconfig, libFile]),`
`24`	`24`	`changes`
`25`	`25`	`});`
`26`	`26`	`}`
Original file line number	Diff line number	Diff line change
`@@ -7,10 +7,6 @@ namespace ts.tscWatch {`
`7`	`7`	`export import libFile = TestFSWithWatch.libFile;`
`8`	`8`	`export import createWatchedSystem = TestFSWithWatch.createWatchedSystem;`
`9`	`9`	`export import checkArray = TestFSWithWatch.checkArray;`
`10`		`- export import checkWatchedFiles = TestFSWithWatch.checkWatchedFiles;`
`11`		`- export import checkWatchedFilesDetailed = TestFSWithWatch.checkWatchedFilesDetailed;`
`12`		`- export import checkWatchedDirectories = TestFSWithWatch.checkWatchedDirectories;`
`13`		`- export import checkWatchedDirectoriesDetailed = TestFSWithWatch.checkWatchedDirectoriesDetailed;`
`14`	`10`	`export import checkOutputContains = TestFSWithWatch.checkOutputContains;`
`15`	`11`	`export import checkOutputDoesNotContain = TestFSWithWatch.checkOutputDoesNotContain;`
`16`	`12`
`@@ -436,7 +432,7 @@ namespace ts.tscWatch {`
`436`	`432`	`return sys;`
`437`	`433`	`}`
`438`	`434`
`439`		`- export function createSystemWithSolutionBuild(solutionRoots: readonly string[], files: readonly TestFSWithWatch.FileOrFolderOrSymLink[], params?: TestFSWithWatch.TestServerHostCreationParameters) {`
	`435`	`+ export function createSystemWithSolutionBuild(solutionRoots: readonly string[], files: TestFSWithWatch.FileOrFolderOrSymLinkMap \| readonly TestFSWithWatch.FileOrFolderOrSymLink[], params?: TestFSWithWatch.TestServerHostCreationParameters) {`
`440`	`436`	`return solutionBuildWithBaseline(createWatchedSystem(files, params), solutionRoots);`
`441`	`437`	`}`
`442`	`438`	`}`