Let the session own what a change reaches

A pull kept the incremental view of each project's program in a map on the
server, keyed by project, and worked out when to rebuild it by comparing program
pointers. That is state the session already knows how to keep: it belongs to a
program, it is replaced when the program is, and it should go when the project
does.

It now sits on the project beside the checker pool, and the collection builder
rolls it forward where it already discards the old pool. Rolling it forward
keeps what the old program worked out and drops the program it worked it out
from, which the map could not do: a map entry held the previous program until
the next pull replaced it, so a project's last two programs were reachable at
once.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: eagarwal-notion

tsc/internal/execute/incremental/program.go

@@ -72,6 +72,16 @@ type TestingData struct {
 	UpdatedSignatureKinds                map[tspath.Path]SignatureUpdateKind
 }
 
+// WithoutProgram returns what a later program needs in order to work out what a change reached,
+// and nothing else. A caller holding a whole Program for that would hold its program, and every
+// type reachable from it, until the next one is built.
+func (p *Program) WithoutProgram() *Program {
+	if p == nil {
+		return nil
+	}
+	return &Program{snapshot: p.snapshot, host: p.host}
+}
+
 func (p *Program) GetTestingData() *TestingData {
 	return p.testingData
 }

tsc/internal/lsp/server.go

@@ -63,25 +63,24 @@ func NewServer(opts *ServerOptions) *Server {
 	}
 
 	s := &Server{
-		r:                            opts.In,
-		w:                            opts.Out,
-		stderr:                       opts.Err,
-		requestQueue:                 newDynamicQueue[*lsproto.RequestMessage](),
-		outgoingQueue:                newDynamicQueue[*lsproto.Message](),
-		pendingClientRequests:        make(map[jsonrpc.ID]pendingClientRequest),
-		pendingServerRequests:        make(map[jsonrpc.ID]chan *lsproto.ResponseMessage),
-		cwd:                          opts.Cwd,
-		fs:                           opts.FS,
-		defaultLibraryPath:           opts.DefaultLibraryPath,
-		typingsLocation:              opts.TypingsLocation,
-		parseCache:                   opts.ParseCache,
-		npmInstall:                   opts.NpmInstall,
-		spawn:                        opts.Spawn,
-		startWatchdog:                opts.SetParentProcessID,
-		initComplete:                 make(chan struct{}),
-		progressDelay:                opts.ProgressDelay,
-		workspaceDiagnostics:         newWorkspaceDiagnosticsCache(),
-		workspaceDiagnosticsPrograms: newWorkspaceDiagnosticsPrograms(),
+		r:                     opts.In,
+		w:                     opts.Out,
+		stderr:                opts.Err,
+		requestQueue:          newDynamicQueue[*lsproto.RequestMessage](),
+		outgoingQueue:         newDynamicQueue[*lsproto.Message](),
+		pendingClientRequests: make(map[jsonrpc.ID]pendingClientRequest),
+		pendingServerRequests: make(map[jsonrpc.ID]chan *lsproto.ResponseMessage),
+		cwd:                   opts.Cwd,
+		fs:                    opts.FS,
+		defaultLibraryPath:    opts.DefaultLibraryPath,
+		typingsLocation:       opts.TypingsLocation,
+		parseCache:            opts.ParseCache,
+		npmInstall:            opts.NpmInstall,
+		spawn:                 opts.Spawn,
+		startWatchdog:         opts.SetParentProcessID,
+		initComplete:          make(chan struct{}),
+		progressDelay:         opts.ProgressDelay,
+		workspaceDiagnostics:  newWorkspaceDiagnosticsCache(),
 	}
 	s.logger = newLogger(s)
 
@@ -257,10 +256,6 @@ type Server struct {
 	// produced the result id a client holds for each file.
 	workspaceDiagnostics *workspaceDiagnosticsCache
 
-	// workspaceDiagnosticsPrograms remembers what each project looked like at the last pull, so a
-	// pull re-checks only the files a change reached.
-	workspaceDiagnosticsPrograms *workspaceDiagnosticsPrograms
-
 	workspaceDiagnosticsRegistrationMu sync.Mutex
 	workspaceDiagnosticsRegistered     bool
 }

tsc/internal/lsp/workspacediagnostics.go

@@ -98,7 +98,6 @@ func (s *Server) computeWorkspaceDiagnostics(ctx context.Context, params *lsprot
 
 	if run.collected {
 		s.workspaceDiagnostics.retain(&run.reported)
-		s.workspaceDiagnosticsPrograms.retain(&run.projects)
 		if s.logger.IsVerbose() {
 			stats := s.workspaceDiagnostics.stats()
 			s.logger.Logf("workspace diagnostics: reported %d files, cached %d files across %d projects",
@@ -123,8 +122,6 @@ type workspaceDiagnosticsRun struct {
 	previous map[lsproto.DocumentUri]string
 	// Documents already covered, so a file in several projects is reported once.
 	reported collections.Set[lsproto.DocumentUri]
-	// Projects this pull was responsible for, so the ones it no longer covers can be let go of.
-	projects collections.Set[tspath.Path]
 
 	// Reports not yet flushed; without a partial result token this holds all of them.
 	pending []workspaceDiagnosticReport
@@ -253,7 +250,7 @@ func (r *workspaceDiagnosticsRun) checkProject(snapshot *project.Snapshot, pf wo
 	}
 	// Ask through the incremental view, so a change is re-checked where it landed rather than
 	// across the whole project.
-	program := r.server.workspaceDiagnosticsPrograms.forProject(pf.project.Id(), pf.languageService.GetProgram())
+	program := snapshot.IncrementalProgram(pf.project)
 	reports := pf.languageService.WorkspaceDiagnosticsForProject(r.ctx, program, files)
 	if r.ctx.Err() != nil {
 		return false
@@ -270,8 +267,6 @@ func (r *workspaceDiagnosticsRun) checkProject(snapshot *project.Snapshot, pf wo
 // emitProject hands a finished project's reports to the client and remembers which program version
 // produced each result id, so the next pull can skip the file.
 func (r *workspaceDiagnosticsRun) emitProject(pf workspaceDiagnosticsProject) {
-	// Recorded here rather than while checking, since emitting is what runs in project order.
-	r.projects.Add(pf.project.Id())
 	for j, report := range pf.reports {
 		if pf.files[j] != nil {
 			r.filesDone++

tsc/internal/lsp/workspacediagnosticsincremental.go

@@ -0,0 +1,53 @@
+package project
+
+import (
+	"sync"
+
+	"github.com/microsoft/TypeScript/tsc/internal/compiler"
+	"github.com/microsoft/TypeScript/tsc/internal/execute/incremental"
+)
+
+// incrementalState carries what a project learned about which files a change reaches from one of
+// its programs to the next, so a pull re-checks only the files an edit affected.
+//
+// It is built on the first pull that asks, not when the program is, because building it walks every
+// file in the program and most programs are never pulled. Like the checker pool it is held by
+// pointer, so the snapshots that share a program share what it has built.
+type incrementalState struct {
+	mu sync.Mutex
+	// What the previous program left behind, holding no program of its own.
+	previous *incremental.Program
+	current  *incremental.Program
+}
+
+// get returns the incremental view of the program, building it from the previous program's
+// bookkeeping the first time it is asked for.
+func (s *incrementalState) get(program *compiler.Program) *incremental.Program {
+	if s == nil {
+		// A project built before it had any state to carry; nothing to chain from.
+		return incremental.NewProgram(program, nil, nil, nil, false)
+	}
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	if s.current == nil {
+		s.current = incremental.NewProgram(program, s.previous, nil, nil, false)
+		// The new view has taken what it needs; holding the old one keeps a program alive.
+		s.previous = nil
+	}
+	return s.current
+}
+
+// next returns the state a replacement program starts from. It keeps what this one worked out and
+// drops the program it worked it out from, which is the largest thing a project holds.
+func (s *incrementalState) next() *incrementalState {
+	if s == nil {
+		return &incrementalState{}
+	}
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	previous := s.current
+	if previous == nil {
+		previous = s.previous
+	}
+	return &incrementalState{previous: previous.WithoutProgram()}
+}

tsc/internal/project/incrementalstate.go

@@ -82,6 +82,8 @@ type Project struct {
 	contentMapperWatchedFiles *collections.Set[tspath.Path]
 
 	checkerPool *checkerPool
+	// incremental carries what a change reaches from one program to the next; see incrementalState.
+	incremental *incrementalState
 
 	// installedTypingsInfo is the value of `project.ComputeTypingsInfo()` that was
 	// used during the most recently completed typings installation.
@@ -184,6 +186,7 @@ func NewProject(
 		Kind:             kind,
 		currentDirectory: currentDirectory,
 		dirty:            true,
+		incremental:      &incrementalState{},
 	}
 
 	project.configFilePath = tspath.ToPath(configFileName, currentDirectory, builder.fs.fs.UseCaseSensitiveFileNames())
@@ -312,6 +315,7 @@ func (p *Project) Clone() *Project {
 		contentMapperWatchedFiles: p.contentMapperWatchedFiles,
 
 		checkerPool: p.checkerPool,
+		incremental: p.incremental,
 
 		installedTypingsInfo: p.installedTypingsInfo,
 		typingsFiles:         p.typingsFiles,

tsc/internal/project/project.go

@@ -1299,6 +1299,7 @@ func (b *ProjectCollectionBuilder) updateProgram(entry dirty.Value[*Project], lo
 				oldHost := project.host
 				oldProgram := project.Program
 				oldCheckerPool := project.checkerPool
+				oldIncremental := project.incremental
 				project.host = newCompilerHost(project.currentDirectory, project, b, logger.Fork("CompilerHost"))
 				result := project.CreateProgram()
 				var watchedFiles []string
@@ -1341,6 +1342,9 @@ func (b *ProjectCollectionBuilder) updateProgram(entry dirty.Value[*Project], lo
 				if oldCheckerPool != nil {
 					oldCheckerPool.Discard()
 				}
+				// Carries what the old program worked out about its files, without carrying the
+				// program. Built here rather than on first use so the old one can be let go of now.
+				project.incremental = oldIncremental.next()
 			})
 		})
 	}

tsc/internal/project/projectcollectionbuilder.go

@@ -13,6 +13,7 @@ import (
 	"github.com/microsoft/TypeScript/tsc/internal/collections"
 	"github.com/microsoft/TypeScript/tsc/internal/contentmapper"
 	"github.com/microsoft/TypeScript/tsc/internal/core"
+	"github.com/microsoft/TypeScript/tsc/internal/execute/incremental"
 	"github.com/microsoft/TypeScript/tsc/internal/ls"
 	"github.com/microsoft/TypeScript/tsc/internal/ls/autoimport"
 	"github.com/microsoft/TypeScript/tsc/internal/ls/lsconv"
@@ -315,6 +316,13 @@ func (s *Snapshot) ReleaseCheckingPool(project *Project) bool {
 	return project.checkerPool.releaseCheckingPool()
 }
 
+// IncrementalProgram returns a project's program together with the record of which files a change
+// since the previous program reached, so a caller checking the project can skip the files it did
+// not. Built on first use, and shared by every snapshot holding the same program.
+func (s *Snapshot) IncrementalProgram(project *Project) *incremental.Program {
+	return project.incremental.get(project.Program)
+}
+
 func (s *Snapshot) OpenProjects() []*Project {
 	var open []*Project
 	for _, project := range s.ProjectCollection.Projects() {