Make sure reused resolutions from file are accounted if all resolutions are reused/are resolved to ambient module names

Author: sheetalkamat

src/compiler/program.ts

@@ -1027,7 +1027,8 @@ function getTypeReferenceResolutionName<T extends FileReference | string>(entry:
     return !isString(entry) ? entry.fileName : entry;
 }
 
-const typeReferenceResolutionNameAndModeGetter: ResolutionNameAndModeGetter<FileReference | string, SourceFile | undefined> = {
+/** @internal */
+export const typeReferenceResolutionNameAndModeGetter: ResolutionNameAndModeGetter<FileReference | string, SourceFile | undefined> = {
     getName: getTypeReferenceResolutionName,
     getMode: (entry, file) => getModeForFileReference(entry, file?.impliedNodeFormat),
 };
@@ -1625,6 +1626,7 @@ export function createProgram(rootNamesOrOptions: readonly string[] | CreateProg
         options: CompilerOptions,
         containingSourceFile: SourceFile,
         reusedNames: readonly StringLiteralLike[] | undefined,
+        ambientModuleNames: readonly StringLiteralLike[] | undefined,
     ) => readonly ResolvedModuleWithFailedLookupLocations[];
     const hasInvalidatedResolutions = host.hasInvalidatedResolutions || returnFalse;
     if (host.resolveModuleNameLiterals) {
@@ -1832,6 +1834,9 @@ export function createProgram(rootNamesOrOptions: readonly string[] | CreateProg
             }
             tracing?.pop();
         }
+        else {
+            host.onReusedTypeReferenceDirectiveResolutions?.(/*reusedNames*/ undefined, /*containingSourceFile*/ undefined, /*redirectedReference*/ undefined, options);
+        }
 
         // Do not process the default library if:
         //  - The '--noLib' flag is used.
@@ -2125,6 +2130,7 @@ export function createProgram(rootNamesOrOptions: readonly string[] | CreateProg
         moduleNames: readonly StringLiteralLike[],
         containingFile: SourceFile,
         reusedNames: readonly StringLiteralLike[] | undefined,
+        ambientModuleNames: readonly StringLiteralLike[] | undefined,
     ): readonly ResolvedModuleWithFailedLookupLocations[] {
         const containingFileName = getNormalizedAbsolutePath(containingFile.originalFileName, currentDirectory);
         const redirectedReference = getRedirectReferenceForResolution(containingFile);
@@ -2137,6 +2143,7 @@ export function createProgram(rootNamesOrOptions: readonly string[] | CreateProg
             options,
             containingFile,
             reusedNames,
+            ambientModuleNames,
         );
         performance.mark("afterResolveModule");
         performance.measure("ResolveModule", "beforeResolveModule", "afterResolveModule");
@@ -2253,6 +2260,7 @@ export function createProgram(rootNamesOrOptions: readonly string[] | CreateProg
             redirectedReference: getRedirectReferenceForResolution(containingFile),
             nameAndModeGetter: moduleResolutionNameAndModeGetter,
             resolutionWorker: resolveModuleNamesWorker,
+            onReusedResolutions: maybeBind(host, host.onReusedModuleResolutions),
             getResolutionFromOldProgram: (name, mode) => oldProgram?.getResolvedModule(containingFile, name, mode),
             getResolved: getResolvedModuleFromResolution,
             canReuseResolutionsInFile: () =>
@@ -2315,6 +2323,7 @@ export function createProgram(rootNamesOrOptions: readonly string[] | CreateProg
             redirectedReference: containingSourceFile && getRedirectReferenceForResolution(containingSourceFile),
             nameAndModeGetter: typeReferenceResolutionNameAndModeGetter,
             resolutionWorker: resolveTypeReferenceDirectiveNamesWorker,
+            onReusedResolutions: maybeBind(host, host.onReusedTypeReferenceDirectiveResolutions),
             getResolutionFromOldProgram: (name, mode) =>
                 containingSourceFile ?
                     oldProgram?.getResolvedTypeReferenceDirective(containingSourceFile, name, mode) :
@@ -2337,7 +2346,17 @@ export function createProgram(rootNamesOrOptions: readonly string[] | CreateProg
             entries: readonly Entry[],
             containingFile: SourceFileOrString,
             reusedNames: readonly Entry[] | undefined,
+            ambientEntries: readonly Entry[] | undefined,
         ) => readonly Resolution[];
+        onReusedResolutions:
+            | ((
+                resuedEntries: readonly Entry[] | undefined,
+                containingSourceFile: SourceFileOrUndefined,
+                redirectedReference: ResolvedProjectReference | undefined,
+                options: CompilerOptions,
+                ambientEntries: readonly Entry[] | undefined,
+            ) => void)
+            | undefined;
         getResolutionFromOldProgram: (name: string, mode: ResolutionMode) => Resolution | undefined;
         getResolved: (oldResolution: Resolution) => ResolutionWithResolvedFileName | undefined;
         canReuseResolutionsInFile: () => boolean;
@@ -2351,19 +2370,24 @@ export function createProgram(rootNamesOrOptions: readonly string[] | CreateProg
         redirectedReference,
         nameAndModeGetter,
         resolutionWorker,
+        onReusedResolutions,
         getResolutionFromOldProgram,
         getResolved,
         canReuseResolutionsInFile,
         isEntryResolvingToAmbientModule,
     }: ResolveNamesReusingOldStateInput<Entry, SourceFileOrString, SourceFileOrUndefined, Resolution>): readonly Resolution[] {
-        if (!entries.length) return emptyArray;
+        if (!entries.length) {
+            onReusedResolutions?.(entries, containingSourceFile, redirectedReference, options, /*ambientEntries*/ undefined);
+            return emptyArray;
+        }
         if (structureIsReused === StructureIsReused.Not && (!isEntryResolvingToAmbientModule || !containingSourceFile!.ambientModuleNames.length)) {
             // If the old program state does not permit reusing resolutions and `file` does not contain locally defined ambient modules,
             // the best we can do is fallback to the default logic.
             return resolutionWorker(
                 entries,
                 containingFile,
                 /*reusedNames*/ undefined,
+                /*ambientEntries*/ undefined,
             );
         }
 
@@ -2372,6 +2396,7 @@ export function createProgram(rootNamesOrOptions: readonly string[] | CreateProg
         let unknownEntryIndices: number[] | undefined;
         let result: Resolution[] | undefined;
         let reusedNames: Entry[] | undefined;
+        let ambientEntries: Entry[] | undefined;
         const reuseResolutions = canReuseResolutionsInFile();
         for (let i = 0; i < entries.length; i++) {
             const entry = entries[i];
@@ -2403,6 +2428,7 @@ export function createProgram(rootNamesOrOptions: readonly string[] | CreateProg
                 }
             }
             if (isEntryResolvingToAmbientModule?.(entry, containingFile)) {
+                (ambientEntries ??= []).push(entry);
                 (result ??= new Array(entries.length))[i] = emptyResolution;
             }
             else {
@@ -2412,8 +2438,16 @@ export function createProgram(rootNamesOrOptions: readonly string[] | CreateProg
             }
         }
 
-        if (!unknownEntries) return result!;
-        const resolutions = resolutionWorker(unknownEntries, containingFile, reusedNames);
+        if (!unknownEntries) {
+            onReusedResolutions?.(reusedNames, containingSourceFile, redirectedReference, options, ambientEntries);
+            return result!;
+        }
+        const resolutions = resolutionWorker(
+            unknownEntries,
+            containingFile,
+            reusedNames,
+            ambientEntries,
+        );
         if (!result) return resolutions;
         resolutions.forEach((resolution, index) => result[unknownEntryIndices![index]] = resolution);
         return result;
@@ -3986,7 +4020,10 @@ export function createProgram(rootNamesOrOptions: readonly string[] | CreateProg
 
     function processTypeReferenceDirectives(file: SourceFile) {
         const typeDirectives = file.typeReferenceDirectives;
-        if (!typeDirectives.length) return;
+        if (!typeDirectives.length) {
+            host.onReusedTypeReferenceDirectiveResolutions?.(/*reusedNames*/ undefined, file, getRedirectReferenceForResolution(file), options);
+            return;
+        }
 
         const resolutions = resolvedTypeReferenceDirectiveNamesProcessing?.get(file.path) ||
             resolveTypeReferenceDirectiveNamesReusingOldState(typeDirectives, file);
@@ -4111,13 +4148,14 @@ export function createProgram(rootNamesOrOptions: readonly string[] | CreateProg
 
     function processImportedModules(file: SourceFile) {
         collectExternalModuleReferences(file);
+        const redirectedReference = getRedirectReferenceForResolution(file);
         if (file.imports.length || file.moduleAugmentations.length) {
             // Because global augmentation doesn't have string literal name, we can check for global augmentation as such.
             const moduleNames = getModuleNames(file);
             const resolutions = resolvedModulesProcessing?.get(file.path) ||
                 resolveModuleNamesReusingOldState(moduleNames, file);
             Debug.assert(resolutions.length === moduleNames.length);
-            const optionsForFile = getRedirectReferenceForResolution(file)?.commandLine.options || options;
+            const optionsForFile = redirectedReference?.commandLine.options || options;
             const resolutionsInFile = createModeAwareCache<ResolutionWithFailedLookupLocations>();
             (resolvedModules ??= new Map()).set(file.path, resolutionsInFile);
             for (let index = 0; index < moduleNames.length; index++) {
@@ -4175,6 +4213,9 @@ export function createProgram(rootNamesOrOptions: readonly string[] | CreateProg
                 }
             }
         }
+        else {
+            host.onReusedModuleResolutions?.(/*reusedNames*/ undefined, file, redirectedReference, options, /*ambientModuleNames*/ undefined);
+        }
     }
 
     function checkSourceFilesBelongToPath(sourceFiles: readonly SourceFile[], rootDirectory: string): boolean {

src/compiler/resolutionCache.ts

@@ -3,6 +3,7 @@ import {
     clearMap,
     closeFileWatcher,
     closeFileWatcherOf,
+    CompilerHostSupportingResolutionCache,
     CompilerOptions,
     createModeAwareCache,
     createModuleResolutionCache,
@@ -20,6 +21,7 @@ import {
     FileWatcher,
     FileWatcherCallback,
     firstDefinedIterator,
+    getAutomaticTypeDirectiveContainingFile,
     GetCanonicalFileName,
     getDirectoryPath,
     getEffectiveTypeRoots,
@@ -61,6 +63,7 @@ import {
     resolutionExtensionIsTSOrJson,
     ResolutionLoader,
     ResolutionMode,
+    ResolutionNameAndModeGetter,
     ResolutionWithResolvedFileName,
     ResolvedModuleWithFailedLookupLocations,
     ResolvedProjectReference,
@@ -73,6 +76,7 @@ import {
     startsWith,
     StringLiteralLike,
     trace,
+    typeReferenceResolutionNameAndModeGetter,
     updateResolutionField,
     WatchDirectoryFlags,
 } from "./_namespaces/ts.js";
@@ -95,7 +99,7 @@ export type CallbackOnNewResolution<T extends ResolutionWithFailedLookupLocation
  *
  * @internal
  */
-export interface ResolutionCache {
+export interface ResolutionCache extends Required<CompilerHostSupportingResolutionCache> {
     rootDirForResolution: string;
     resolvedModuleNames: Map<Path, ModeAwareCache<CachedResolvedModuleWithFailedLookupLocations>>;
     resolvedTypeReferenceDirectives: Map<Path, ModeAwareCache<CachedResolvedTypeReferenceDirectiveWithFailedLookupLocations>>;
@@ -125,6 +129,7 @@ export interface ResolutionCache {
         options: CompilerOptions,
         containingSourceFile: SourceFile,
         reusedNames: readonly StringLiteralLike[] | undefined,
+        ambientModuleNames: readonly StringLiteralLike[] | undefined,
         onNewResolution?: CallbackOnNewResolution<ResolvedModuleWithFailedLookupLocations>,
     ): readonly ResolvedModuleWithFailedLookupLocations[];
     resolveTypeReferenceDirectiveReferences<T extends FileReference | string>(
@@ -683,6 +688,8 @@ export function createResolutionCache(
         finishCachingPerDirectoryResolution,
         resolveModuleNameLiterals,
         resolveTypeReferenceDirectiveReferences,
+        onReusedModuleResolutions,
+        onReusedTypeReferenceDirectiveResolutions,
         resolveLibrary,
         resolveSingleModuleNameWithoutWatching,
         removeResolutionsFromProjectReferenceRedirects,
@@ -867,6 +874,7 @@ export function createResolutionCache(
         redirectedReference: ResolvedProjectReference | undefined;
         options: CompilerOptions;
         reusedNames?: readonly Entry[];
+        ambientEntries?: readonly Entry[];
         perFileCache: Map<Path, ModeAwareCache<T>>;
         loader: ResolutionLoader<Entry, T, SourceFile>;
         getResolutionWithResolvedFileName: GetResolutionWithResolvedFileName<T, R>;
@@ -881,6 +889,7 @@ export function createResolutionCache(
         options,
         perFileCache,
         reusedNames,
+        ambientEntries,
         loader,
         getResolutionWithResolvedFileName,
         deferWatchingNonRelativeResolution,
@@ -955,13 +964,66 @@ export function createResolutionCache(
             seenNamesInFile.set(name, mode, true);
             resolvedModules.push(resolution);
         }
+        onReusedResolutions({
+            reusedNames,
+            containingSourceFile,
+            redirectedReference,
+            options,
+            ambientEntries,
+            path,
+            resolutionsInFile,
+            seenNamesInFile,
+            nameAndModeGetter: loader.nameAndMode,
+            getResolutionWithResolvedFileName,
+        });
+        return resolvedModules;
+    }
+
+    interface OnReusedResolutionsInput<Entry, SourceFile, T extends ResolutionWithFailedLookupLocations, R extends ResolutionWithResolvedFileName> {
+        reusedNames: readonly Entry[] | undefined;
+        containingSourceFile: SourceFile;
+        redirectedReference: ResolvedProjectReference | undefined;
+        options: CompilerOptions;
+        ambientEntries?: readonly Entry[];
+        path: Path;
+        resolutionsInFile: ModeAwareCache<T> | undefined;
+        seenNamesInFile?: ModeAwareCache<true>;
+        nameAndModeGetter: ResolutionNameAndModeGetter<Entry, SourceFile>;
+        getResolutionWithResolvedFileName: GetResolutionWithResolvedFileName<T, R>;
+    }
+    function onReusedResolutions<Entry, SourceFile, T extends ResolutionWithFailedLookupLocations, R extends ResolutionWithResolvedFileName>({
+        reusedNames,
+        containingSourceFile,
+        redirectedReference,
+        options,
+        path,
+        resolutionsInFile,
+        seenNamesInFile,
+        nameAndModeGetter,
+        getResolutionWithResolvedFileName,
+        ambientEntries,
+    }: OnReusedResolutionsInput<Entry, SourceFile, T, R>) {
+        if (!resolutionsInFile) return;
+        if (!seenNamesInFile) seenNamesInFile = createModeAwareCache();
         reusedNames?.forEach(entry =>
             seenNamesInFile.set(
-                loader.nameAndMode.getName(entry),
-                loader.nameAndMode.getMode(entry, containingSourceFile, redirectedReference?.commandLine.options || options),
+                nameAndModeGetter.getName(entry),
+                nameAndModeGetter.getMode(entry, containingSourceFile, redirectedReference?.commandLine.options || options),
                 true,
             )
         );
+        // For ambient module names, if its not invalidated keep it
+        ambientEntries?.forEach(entry => {
+            const name = nameAndModeGetter.getName(entry);
+            const mode = nameAndModeGetter.getMode(entry, containingSourceFile, redirectedReference?.commandLine.options || options);
+            if (!seenNamesInFile.has(name, mode)) {
+                const resolution = resolutionsInFile.get(name, mode);
+                // Keep this resolution from old time for ambient module names
+                if (resolution && !resolution.isInvalidated) {
+                    seenNamesInFile.set(name, mode, true);
+                }
+            }
+        });
         if (resolutionsInFile.size() !== seenNamesInFile.size()) {
             // Stop watching and remove the unused name
             resolutionsInFile.forEach((resolution, name, mode) => {
@@ -971,7 +1033,47 @@ export function createResolutionCache(
                 }
             });
         }
-        return resolvedModules;
+    }
+
+    function onReusedModuleResolutions(
+        reusedNames: readonly StringLiteralLike[] | undefined,
+        containingSourceFile: SourceFile,
+        redirectedReference: ResolvedProjectReference | undefined,
+        options: CompilerOptions,
+        ambientModuleNames: readonly StringLiteralLike[] | undefined,
+    ) {
+        onReusedResolutions({
+            reusedNames,
+            containingSourceFile,
+            redirectedReference,
+            options,
+            ambientEntries: ambientModuleNames,
+            path: containingSourceFile.path,
+            resolutionsInFile: resolvedModuleNames.get(containingSourceFile.path),
+            nameAndModeGetter: moduleResolutionNameAndModeGetter,
+            getResolutionWithResolvedFileName: getResolvedModuleFromResolution,
+        });
+    }
+
+    function onReusedTypeReferenceDirectiveResolutions<T extends FileReference | string>(
+        reusedNames: readonly T[] | undefined,
+        containingSourceFile: SourceFile | undefined,
+        redirectedReference: ResolvedProjectReference | undefined,
+        options: CompilerOptions,
+    ) {
+        const path = containingSourceFile ?
+            containingSourceFile.path :
+            resolutionHost.toPath(getAutomaticTypeDirectiveContainingFile(resolutionHost.getCompilationSettings(), getCurrentDirectory()));
+        onReusedResolutions({
+            reusedNames,
+            containingSourceFile,
+            redirectedReference,
+            options,
+            path,
+            resolutionsInFile: resolvedTypeReferenceDirectives.get(path),
+            nameAndModeGetter: typeReferenceResolutionNameAndModeGetter,
+            getResolutionWithResolvedFileName: getResolvedTypeReferenceDirectiveFromResolution,
+        });
     }
 
     function resolveTypeReferenceDirectiveReferences<T extends FileReference | string>(
@@ -1009,6 +1111,7 @@ export function createResolutionCache(
         options: CompilerOptions,
         containingSourceFile: SourceFile,
         reusedNames: readonly StringLiteralLike[] | undefined,
+        ambientModuleNames: readonly StringLiteralLike[] | undefined,
         onNewResolution?: CallbackOnNewResolution<ResolvedModuleWithFailedLookupLocations>,
     ): readonly ResolvedModuleWithFailedLookupLocations[] {
         return resolveNamesWithLocalCache({
@@ -1018,6 +1121,7 @@ export function createResolutionCache(
             redirectedReference,
             options,
             reusedNames,
+            ambientEntries: ambientModuleNames,
             perFileCache: resolvedModuleNames,
             loader: createModuleResolutionLoaderUsingGlobalCache(
                 containingFile,