Save names of auto type directive names so that we can update program correctly

Author: sheetalkamat

src/compiler/builder.ts

@@ -87,6 +87,7 @@ namespace ts {
         sourceFileToPackageName: ESMap<Path, string>;
         projectReferences: readonly ProjectReference[] | undefined;
         resolvedProjectReferences: readonly (ResolvedProjectReferenceOfProgramFromBuildInfo | undefined)[] | undefined;
+        automaticTypeDirectiveNames: string[] | undefined;
         resolvedTypeReferenceDirectives: ESMap<string, ResolvedTypeReferenceDirectiveWithFailedLookupLocations>;
         fileProcessingDiagnostics: FilePreprocessingDiagnostic[] | undefined;
     }
@@ -351,6 +352,7 @@ namespace ts {
             projectReferences: state.program.getProjectReferences(),
             resolvedProjectReferences: state.program.getResolvedProjectReferences()?.map(toResolvedProjectReferenceOfProgramFromBuildInfo),
             resolvedTypeReferenceDirectives: state.program.getResolvedTypeReferenceDirectives(),
+            automaticTypeDirectiveNames: state.program.getAutomaticTypeDirectiveNames(),
             fileProcessingDiagnostics: state.program.getFileProcessingDiagnostics(),
         };
 
@@ -918,6 +920,7 @@ namespace ts {
         filesByName: readonly PersistedProgramFileByNameEntry[] | undefined;
         projectReferences: readonly PersistedProgramProjectReference[] | undefined;
         resolvedProjectReferences: readonly (PersistedProgramResolvedProjectReference | undefined)[] | undefined;
+        automaticTypeDirectiveNames: string[] | undefined;
         resolvedTypeReferenceDirectives: readonly PersistedProgramResolutionEntry[] | undefined;
         fileProcessingDiagnostics: readonly PersistedProgramFilePreprocessingDiagnostic[] | undefined;
         resolutions: readonly PersistedProgramResolution[] | undefined;
@@ -1030,6 +1033,7 @@ namespace ts {
                 projectReferences: program.getProjectReferences()?.map(toPersistedProgramProjectReference),
                 resolvedProjectReferences: program.getResolvedProjectReferences()?.map(toPersistedProgramResolvedProjectReference),
                 resolvedTypeReferenceDirectives: toPersistedProgramResolutionMap(program.getResolvedTypeReferenceDirectives()),
+                automaticTypeDirectiveNames: program.getAutomaticTypeDirectiveNames()?.length ? program.getAutomaticTypeDirectiveNames() : undefined,
                 fileProcessingDiagnostics: mapToReadonlyArrayOrUndefined(program.getFileProcessingDiagnostics(), toPersistedProgramFilePreprocessingDiagnostic),
                 resolutions: mapToReadonlyArrayOrUndefined(resolutions, toPersistedProgramResolution),
             };
@@ -1745,6 +1749,7 @@ namespace ts {
             sourceFileToPackageName,
             projectReferences: program.peristedProgram.projectReferences?.map(toProjectReference),
             resolvedProjectReferences: program.peristedProgram.resolvedProjectReferences?.map(toResolvedProjectReference),
+            automaticTypeDirectiveNames: program.peristedProgram.automaticTypeDirectiveNames,
             resolvedTypeReferenceDirectives: toResolutionMap(program.peristedProgram.resolvedTypeReferenceDirectives) || new Map(),
             fileProcessingDiagnostics: map(program.peristedProgram.fileProcessingDiagnostics, toFileProcessingDiagnostic),
         };
@@ -1863,6 +1868,7 @@ namespace ts {
             },
             getProjectReferences: () => persistedProgramState.projectReferences,
             getResolvedProjectReferences: () => persistedProgramState.resolvedProjectReferences,
+            getAutomaticTypeDirectiveNames: () => persistedProgramState.automaticTypeDirectiveNames,
             getMissingFilePaths: () => missingFilePaths ||= getMissingFilePaths(persistedProgramState.filesByName),
             getFileIncludeReasons: () => persistedProgramState.fileIncludeReasons,
             getResolvedTypeReferenceDirectives: () => persistedProgramState.resolvedTypeReferenceDirectives,

src/compiler/program.ts

@@ -847,6 +847,7 @@ namespace ts {
         const cachedBindAndCheckDiagnosticsForFile: DiagnosticCache<Diagnostic> = {};
         const cachedDeclarationDiagnosticsForFile: DiagnosticCache<DiagnosticWithLocation> = {};
 
+        let automaticTypeDirectiveNames: string[] | undefined;
         let resolvedTypeReferenceDirectives = new Map<string, ResolvedTypeReferenceDirectiveWithFailedLookupLocations>();
         let fileProcessingDiagnostics: FilePreprocessingDiagnostic[] | undefined;
 
@@ -1023,16 +1024,16 @@ namespace ts {
             tracing?.pop();
 
             // load type declarations specified via 'types' argument or implicitly from types/ and node_modules/@types folders
-            const typeReferences: string[] = rootNames.length ? getAutomaticTypeDirectiveNames(options, host) : emptyArray;
+            automaticTypeDirectiveNames ||= rootNames.length ? getAutomaticTypeDirectiveNames(options, host) : emptyArray;
 
-            if (typeReferences.length) {
-                tracing?.push(tracing.Phase.Program, "processTypeReferences", { count: typeReferences.length });
+            if (automaticTypeDirectiveNames.length) {
+                tracing?.push(tracing.Phase.Program, "processTypeReferences", { count: automaticTypeDirectiveNames.length });
                 // 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);
-                for (let i = 0; i < typeReferences.length; i++) {
-                    processTypeReferenceDirective(typeReferences[i], resolutions[i], { kind: FileIncludeKind.AutomaticTypeDirectiveFile, typeReference: typeReferences[i], packageId: resolutions[i]?.resolvedTypeReferenceDirective?.packageId });
+                const resolutions = resolveTypeReferenceDirectiveNamesWorker(automaticTypeDirectiveNames, containingFilename);
+                for (let i = 0; i < automaticTypeDirectiveNames.length; i++) {
+                    processTypeReferenceDirective(automaticTypeDirectiveNames[i], resolutions[i], { kind: FileIncludeKind.AutomaticTypeDirectiveFile, typeReference: automaticTypeDirectiveNames[i], packageId: resolutions[i]?.resolvedTypeReferenceDirective?.packageId });
                 }
                 tracing?.pop();
             }
@@ -1136,6 +1137,7 @@ namespace ts {
             getRelationCacheSizes: () => getDiagnosticsProducingTypeChecker().getRelationCacheSizes(),
             getFileProcessingDiagnostics: () => fileProcessingDiagnostics,
             getResolvedTypeReferenceDirectives: () => resolvedTypeReferenceDirectives,
+            getAutomaticTypeDirectiveNames: () => automaticTypeDirectiveNames!,
             isSourceFileFromExternalLibrary,
             isSourceFileFromExternalLibraryPath,
             isSourceFileDefaultLibrary,
@@ -1680,10 +1682,21 @@ namespace ts {
                 return structureIsReused;
             }
 
-            if (changesAffectingProgramStructure(oldOptions, options) || host.hasChangedAutomaticTypeDirectiveNames?.()) {
+            if (changesAffectingProgramStructure(oldOptions, options)) {
                 return StructureIsReused.SafeModules;
             }
 
+            if (host.hasChangedAutomaticTypeDirectiveNames) {
+                if (host.hasChangedAutomaticTypeDirectiveNames()) return StructureIsReused.SafeModules;
+            }
+            else {
+                // See if auto type reference directives have changed
+                automaticTypeDirectiveNames = rootNames.length ? getAutomaticTypeDirectiveNames(options, host) : emptyArray;
+                if (!arrayIsEqualTo(automaticTypeDirectiveNames, oldProgram.getAutomaticTypeDirectiveNames() || emptyArray)) {
+                    return StructureIsReused.SafeModules;
+                }
+            }
+
             // update fileName -> file mapping
             for (let index = 0; index < newSourceFiles.length; index++) {
                 const newSourceFile = newSourceFiles[index];
@@ -1726,6 +1739,7 @@ namespace ts {
             fileReasons = oldProgram.getFileIncludeReasons();
             fileProcessingDiagnostics = oldProgram.getFileProcessingDiagnostics();
             resolvedTypeReferenceDirectives = oldProgram.getResolvedTypeReferenceDirectives();
+            automaticTypeDirectiveNames = oldProgram.getAutomaticTypeDirectiveNames() || emptyArray;
 
             sourceFileToPackageName = oldProgram.sourceFileToPackageName;
             redirectTargetsMap = oldProgram.redirectTargetsMap;

src/compiler/types.ts

@@ -3937,6 +3937,7 @@ namespace ts {
 
         /* @internal */ getFileProcessingDiagnostics(): FilePreprocessingDiagnostic[] | undefined;
         /* @internal */ getResolvedTypeReferenceDirectives(): ESMap<string, ResolvedTypeReferenceDirectiveWithFailedLookupLocations>;
+        /* @internal */ getAutomaticTypeDirectiveNames(): string[];
         isSourceFileFromExternalLibrary(file: SourceFile): boolean;
         /* @internal */ isSourceFileFromExternalLibraryPath(path: Path): boolean;
         isSourceFileDefaultLibrary(file: SourceFile): boolean;
@@ -4040,6 +4041,7 @@ namespace ts {
         getMissingFilePaths(): readonly Path[];
         getFileIncludeReasons(): MultiMap<Path, FileIncludeReason>;
         getResolvedTypeReferenceDirectives(): ESMap<string, ResolvedTypeReferenceDirectiveWithFailedLookupLocations>;
+        getAutomaticTypeDirectiveNames(): string[] | undefined;
         getFilesByNameMap(): ESMap<Path, SourceFileOfProgramFromBuildInfo | Path | typeof missingSourceOfProjectReferenceRedirect | typeof missingFile>;
         isSourceFileFromExternalLibraryPath(path: Path): boolean;
         getFileProcessingDiagnostics(): FilePreprocessingDiagnostic[] | undefined;

src/testRunner/unittests/tsc/persistResolutions.ts

@@ -2,8 +2,8 @@ namespace ts.PersistentResolutionsTests {
     describe("unittests:: tsc:: persistResolutions::", () => {
         const cleanResolutionsWithProject = cleanResolutions("--p");
         const cleanResolutionsAgainWithProject = cleanResolutionsAgain("--p");
-        const installNewTypeWithProject = installNewType("Install another type and it is not picked by program");
-        const deleteExistingTypeWithProject = deleteExistingType("Delete existing type and this will trigger new program so above new type becomes part of program");
+        const installNewTypeWithProject = installNewType("Install another type");
+        const deleteExistingTypeWithProject = deleteExistingType("Delete existing type");
 
         verifyTscSerializedIncrementalEdits({
             scenario: "persistResolutions",