Do not cache directory structure for symlinked directories (#42868)

Fixes #42839

Author: sheetalkamat

src/compiler/watchUtilities.ts

@@ -44,7 +44,7 @@ namespace ts {
             return undefined;
         }
 
-        const cachedReadDirectoryResult = new Map<string, MutableFileSystemEntries>();
+        const cachedReadDirectoryResult = new Map<string, MutableFileSystemEntries | false>();
         const getCanonicalFileName = createGetCanonicalFileName(useCaseSensitiveFileNames);
         return {
             useCaseSensitiveFileNames,
@@ -65,11 +65,11 @@ namespace ts {
             return ts.toPath(fileName, currentDirectory, getCanonicalFileName);
         }
 
-        function getCachedFileSystemEntries(rootDirPath: Path): MutableFileSystemEntries | undefined {
+        function getCachedFileSystemEntries(rootDirPath: Path) {
             return cachedReadDirectoryResult.get(ensureTrailingDirectorySeparator(rootDirPath));
         }
 
-        function getCachedFileSystemEntriesForBaseDir(path: Path): MutableFileSystemEntries | undefined {
+        function getCachedFileSystemEntriesForBaseDir(path: Path) {
             return getCachedFileSystemEntries(getDirectoryPath(path));
         }
 
@@ -78,21 +78,32 @@ namespace ts {
         }
 
         function createCachedFileSystemEntries(rootDir: string, rootDirPath: Path) {
-            const resultFromHost: MutableFileSystemEntries = {
-                files: map(host.readDirectory!(rootDir, /*extensions*/ undefined, /*exclude*/ undefined, /*include*/["*.*"]), getBaseNameOfFileName) || [],
-                directories: host.getDirectories!(rootDir) || []
-            };
+            if (!host.realpath || ensureTrailingDirectorySeparator(toPath(host.realpath(rootDir))) === rootDirPath) {
+                const resultFromHost: MutableFileSystemEntries = {
+                    files: map(host.readDirectory!(rootDir, /*extensions*/ undefined, /*exclude*/ undefined, /*include*/["*.*"]), getBaseNameOfFileName) || [],
+                    directories: host.getDirectories!(rootDir) || []
+                };
+
+                cachedReadDirectoryResult.set(ensureTrailingDirectorySeparator(rootDirPath), resultFromHost);
+                return resultFromHost;
+            }
 
-            cachedReadDirectoryResult.set(ensureTrailingDirectorySeparator(rootDirPath), resultFromHost);
-            return resultFromHost;
+            // If the directory is symlink do not cache the result
+            if (host.directoryExists?.(rootDir)) {
+                cachedReadDirectoryResult.set(rootDirPath, false);
+                return false;
+            }
+
+            // Non existing directory
+            return undefined;
         }
 
         /**
          * If the readDirectory result was already cached, it returns that
          * Otherwise gets result from host and caches it.
          * The host request is done under try catch block to avoid caching incorrect result
          */
-        function tryReadDirectory(rootDir: string, rootDirPath: Path): MutableFileSystemEntries | undefined {
+        function tryReadDirectory(rootDir: string, rootDirPath: Path) {
             rootDirPath = ensureTrailingDirectorySeparator(rootDirPath);
             const cachedResult = getCachedFileSystemEntries(rootDirPath);
             if (cachedResult) {
@@ -170,18 +181,32 @@ namespace ts {
 
         function readDirectory(rootDir: string, extensions?: readonly string[], excludes?: readonly string[], includes?: readonly string[], depth?: number): string[] {
             const rootDirPath = toPath(rootDir);
-            const result = tryReadDirectory(rootDir, rootDirPath);
-            if (result) {
+            const rootResult = tryReadDirectory(rootDir, rootDirPath);
+            let rootSymLinkResult: FileSystemEntries | undefined;
+            if (rootResult !== undefined) {
                 return matchFiles(rootDir, extensions, excludes, includes, useCaseSensitiveFileNames, currentDirectory, depth, getFileSystemEntries, realpath);
             }
             return host.readDirectory!(rootDir, extensions, excludes, includes, depth);
 
             function getFileSystemEntries(dir: string): FileSystemEntries {
                 const path = toPath(dir);
                 if (path === rootDirPath) {
-                    return result!;
+                    return rootResult || getFileSystemEntriesFromHost(dir, path);
                 }
-                return tryReadDirectory(dir, path) || emptyFileSystemEntries;
+                const result = tryReadDirectory(dir, path);
+                return result !== undefined ?
+                    result || getFileSystemEntriesFromHost(dir, path) :
+                    emptyFileSystemEntries;
+            }
+
+            function getFileSystemEntriesFromHost(dir: string, path: Path): FileSystemEntries {
+                if (rootSymLinkResult && path === rootDirPath) return rootSymLinkResult;
+                const result: FileSystemEntries = {
+                    files: map(host.readDirectory!(dir, /*extensions*/ undefined, /*exclude*/ undefined, /*include*/["*.*"]), getBaseNameOfFileName) || emptyArray,
+                    directories: host.getDirectories!(dir) || emptyArray
+                };
+                if (path === rootDirPath) rootSymLinkResult = result;
+                return result;
             }
         }
 
@@ -191,7 +216,7 @@ namespace ts {
 
         function addOrDeleteFileOrDirectory(fileOrDirectory: string, fileOrDirectoryPath: Path) {
             const existingResult = getCachedFileSystemEntries(fileOrDirectoryPath);
-            if (existingResult) {
+            if (existingResult !== undefined) {
                 // Just clear the cache for now
                 // For now just clear the cache, since this could mean that multiple level entries might need to be re-evaluated
                 clearCache();

src/harness/virtualFileSystemWithWatch.ts

@@ -1001,14 +1001,18 @@ interface Array<T> { length: number; [n: number]: T; }`
 
             // base folder has to be present
             const base = getDirectoryPath(file.path);
-            const folder = this.fs.get(base) as FsFolder;
-            Debug.assert(isFsFolder(folder));
+            const folder = Debug.checkDefined(this.getRealFolder(base));
 
-            if (!this.fs.has(file.path)) {
-                this.addFileOrFolderInFolder(folder, file);
+            if (folder.path === base) {
+                if (!this.fs.has(file.path)) {
+                    this.addFileOrFolderInFolder(folder, file);
+                }
+                else {
+                    this.modifyFile(path, content);
+                }
             }
             else {
-                this.modifyFile(path, content);
+                this.writeFile(this.realpath(path), content);
             }
         }
 

src/testRunner/unittests/tscWatch/programUpdates.ts

@@ -1696,5 +1696,43 @@ import { x } from "../b";`),
                 },
             ]
         });
+
+        verifyTscWatch({
+            scenario,
+            subScenario: "when creating new file in symlinked folder",
+            commandLineArgs: ["-w", "-p", ".", "--extendedDiagnostics"],
+            sys: () => {
+                const module1: File = {
+                    path: `${projectRoot}/client/folder1/module1.ts`,
+                    content: `export class Module1Class { }`
+                };
+                const module2: File = {
+                    path: `${projectRoot}/folder2/module2.ts`,
+                    content: `import * as M from "folder1/module1";`
+                };
+                const symlink: SymLink = {
+                    path: `${projectRoot}/client/linktofolder2`,
+                    symLink: `${projectRoot}/folder2`,
+                };
+                const config: File = {
+                    path: `${projectRoot}/tsconfig.json`,
+                    content: JSON.stringify({
+                        compilerOptions: {
+                            baseUrl: "client",
+                            paths: { "*": ["*"] },
+                        },
+                        include: ["client/**/*", "folder2"]
+                    })
+                };
+                return createWatchedSystem([module1, module2, symlink, config, libFile], { currentDirectory: projectRoot });
+            },
+            changes: [
+                {
+                    caption: "Add module3 to folder2",
+                    change: sys => sys.writeFile(`${projectRoot}/client/linktofolder2/module3.ts`, `import * as M from "folder1/module1";`),
+                    timeouts: checkSingleTimeoutQueueLengthAndRun,
+                },
+            ]
+        });
     });
 }

src/testRunner/unittests/tsserver/cachingFileSystemInformation.ts

@@ -713,5 +713,40 @@ namespace ts.projectSystem {
             checkProjectActualFiles(project, files.map(f => f.path));
             assert.deepEqual(project.getLanguageService().getSemanticDiagnostics(app.path).map(diag => diag.messageText), []);
         });
+
+        it("when creating new file in symlinked folder", () => {
+            const module1: File = {
+                path: `${tscWatch.projectRoot}/client/folder1/module1.ts`,
+                content: `export class Module1Class { }`
+            };
+            const module2: File = {
+                path: `${tscWatch.projectRoot}/folder2/module2.ts`,
+                content: `import * as M from "folder1/module1";`
+            };
+            const symlink: SymLink = {
+                path: `${tscWatch.projectRoot}/client/linktofolder2`,
+                symLink: `${tscWatch.projectRoot}/folder2`,
+            };
+            const config: File = {
+                path: `${tscWatch.projectRoot}/tsconfig.json`,
+                content: JSON.stringify({
+                    compilerOptions: {
+                        baseUrl: "client",
+                        paths: { "*": ["*"] },
+                    },
+                    include: ["client/**/*", "folder2"]
+                })
+            };
+            const host = createServerHost([module1, module2, symlink, config, libFile]);
+            const service = createProjectService(host);
+            service.openClientFile(`${symlink.path}/module2.ts`);
+            checkNumberOfProjects(service, { configuredProjects: 1 });
+            const project = Debug.checkDefined(service.configuredProjects.get(config.path));
+            checkProjectActualFiles(project, [module1.path, `${symlink.path}/module2.ts`, config.path, libFile.path]);
+            host.writeFile(`${symlink.path}/module3.ts`, `import * as M from "folder1/module1";`);
+            host.runQueuedTimeoutCallbacks();
+            checkNumberOfProjects(service, { configuredProjects: 1 });
+            checkProjectActualFiles(project, [module1.path, `${symlink.path}/module2.ts`, config.path, libFile.path, `${symlink.path}/module3.ts`]);
+        });
     });
 }