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

Author: sheetalkamat

src/compiler/moduleNameResolver.ts

@@ -443,7 +443,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;
     }
 
     /**
@@ -452,7 +457,6 @@ namespace ts {
      */
     export interface NonRelativeModuleNameResolutionCache {
         getOrCreateCacheForModuleName(nonRelativeModuleName: string, redirectedReference?: ResolvedProjectReference): PerModuleNameCache;
-        /*@internal*/ moduleNameToDirectoryMap: CacheWithRedirects<PerModuleNameCache>;
     }
 
     export interface PerModuleNameCache {
@@ -528,7 +532,41 @@ namespace ts {
         currentDirectory: string,
         getCanonicalFileName: GetCanonicalFileName): ModuleResolutionCache {
 
-        return { getOrCreateCacheForDirectory, getOrCreateCacheForModuleName, directoryToModuleNameMap, moduleNameToDirectoryMap };
+        return {
+            getOrCreateCacheForDirectory,
+            getOrCreateCacheForModuleName,
+            clear,
+            update,
+        };
+
+        function clear() {
+            directoryToModuleNameMap.clear();
+            moduleNameToDirectoryMap.clear();
+        }
+
+        function update(options: CompilerOptions) {
+            if (!options.configFile) return;
+            if (directoryToModuleNameMap.redirectsMap.size === 0) {
+                // The own map will be for projectCompilerOptions
+                Debug.assert(moduleNameToDirectoryMap.redirectsMap.size === 0);
+                Debug.assert(directoryToModuleNameMap.ownMap.size === 0);
+                Debug.assert(moduleNameToDirectoryMap.ownMap.size === 0);
+                directoryToModuleNameMap.redirectsMap.set(options.configFile.path, directoryToModuleNameMap.ownMap);
+                moduleNameToDirectoryMap.redirectsMap.set(options.configFile.path, moduleNameToDirectoryMap.ownMap);
+            }
+            else {
+                // Set correct own map
+                Debug.assert(moduleNameToDirectoryMap.redirectsMap.size > 0);
+                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;
     }
 
@@ -842,7 +839,7 @@ namespace ts {
             const { host, compilerHost } = state;
             state.projectCompilerOptions = config.options;
             // Update module resolution cache if needed
-            updateModuleResolutionCache(state, project, config);
+            state.moduleResolutionCache?.update(config.options);
 
             // Create program
             program = host.createProgram(
@@ -1306,37 +1303,6 @@ namespace ts {
         return { buildResult, step: BuildStep.QueueReferencingProjects };
     }
 
-    function updateModuleResolutionCache(
-        state: SolutionBuilderState,
-        proj: ResolvedConfigFileName,
-        config: ParsedCommandLine
-    ) {
-        if (!state.moduleResolutionCache) return;
-
-        // Update module resolution cache if needed
-        const { moduleResolutionCache } = state;
-        const projPath = toPath(state, proj);
-        if (moduleResolutionCache.directoryToModuleNameMap.redirectsMap.size === 0) {
-            // The own map will be for projectCompilerOptions
-            Debug.assert(moduleResolutionCache.moduleNameToDirectoryMap.redirectsMap.size === 0);
-            moduleResolutionCache.directoryToModuleNameMap.redirectsMap.set(projPath, moduleResolutionCache.directoryToModuleNameMap.ownMap);
-            moduleResolutionCache.moduleNameToDirectoryMap.redirectsMap.set(projPath, moduleResolutionCache.moduleNameToDirectoryMap.ownMap);
-        }
-        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.directoryToModuleNameMap.setOwnOptions(config.options);
-        moduleResolutionCache.moduleNameToDirectoryMap.setOwnOptions(config.options);
-    }
-
     function checkConfigFileUpToDateStatus(state: SolutionBuilderState, configFile: string, oldestOutputFileTime: Date, oldestOutputFileName: string): Status.OutOfDateWithSelf | undefined {
         // Check tsconfig time
         const tsconfigTime = getModifiedTime(state.host, configFile);

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