Offer workspace diagnostics through dynamic registration

The capability cannot be advertised at initialize. The setting that turns
workspace diagnostics on arrives after it, and a server that claimed the
capability while the setting was off would have clients pulling a workspace
nobody asked it to check.

It is registered and unregistered dynamically instead, as the setting changes,
and only ever by the one provider. The client runs a workspace pull per
provider that asks for it, into that provider's own collection, so a second
provider carrying the capability would report every problem twice; the content
mapper's registration deliberately leaves it off, and the provider that does
carry it covers content-mapped files too.

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

Author: eagarwal-notion

tsc/internal/lsp/server.go

@@ -256,6 +256,9 @@ type Server struct {
 	// produced the result id a client holds for each file.
 	workspaceDiagnostics *workspaceDiagnosticsCache
 
+	workspaceDiagnosticsRegistrationMu sync.Mutex
+	workspaceDiagnosticsRegistered     bool
+
 	// workspaceDiagnosticsPull is the `workspace/diagnostic` request currently running, if any. A
 	// newer pull supersedes it; see supersedeWorkspaceDiagnostics.
 	workspaceDiagnosticsMu   sync.Mutex
@@ -525,6 +528,10 @@ func (s *Server) RegisterContentMapperExtensions(ctx context.Context, extensions
 		{
 			Id: contentMapperDiagnosticRegistrationID,
 			RegisterOptions: &lsproto.RegisterOptions{
+				// Must not set WorkspaceDiagnostics: the client runs one workspace pull per provider
+				// that asks for it, into that provider's own collection, so a second one would report
+				// every problem twice. workspaceDiagnosticsRegistrationID is the only provider that
+				// carries it, and it covers content-mapped files too.
 				TextDocumentDiagnostic: &lsproto.DiagnosticRegistrationOptions{
 					DocumentSelector:      selector,
 					Identifier:            new("typescript"),
@@ -1780,6 +1787,7 @@ func (s *Server) handleInitialized(ctx context.Context, params *lsproto.Initiali
 		return err
 	}
 	s.session.InitializeWithUserConfig(userPreferences)
+	s.syncWorkspaceDiagnosticsRegistration(ctx, userPreferences)
 
 	_, err = sendClientRequest(ctx, s, lsproto.ClientRegisterCapabilityInfo, &lsproto.RegistrationParams{
 		Registrations: []*lsproto.Registration{
@@ -1830,6 +1838,7 @@ func (s *Server) handleDidChangeWorkspaceConfiguration(ctx context.Context, para
 	} else if settings, ok := params.Settings.(map[string]any); ok {
 		preferences := lsutil.ParseUserPreferences(settings)
 		s.session.Configure(preferences)
+		s.syncWorkspaceDiagnosticsRegistration(ctx, preferences)
 	}
 	return nil
 }

tsc/internal/lsp/server_workspacediagnosticsregistration_test.go

@@ -0,0 +1,86 @@
+package lsp_test
+
+import (
+	"slices"
+	"testing"
+
+	"github.com/microsoft/TypeScript/tsc/internal/bundled"
+	"github.com/microsoft/TypeScript/tsc/internal/lsp/lsproto"
+	"github.com/microsoft/TypeScript/tsc/internal/testutil/lsptestutil"
+	"gotest.tools/v3/assert"
+)
+
+// The capability is withheld at initialize and only offered once the setting asks for it, then
+// withdrawn when it is turned back off.
+func TestWorkspaceDiagnosticsCapabilityFollowsScope(t *testing.T) {
+	t.Parallel()
+
+	if !bundled.Embedded {
+		t.Skip("bundled files are not embedded")
+	}
+
+	client, progress := startWorkspaceDiagnosticsClient(t, workspaceDiagnosticsFiles)
+
+	// Nothing is offered while the setting sits at its default.
+	assert.Assert(t, !slices.Contains(progress.registrationIDs(), "workspace-diagnostics"),
+		"workspace diagnostics should not be registered by default, got %v", progress.registrationIDs())
+
+	setWorkspaceDiagnosticsScope(t, client, "allProjects")
+	openWorkspaceDiagnosticsProject(t, client)
+	pullWorkspaceDiagnostics(t, client, &lsproto.WorkspaceDiagnosticParams{PreviousResultIds: []lsproto.PreviousResultId{}})
+	assert.Assert(t, slices.Contains(progress.registrationIDs(), "workspace-diagnostics"),
+		"expected a workspace diagnostics registration, got %v", progress.registrationIDs())
+
+	setWorkspaceDiagnosticsScope(t, client, "off")
+	pullWorkspaceDiagnostics(t, client, &lsproto.WorkspaceDiagnosticParams{PreviousResultIds: []lsproto.PreviousResultId{}})
+	assert.Assert(t, slices.Contains(progress.unregistrationIDs(), "workspace-diagnostics"),
+		"expected the registration to be withdrawn, got %v", progress.unregistrationIDs())
+}
+
+// Moving between two enabled scopes must not churn the registration.
+func TestWorkspaceDiagnosticsCapabilityRegisteredOnce(t *testing.T) {
+	t.Parallel()
+
+	if !bundled.Embedded {
+		t.Skip("bundled files are not embedded")
+	}
+
+	client, progress := startWorkspaceDiagnosticsClient(t, workspaceDiagnosticsFiles)
+	setWorkspaceDiagnosticsScope(t, client, "openProjects")
+	setWorkspaceDiagnosticsScope(t, client, "allProjects")
+	setWorkspaceDiagnosticsScope(t, client, "openProjectsAndDependents")
+	openWorkspaceDiagnosticsProject(t, client)
+	pullWorkspaceDiagnostics(t, client, &lsproto.WorkspaceDiagnosticParams{PreviousResultIds: []lsproto.PreviousResultId{}})
+
+	progress.mu.Lock()
+	defer progress.mu.Unlock()
+	assert.Equal(t, progress.workspaceRegos, 1, "expected exactly one workspace diagnostics registration")
+	assert.Assert(t, !slices.Contains(progress.unregistered, "workspace-diagnostics"))
+}
+
+// Turning validation off silences diagnostics entirely, so the capability is withdrawn rather than
+// left in place for a client that would keep pulling the workspace every couple of seconds.
+func TestWorkspaceDiagnosticsCapabilityWithdrawnWhenValidationDisabled(t *testing.T) {
+	t.Parallel()
+
+	if !bundled.Embedded {
+		t.Skip("bundled files are not embedded")
+	}
+
+	client, progress := startWorkspaceDiagnosticsClient(t, workspaceDiagnosticsFiles)
+	setWorkspaceDiagnosticsScope(t, client, "allProjects")
+	openWorkspaceDiagnosticsProject(t, client)
+	pullWorkspaceDiagnostics(t, client, &lsproto.WorkspaceDiagnosticParams{PreviousResultIds: []lsproto.PreviousResultId{}})
+	assert.Assert(t, slices.Contains(progress.registrationIDs(), "workspace-diagnostics"))
+
+	// The scope still asks for every project, but validation is off.
+	lsptestutil.SendNotification(t, client, lsproto.WorkspaceDidChangeConfigurationInfo, &lsproto.DidChangeConfigurationParams{
+		Settings: map[string]any{"typescript": map[string]any{
+			"validate":     map[string]any{"enabled": false},
+			"experimental": map[string]any{"workspaceDiagnostics": map[string]any{"scope": "allProjects"}},
+		}},
+	})
+	pullWorkspaceDiagnostics(t, client, &lsproto.WorkspaceDiagnosticParams{PreviousResultIds: []lsproto.PreviousResultId{}})
+	assert.Assert(t, slices.Contains(progress.unregistrationIDs(), "workspace-diagnostics"),
+		"expected the registration to be withdrawn, got %v", progress.unregistrationIDs())
+}

tsc/internal/lsp/workspacediagnosticsregistration.go

@@ -0,0 +1,65 @@
+package lsp
+
+import (
+	"context"
+
+	"github.com/microsoft/TypeScript/tsc/internal/ls/lsutil"
+	"github.com/microsoft/TypeScript/tsc/internal/lsp/lsproto"
+)
+
+const workspaceDiagnosticsRegistrationID = "workspace-diagnostics"
+
+// syncWorkspaceDiagnosticsRegistration offers workspace diagnostics to the client, or withdraws the
+// offer, to match the current settings. Workspace support is a property of a diagnostic provider,
+// so it is offered by registering one. A client that holds the capability re-pulls on a timer, so
+// withdrawing it matters as much as offering it.
+func (s *Server) syncWorkspaceDiagnosticsRegistration(ctx context.Context, preferences lsutil.UserPreferences) {
+	if !s.clientCapabilities.TextDocument.Diagnostic.DynamicRegistration {
+		return
+	}
+
+	s.workspaceDiagnosticsRegistrationMu.Lock()
+	defer s.workspaceDiagnosticsRegistrationMu.Unlock()
+
+	// Validation off silences diagnostics whatever the scope says.
+	wanted := preferences.WorkspaceDiagnosticsScope.Enabled() && !preferences.EnableValidation.IsFalse()
+	if wanted == s.workspaceDiagnosticsRegistered {
+		return
+	}
+
+	if !wanted {
+		if _, err := sendClientRequest(ctx, s, lsproto.ClientUnregisterCapabilityInfo, &lsproto.UnregistrationParams{
+			Unregisterations: []*lsproto.Unregistration{
+				{Id: workspaceDiagnosticsRegistrationID, Method: string(lsproto.MethodTextDocumentDiagnostic)},
+			},
+		}); err != nil {
+			s.logger.Error("failed to unregister workspace diagnostics: ", err)
+			return
+		}
+		s.workspaceDiagnosticsRegistered = false
+		return
+	}
+
+	// The empty document selector is deliberate: document diagnostics are served by the provider
+	// advertised at initialize, and matching no document keeps this one from pulling them twice.
+	if _, err := sendClientRequest(ctx, s, lsproto.ClientRegisterCapabilityInfo, &lsproto.RegistrationParams{
+		Registrations: []*lsproto.Registration{
+			{
+				Id: workspaceDiagnosticsRegistrationID,
+				RegisterOptions: &lsproto.RegisterOptions{
+					TextDocumentDiagnostic: &lsproto.DiagnosticRegistrationOptions{
+						DocumentSelector:      lsproto.DocumentSelectorOrNull{DocumentSelector: &[]lsproto.TextDocumentFilterLanguageOrSchemeOrPattern{}},
+						Identifier:            new("typescript-workspace"),
+						InterFileDependencies: true,
+						WorkspaceDiagnostics:  true,
+						Id:                    new(workspaceDiagnosticsRegistrationID),
+					},
+				},
+			},
+		},
+	}); err != nil {
+		s.logger.Error("failed to register workspace diagnostics: ", err)
+		return
+	}
+	s.workspaceDiagnosticsRegistered = true
+}