TypeReference directive reuse

Author: sheetalkamat

src/compiler/moduleNameResolver.ts

@@ -773,9 +773,9 @@ namespace ts {
     }
 
     /* @internal */
-    export function getResolutionName(entry: FileReference | StringLiteralLike) {
+    export function getResolutionName(entry: string | FileReference | StringLiteralLike) {
         // We lower-case all type references because npm automatically lowercases all packages. See GH#9824.
-        return isStringLiteralLike(entry) ? entry.text : entry.fileName.toLowerCase();
+        return !isString(entry) ? isStringLiteralLike(entry) ? entry.text : toFileNameLowerCase(entry.fileName) : entry;
     }
 
     /* @internal */

src/compiler/program.ts

@@ -501,8 +501,7 @@ namespace ts {
         for (const name of names) {
             let result: T;
             const mode = getModeForFileReference(name, containingFileMode);
-            // We lower-case all type references because npm automatically lowercases all packages. See GH#9824.
-            const strName = isString(name) ? name : name.fileName.toLowerCase();
+            const strName = getResolutionName(name);
             const cacheKey = mode !== undefined ? `${mode}|${strName}` : strName;
             if (cache.has(cacheKey)) {
                 result = cache.get(cacheKey)!;
@@ -1138,9 +1137,16 @@ namespace ts {
                 loadWithModeAwareCache(moduleNames, containingFile, containingFileName, redirectedReference, resolutionInfo, loader);
         }
 
-        let actualResolveTypeReferenceDirectiveNamesWorker: (typeDirectiveNames: string[] | readonly FileReference[], containingFile: string, redirectedReference?: ResolvedProjectReference, containingFileMode?: SourceFile["impliedNodeFormat"] | undefined) => (ResolvedTypeReferenceDirective | undefined)[];
+        let actualResolveTypeReferenceDirectiveNamesWorker: (
+            typeDirectiveNames: string[] | readonly FileReference[],
+            containingFile: string,
+            redirectedReference: ResolvedProjectReference | undefined,
+            containingFileMode: SourceFile["impliedNodeFormat"] | undefined,
+            resolutionInfo: TypeReferenceDirectiveResolutionInfo | undefined,
+        ) => (ResolvedTypeReferenceDirective | undefined)[];
         if (host.resolveTypeReferenceDirectives) {
-            actualResolveTypeReferenceDirectiveNamesWorker = (typeDirectiveNames, containingFile, redirectedReference, containingFileMode) => host.resolveTypeReferenceDirectives!(Debug.checkEachDefined(typeDirectiveNames), containingFile, redirectedReference, options, containingFileMode);
+            actualResolveTypeReferenceDirectiveNamesWorker = (typeDirectiveNames, containingFile, redirectedReference, containingFileMode, resolutionInfo) =>
+                host.resolveTypeReferenceDirectives!(Debug.checkEachDefined(typeDirectiveNames), containingFile, redirectedReference, options, containingFileMode, resolutionInfo);
         }
         else {
             typeReferenceDirectiveResolutionCache = createTypeReferenceDirectiveResolutionCache(currentDirectory, getCanonicalFileName, /*options*/ undefined, moduleResolutionCache?.getPackageJsonInfoCache());
@@ -1254,7 +1260,7 @@ namespace ts {
                 // This containingFilename needs to match with the one used in managed-side
                 const containingDirectory = options.configFilePath ? getDirectoryPath(options.configFilePath) : host.getCurrentDirectory();
                 const containingFilename = combinePaths(containingDirectory, inferredTypesContainingFile);
-                const resolutions = resolveTypeReferenceDirectiveNamesWorker(typeReferences, containingFilename);
+                const resolutions = resolveTypeReferenceDirectiveNamesReusingOldState(typeReferences, containingFilename);
                 for (let i = 0; i < typeReferences.length; i++) {
                     // under node16/nodenext module resolution, load `types`/ata include names as cjs resolution results by passing an `undefined` mode
                     processTypeReferenceDirective(typeReferences[i], /*mode*/ undefined, resolutions[i], { kind: FileIncludeKind.AutomaticTypeDirectiveFile, typeReference: typeReferences[i], packageId: resolutions[i]?.packageId });
@@ -1452,14 +1458,14 @@ namespace ts {
             return result;
         }
 
-        function resolveTypeReferenceDirectiveNamesWorker(typeDirectiveNames: string[] | readonly FileReference[], containingFile: string | SourceFile): readonly (ResolvedTypeReferenceDirective | undefined)[] {
+        function resolveTypeReferenceDirectiveNamesWorker(typeDirectiveNames: string[] | readonly FileReference[], containingFile: string | SourceFile, resolutionInfo: TypeReferenceDirectiveResolutionInfo | undefined): readonly (ResolvedTypeReferenceDirective | undefined)[] {
             if (!typeDirectiveNames.length) return [];
             const containingFileName = !isString(containingFile) ? getNormalizedAbsolutePath(containingFile.originalFileName, currentDirectory) : containingFile;
             const redirectedReference = !isString(containingFile) ? getRedirectReferenceForResolution(containingFile) : undefined;
             const containingFileMode = !isString(containingFile) ? containingFile.impliedNodeFormat : undefined;
             tracing?.push(tracing.Phase.Program, "resolveTypeReferenceDirectiveNamesWorker", { containingFileName });
             performance.mark("beforeResolveTypeReference");
-            const result = actualResolveTypeReferenceDirectiveNamesWorker(typeDirectiveNames, containingFileName, redirectedReference, containingFileMode);
+            const result = actualResolveTypeReferenceDirectiveNamesWorker(typeDirectiveNames, containingFileName, redirectedReference, containingFileMode, resolutionInfo);
             performance.mark("afterResolveTypeReference");
             performance.measure("ResolveTypeReference", "beforeResolveTypeReference", "afterResolveTypeReference");
             tracing?.pop();
@@ -1695,6 +1701,96 @@ namespace ts {
             }
         }
 
+        function resolveTypeReferenceDirectiveNamesReusingOldState(typeDirectiveNames: readonly FileReference[], containingFile: SourceFile): readonly (ResolvedTypeReferenceDirective | undefined)[];
+        function resolveTypeReferenceDirectiveNamesReusingOldState(typeDirectiveNames: string[], containingFile: string): readonly (ResolvedTypeReferenceDirective | undefined)[];
+        function resolveTypeReferenceDirectiveNamesReusingOldState(typeDirectiveNames: string[] | readonly FileReference[], containingFile: string | SourceFile): readonly (ResolvedTypeReferenceDirective | undefined)[] {
+            if (structureIsReused === StructureIsReused.Not) {
+                // 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 resolveTypeReferenceDirectiveNamesWorker(typeDirectiveNames, containingFile, /*resolutionInfo*/ undefined);
+            }
+
+            const oldSourceFile = !isString(containingFile) ? oldProgram && oldProgram.getSourceFile(containingFile.fileName) : undefined;
+            if (!isString(containingFile)) {
+                if (oldSourceFile !== containingFile && containingFile.resolvedTypeReferenceDirectiveNames) {
+                    // `file` was created for the new program.
+                    //
+                    // We only set `file.resolvedTypeReferenceDirectiveNames` via work from the current function,
+                    // so it is defined iff we already called the current function on `file`.
+                    // That call happened no later than the creation of the `file` object,
+                    // which per above occurred during the current program creation.
+                    // Since we assume the filesystem does not change during program creation,
+                    // it is safe to reuse resolutions from the earlier call.
+                    const result: (ResolvedTypeReferenceDirective | undefined)[] = [];
+                    for (const typeDirectiveName of typeDirectiveNames as readonly FileReference[]) {
+                        // We lower-case all type references because npm automatically lowercases all packages. See GH#9824.
+                        const resolvedTypeReferenceDirective = containingFile.resolvedTypeReferenceDirectiveNames.get(getResolutionName(typeDirectiveName), typeDirectiveName.resolutionMode || containingFile.impliedNodeFormat);
+                        result.push(resolvedTypeReferenceDirective);
+                    }
+                    return result;
+                }
+            }
+
+            /** An ordered list of module names for which we cannot recover the resolution. */
+            let unknownTypeReferenceDirectiveNames: string[] | FileReference[] | undefined;
+            let result: (ResolvedTypeReferenceDirective | undefined)[] | undefined;
+            let reusedNames: (string | FileReference)[] | undefined;
+            const containingSourceFile = !isString(containingFile) ? containingFile : undefined;
+            const canReuseResolutions = !isString(containingFile) ?
+                containingFile === oldSourceFile && !hasInvalidatedResolutions(oldSourceFile.path) :
+                !hasInvalidatedResolutions(toPath(containingFile));
+            for (let i = 0; i < typeDirectiveNames.length; i++) {
+                const entry = typeDirectiveNames[i];
+                if (canReuseResolutions) {
+                    const typeDirectiveName = getResolutionName(entry);
+                    const mode = getModeForFileReference(entry, containingSourceFile?.impliedNodeFormat);
+                    const oldResolvedTypeReferenceDirective = getResolvedTypeReferenceDirective(oldSourceFile, typeDirectiveName, mode);
+                    if (oldResolvedTypeReferenceDirective) {
+                        if (isTraceEnabled(options, host)) {
+                            trace(host,
+                                oldResolvedTypeReferenceDirective.packageId ?
+                                    Diagnostics.Reusing_resolution_of_type_reference_directive_0_from_1_of_old_program_it_was_successfully_resolved_to_2_with_Package_ID_3 :
+                                    Diagnostics.Reusing_resolution_of_type_reference_directive_0_from_1_of_old_program_it_was_successfully_resolved_to_2,
+                                typeDirectiveName,
+                                !isString(containingFile) ? getNormalizedAbsolutePath(containingFile.originalFileName, currentDirectory) : containingFile,
+                                oldResolvedTypeReferenceDirective.resolvedFileName,
+                                oldResolvedTypeReferenceDirective.packageId && packageIdToString(oldResolvedTypeReferenceDirective.packageId)
+                            );
+                        }
+                        (result ??= new Array(typeDirectiveNames.length))[i] = oldResolvedTypeReferenceDirective;
+                        (reusedNames ??= []).push(entry);
+                        continue;
+                    }
+                }
+                // Resolution failed in the old program, or resolved to an ambient module for which we can't reuse the result.
+                (unknownTypeReferenceDirectiveNames ??= []).push(entry as FileReference & string);
+            }
+
+            if (!unknownTypeReferenceDirectiveNames) return result || emptyArray;
+            const resolutions = resolveTypeReferenceDirectiveNamesWorker(
+                unknownTypeReferenceDirectiveNames,
+                containingFile,
+                { names: unknownTypeReferenceDirectiveNames, reusedNames }
+            );
+
+            // Combine results of resolutions
+            if (!result) {
+                // There were no unresolved resolutions.
+                Debug.assert(resolutions.length === typeDirectiveNames.length);
+                return resolutions;
+            }
+
+            let j = 0;
+            for (let i = 0; i < result.length; i++) {
+                if (!result[i]) {
+                    result[i] = resolutions[j];
+                    j++;
+                }
+            }
+            Debug.assert(j === resolutions.length);
+            return result;
+        }
+
         function canReuseProjectReferences(): boolean {
             return !forEachProjectReference(
                 oldProgram!.getProjectReferences(),
@@ -1898,7 +1994,7 @@ namespace ts {
                     newSourceFile.resolvedModules = oldSourceFile.resolvedModules;
                 }
                 const typesReferenceDirectives = newSourceFile.typeReferenceDirectives;
-                const typeReferenceResolutions = resolveTypeReferenceDirectiveNamesWorker(typesReferenceDirectives, newSourceFile);
+                const typeReferenceResolutions = resolveTypeReferenceDirectiveNamesReusingOldState(typesReferenceDirectives, newSourceFile);
                 // ensure that types resolutions are still correct
                 const typeReferenceResolutionsChanged = hasChangesInResolutions(typesReferenceDirectives, newSourceFile, typeReferenceResolutions, oldSourceFile.resolvedTypeReferenceDirectiveNames, typeDirectiveIsEqualTo);
                 if (typeReferenceResolutionsChanged) {
@@ -3165,13 +3261,13 @@ namespace ts {
                 return;
             }
 
-            const resolutions = resolveTypeReferenceDirectiveNamesWorker(typeDirectives, file);
+            const resolutions = resolveTypeReferenceDirectiveNamesReusingOldState(typeDirectives, file);
             for (let index = 0; index < typeDirectives.length; index++) {
                 const ref = file.typeReferenceDirectives[index];
                 const resolvedTypeReferenceDirective = resolutions[index];
                 // store resolved type directive on the file
                 const fileName = toFileNameLowerCase(ref.fileName);
-                setResolvedTypeReferenceDirective(file, fileName, resolvedTypeReferenceDirective);
+                setResolvedTypeReferenceDirective(file, fileName, resolvedTypeReferenceDirective, getModeForFileReference(ref, file.impliedNodeFormat));
                 const mode = ref.resolutionMode || file.impliedNodeFormat;
                 if (mode && getEmitModuleResolutionKind(options) !== ModuleResolutionKind.Node16 && getEmitModuleResolutionKind(options) !== ModuleResolutionKind.NodeNext) {
                     programDiagnostics.add(createDiagnosticForRange(file, ref, Diagnostics.resolution_mode_assertions_are_only_supported_when_moduleResolution_is_node16_or_nodenext));

src/compiler/resolutionCache.ts

@@ -14,7 +14,13 @@ namespace ts {
             resolutionInfo: ModuleResolutionInfo | undefined
         ): (ResolvedModuleFull | undefined)[];
         getResolvedModuleWithFailedLookupLocationsFromCache(moduleName: string, containingFile: string, resolutionMode?: ModuleKind.CommonJS | ModuleKind.ESNext): CachedResolvedModuleWithFailedLookupLocations | undefined;
-        resolveTypeReferenceDirectives(typeDirectiveNames: string[] | readonly FileReference[], containingFile: string, redirectedReference?: ResolvedProjectReference, containingFileMode?: SourceFile["impliedNodeFormat"]): (ResolvedTypeReferenceDirective | undefined)[];
+        resolveTypeReferenceDirectives(
+            typeDirectiveNames: string[] | readonly FileReference[],
+            containingFile: string,
+            redirectedReference: ResolvedProjectReference | undefined,
+            containingFileMode: SourceFile["impliedNodeFormat"] | undefined,
+            resolutionInfo: TypeReferenceDirectiveResolutionInfo | undefined,
+        ): (ResolvedTypeReferenceDirective | undefined)[];
 
         invalidateResolutionsOfFailedLookupLocations(): boolean;
         invalidateResolutionOfFile(filePath: Path): void;
@@ -416,7 +422,7 @@ namespace ts {
             getResolutionWithResolvedFileName: GetResolutionWithResolvedFileName<T, R>;
             shouldRetryResolution: (t: T) => boolean;
             reusedNames?: readonly string[];
-            resolutionInfo?: ModuleResolutionInfo;
+            resolutionInfo?: ModuleResolutionInfo | TypeReferenceDirectiveResolutionInfo;
             logChanges?: boolean;
             containingSourceFile?: SourceFile;
             containingSourceFileMode?: SourceFile["impliedNodeFormat"];
@@ -450,7 +456,7 @@ namespace ts {
             const seenNamesInFile = createModeAwareCache<true>();
             let i = 0;
             for (const entry of containingSourceFile && resolutionInfo ? resolutionInfo.names : names) {
-                const name = !isString(entry) ? getResolutionName(entry) : entry;
+                const name = getResolutionName(entry);
                 // Imports supply a `containingSourceFile` but no `containingSourceFileMode` - it would be redundant
                 // they require calculating the mode for a given import from it's position in the resolution table, since a given
                 // import's syntax may override the file's default mode.
@@ -547,7 +553,13 @@ namespace ts {
             }
 
             if (containingSourceFile && resolutionInfo) {
-                resolutionInfo.reusedNames?.forEach(literal => seenNamesInFile.set(literal.text, getModeForUsageLocation(containingSourceFile, literal), true));
+                resolutionInfo.reusedNames?.forEach(entry => seenNamesInFile.set(
+                    getResolutionName(entry),
+                    !isString(entry) && isStringLiteralLike(entry) ?
+                        getModeForUsageLocation(containingSourceFile, entry) :
+                        getModeForFileReference(entry, containingSourceFile.impliedNodeFormat),
+                    true,
+                ));
                 reusedNames = undefined;
             }
             if (resolutionsInFile.size() !== seenNamesInFile.size()) {
@@ -581,7 +593,13 @@ namespace ts {
             }
         }
 
-        function resolveTypeReferenceDirectives(typeDirectiveNames: string[] | readonly FileReference[], containingFile: string, redirectedReference?: ResolvedProjectReference, containingFileMode?: SourceFile["impliedNodeFormat"]): (ResolvedTypeReferenceDirective | undefined)[] {
+        function resolveTypeReferenceDirectives(
+            typeDirectiveNames: string[] | readonly FileReference[],
+            containingFile: string,
+            redirectedReference?: ResolvedProjectReference,
+            containingFileMode?: SourceFile["impliedNodeFormat"],
+            resolutionInfo?: TypeReferenceDirectiveResolutionInfo,
+        ): (ResolvedTypeReferenceDirective | undefined)[] {
             return resolveNamesWithLocalCache<CachedResolvedTypeReferenceDirectiveWithFailedLookupLocations, ResolvedTypeReferenceDirective>({
                 names: typeDirectiveNames,
                 containingFile,
@@ -591,7 +609,8 @@ namespace ts {
                 loader: resolveTypeReferenceDirective,
                 getResolutionWithResolvedFileName: getResolvedTypeReferenceDirective,
                 shouldRetryResolution: resolution => resolution.resolvedTypeReferenceDirective === undefined,
-                containingSourceFileMode: containingFileMode
+                containingSourceFileMode: containingFileMode,
+                resolutionInfo,
             });
         }