properly handle references config changes

Author: gabritto

tsc/internal/project/configfileregistrybuilder.go

@@ -353,6 +353,23 @@ func (c *configFileRegistryBuilder) releaseConfigForProject(configFilePath tspat
 	}
 }
 
+func (c *configFileRegistryBuilder) retainConfigForProject(configFilePath tspath.Path, projectPath tspath.Path) {
+	if entry, ok := c.configs.Load(configFilePath); ok {
+		entry.ChangeIf(
+			func(config *configFileEntry) bool {
+				_, exists := config.retainingProjects[projectPath]
+				return !exists
+			},
+			func(config *configFileEntry) {
+				if config.retainingProjects == nil {
+					config.retainingProjects = make(map[tspath.Path]struct{})
+				}
+				config.retainingProjects[projectPath] = struct{}{}
+			},
+		)
+	}
+}
+
 // didCloseFile removes the open file from the config entry. Once no projects
 // or files are associated with the config entry, it will be removed on the next call to `cleanup`.
 func (c *configFileRegistryBuilder) didCloseFile(path tspath.Path) {

tsc/internal/project/projectcollectionbuilder.go

@@ -763,8 +763,13 @@ func (b *ProjectCollectionBuilder) markProjectsAffectedByConfigChanges(
 	logger *logging.LogTree,
 ) bool {
 	for projectPath := range configChangeResult.affectedProjects {
-		project, ok := b.configuredProjects.Load(projectPath)
-		if !ok {
+		var project dirty.Value[*Project]
+		if projectPath == inferredProjectName {
+			project = b.inferredProject
+		} else {
+			project, _ = b.configuredProjects.Load(projectPath)
+		}
+		if project == nil || project.Value() == nil {
 			panic(fmt.Sprintf("project %s affected by config change not found", projectPath))
 		}
 		project.ChangeIf(
@@ -1126,12 +1131,17 @@ func (b *ProjectCollectionBuilder) updateInferredProjectRoots(rootFileNames []st
 	return b.updateInferredProject(rootFileNames, b.compilerOptionsForInferredProjects, projectReferences, configFileParsingDiagnostics, b.inferredContentMappers, logger)
 }
 
-// seedInferredProjectForProgram adapts one selected project into the isolated synthetic-project slot used by createProgram.
+// seedInferredProjectForProgram copies the specified project into the synthetic inferred project used by createProgram.
 func (b *ProjectCollectionBuilder) seedInferredProjectForProgram(project *Project, logger *logging.LogTree) {
 	if project == nil || project.Program == nil {
 		return
 	}
-	b.inferredProject.Set(newInferredProjectFromProject(project, b, logger))
+	inferredProject := newInferredProjectFromProject(project, b, logger)
+	project.Program.RangeResolvedProjectReference(func(referencePath tspath.Path, _ *tsoptions.ParsedCommandLine, _ *tsoptions.ParsedCommandLine, _ int) bool {
+		b.configFileRegistryBuilder.retainConfigForProject(referencePath, inferredProject.configFilePath)
+		return true
+	})
+	b.inferredProject.Set(inferredProject)
 }
 
 // updateInferredProject preserves the current command line when roots/options are unchanged.

tsc/internal/project/refcountcache_test.go

@@ -7,6 +7,7 @@ import (
 
 	"github.com/microsoft/TypeScript/tsc/internal/ast"
 	"github.com/microsoft/TypeScript/tsc/internal/bundled"
+	"github.com/microsoft/TypeScript/tsc/internal/collections"
 	"github.com/microsoft/TypeScript/tsc/internal/compiler"
 	"github.com/microsoft/TypeScript/tsc/internal/contentmapper"
 	"github.com/microsoft/TypeScript/tsc/internal/core"
@@ -491,5 +492,81 @@ func TestRefCountingCaches(t *testing.T) {
 			_, ok = session.extendedConfigCache.entries.Load(extendedConfigPath)
 			assert.Assert(t, !ok)
 		})
+
+		t.Run("createProgram retains and reloads extended configs from referenced projects", func(t *testing.T) {
+			t.Parallel()
+
+			const (
+				appConfigPath     = "/user/username/projects/app/tsconfig.json"
+				appFilePath       = "/user/username/projects/app/index.ts"
+				libConfigPath     = "/user/username/projects/lib/tsconfig.json"
+				libBaseConfigPath = "/user/username/projects/lib/tsconfig.base.json"
+				libFilePath       = "/user/username/projects/lib/index.ts"
+			)
+			session := setup(map[string]any{
+				appConfigPath:     `{"compilerOptions":{"noLib":true},"files":["index.ts"],"references":[{"path":"../lib"}]}`,
+				appFilePath:       "export const app = 1;",
+				libConfigPath:     `{"extends":"./tsconfig.base.json","files":["index.ts"]}`,
+				libBaseConfigPath: `{"compilerOptions":{"composite":true,"noLib":true}}`,
+				libFilePath:       "export const lib = 1;",
+			})
+			defer session.Close()
+			ctx := context.Background()
+
+			baseSnapshot, err := session.APIUpdate(ctx, FileChangeSummary{}, &APISnapshotRequest{
+				OpenProjects: collections.NewSetFromItems(appConfigPath),
+			})
+			assert.NilError(t, err)
+			defer baseSnapshot.Deref(session)
+			appProject := baseSnapshot.ProjectCollection.GetProjectByPath(baseSnapshot.toPath(appConfigPath))
+			assert.Assert(t, appProject != nil)
+
+			programSnapshot := session.APICreateProgram(
+				ctx,
+				appProject.CommandLine.FileNames(),
+				appProject.CommandLine.CompilerOptions(),
+				appProject.CommandLine.ProjectReferences(),
+				appProject.CommandLine.Errors,
+				baseSnapshot,
+				appProject,
+				FileChangeSummary{},
+			)
+			defer programSnapshot.Deref(session)
+			programProject := programSnapshot.ProjectCollection.InferredProject()
+			assert.Assert(t, programProject != nil)
+			assert.Assert(t, programProject.Program == appProject.Program)
+
+			extendedConfigEntry, ok := session.extendedConfigCache.entries.Load(tspath.Path(libBaseConfigPath))
+			assert.Assert(t, ok)
+			extendedConfigEntry.mu.Lock()
+			_, ownedByBaseSnapshot := extendedConfigEntry.owners[baseSnapshot.id]
+			_, ownedByProgramSnapshot := extendedConfigEntry.owners[programSnapshot.id]
+			ownerCount := len(extendedConfigEntry.owners)
+			extendedConfigEntry.mu.Unlock()
+			assert.Assert(t, ownedByBaseSnapshot)
+			assert.Assert(t, ownedByProgramSnapshot)
+			assert.Equal(t, ownerCount, 2)
+
+			assert.NilError(t, session.fs.fs.WriteFile(libBaseConfigPath, `{"compilerOptions":{"composite":true,"noLib":true,"strict":true}}`))
+			var fileChanges FileChangeSummary
+			fileChanges.Changed.Add(lsproto.DocumentUri("file://" + libBaseConfigPath))
+			updatedProgramSnapshot := session.APICreateProgram(
+				ctx,
+				programProject.CommandLine.FileNames(),
+				programProject.CommandLine.CompilerOptions(),
+				programProject.CommandLine.ProjectReferences(),
+				programProject.CommandLine.Errors,
+				programSnapshot,
+				programProject,
+				fileChanges,
+			)
+			defer updatedProgramSnapshot.Deref(session)
+			updatedProgramProject := updatedProgramSnapshot.ProjectCollection.InferredProject()
+			assert.Assert(t, updatedProgramProject != nil)
+			assert.Assert(t, updatedProgramProject.Program != programProject.Program)
+			updatedReferences := updatedProgramProject.Program.GetResolvedProjectReferences()
+			assert.Equal(t, len(updatedReferences), 1)
+			assert.Equal(t, updatedReferences[0].CompilerOptions().Strict, core.TSTrue)
+		})
 	})
 }