Refactor

Author: sheetalkamat

src/compiler/builder.ts

@@ -1276,8 +1276,8 @@ namespace ts {
         let perDirPackageJsonMap: ESMap<Path, string> | undefined;
         const getCanonicalFileName = createGetCanonicalFileName(state.program!.useCaseSensitiveFileNames());
         state.program!.getSourceFiles().forEach(f => {
-            modules = toPerDirectoryCache(state, getCanonicalFileName, modules, f, f.resolvedModules, moduleNameToDirectoryMap);
-            typeRefs = toPerDirectoryCache(state, getCanonicalFileName, typeRefs, f, f.resolvedTypeReferenceDirectiveNames);
+            modules = toPerDirectoryCache(state, getCanonicalFileName, modules, getResolvedModuleOfResolution, f, f.resolvedModules, moduleNameToDirectoryMap);
+            typeRefs = toPerDirectoryCache(state, getCanonicalFileName, typeRefs, getResolvedTypeReferenceDirectiveOfResolution, f, f.resolvedTypeReferenceDirectiveNames);
             if (f.packageJsonScope) {
                 const dirPath = getDirectoryPath(f.resolvedPath);
                 if (!dirToPackageJsonMap?.has(dirPath)) {
@@ -1298,7 +1298,7 @@ namespace ts {
         if (automaticTypeDirectiveNames.length) {
             const currentDirectory = state.program!.getCurrentDirectory();
             const containingPath = toPath(state.program!.getAutomaticTypeDirectiveContainingFile(), currentDirectory, getCanonicalFileName);
-            typeRefs = toPerDirectoryCache(state, getCanonicalFileName, typeRefs, containingPath, state.program!.getAutomaticTypeDirectiveResolutions());
+            typeRefs = toPerDirectoryCache(state, getCanonicalFileName, typeRefs, getResolvedTypeReferenceDirectiveOfResolution, containingPath, state.program!.getAutomaticTypeDirectiveResolutions());
         }
         return state.cacheResolutions = {
             modules,
@@ -1310,70 +1310,32 @@ namespace ts {
         };
      }
 
-    function toPerDirectoryCache(
+    function toPerDirectoryCache<T extends ResolutionWithFailedLookupLocations, R extends ResolutionWithResolvedFileName>(
         state: BuilderProgramState,
         getCanonicalFileName: GetCanonicalFileName,
-        cacheWithRedirects: CacheWithRedirects<Path, ModeAwareCache<ResolvedTypeReferenceDirectiveWithFailedLookupLocations>> | undefined,
-        fOrPath: SourceFile | Path,
-        cache: ModeAwareCache<ResolvedTypeReferenceDirectiveWithFailedLookupLocations> | undefined,
-    ): CacheWithRedirects<Path, ModeAwareCache<ResolvedTypeReferenceDirectiveWithFailedLookupLocations>> | undefined;
-    function toPerDirectoryCache(
-        state: BuilderProgramState,
-        getCanonicalFileName: GetCanonicalFileName,
-        cacheWithRedirects: CacheWithRedirects<Path, ModeAwareCache<ResolvedModuleWithFailedLookupLocations>> | undefined,
-        f: SourceFile,
-        cache: ModeAwareCache<ResolvedModuleWithFailedLookupLocations> | undefined,
-        moduleNameToDirectoryMap: CacheWithRedirects<ModeAwareCacheKey, ESMap<Path, ResolvedModuleWithFailedLookupLocations>>,
-    ): CacheWithRedirects<Path, ModeAwareCache<ResolvedModuleWithFailedLookupLocations>> | undefined;
-    function toPerDirectoryCache<T extends ResolvedModuleWithFailedLookupLocations | ResolvedTypeReferenceDirectiveWithFailedLookupLocations>(
-        state: BuilderProgramState,
-        getCanonicalFileName: GetCanonicalFileName,
-        cacheWithRedirects: CacheWithRedirects<Path, ModeAwareCache<T>> | undefined,
-        fOrPath: SourceFile | Path,
-        cache: ModeAwareCache<T> | undefined,
+        perDirCache: CacheWithRedirects<Path, ModeAwareCache<T>> | undefined,
+        getResolutionWithResolvedFileName: GetResolutionWithResolvedFileName<T, R>,
+        sourceFileOrPath: SourceFile | Path,
+        fileCacheFromProgram: ModeAwareCache<T> | undefined,
         moduleNameToDirectoryMap?: CacheWithRedirects<ModeAwareCacheKey, ESMap<Path, ResolvedModuleWithFailedLookupLocations>> | undefined,
     ): CacheWithRedirects<Path, ModeAwareCache<T>> | undefined {
-        if (!cache?.size()) return cacheWithRedirects;
-        let dirPath: Path, redirectedReference: ResolvedProjectReference | undefined;
-        if (!isString(fOrPath)) {
-            redirectedReference = state.program!.getRedirectReferenceForResolution(fOrPath);
-            dirPath = getDirectoryPath(fOrPath.path);
-        }
-        else {
-            dirPath = getDirectoryPath(fOrPath);
-        }
-        let perDirResolutionCache = cacheWithRedirects?.getMapOfCacheRedirects(redirectedReference);
-        let dirCache = perDirResolutionCache?.get(dirPath);
-        cache.forEach((resolution, name, mode) => {
-            if (!(resolution as ResolvedModuleWithFailedLookupLocations).resolvedModule?.resolvedFileName && !(resolution as ResolvedTypeReferenceDirectiveWithFailedLookupLocations).resolvedTypeReferenceDirective?.resolvedFileName) return;
-            if (dirCache?.has(name, mode)) return;
-            // If there was already external module resolution that is same, set for child directory, dont set resolution for this directory
-            if (moduleNameToDirectoryMap &&
-                !isExternalModuleNameRelative(name) &&
-                moduleNameToDirectoryMap.getMapOfCacheRedirects(redirectedReference)?.get(getModeAwareCacheKey(name, mode))?.get(dirPath)) {
-                return;
-            }
-            if (!dirCache) {
-                perDirResolutionCache ??= (cacheWithRedirects ??= createCacheWithRedirects(state.compilerOptions)).getOrCreateMapOfCacheRedirects(redirectedReference);
-                perDirResolutionCache.set(dirPath, dirCache = createModeAwareCache());
-            }
-            dirCache.set(name, mode, resolution);
-            if (!moduleNameToDirectoryMap || isExternalModuleNameRelative(name)) return;
-            // put result in per-module name cache and delete everything that is not needed
-            const actualModuleNameToDirectoryMap = moduleNameToDirectoryMap.getOrCreateMapOfCacheRedirects(redirectedReference);
-            const key = getModeAwareCacheKey(name, mode);
-            let directoryPathMap = actualModuleNameToDirectoryMap.get(key);
-            if (!directoryPathMap) actualModuleNameToDirectoryMap.set(key, directoryPathMap = new Map());
-            moduleNameToDirectorySet(
-                directoryPathMap,
-                dirPath,
-                resolution as ResolvedModuleWithFailedLookupLocations,
-                getResolvedFileNameForModuleNameToDirectorySet,
-                dir => toPath(dir, state.program!.getCurrentDirectory(), getCanonicalFileName),
-                ancestorPath => perDirResolutionCache?.get(ancestorPath)?.delete(name, mode)
-            );
-        });
-        return cacheWithRedirects;
+        return toPerDirectoryResolution(
+            state.program!,
+            fileCacheFromProgram,
+            sourceFileOrPath,
+            perDirCache,
+            moduleNameToDirectoryMap,
+            noop,
+            (r, name, mode, _key, redirectedReference, dirPath) =>
+                // If this is not resolved, dont put in per dir Cache
+                !getResolutionWithResolvedFileName(r)?.resolvedFileName ||
+                // If there was already external module resolution that is same, set for child directory, dont set resolution for this directory
+                (moduleNameToDirectoryMap &&
+                    !isExternalModuleNameRelative(name) &&
+                    moduleNameToDirectoryMap.getMapOfCacheRedirects(redirectedReference)?.get(getModeAwareCacheKey(name, mode))?.get(dirPath)),
+            dir => toPath(dir, state.program!.getCurrentDirectory(), getCanonicalFileName),
+            (ancestorPath, name, mode, perDirResolutionCache) => perDirResolutionCache?.get(ancestorPath)?.delete(name, mode),
+        );
     }
 
     export enum BuilderProgramKind {