Optimize symlink module specifier generation

Author: andrewbranch

src/compiler/moduleSpecifiers.ts

@@ -286,7 +286,8 @@ namespace ts.moduleSpecifiers {
         const getCanonicalFileName = hostGetCanonicalFileName(host);
         const cwd = host.getCurrentDirectory();
         const referenceRedirect = host.isSourceOfProjectReferenceRedirect(importedFileName) ? host.getProjectReferenceRedirect(importedFileName) : undefined;
-        const redirects = host.redirectTargetsMap.get(toPath(importedFileName, cwd, getCanonicalFileName)) || emptyArray;
+        const importedPath = toPath(importedFileName, cwd, getCanonicalFileName);
+        const redirects = host.redirectTargetsMap.get(importedPath) || emptyArray;
         const importedFileNames = [...(referenceRedirect ? [referenceRedirect] : emptyArray), importedFileName, ...redirects];
         const targets = importedFileNames.map(f => getNormalizedAbsolutePath(f, cwd));
         if (!preferSymlinks) {
@@ -299,22 +300,24 @@ namespace ts.moduleSpecifiers {
             ? host.getSymlinkCache()
             : discoverProbableSymlinks(host.getSourceFiles(), getCanonicalFileName, cwd);
 
-        const symlinkedDirectories = links.getSymlinkedDirectories();
-        const useCaseSensitiveFileNames = !host.useCaseSensitiveFileNames || host.useCaseSensitiveFileNames();
-        const result = symlinkedDirectories && forEachEntry(symlinkedDirectories, (resolved, path) => {
-            if (resolved === false) return undefined;
-            if (startsWithDirectory(importingFileName, resolved.realPath, getCanonicalFileName)) {
-                return undefined; // Don't want to a package to globally import from itself
+        const symlinkedDirectories = links.getSymlinkedDirectoriesByRealpath();
+        const result = symlinkedDirectories && forEachAncestorDirectory(getDirectoryPath(importedPath), realPathDirectory => {
+            const symlinkDirectories = symlinkedDirectories.get(realPathDirectory);
+            if (!symlinkDirectories) return undefined; // Continue to ancestor directory
+
+            // Don't want to a package to globally import from itself (importNameCodeFix_symlink_own_package.ts)
+            if (startsWithDirectory(importingFileName, realPathDirectory, getCanonicalFileName)) {
+                return false; // Stop search, each ancestor directory will also hit this condition
             }
 
             return forEach(targets, target => {
-                if (!containsPath(resolved.real, target, !useCaseSensitiveFileNames)) {
+                if (!startsWithDirectory(target, realPathDirectory, getCanonicalFileName)) {
                     return;
                 }
 
-                const relative = getRelativePathFromDirectory(resolved.real, target, getCanonicalFileName);
-                const option = resolvePath(path, relative);
-                if (!host.fileExists || host.fileExists(option)) {
+                const relative = getRelativePathFromDirectory(realPathDirectory, target, getCanonicalFileName);
+                for (const symlinkDirectory of symlinkDirectories) {
+                    const option = resolvePath(symlinkDirectory, relative);
                     const result = cb(option, target === referenceRedirect);
                     if (result) return result;
                 }

src/compiler/path.ts

@@ -762,7 +762,7 @@ namespace ts {
      * Determines whether `fileName` starts with the specified `directoryName` using the provided path canonicalization callback.
      * Comparison is case-sensitive between the canonical paths.
      *
-     * @deprecated Use `containsPath` if possible.
+     * Use `containsPath` if file names are not already reduced and absolute.
      */
     export function startsWithDirectory(fileName: string, directoryName: string, getCanonicalFileName: GetCanonicalFileName): boolean {
         const canonicalFileName = getCanonicalFileName(fileName);

src/compiler/utilities.ts

@@ -6079,25 +6079,34 @@ namespace ts {
     }
 
     export interface SymlinkCache {
+        /** Gets a map from symlink to realpath */
         getSymlinkedDirectories(): ReadonlyESMap<Path, SymlinkedDirectory | false> | undefined;
+        /** Gets a map from realpath to symlinks */
+        getSymlinkedDirectoriesByRealpath(): MultiMap<Path, Path> | undefined;
+        /** Gets a map from symlink to realpath */
         getSymlinkedFiles(): ReadonlyESMap<Path, string> | undefined;
-        setSymlinkedDirectory(path: Path, directory: SymlinkedDirectory | false): void;
-        setSymlinkedFile(path: Path, real: string): void;
+        setSymlinkedDirectory(symlinkPath: Path, directory: SymlinkedDirectory | false): void;
+        setSymlinkedFile(symlinkPath: Path, real: string): void;
     }
 
     export function createSymlinkCache(): SymlinkCache {
         let symlinkedDirectories: ESMap<Path, SymlinkedDirectory | false> | undefined;
+        let symlinkedDirectoriesByRealpath: MultiMap<Path, Path> | undefined;
         let symlinkedFiles: ESMap<Path, string> | undefined;
         return {
             getSymlinkedFiles: () => symlinkedFiles,
             getSymlinkedDirectories: () => symlinkedDirectories,
+            getSymlinkedDirectoriesByRealpath: () => symlinkedDirectoriesByRealpath,
             setSymlinkedFile: (path, real) => (symlinkedFiles || (symlinkedFiles = new Map())).set(path, real),
-            setSymlinkedDirectory: (path, directory) => {
+            setSymlinkedDirectory: (symlinkPath, directory) => {
                 // Large, interconnected dependency graphs in pnpm will have a huge number of symlinks
                 // where both the realpath and the symlink path are inside node_modules/.pnpm. Since
                 // this path is never a candidate for a module specifier, we can ignore it entirely.
-                if (!containsIgnoredPath(path)) {
-                    (symlinkedDirectories || (symlinkedDirectories = new Map())).set(path, directory);
+                if (!containsIgnoredPath(symlinkPath)) {
+                    if (directory !== false && !symlinkedDirectories?.has(symlinkPath)) {
+                        (symlinkedDirectoriesByRealpath ||= createMultiMap()).add(directory.realPath, symlinkPath)
+                    }
+                    (symlinkedDirectories || (symlinkedDirectories = new Map())).set(symlinkPath, directory);
                 }
             }
         };