Sweep a project in one call instead of a file at a time

The sweep asked for each file's diagnostics separately, which meant it, rather
than the program, decided how checking was spread over checkers.

WorkspaceDiagnosticsForProject checks the program once and keys the result by
file, so the program splits the work as a build would and the sweep only
formats what comes back. A project now reports when it is done rather than
streaming as each of its files finishes; projects still stream as they finish.

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

Author: eagarwal-notion

tsc/internal/ls/diagnostics.go

@@ -161,3 +161,47 @@ 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 {
+	reports := make(map[*ast.SourceFile][]*lsproto.Diagnostic, len(files))
+	if l.UserPreferences().EnableValidation.IsFalse() {
+		for _, file := range files {
+			reports[file] = []*lsproto.Diagnostic{}
+		}
+		return reports
+	}
+
+	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),
+	} {
+		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)
+			}
+		}
+	}
+
+	for _, file := range files {
+		// A file's supplemental sources report under the file itself, as they do for a pull on it.
+		diagnostics := byFile[file]
+		for _, supplemental := range file.SupplementalSourceFiles() {
+			diagnostics = append(diagnostics, byFile[supplemental]...)
+		}
+		reports[file] = l.toLSPDiagnostics(ctx, diagnostics)
+	}
+	return reports
+}

tsc/internal/lsp/workspacediagnostics.go

@@ -8,7 +8,6 @@ import (
 	"github.com/microsoft/TypeScript/tsc/internal/collections"
 	"github.com/microsoft/TypeScript/tsc/internal/core"
 	"github.com/microsoft/TypeScript/tsc/internal/diagnostics"
-	"github.com/microsoft/TypeScript/tsc/internal/ls"
 	"github.com/microsoft/TypeScript/tsc/internal/ls/lsconv"
 	"github.com/microsoft/TypeScript/tsc/internal/ls/lsutil"
 	"github.com/microsoft/TypeScript/tsc/internal/lsp/lsproto"
@@ -237,15 +236,26 @@ func (r *workspaceDiagnosticsRun) checkConcurrently(snapshot *project.Snapshot,
 
 // checkProject fills in the reports for the files of one project, reporting whether it got through
 // them all. A cancelled project must not be emitted: its remaining reports are still zero values.
+// checkProject checks a project's files and builds their reports. The program checks them all in
+// one call, so the work is split across the checkers a build would use rather than being driven a
+// file at a time from here; the trade is that a project reports once it is done rather than
+// streaming as each of its files finishes.
 func (r *workspaceDiagnosticsRun) checkProject(snapshot *project.Snapshot, pf workspaceDiagnosticsProject) bool {
+	files := make([]*ast.SourceFile, 0, len(pf.files))
+	for _, file := range pf.files {
+		if file != nil {
+			files = append(files, file)
+		}
+	}
+	reports := pf.languageService.WorkspaceDiagnosticsForProject(r.ctx, files)
+	if r.ctx.Err() != nil {
+		return false
+	}
 	for j, file := range pf.files {
 		if file == nil {
 			continue
 		}
-		if r.ctx.Err() != nil {
-			return false
-		}
-		pf.reports[j] = r.reportForFile(snapshot, pf.languageService, file)
+		pf.reports[j] = r.reportForFile(snapshot, file, reports[file])
 	}
 	return true
 }
@@ -268,9 +278,8 @@ func (r *workspaceDiagnosticsRun) emitProject(pf workspaceDiagnosticsProject) {
 	}
 }
 
-func (r *workspaceDiagnosticsRun) reportForFile(snapshot *project.Snapshot, languageService *ls.LanguageService, file *ast.SourceFile) workspaceDiagnosticReport {
+func (r *workspaceDiagnosticsRun) reportForFile(snapshot *project.Snapshot, file *ast.SourceFile, items []*lsproto.Diagnostic) workspaceDiagnosticReport {
 	uri := lsconv.FileNameToDocumentURI(file.FileName())
-	items := languageService.ProvideDiagnosticsForFile(r.ctx, file)
 	resultID := workspaceDiagnosticsResultID(items)
 	version := openDocumentVersion(snapshot, file.FileName())