Make the module resolution cache apis for updating compiler options or clearing it

Author: sheetalkamat

src/compiler/moduleNameResolver.ts

@@ -444,6 +444,12 @@ namespace ts {
     export interface ModuleResolutionCache extends NonRelativeModuleNameResolutionCache {
         getOrCreateCacheForDirectory(directoryName: string, redirectedReference?: ResolvedProjectReference): Map<ResolvedModuleWithFailedLookupLocations>;
         /*@internal*/ directoryToModuleNameMap: CacheWithRedirects<ESMap<string, ResolvedModuleWithFailedLookupLocations>>;
+        clear(): void;
+        /**
+         *  Updates with the current compilerOptions the cache will operate with.
+         *  This updates the redirects map as well if needed so module resolutions are cached if they can across the projects
+         */
+        update(options: CompilerOptions): void;
     }
 
     /**
@@ -528,7 +534,31 @@ namespace ts {
         currentDirectory: string,
         getCanonicalFileName: GetCanonicalFileName): ModuleResolutionCache {
 
-        return { getOrCreateCacheForDirectory, getOrCreateCacheForModuleName, directoryToModuleNameMap, moduleNameToDirectoryMap };
+        return {
+            getOrCreateCacheForDirectory,
+            getOrCreateCacheForModuleName,
+            directoryToModuleNameMap,
+            moduleNameToDirectoryMap,
+            clear,
+            update,
+        };
+
+        function clear() {
+            directoryToModuleNameMap.clear();
+            moduleNameToDirectoryMap.clear();
+        }
+
+        function update(options: CompilerOptions) {
+            if (!options.configFile) return;
+            const ref: ResolvedProjectReference = {
+                sourceFile: options.configFile,
+                commandLine: { options } as ParsedCommandLine
+            };
+            directoryToModuleNameMap.setOwnMap(directoryToModuleNameMap.getOrCreateMapOfCacheRedirects(ref));
+            moduleNameToDirectoryMap.setOwnMap(moduleNameToDirectoryMap.getOrCreateMapOfCacheRedirects(ref));
+            directoryToModuleNameMap.setOwnOptions(options);
+            moduleNameToDirectoryMap.setOwnOptions(options);
+        }
 
         function getOrCreateCacheForDirectory(directoryName: string, redirectedReference?: ResolvedProjectReference) {
             const path = toPath(directoryName, currentDirectory, getCanonicalFileName);

src/compiler/resolutionCache.ts

@@ -284,8 +284,7 @@ namespace ts {
         }
 
         function clearPerDirectoryResolutions() {
-            perDirectoryResolvedModuleNames.clear();
-            nonRelativeModuleNameCache.clear();
+            moduleResolutionCache.clear();
             perDirectoryResolvedTypeReferenceDirectives.clear();
             nonRelativeExternalModuleResolutions.forEach(watchFailedLookupLocationOfNonRelativeModuleResolutions);
             nonRelativeExternalModuleResolutions.clear();

src/compiler/tsbuildPublic.ts

@@ -558,10 +558,7 @@ namespace ts {
         compilerHost.getSourceFile = cache.originalGetSourceFile;
         state.readFileWithCache = cache.originalReadFileWithCache;
         extendedConfigCache.clear();
-        if (moduleResolutionCache) {
-            moduleResolutionCache.directoryToModuleNameMap.clear();
-            moduleResolutionCache.moduleNameToDirectoryMap.clear();
-        }
+        moduleResolutionCache?.clear();
         state.cache = undefined;
     }
 
@@ -1321,20 +1318,14 @@ namespace ts {
             Debug.assert(moduleResolutionCache.moduleNameToDirectoryMap.redirectsMap.size === 0);
             moduleResolutionCache.directoryToModuleNameMap.redirectsMap.set(projPath, moduleResolutionCache.directoryToModuleNameMap.ownMap);
             moduleResolutionCache.moduleNameToDirectoryMap.redirectsMap.set(projPath, moduleResolutionCache.moduleNameToDirectoryMap.ownMap);
+            moduleResolutionCache.directoryToModuleNameMap.setOwnOptions(config.options);
+            moduleResolutionCache.moduleNameToDirectoryMap.setOwnOptions(config.options);
         }
         else {
             // Set correct own map
             Debug.assert(moduleResolutionCache.moduleNameToDirectoryMap.redirectsMap.size > 0);
-
-            const ref: ResolvedProjectReference = {
-                sourceFile: config.options.configFile!,
-                commandLine: config
-            };
-            moduleResolutionCache.directoryToModuleNameMap.setOwnMap(moduleResolutionCache.directoryToModuleNameMap.getOrCreateMapOfCacheRedirects(ref));
-            moduleResolutionCache.moduleNameToDirectoryMap.setOwnMap(moduleResolutionCache.moduleNameToDirectoryMap.getOrCreateMapOfCacheRedirects(ref));
+            moduleResolutionCache.update(config.options);
         }
-        moduleResolutionCache.directoryToModuleNameMap.setOwnOptions(config.options);
-        moduleResolutionCache.moduleNameToDirectoryMap.setOwnOptions(config.options);
     }
 
     function checkConfigFileUpToDateStatus(state: SolutionBuilderState, configFile: string, oldestOutputFileTime: Date, oldestOutputFileName: string): Status.OutOfDateWithSelf | undefined {

tests/baselines/reference/api/tsserverlibrary.d.ts

@@ -4729,6 +4729,12 @@ declare namespace ts {
      */
     interface ModuleResolutionCache extends NonRelativeModuleNameResolutionCache {
         getOrCreateCacheForDirectory(directoryName: string, redirectedReference?: ResolvedProjectReference): Map<ResolvedModuleWithFailedLookupLocations>;
+        clear(): void;
+        /**
+         *  Updates with the current compilerOptions the cache will operate with.
+         *  This updates the redirects map as well if needed so module resolutions are cached if they can across the projects
+         */
+        update(options: CompilerOptions): void;
     }
     /**
      * Stored map from non-relative module name to a table: directory -> result of module lookup in this directory

tests/baselines/reference/api/typescript.d.ts

@@ -4729,6 +4729,12 @@ declare namespace ts {
      */
     interface ModuleResolutionCache extends NonRelativeModuleNameResolutionCache {
         getOrCreateCacheForDirectory(directoryName: string, redirectedReference?: ResolvedProjectReference): Map<ResolvedModuleWithFailedLookupLocations>;
+        clear(): void;
+        /**
+         *  Updates with the current compilerOptions the cache will operate with.
+         *  This updates the redirects map as well if needed so module resolutions are cached if they can across the projects
+         */
+        update(options: CompilerOptions): void;
     }
     /**
      * Stored map from non-relative module name to a table: directory -> result of module lookup in this directory