Handle auto type reference directive resolutions

Author: sheetalkamat

src/compiler/program.ts

@@ -1670,32 +1670,33 @@ 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)[] {
-            // TODO: (shkamat) reuse auto type reference resolutions
-            if (structureIsReused === StructureIsReused.Not || isString(containingFile)) {
+            if (structureIsReused === StructureIsReused.Not) {
                 return resolveTypeReferenceDirectiveNamesWorker(typeDirectiveNames, containingFile, /*partialResolutionInfo*/ undefined);
             }
 
-            const oldSourceFile = oldProgram && oldProgram.getSourceFile(containingFile.fileName);
-            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[] = [];
-                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(typeDirectiveName.fileName.toLowerCase(), typeDirectiveName.resolutionMode || containingFile.impliedNodeFormat)!;
-                    result.push(resolvedTypeReferenceDirective);
+            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[] = [];
+                    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(typeDirectiveName.fileName.toLowerCase(), typeDirectiveName.resolutionMode || containingFile.impliedNodeFormat)!;
+                        result.push(resolvedTypeReferenceDirective);
+                    }
+                    return result;
                 }
-                return result;
             }
 
             /** An ordered list of module names for which we cannot recover the resolution. */
-            let unknownTypeReferenceDirectiveNames: FileReference[] | undefined;
+            let unknownTypeReferenceDirectiveNames: string [] | FileReference[] | undefined;
             let unknownTypeReferenceDirectiveNamesIndex: number[] | undefined;
             /**
              * The indexing of elements in this list matches that of `moduleNames`.
@@ -1705,12 +1706,15 @@ namespace ts {
              */
             let result: (ResolvedTypeReferenceDirective | undefined)[] | undefined;
             let reusedNames: { name: string; mode: ModuleKind.CommonJS | ModuleKind.ESNext | undefined; }[] | undefined;
+            const canReuseResolutions = !isString(containingFile) ?
+                containingFile === oldSourceFile && !hasInvalidatedResolution(oldSourceFile.path) :
+                !hasInvalidatedResolution(toPath(containingFile));
             for (let i = 0; i < typeDirectiveNames.length; i++) {
-                const entry = typeDirectiveNames[i] as FileReference;
+                const entry = typeDirectiveNames[i];
                 // If the source file is unchanged and doesnt have invalidated resolution, reuse the module resolutions
-                if (containingFile === oldSourceFile && !hasInvalidatedResolution(oldSourceFile.path)) {
-                    const typeDirectiveName = entry.fileName.toLowerCase();
-                    const mode = getModeForFileReference(entry, oldSourceFile.impliedNodeFormat);
+                if (canReuseResolutions) {
+                    const typeDirectiveName = !isString(entry) ? entry.fileName.toLowerCase() : entry;
+                    const mode = getModeForFileReference(entry, oldSourceFile?.impliedNodeFormat);
                     const oldResolvedTypeReferenceDirective = getResolvedTypeReferenceDirective(oldSourceFile, typeDirectiveName, mode);
                     if (oldResolvedTypeReferenceDirective) {
                         if (isTraceEnabled(options, host)) {
@@ -1719,7 +1723,7 @@ namespace ts {
                                     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,
-                                getNormalizedAbsolutePath(containingFile.originalFileName, currentDirectory),
+                                !isString(containingFile) ? getNormalizedAbsolutePath(containingFile.originalFileName, currentDirectory) : containingFile,
                                 oldResolvedTypeReferenceDirective.resolvedFileName,
                                 oldResolvedTypeReferenceDirective.packageId && packageIdToString(oldResolvedTypeReferenceDirective.packageId)
                             );
@@ -1730,7 +1734,7 @@ namespace ts {
                     }
                 }
                 // Resolution failed in the old program, or resolved to an ambient module for which we can't reuse the result.
-                (unknownTypeReferenceDirectiveNames ??= []).push(entry);
+                (unknownTypeReferenceDirectiveNames ??= []).push(entry as FileReference & string);
                 (unknownTypeReferenceDirectiveNamesIndex ??= []).push(i);
             }
 

src/testRunner/unittests/tscWatch/moduleResolution.ts

@@ -142,5 +142,94 @@ namespace ts.tscWatch {
                 }
             ]
         });
+
+        verifyTscWatch({
+            scenario: "moduleResolution",
+            subScenario: "type reference resolutions reuse",
+            sys: () => createWatchedSystem([
+                {
+                    path: `${projectRoot}/tsconfig.json`,
+                    content: JSON.stringify({
+                        compilerOptions: { moduleResolution: "node16" },
+                    })
+                },
+                {
+                    path: `${projectRoot}/index.ts`,
+                    content: Utils.dedent`
+                        /// <reference types="pkg" resolution-mode="import"/>
+                        /// <reference types="pkg1" resolution-mode="require"/>
+                        export interface LocalInterface extends RequireInterface {}
+                    `
+                },
+                {
+                    path: `${projectRoot}/a.ts`,
+                    content: Utils.dedent`
+                        export const x = 10;
+                    `
+                },
+                {
+                    path: `${projectRoot}/node_modules/pkg/package.json`,
+                    content: JSON.stringify({
+                        name: "pkg",
+                        version: "0.0.1",
+                        exports: {
+                            import: "./import.js",
+                            require: "./require.js"
+                        }
+                    })
+                },
+                {
+                    path: `${projectRoot}/node_modules/pkg/import.d.ts`,
+                    content: Utils.dedent`
+                        export {};
+                        declare global {
+                            interface ImportInterface {}
+                        }
+                    `
+                },
+                {
+                    path: `${projectRoot}/node_modules/pkg/require.d.ts`,
+                    content: Utils.dedent`
+                        export {};
+                        declare global {
+                            interface RequireInterface {}
+                        }
+                    `
+                },
+                {
+                    path: `${projectRoot}/node_modules/pkg1/package.json`,
+                    content: JSON.stringify({
+                        name: "pkg1",
+                        version: "0.0.1",
+                        exports: {
+                            import: "./import.js",
+                            require: "./require.js"
+                        }
+                    })
+                },
+                {
+                    path: `${projectRoot}/node_modules/pkg1/import.d.ts`,
+                    content: Utils.dedent`
+                        export {};
+                        declare global {
+                            interface ImportInterface {}
+                        }
+                    `
+                },
+                {
+                    path: `${projectRoot}/node_modules/@types/pkg2/index.d.ts`,
+                    content: `export const x = 10;`
+                },
+                libFile
+            ], { currentDirectory: projectRoot }),
+            commandLineArgs: ["-w", "--traceResolution"],
+            changes: [
+                {
+                    caption: "modify aFile by adding import",
+                    change: sys => sys.prependFile(`${projectRoot}/a.ts`, `/// <reference types="pkg" resolution-mode="import"/>\n`),
+                    timeouts: sys => sys.runQueuedTimeoutCallbacks(),
+                }
+            ]
+        });
     });
 }