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

@@ -1591,6 +1591,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) {
@@ -1795,6 +1796,9 @@ export function createProgram(rootNamesOrOptions: readonly string[] | CreateProg
             }
             tracing?.pop();
         }
+        else {
+            host.onReusedTypeReferenceDirectiveResolutions?.(/*reusedNames*/ undefined, /*containingSourceFile*/ undefined);
+        }
 
         // Do not process the default library if:
         //  - The '--noLib' flag is used.
@@ -2041,6 +2045,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);
@@ -2053,6 +2058,7 @@ export function createProgram(rootNamesOrOptions: readonly string[] | CreateProg
             options,
             containingFile,
             reusedNames,
+            ambientModuleNames,
         );
         performance.mark("afterResolveModule");
         performance.measure("ResolveModule", "beforeResolveModule", "afterResolveModule");
@@ -2168,6 +2174,7 @@ export function createProgram(rootNamesOrOptions: readonly string[] | CreateProg
             containingSourceFile: containingFile,
             nameAndModeGetter: moduleResolutionNameAndModeGetter,
             resolutionWorker: resolveModuleNamesWorker,
+            onReusedResolutions: maybeBind(host, host.onReusedModuleResolutions),
             getReusableOldResolution: (name, mode) => oldProgram?.getResolvedModule(containingFile, name, mode),
             getResolved: getResolvedModuleFromResolution,
             canReuseResolutionsInFile: () => containingFile === oldProgram?.getSourceFile(containingFile.fileName) && !hasInvalidatedResolutions(containingFile.path),
@@ -2227,6 +2234,7 @@ export function createProgram(rootNamesOrOptions: readonly string[] | CreateProg
             containingSourceFile,
             nameAndModeGetter: typeReferenceResolutionNameAndModeGetter,
             resolutionWorker: resolveTypeReferenceDirectiveNamesWorker,
+            onReusedResolutions: maybeBind(host, host.onReusedTypeReferenceDirectiveResolutions),
             getReusableOldResolution: (name, mode) =>
                 containingSourceFile ?
                     oldProgram?.getResolvedTypeReferenceDirective(containingSourceFile, name, mode) :
@@ -2248,7 +2256,15 @@ 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,
+                ambientEntries: readonly Entry[] | undefined,
+            ) => void)
+            | undefined;
         getReusableOldResolution: (name: string, mode: ResolutionMode) => Resolution | undefined;
         getResolved: (oldResolution: Resolution) => ResolutionWithResolvedFileName | undefined;
         canReuseResolutionsInFile: () => boolean;
@@ -2261,12 +2277,14 @@ export function createProgram(rootNamesOrOptions: readonly string[] | CreateProg
         containingSourceFile,
         nameAndModeGetter,
         resolutionWorker,
+        onReusedResolutions,
         getReusableOldResolution,
         getResolved,
         canReuseResolutionsInFile,
         isEntryResolvingToAmbientModule,
     }: ResolveNamesReusingOldStateInput<Entry, SourceFileOrString, SourceFileOrUndefined, Resolution>): readonly Resolution[] {
         if (!entries.length) {
+            onReusedResolutions?.(entries, containingSourceFile, /*ambientEntries*/ undefined);
             return emptyArray;
         }
         if (structureIsReused === StructureIsReused.Not && (!isEntryResolvingToAmbientModule || !containingSourceFile!.ambientModuleNames.length)) {
@@ -2276,6 +2294,7 @@ export function createProgram(rootNamesOrOptions: readonly string[] | CreateProg
                 entries,
                 containingFile,
                 /*reusedNames*/ undefined,
+                /*ambientEntries*/ undefined,
             );
         }
 
@@ -2284,6 +2303,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];
@@ -2315,6 +2335,7 @@ export function createProgram(rootNamesOrOptions: readonly string[] | CreateProg
                 }
             }
             if (isEntryResolvingToAmbientModule?.(entry, containingFile)) {
+                (ambientEntries ??= []).push(entry);
                 (result || (result = new Array(entries.length)))[i] = emptyResolution;
             }
             else {
@@ -2325,12 +2346,14 @@ export function createProgram(rootNamesOrOptions: readonly string[] | CreateProg
         }
 
         if (!unknownEntries) {
+            onReusedResolutions?.(reusedNames, containingSourceFile, ambientEntries);
             return result!;
         }
         const resolutions = resolutionWorker(
             unknownEntries,
             containingFile,
             reusedNames,
+            ambientEntries,
         );
         if (!result) return resolutions;
         resolutions.forEach((resolution, index) => {
@@ -3860,7 +3883,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);
+            return;
+        }
 
         const resolutions = resolvedTypeReferenceDirectiveNamesProcessing?.get(file.path) ||
             resolveTypeReferenceDirectiveNamesReusingOldState(typeDirectives, file);
@@ -4091,6 +4117,9 @@ export function createProgram(rootNamesOrOptions: readonly string[] | CreateProg
                 }
             }
         }
+        else {
+            host.onReusedModuleResolutions?.(/*reusedNames*/ undefined, file, /*ambientModuleNames*/ undefined);
+        }
     }
 
     function checkSourceFilesBelongToPath(sourceFiles: readonly SourceFile[], rootDirectory: string): boolean {

src/compiler/resolutionCache.ts

@@ -4,6 +4,7 @@ import {
     clearMap,
     closeFileWatcher,
     closeFileWatcherOf,
+    CompilerHostSupportingResolutionCache,
     CompilerOptions,
     createModeAwareCache,
     createModuleResolutionCache,
@@ -21,6 +22,7 @@ import {
     FileWatcher,
     FileWatcherCallback,
     firstDefinedIterator,
+    getAutomaticTypeDirectiveContainingFile,
     GetCanonicalFileName,
     getDirectoryPath,
     getEffectiveTypeRoots,
@@ -63,6 +65,7 @@ import {
     resolutionExtensionIsTSOrJson,
     ResolutionLoader,
     ResolutionMode,
+    ResolutionNameAndModeGetter,
     ResolutionWithResolvedFileName,
     ResolvedModuleWithFailedLookupLocations,
     ResolvedProjectReference,
@@ -75,6 +78,7 @@ import {
     startsWith,
     StringLiteralLike,
     trace,
+    typeReferenceResolutionNameAndModeGetter,
     updateResolutionField,
     WatchDirectoryFlags,
 } from "./_namespaces/ts";
@@ -97,7 +101,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>(
@@ -630,6 +635,8 @@ export function createResolutionCache(
         finishCachingPerDirectoryResolution,
         resolveModuleNameLiterals,
         resolveTypeReferenceDirectiveReferences,
+        onReusedModuleResolutions,
+        onReusedTypeReferenceDirectiveResolutions,
         resolveLibrary,
         resolveSingleModuleNameWithoutWatching,
         removeResolutionsFromProjectReferenceRedirects,
@@ -801,6 +808,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>;
@@ -815,6 +823,7 @@ export function createResolutionCache(
         options,
         perFileCache,
         reusedNames,
+        ambientEntries,
         loader,
         getResolutionWithResolvedFileName,
         deferWatchingNonRelativeResolution,
@@ -889,23 +898,102 @@ export function createResolutionCache(
             seenNamesInFile.set(name, mode, true);
             resolvedModules.push(resolution);
         }
+        onReusedResolutions({
+            reusedNames,
+            containingSourceFile,
+            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;
+        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,
+        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),
+            seenNamesInFile!.set(
+                nameAndModeGetter.getName(entry),
+                nameAndModeGetter.getMode(entry, containingSourceFile),
                 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);
+            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) => {
-                if (!seenNamesInFile.has(name, mode)) {
+                if (!seenNamesInFile!.has(name, mode)) {
                     stopWatchFailedLookupLocationOfResolution(resolution, path, getResolutionWithResolvedFileName);
                     resolutionsInFile.delete(name, mode);
                 }
             });
         }
-        return resolvedModules;
+    }
+
+    function onReusedModuleResolutions(
+        reusedNames: readonly StringLiteralLike[] | undefined,
+        containingSourceFile: SourceFile,
+        ambientModuleNames: readonly StringLiteralLike[] | undefined,
+    ) {
+        onReusedResolutions({
+            reusedNames,
+            containingSourceFile,
+            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,
+    ) {
+        const path = containingSourceFile ?
+            containingSourceFile.path :
+            resolutionHost.toPath(getAutomaticTypeDirectiveContainingFile(resolutionHost.getCompilationSettings(), getCurrentDirectory()));
+        onReusedResolutions({
+            reusedNames,
+            containingSourceFile,
+            path,
+            resolutionsInFile: resolvedTypeReferenceDirectives.get(path),
+            nameAndModeGetter: typeReferenceResolutionNameAndModeGetter,
+            getResolutionWithResolvedFileName: getResolvedTypeReferenceDirectiveFromResolution,
+        });
     }
 
     function resolveTypeReferenceDirectiveReferences<T extends FileReference | string>(
@@ -943,6 +1031,7 @@ export function createResolutionCache(
         options: CompilerOptions,
         containingSourceFile: SourceFile,
         reusedNames: readonly StringLiteralLike[] | undefined,
+        ambientModuleNames: readonly StringLiteralLike[] | undefined,
         onNewResolution?: CallbackOnNewResolution<ResolvedModuleWithFailedLookupLocations>,
     ): readonly ResolvedModuleWithFailedLookupLocations[] {
         return resolveNamesWithLocalCache({
@@ -952,6 +1041,7 @@ export function createResolutionCache(
             redirectedReference,
             options,
             reusedNames,
+            ambientEntries: ambientModuleNames,
             perFileCache: resolvedModuleNames,
             loader: createModuleResolutionLoaderUsingGlobalCache(
                 containingFile,

src/compiler/types.ts

@@ -7786,6 +7786,7 @@ export interface CompilerHost extends ModuleResolutionHost {
         options: CompilerOptions,
         containingSourceFile: SourceFile,
         reusedNames: readonly StringLiteralLike[] | undefined,
+        ambientModuleNames: readonly StringLiteralLike[] | undefined,
     ): readonly ResolvedModuleWithFailedLookupLocations[];
     resolveTypeReferenceDirectiveReferences?<T extends FileReference | string>(
         typeDirectiveReferences: readonly T[],
@@ -7828,6 +7829,22 @@ export interface CompilerHost extends ModuleResolutionHost {
     jsDocParsingMode?: JSDocParsingMode;
 }
 
+/** @internal */
+export interface CompilerHostSupportingResolutionCache {
+    onReusedModuleResolutions?(
+        reusedNames: readonly StringLiteralLike[] | undefined,
+        containingSourceFile: SourceFile,
+        ambientModuleNames: readonly StringLiteralLike[] | undefined,
+    ): void;
+    onReusedTypeReferenceDirectiveResolutions?<T extends FileReference | string>(
+        reusedNames: readonly T[] | undefined,
+        containingSourceFile: SourceFile | undefined,
+    ): void;
+}
+/** @internal */
+export interface CompilerHost extends CompilerHostSupportingResolutionCache {
+}
+
 /** true if --out otherwise source file name *
  * @internal
  */

src/compiler/watchPublic.ts

@@ -228,6 +228,7 @@ export interface ProgramHost<T extends BuilderProgram> {
         options: CompilerOptions,
         containingSourceFile: SourceFile,
         reusedNames: readonly StringLiteralLike[] | undefined,
+        ambientModuleNames: readonly StringLiteralLike[] | undefined,
     ): readonly ResolvedModuleWithFailedLookupLocations[];
     resolveTypeReferenceDirectiveReferences?<T extends FileReference | string>(
         typeDirectiveReferences: readonly T[],
@@ -522,11 +523,13 @@ export function createWatchProgram<T extends BuilderProgram>(host: WatchCompiler
     compilerHost.resolveModuleNames = maybeBind(host, host.resolveModuleNames);
     if (!compilerHost.resolveModuleNameLiterals && !compilerHost.resolveModuleNames) {
         compilerHost.resolveModuleNameLiterals = resolutionCache.resolveModuleNameLiterals.bind(resolutionCache);
+        compilerHost.onReusedModuleResolutions = resolutionCache.onReusedModuleResolutions.bind(resolutionCache);
     }
     compilerHost.resolveTypeReferenceDirectiveReferences = maybeBind(host, host.resolveTypeReferenceDirectiveReferences);
     compilerHost.resolveTypeReferenceDirectives = maybeBind(host, host.resolveTypeReferenceDirectives);
     if (!compilerHost.resolveTypeReferenceDirectiveReferences && !compilerHost.resolveTypeReferenceDirectives) {
         compilerHost.resolveTypeReferenceDirectiveReferences = resolutionCache.resolveTypeReferenceDirectiveReferences.bind(resolutionCache);
+        compilerHost.onReusedTypeReferenceDirectiveResolutions = resolutionCache.onReusedTypeReferenceDirectiveResolutions.bind(resolutionCache);
     }
     compilerHost.resolveLibrary = !host.resolveLibrary ?
         resolutionCache.resolveLibrary.bind(resolutionCache) :