Re-check only the files an edit affects

A pull re-checked every file of every project in scope, however little had
changed since the last one.

Watch mode already solves this, so a pull now asks through the same thing it
uses: incremental.Program tracks which files changed against the previous
program and which files those changes reach, re-checks only those, and answers
for the rest from what it cached. That brings its declaration signature
comparison with it, so an edit that leaves a file's public shape alone stops at
that file rather than travelling to its importers.

Kept per project and rebuilt only when the project's program is, chained to the
previous one so it can work out the change set.

Suggestion diagnostics are no longer reported for files a pull covers: nothing
caches them, so asking would re-check every file and undo all of this. A file
the editor has open still reports them, since it is pulled directly.

Measured on a chain of 300 files, editing the file everything depends on:
154ms to check the project, 20ms to answer the next pull.

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

Author: eagarwal-notion

tsc/internal/ls/diagnostics.go

@@ -162,11 +162,16 @@ func worstCategory(diags []*ast.Diagnostic) diagnostics.Category {
 	return worst
 }
 
-// WorkspaceDiagnosticsForProject checks the whole program at once and returns what each file it
-// owns should report. Checking every file in one call lets the program split the work across the
-// checkers a build would use, and keeps the checker pool's own coordination rather than repeating
-// it per file; the diagnostics come back keyed by the file they belong to.
-func (l *LanguageService) WorkspaceDiagnosticsForProject(ctx context.Context, files []*ast.SourceFile) map[*ast.SourceFile][]*lsproto.Diagnostic {
+// WorkspaceDiagnosticsForProject checks a project in one call and returns what each of its files
+// should report, keyed by file. Checking everything in one call lets the program split the work
+// across the checkers a build would use and keeps the pool's own coordination rather than repeating
+// it per file.
+//
+// The program is passed in rather than taken from the language service because a sweep hands over
+// the incremental view of it, which re-checks only the files a change reached and serves the rest
+// from what it cached last time. Suggestions are left out: nothing caches them, so asking would
+// re-check every file and undo that.
+func (l *LanguageService) WorkspaceDiagnosticsForProject(ctx context.Context, program compiler.ProgramLike, files []*ast.SourceFile) map[*ast.SourceFile][]*lsproto.Diagnostic {
 	reports := make(map[*ast.SourceFile][]*lsproto.Diagnostic, len(files))
 	if l.UserPreferences().EnableValidation.IsFalse() {
 		for _, file := range files {
@@ -176,23 +181,17 @@ func (l *LanguageService) WorkspaceDiagnosticsForProject(ctx context.Context, fi
 	}
 
 	byFile := make(map[*ast.SourceFile][]*ast.Diagnostic, len(files))
-	for _, diagnostics := range [][]*ast.Diagnostic{
-		l.program.GetSyntacticDiagnostics(ctx, nil),
-		l.program.GetSemanticDiagnostics(ctx, nil),
-		l.program.GetSuggestionDiagnostics(ctx, nil),
-	} {
+	collect := func(diagnostics []*ast.Diagnostic) {
 		for _, diagnostic := range diagnostics {
 			if file := diagnostic.File(); file != nil {
 				byFile[file] = append(byFile[file], diagnostic)
 			}
 		}
 	}
-	if l.program.Options().GetEmitDeclarations() {
-		for _, diagnostic := range l.program.GetDeclarationDiagnostics(ctx, nil) {
-			if file := diagnostic.File(); file != nil {
-				byFile[file] = append(byFile[file], diagnostic)
-			}
-		}
+	collect(program.GetSyntacticDiagnostics(ctx, nil))
+	collect(program.GetSemanticDiagnostics(ctx, nil))
+	if program.Options().GetEmitDeclarations() {
+		collect(program.GetDeclarationDiagnostics(ctx, nil))
 	}
 
 	for _, file := range files {

tsc/internal/lsp/server.go

@@ -63,24 +63,25 @@ 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(),
+		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(),
 	}
 	s.logger = newLogger(s)
 
@@ -256,6 +257,10 @@ 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/server_workspacediagnostics_test.go

@@ -930,3 +930,66 @@ func TestWorkspaceDiagnosticsDependentsAreTransitive(t *testing.T) {
 		"file:///home/projects/unrelated/index.ts",
 	})
 }
+
+// An edit should cost what it affects, not what the project contains. These files form a chain
+// where each consumes the previous file's interface, so widening one breaks its direct importer and
+// nothing beyond it.
+func TestWorkspaceDiagnosticsRechecksOnlyWhatAnEditAffects(t *testing.T) {
+	t.Parallel()
+
+	if !bundled.Embedded {
+		t.Skip("bundled files are not embedded")
+	}
+
+	const n = 12
+	body := func(f int, extra string) string {
+		prev := ""
+		if f > 0 {
+			prev = fmt.Sprintf("import type { I%d } from \"./f%d.js\";\nexport const uses%d: I%d = { a: \"x\", b: %d };\n", f-1, f-1, f, f-1, f)
+		}
+		return fmt.Sprintf("%sexport interface I%d { a: string; b: number%s }\n", prev, f, extra)
+	}
+	files := map[string]string{"/home/projects/tsconfig.json": `{"compilerOptions":{"strict":true}}`}
+	for f := range n {
+		files[fmt.Sprintf("/home/projects/f%d.ts", f)] = body(f, "")
+	}
+
+	client, _ := initWorkspaceDiagnosticsClient(t, files)
+	lsptestutil.SendNotification(t, client, lsproto.TextDocumentDidOpenInfo, &lsproto.DidOpenTextDocumentParams{
+		TextDocument: &lsproto.TextDocumentItem{
+			Uri: "file:///home/projects/f0.ts", LanguageId: "typescript", Version: 1, Text: body(0, ""),
+		},
+	})
+
+	first := pullWorkspaceDiagnostics(t, client, &lsproto.WorkspaceDiagnosticParams{
+		PreviousResultIds: []lsproto.PreviousResultId{},
+	})
+	var ids []lsproto.PreviousResultId
+	for _, item := range first.Items {
+		if full := item.FullDocumentDiagnosticReport; full != nil && full.ResultId != nil {
+			ids = append(ids, lsproto.PreviousResultId{Uri: full.Uri, Value: *full.ResultId})
+		}
+	}
+
+	// Requiring a new member of I0 breaks f1, which builds one, and leaves f2 onwards alone.
+	lsptestutil.SendNotification(t, client, lsproto.TextDocumentDidChangeInfo, &lsproto.DidChangeTextDocumentParams{
+		TextDocument: lsproto.VersionedTextDocumentIdentifier{Uri: "file:///home/projects/f0.ts", Version: 2},
+		ContentChanges: []lsproto.TextDocumentContentChangePartialOrWholeDocument{
+			{WholeDocument: &lsproto.TextDocumentContentChangeWholeDocument{Text: body(0, "; c: string")}},
+		},
+	})
+
+	second := pullWorkspaceDiagnostics(t, client, &lsproto.WorkspaceDiagnosticParams{PreviousResultIds: ids})
+
+	var reportedInFull []string
+	for _, item := range second.Items {
+		if full := item.FullDocumentDiagnosticReport; full != nil {
+			reportedInFull = append(reportedInFull, string(full.Uri))
+		}
+	}
+	assert.DeepEqual(t, reportedInFull, []string{"file:///home/projects/f1.ts"})
+
+	broken := findFullReport(t, second.Items, "file:///home/projects/f1.ts")
+	assert.Equal(t, len(broken.Items), 1)
+	assert.Assert(t, strings.Contains(broken.Items[0].Message.AsString(), "c"))
+}

tsc/internal/lsp/workspacediagnostics.go

@@ -98,6 +98,7 @@ 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",
@@ -122,6 +123,8 @@ 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
@@ -248,7 +251,10 @@ func (r *workspaceDiagnosticsRun) checkProject(snapshot *project.Snapshot, pf wo
 			files = append(files, file)
 		}
 	}
-	reports := pf.languageService.WorkspaceDiagnosticsForProject(r.ctx, files)
+	// 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())
+	reports := pf.languageService.WorkspaceDiagnosticsForProject(r.ctx, program, files)
 	if r.ctx.Err() != nil {
 		return false
 	}
@@ -264,6 +270,8 @@ 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,65 @@
+package lsp
+
+import (
+	"sync"
+
+	"github.com/microsoft/TypeScript/tsc/internal/collections"
+	"github.com/microsoft/TypeScript/tsc/internal/compiler"
+	"github.com/microsoft/TypeScript/tsc/internal/execute/incremental"
+	"github.com/microsoft/TypeScript/tsc/internal/tspath"
+)
+
+// workspaceDiagnosticsPrograms keeps, per project, the incremental view of its program that watch
+// mode builds: which files changed since the last one, which files those changes reach, and the
+// diagnostics of everything they did not. A sweep asks through that view, so an edit re-checks the
+// files it affects instead of the project.
+//
+// The view is rebuilt when the project's program is, chained to the previous one so it can tell
+// what changed. A program that has not been replaced keeps its view, since nothing has changed for
+// it to find.
+type workspaceDiagnosticsPrograms struct {
+	mu      sync.Mutex
+	entries map[tspath.Path]workspaceDiagnosticsProgram
+}
+
+type workspaceDiagnosticsProgram struct {
+	// The program the view was built for, to notice when the project has been rebuilt.
+	program     *compiler.Program
+	incremental *incremental.Program
+}
+
+func newWorkspaceDiagnosticsPrograms() *workspaceDiagnosticsPrograms {
+	return &workspaceDiagnosticsPrograms{entries: map[tspath.Path]workspaceDiagnosticsProgram{}}
+}
+
+// forProject returns the incremental view of a project's program, building it from the previous one
+// when the project has been rebuilt.
+func (p *workspaceDiagnosticsPrograms) forProject(project tspath.Path, program *compiler.Program) *incremental.Program {
+	p.mu.Lock()
+	defer p.mu.Unlock()
+	if entry, ok := p.entries[project]; ok {
+		if entry.program == program {
+			return entry.incremental
+		}
+		// Chained to the old view, which is what lets it work out the change set. A nil host is
+		// enough because a pull never emits, which is all the host is for.
+		next := incremental.NewProgram(program, entry.incremental, nil, nil, false)
+		p.entries[project] = workspaceDiagnosticsProgram{program: program, incremental: next}
+		return next
+	}
+	first := incremental.NewProgram(program, nil, nil, nil, false)
+	p.entries[project] = workspaceDiagnosticsProgram{program: program, incremental: first}
+	return first
+}
+
+// retain drops the views of projects a sweep no longer reports on. Each holds the diagnostics of
+// every file in its project, so they cannot be kept for projects that have gone away.
+func (p *workspaceDiagnosticsPrograms) retain(seen *collections.Set[tspath.Path]) {
+	p.mu.Lock()
+	defer p.mu.Unlock()
+	for project := range p.entries {
+		if !seen.Has(project) {
+			delete(p.entries, project)
+		}
+	}
+}