Cap how many projects a workspace pull checks at once

How many projects a pull checks concurrently was a constant.
experimental.workspaceDiagnostics.maxProjects sets it; zero still derives a
value from the available processors and single threaded mode still collapses it
to one.

The cap is budgeted against the per-project checker split rather than
multiplied by it, so a project checked by four checkers does not also multiply
how many projects run at once.

Worth 2.7x on a single project, which is where checking projects concurrently
had nothing to offer.

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

Author: eagarwal-notion

tsc/internal/lsp/workspacediagnostics.go

@@ -2,6 +2,7 @@ package lsp
 
 import (
 	"context"
+	"sync/atomic"
 	"time"
 
 	"github.com/microsoft/TypeScript/tsc/internal/ast"
@@ -168,7 +169,8 @@ func (r *workspaceDiagnosticsRun) collect(snapshot *project.Snapshot, scope lsut
 	}
 	r.beginProgress()
 
-	if concurrency := workspaceDiagnosticsConcurrency(work); concurrency > 1 {
+	configured := snapshot.UserPreferences().WorkspaceDiagnosticsMaxProjects
+	if concurrency := workspaceDiagnosticsConcurrency(snapshot, work, configured); concurrency > 1 {
 		r.checkConcurrently(snapshot, work, concurrency)
 	} else {
 		r.checkSequentially(snapshot, work)
@@ -237,17 +239,42 @@ 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.
+//
+// Files are grouped by the diagnostics checker that owns them. A group shares a checker so it runs
+// in sequence, but the groups run together, which is what splitting a project's diagnostics across
+// checkers buys.
 func (r *workspaceDiagnosticsRun) checkProject(snapshot *project.Snapshot, pf workspaceDiagnosticsProject) bool {
+	slots := make([]*ast.SourceFile, len(pf.files))
+	byFile := make(map[*ast.SourceFile]int, len(pf.files))
 	for j, file := range pf.files {
-		if file == nil {
-			continue
+		if file != nil {
+			slots[j] = file
+			byFile[file] = j
 		}
-		if r.ctx.Err() != nil {
-			return false
+	}
+	toCheck := make([]*ast.SourceFile, 0, pf.toCheck)
+	for _, file := range slots {
+		if file != nil {
+			toCheck = append(toCheck, file)
 		}
-		pf.reports[j] = r.reportForFile(snapshot, pf.languageService, file)
 	}
-	return true
+
+	groups := snapshot.GroupFilesByDiagnosticsChecker(pf.project, toCheck)
+	var cancelled atomic.Bool
+	wg := core.NewWorkGroup(len(groups) == 1)
+	for _, group := range groups {
+		wg.Queue(func() {
+			for _, file := range group {
+				if r.ctx.Err() != nil {
+					cancelled.Store(true)
+					return
+				}
+				pf.reports[byFile[file]] = r.reportForFile(snapshot, pf.languageService, file)
+			}
+		})
+	}
+	wg.RunAndWait()
+	return !cancelled.Load()
 }
 
 // emitProject hands a finished project's reports to the client and remembers which program version

tsc/internal/lsp/workspacediagnosticsscope.go

@@ -14,20 +14,32 @@ import (
 	"github.com/microsoft/TypeScript/tsc/internal/tspath"
 )
 
-// Each concurrent project holds its own diagnostics checker, so this bounds peak memory.
+// Each concurrent project holds its own diagnostics checkers, so this bounds peak memory.
 const workspaceDiagnosticsMaxProjects = 4
 
-// workspaceDiagnosticsConcurrency returns how many projects to check at once, mirroring the default
-// the build orchestrator uses for --builders: four, or one under single threaded mode. Unlike a
-// build, a pull runs while the user is typing, so it also leaves half the processors for the
-// requests they are waiting on.
-func workspaceDiagnosticsConcurrency(work []workspaceDiagnosticsProject) int {
+// workspaceDiagnosticsConcurrency returns how many projects to check at once. Left to itself it
+// mirrors what the build orchestrator uses for --builders: four, or one under single threaded mode.
+// Unlike a build, a pull runs while the user is typing, so the default also leaves half the
+// processors for the requests they are waiting on.
+//
+// Every project being checked holds a checker per file group, and each of those holds the types for
+// its share of that project, so the default budget is spent across both caps rather than allowing
+// projects times checkers of them at once. A configured value is taken at its word.
+func workspaceDiagnosticsConcurrency(snapshot *project.Snapshot, work []workspaceDiagnosticsProject, configured int) int {
 	for _, pf := range work {
 		if pf.languageService.GetProgram().SingleThreaded() {
 			return 1
 		}
 	}
-	return min(len(work), workspaceDiagnosticsMaxProjects, max(1, runtime.GOMAXPROCS(0)/2))
+	if configured > 0 {
+		return min(len(work), configured)
+	}
+	budget := min(workspaceDiagnosticsMaxProjects, max(1, runtime.GOMAXPROCS(0)/2))
+	perProject := 1
+	for _, pf := range work {
+		perProject = max(perProject, snapshot.DiagnosticCheckerCount(pf.project))
+	}
+	return min(len(work), max(1, budget/perProject))
 }
 
 // projectsInScope narrows the loaded projects to the ones the scope reports on, in snapshot order.