Fix issues with global typings cache and what gets watches (#59869)

Author: sheetalkamat

src/compiler/checker.ts

@@ -52732,6 +52732,7 @@ function createBasicNodeBuilderModuleSpecifierResolutionHost(host: TypeCheckerHo
         readFile: host.readFile ? (fileName => host.readFile!(fileName)) : undefined,
         getDefaultResolutionModeForFile: file => host.getDefaultResolutionModeForFile(file),
         getModeForResolutionAtIndex: (file, index) => host.getModeForResolutionAtIndex(file, index),
+        getGlobalTypingsCacheLocation: maybeBind(host, host.getGlobalTypingsCacheLocation),
     };
 }
 

src/compiler/moduleNameResolver.ts

@@ -74,6 +74,7 @@ import {
     ModuleResolutionKind,
     moduleResolutionOptionDeclarations,
     moduleResolutionSupportsPackageJsonExportsAndImports,
+    ModuleSpecifierResolutionHost,
     noop,
     normalizePath,
     normalizeSlashes,
@@ -788,7 +789,7 @@ export function resolvePackageNameToPackageJson(
 ): PackageJsonInfo | undefined {
     const moduleResolutionState = getTemporaryModuleResolutionState(cache?.getPackageJsonInfoCache(), host, options);
 
-    return forEachAncestorDirectory(containingDirectory, ancestorDirectory => {
+    return forEachAncestorDirectoryStoppingAtGlobalCache(host, containingDirectory, ancestorDirectory => {
         if (getBaseFileName(ancestorDirectory) !== "node_modules") {
             const nodeModulesFolder = combinePaths(ancestorDirectory, "node_modules");
             const candidate = combinePaths(nodeModulesFolder, packageName);
@@ -2383,7 +2384,8 @@ export interface PackageJsonInfoContents {
  * @internal
  */
 export function getPackageScopeForPath(directory: string, state: ModuleResolutionState): PackageJsonInfo | undefined {
-    return forEachAncestorDirectory(
+    return forEachAncestorDirectoryStoppingAtGlobalCache(
+        state.host,
         directory,
         dir => getPackageJsonInfo(dir, /*onlyRecordFailures*/ false, state),
     );
@@ -3003,18 +3005,41 @@ function loadModuleFromNearestNodeModulesDirectoryWorker(extensions: Extensions,
     }
 
     function lookup(extensions: Extensions) {
-        return forEachAncestorDirectory(normalizeSlashes(directory), ancestorDirectory => {
-            if (getBaseFileName(ancestorDirectory) !== "node_modules") {
-                const resolutionFromCache = tryFindNonRelativeModuleNameInCache(cache, moduleName, mode, ancestorDirectory, redirectedReference, state);
-                if (resolutionFromCache) {
-                    return resolutionFromCache;
+        return forEachAncestorDirectoryStoppingAtGlobalCache(
+            state.host,
+            normalizeSlashes(directory),
+            ancestorDirectory => {
+                // Dont go past global cache location
+                if (getBaseFileName(ancestorDirectory) !== "node_modules") {
+                    const resolutionFromCache = tryFindNonRelativeModuleNameInCache(cache, moduleName, mode, ancestorDirectory, redirectedReference, state);
+                    if (resolutionFromCache) {
+                        return resolutionFromCache;
+                    }
+                    return toSearchResult(loadModuleFromImmediateNodeModulesDirectory(extensions, moduleName, ancestorDirectory, state, typesScopeOnly, cache, redirectedReference));
                 }
-                return toSearchResult(loadModuleFromImmediateNodeModulesDirectory(extensions, moduleName, ancestorDirectory, state, typesScopeOnly, cache, redirectedReference));
-            }
-        });
+            },
+        );
     }
 }
 
+/**
+ * Calls `callback` on `directory` and every ancestor directory it has, returning the first defined result.
+ * Stops at global cache location
+ * @internal
+ */
+export function forEachAncestorDirectoryStoppingAtGlobalCache<T, P extends string>(
+    host: ModuleResolutionHost | ModuleSpecifierResolutionHost,
+    directory: P,
+    callback: (directory: P) => T | undefined,
+): T | undefined {
+    const globalCache = host?.getGlobalTypingsCacheLocation?.();
+    return forEachAncestorDirectory(directory, ancestorDirectory => {
+        const result = callback(ancestorDirectory as P);
+        if (result !== undefined) return result;
+        if (ancestorDirectory === globalCache) return false;
+    }) || undefined;
+}
+
 function loadModuleFromImmediateNodeModulesDirectory(extensions: Extensions, moduleName: string, directory: string, state: ModuleResolutionState, typesScopeOnly: boolean, cache: ModuleResolutionCache | undefined, redirectedReference: ResolvedProjectReference | undefined): Resolved | undefined {
     const nodeModulesFolder = combinePaths(directory, "node_modules");
     const nodeModulesFolderExists = directoryProbablyExists(nodeModulesFolder, state.host);
@@ -3258,14 +3283,18 @@ export function classicNameResolver(moduleName: string, containingFile: string,
 
         if (!isExternalModuleNameRelative(moduleName)) {
             // Climb up parent directories looking for a module.
-            const resolved = forEachAncestorDirectory(containingDirectory, directory => {
-                const resolutionFromCache = tryFindNonRelativeModuleNameInCache(cache, moduleName, /*mode*/ undefined, directory, redirectedReference, state);
-                if (resolutionFromCache) {
-                    return resolutionFromCache;
-                }
-                const searchName = normalizePath(combinePaths(directory, moduleName));
-                return toSearchResult(loadModuleFromFileNoPackageId(extensions, searchName, /*onlyRecordFailures*/ false, state));
-            });
+            const resolved = forEachAncestorDirectoryStoppingAtGlobalCache(
+                state.host,
+                containingDirectory,
+                directory => {
+                    const resolutionFromCache = tryFindNonRelativeModuleNameInCache(cache, moduleName, /*mode*/ undefined, directory, redirectedReference, state);
+                    if (resolutionFromCache) {
+                        return resolutionFromCache;
+                    }
+                    const searchName = normalizePath(combinePaths(directory, moduleName));
+                    return toSearchResult(loadModuleFromFileNoPackageId(extensions, searchName, /*onlyRecordFailures*/ false, state));
+                },
+            );
             if (resolved) return resolved;
             if (extensions & (Extensions.TypeScript | Extensions.Declaration)) {
                 // If we didn't find the file normally, look it up in @types.

src/compiler/moduleSpecifiers.ts

@@ -33,7 +33,7 @@ import {
     flatMap,
     flatten,
     forEach,
-    forEachAncestorDirectory,
+    forEachAncestorDirectoryStoppingAtGlobalCache,
     FutureSourceFile,
     getBaseFileName,
     GetCanonicalFileName,
@@ -701,9 +701,14 @@ function getNearestAncestorDirectoryWithPackageJson(host: ModuleSpecifierResolut
     if (host.getNearestAncestorDirectoryWithPackageJson) {
         return host.getNearestAncestorDirectoryWithPackageJson(fileName);
     }
-    return forEachAncestorDirectory(fileName, directory => {
-        return host.fileExists(combinePaths(directory, "package.json")) ? directory : undefined;
-    });
+    return forEachAncestorDirectoryStoppingAtGlobalCache(
+        host,
+        fileName,
+        directory =>
+            host.fileExists(combinePaths(directory, "package.json")) ?
+                directory :
+                undefined,
+    );
 }
 
 /** @internal */
@@ -732,29 +737,33 @@ export function forEachFileNameOfModule<T>(
 
     const symlinkedDirectories = host.getSymlinkCache?.().getSymlinkedDirectoriesByRealpath();
     const fullImportedFileName = getNormalizedAbsolutePath(importedFileName, cwd);
-    const result = symlinkedDirectories && forEachAncestorDirectory(getDirectoryPath(fullImportedFileName), realPathDirectory => {
-        const symlinkDirectories = symlinkedDirectories.get(ensureTrailingDirectorySeparator(toPath(realPathDirectory, cwd, getCanonicalFileName)));
-        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 (!startsWithDirectory(target, realPathDirectory, getCanonicalFileName)) {
-                return;
+    const result = symlinkedDirectories && forEachAncestorDirectoryStoppingAtGlobalCache(
+        host,
+        getDirectoryPath(fullImportedFileName),
+        realPathDirectory => {
+            const symlinkDirectories = symlinkedDirectories.get(ensureTrailingDirectorySeparator(toPath(realPathDirectory, cwd, getCanonicalFileName)));
+            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
             }
 
-            const relative = getRelativePathFromDirectory(realPathDirectory, target, getCanonicalFileName);
-            for (const symlinkDirectory of symlinkDirectories) {
-                const option = resolvePath(symlinkDirectory, relative);
-                const result = cb(option, target === referenceRedirect);
-                shouldFilterIgnoredPaths = true; // We found a non-ignored path in symlinks, so we can reject ignored-path realpaths
-                if (result) return result;
-            }
-        });
-    });
+            return forEach(targets, target => {
+                if (!startsWithDirectory(target, realPathDirectory, getCanonicalFileName)) {
+                    return;
+                }
+
+                const relative = getRelativePathFromDirectory(realPathDirectory, target, getCanonicalFileName);
+                for (const symlinkDirectory of symlinkDirectories) {
+                    const option = resolvePath(symlinkDirectory, relative);
+                    const result = cb(option, target === referenceRedirect);
+                    shouldFilterIgnoredPaths = true; // We found a non-ignored path in symlinks, so we can reject ignored-path realpaths
+                    if (result) return result;
+                }
+            });
+        },
+    );
     return result || (preferSymlinks
         ? forEach(targets, p => shouldFilterIgnoredPaths && containsIgnoredPath(p) ? undefined : cb(p, p === referenceRedirect))
         : undefined);

src/compiler/program.ts

@@ -2016,6 +2016,7 @@ export function createProgram(rootNamesOrOptions: readonly string[] | CreateProg
         getFileIncludeReasons: () => fileReasons,
         structureIsReused,
         writeFile,
+        getGlobalTypingsCacheLocation: maybeBind(host, host.getGlobalTypingsCacheLocation),
     };
 
     onProgramCreateComplete();
@@ -2741,6 +2742,7 @@ export function createProgram(rootNamesOrOptions: readonly string[] | CreateProg
             createHash: maybeBind(host, host.createHash),
             getModuleResolutionCache: () => program.getModuleResolutionCache(),
             trace: maybeBind(host, host.trace),
+            getGlobalTypingsCacheLocation: program.getGlobalTypingsCacheLocation,
         };
     }
 

src/compiler/resolutionCache.ts

@@ -193,7 +193,6 @@ export interface ResolutionCacheHost extends MinimalResolutionCacheHost {
     scheduleInvalidateResolutionsOfFailedLookupLocations(): void;
     getCachedDirectoryStructureHost(): CachedDirectoryStructureHost | undefined;
     projectName?: string;
-    getGlobalCache?(): string | undefined;
     globalCacheResolutionModuleName?(externalModuleName: string): string;
     writeLog(s: string): void;
     getCurrentProgram(): Program | undefined;
@@ -313,6 +312,11 @@ export function canWatchDirectoryOrFile(pathComponents: Readonly<PathPathCompone
     return length > perceivedOsRootLength + 1;
 }
 
+/** @internal */
+export function canWatchDirectoryOrFilePath(path: Path) {
+    return canWatchDirectoryOrFile(getPathComponents(path));
+}
+
 /** @internal */
 export function canWatchAtTypes(atTypes: Path) {
     // Otherwise can watch directory only if we can watch the parent directory of node_modules/@types
@@ -328,7 +332,7 @@ function isInDirectoryPath(dirComponents: Readonly<PathPathComponents>, fileOrDi
 }
 
 function canWatchAffectedPackageJsonOrNodeModulesOfAtTypes(fileOrDirPath: Path) {
-    return canWatchDirectoryOrFile(getPathComponents(fileOrDirPath));
+    return canWatchDirectoryOrFilePath(fileOrDirPath);
 }
 
 /** @internal */
@@ -343,6 +347,7 @@ export function getDirectoryToWatchFailedLookupLocation(
     rootDir: string,
     rootPath: Path,
     rootPathComponents: Readonly<PathPathComponents>,
+    isRootWatchable: boolean,
     getCurrentDirectory: () => string | undefined,
     preferNonRecursiveWatch: boolean | undefined,
 ): DirectoryOfFailedLookupWatch | undefined {
@@ -356,7 +361,7 @@ export function getDirectoryToWatchFailedLookupLocation(
     const nodeModulesIndex = failedLookupPathComponents.indexOf("node_modules" as Path);
     if (nodeModulesIndex !== -1 && nodeModulesIndex + 1 <= perceivedOsRootLength + 1) return undefined; // node_modules not at position where it can be watched
     const lastNodeModulesIndex = failedLookupPathComponents.lastIndexOf("node_modules" as Path);
-    if (isInDirectoryPath(rootPathComponents, failedLookupPathComponents)) {
+    if (isRootWatchable && isInDirectoryPath(rootPathComponents, failedLookupPathComponents)) {
         if (failedLookupPathComponents.length > rootPathComponents.length + 1) {
             // Instead of watching root, watch directory in root to avoid watching excluded directories not needed for module resolution
             return getDirectoryOfFailedLookupWatch(
@@ -461,12 +466,13 @@ export function getDirectoryToWatchFailedLookupLocationFromTypeRoot(
     typeRootPath: Path,
     rootPath: Path,
     rootPathComponents: Readonly<PathPathComponents>,
+    isRootWatchable: boolean,
     getCurrentDirectory: () => string | undefined,
     preferNonRecursiveWatch: boolean | undefined,
     filterCustomPath: (path: Path) => boolean, // Return true if this path can be used
 ): Path | undefined {
     const typeRootPathComponents = getPathComponents(typeRootPath);
-    if (isInDirectoryPath(rootPathComponents, typeRootPathComponents)) {
+    if (isRootWatchable && isInDirectoryPath(rootPathComponents, typeRootPathComponents)) {
         // Because this is called when we are watching typeRoot, we dont need additional check whether typeRoot is not say c:/users/node_modules/@types when root is c:/
         return rootPath;
     }
@@ -531,12 +537,12 @@ function resolveModuleNameUsingGlobalCache(
     const host = getModuleResolutionHost(resolutionHost);
     const primaryResult = ts_resolveModuleName(moduleName, containingFile, compilerOptions, host, moduleResolutionCache, redirectedReference, mode);
     // return result immediately only if global cache support is not enabled or if it is .ts, .tsx or .d.ts
-    if (!resolutionHost.getGlobalCache) {
+    if (!resolutionHost.getGlobalTypingsCacheLocation) {
         return primaryResult;
     }
 
     // otherwise try to load typings from @types
-    const globalCache = resolutionHost.getGlobalCache();
+    const globalCache = resolutionHost.getGlobalTypingsCacheLocation();
     if (globalCache !== undefined && !isExternalModuleNameRelative(moduleName) && !(primaryResult.resolvedModule && extensionIsTS(primaryResult.resolvedModule.extension))) {
         // create different collection of failed lookup locations for second pass
         // if it will fail and we've already found something during the first pass - we don't want to pollute its results
@@ -620,6 +626,7 @@ export function createResolutionCache(resolutionHost: ResolutionCacheHost, rootD
     const rootDir = getRootDirectoryOfResolutionCache(rootDirForResolution, getCurrentDirectory);
     const rootPath = resolutionHost.toPath(rootDir);
     const rootPathComponents = getPathComponents(rootPath);
+    const isRootWatchable = canWatchDirectoryOrFile(rootPathComponents);
 
     const isSymlinkCache = new Map<Path, boolean>();
     const packageDirWatchers = new Map<Path, PackageDirWatcher>(); // Watching packageDir if symlink otherwise watching dirPath
@@ -1118,6 +1125,7 @@ export function createResolutionCache(resolutionHost: ResolutionCacheHost, rootD
             rootDir,
             rootPath,
             rootPathComponents,
+            isRootWatchable,
             getCurrentDirectory,
             resolutionHost.preferNonRecursiveWatch,
         );
@@ -1328,6 +1336,7 @@ export function createResolutionCache(resolutionHost: ResolutionCacheHost, rootD
             rootDir,
             rootPath,
             rootPathComponents,
+            isRootWatchable,
             getCurrentDirectory,
             resolutionHost.preferNonRecursiveWatch,
         );
@@ -1629,6 +1638,7 @@ export function createResolutionCache(resolutionHost: ResolutionCacheHost, rootD
                     resolutionHost.toPath(typeRoot),
                     rootPath,
                     rootPathComponents,
+                    isRootWatchable,
                     getCurrentDirectory,
                     resolutionHost.preferNonRecursiveWatch,
                     dirPath => directoryWatchesOfFailedLookups.has(dirPath) || dirPathToSymlinkPackageRefCount.has(dirPath),

src/compiler/types.ts

@@ -7897,6 +7897,7 @@ export interface ModuleResolutionHost {
     getCurrentDirectory?(): string;
     getDirectories?(path: string): string[];
     useCaseSensitiveFileNames?: boolean | (() => boolean) | undefined;
+    /** @internal */ getGlobalTypingsCacheLocation?(): string | undefined;
 }
 
 /**

src/harness/incrementalUtils.ts

@@ -499,14 +499,32 @@ function verifyProgram(service: ts.server.ProjectService, project: ts.server.Pro
         if (fileSize > ts.server.maxFileSize) return "";
         return text !== undefined ? text || undefined : readFile(fileName);
     };
+    const getSourceFile = compilerHost.getSourceFile;
+    compilerHost.getSourceFile = (fileName, languageVersionOrOptions, onError, shouldCreateNewSourceFile) => {
+        const projectScriptKind = project.getScriptKind(fileName);
+        const scriptKind = ts.ensureScriptKind(fileName, /*scriptKind*/ undefined);
+        if (scriptKind === projectScriptKind) return getSourceFile(fileName, languageVersionOrOptions, onError, shouldCreateNewSourceFile);
+
+        let text: string | undefined;
+        try {
+            text = compilerHost.readFile(fileName);
+        }
+        catch (e) {
+            onError?.(e.message);
+            text = "";
+        }
+        return text !== undefined ?
+            ts.createSourceFile(fileName, text, languageVersionOrOptions, /*setParentNodes*/ undefined, projectScriptKind) :
+            undefined;
+    };
     const resolutionHostCacheHost: ts.ResolutionCacheHost = {
         ...compilerHost,
 
         getCompilerHost: () => compilerHost,
         toPath: project.toPath.bind(project),
         getCompilationSettings: project.getCompilationSettings.bind(project),
         projectName: project.projectName,
-        getGlobalCache: project.getGlobalCache.bind(project),
+        getGlobalTypingsCacheLocation: project.getGlobalTypingsCacheLocation.bind(project),
         globalCacheResolutionModuleName: project.globalCacheResolutionModuleName.bind(project),
         fileIsOpen: project.fileIsOpen.bind(project),
         getCurrentProgram: () => project.getCurrentProgram(),
@@ -540,6 +558,7 @@ function verifyProgram(service: ts.server.ProjectService, project: ts.server.Pro
                     moduleResolutionCache,
                 ),
         );
+    compilerHost.getGlobalTypingsCacheLocation = resolutionHostCacheHost.getGlobalTypingsCacheLocation;
     verifyProgramStructure(
         ts.createProgram({
             rootNames: project.getScriptFileNames(),