symlink fixes

realPathToSymlinks

don't add paths more than once

realPathToSymlinks ternary + path over realPath

flip in the ternary

fix boolean

Author: Jeremy Dorne

src/compiler/moduleSpecifiers.ts

@@ -213,7 +213,7 @@ namespace ts.moduleSpecifiers {
     }
 
     export function forEachFileNameOfModule<T>(
-        importingFileName: string,
+        _importingFileName: string,
         importedFileName: string,
         host: ModuleSpecifierResolutionHost,
         preferSymlinks: boolean,
@@ -233,27 +233,23 @@ 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 realPathToSymlinks = links.getRealPathToSymlinks();
+        const result = realPathToSymlinks && forEachEntry(realPathToSymlinks, (paths, resolved) => {
             return forEach(targets, target => {
-                if (!containsPath(resolved.real, target, !useCaseSensitiveFileNames)) {
+                if (!containsPath(resolved, target, !useCaseSensitiveFileNames)) {
                     return;
                 }
 
-                const relative = getRelativePathFromDirectory(resolved.real, target, getCanonicalFileName);
-                const option = resolvePath(path, relative);
-                if (!host.fileExists || host.fileExists(option)) {
+                const relative = getRelativePathFromDirectory(resolved, target, getCanonicalFileName);
+                for (const path of paths) {
+                    const option = resolvePath(path, relative);
                     const result = cb(option, target === referenceRedirect);
                     if (result) return result;
                 }
             });
         });
+
         return result ||
             (preferSymlinks ? forEach(targets, p => cb(p, p === referenceRedirect)) : undefined);
     }

src/compiler/utilities.ts

@@ -6050,18 +6050,31 @@ namespace ts {
     export interface SymlinkCache {
         getSymlinkedDirectories(): ReadonlyESMap<Path, SymlinkedDirectory | false> | undefined;
         getSymlinkedFiles(): ReadonlyESMap<Path, string> | undefined;
+        getRealPathToSymlinks(): ReadonlyESMap<string, Path[]> | undefined;
         setSymlinkedDirectory(path: Path, directory: SymlinkedDirectory | false): void;
         setSymlinkedFile(path: Path, real: string): void;
     }
 
     export function createSymlinkCache(): SymlinkCache {
         let symlinkedDirectories: ESMap<Path, SymlinkedDirectory | false> | undefined;
         let symlinkedFiles: ESMap<Path, string> | undefined;
+        let realPathToSymlinks: ESMap<string, Path[]>;
         return {
             getSymlinkedFiles: () => symlinkedFiles,
             getSymlinkedDirectories: () => symlinkedDirectories,
+            getRealPathToSymlinks: () => realPathToSymlinks,
             setSymlinkedFile: (path, real) => (symlinkedFiles || (symlinkedFiles = new Map())).set(path, real),
-            setSymlinkedDirectory: (path, directory) => (symlinkedDirectories || (symlinkedDirectories = new Map())).set(path, directory),
+            setSymlinkedDirectory: (path, directory) => {
+                // Don't add false directories or directories that have already been added
+                if (directory !== false && symlinkedDirectories?.has(path) !== true) {
+                    if (realPathToSymlinks === undefined) {
+                        realPathToSymlinks = new Map();
+                    }
+                    realPathToSymlinks.has(directory.real) ? realPathToSymlinks.get(directory.real)?.push(path) : realPathToSymlinks.set(directory.real, [path]);
+                }
+
+                (symlinkedDirectories || (symlinkedDirectories = new Map())).set(path, directory);
+            },
         };
     }