Clear stale LSP diagnostics when a file is closed

When the user closed a file, the LSP server never published empty
diagnostics to clear the Problems panel. The root cause is that the
workspace's indexFiles path calls fileManager.Track for every file in
the module, incrementing the reference count beyond the editor's own
reference. When DidClose decrements the count, it rarely drops to zero,
so fileManager.Close never calls Reset and diagnostics were never cleared.

Fix this by handling the clear explicitly in DidClose: cancel in-flight
checks, publish empty diagnostics (while IsOpenInEditor is still true),
then set version=-1 to mark the file as no longer open in the editor so
subsequent RunChecks skip re-publishing lint diagnostics.

Also update Reset to be defensive: publish empty diagnostics if
IsOpenInEditor is still true at Reset time (e.g. for workspace-external
files whose ref count drops to zero without going through DidClose).

Extract the "buf lint" diagnostic source string into a named constant
lintSourceName alongside the existing serverName constant.

Add a regression test that opens a file with a known lint violation,
waits for diagnostics, sends DidClose, then asserts the Problems panel
is cleared.

Fixes bufbuild/vscode-buf#626.

Author: stefanvanburen

private/buf/buflsp/diagnostics_test.go

@@ -511,6 +511,47 @@ func TestDiagnosticsNoTransitiveLeak(t *testing.T) {
 	})
 }
 
+// TestDiagnosticsClearedOnClose verifies that stale diagnostics are cleared from the
+// client when a file is closed, reproducing the scenario from
+// https://github.com/bufbuild/vscode-buf/issues/626 where lint errors on a deleted file
+// continued to show in the editor's Problems panel after the file was removed.
+func TestDiagnosticsClearedOnClose(t *testing.T) {
+	t.Parallel()
+
+	t.Run("lint_diagnostics_cleared_after_close", func(t *testing.T) {
+		t.Parallel()
+
+		synctest.Test(t, func(t *testing.T) {
+			// Use an existing testdata file with a known lint violation (IMPORT_USED)
+			// so the workspace is fully configured and RunChecks produces diagnostics.
+			protoPath, err := filepath.Abs("testdata/diagnostics/unused_import.proto")
+			require.NoError(t, err)
+
+			clientJSONConn, testURI, capture := setupLSPServerWithDiagnostics(t, protoPath)
+
+			ctx := t.Context()
+
+			// Wait for lint diagnostics to appear.
+			initial := capture.wait(t, testURI, 10*time.Second, func(p *protocol.PublishDiagnosticsParams) bool {
+				return len(p.Diagnostics) > 0
+			})
+			require.NotEmpty(t, initial.Diagnostics, "expected lint diagnostics before close")
+
+			// Close the file, simulating what happens when the user closes or deletes it.
+			err = clientJSONConn.Notify(ctx, protocol.MethodTextDocumentDidClose, &protocol.DidCloseTextDocumentParams{
+				TextDocument: protocol.TextDocumentIdentifier{URI: testURI},
+			})
+			require.NoError(t, err)
+
+			// The server must publish empty diagnostics so the Problems panel clears.
+			cleared := capture.wait(t, testURI, 5*time.Second, func(p *protocol.PublishDiagnosticsParams) bool {
+				return len(p.Diagnostics) == 0
+			})
+			assert.Empty(t, cleared.Diagnostics, "stale diagnostics should be cleared after file close")
+		})
+	})
+}
+
 // diagnosticsCapture captures publishDiagnostics notifications from the LSP server.
 type diagnosticsCapture struct {
 	mu          sync.Mutex

private/buf/buflsp/file.go

@@ -101,6 +101,7 @@ func (f *file) Reset(ctx context.Context) {
 	// Evict the query key if there is a query cached on the file. We cache the [queries.File]
 	// query since this allows the executor to evict all dependent queries, e.g. AST and IR.
 	f.lsp.queryExecutor.Evict(f.queryFileKeys()...)
+	f.clearEditorState(ctx)
 	// Clear the file as nothing should use it after reset. This asserts that.
 	*f = file{}
 }
@@ -110,6 +111,7 @@ func (f *file) Reset(ctx context.Context) {
 // This will not necessarily evict the file, since there may be more than one user
 // for this file.
 func (f *file) Close(ctx context.Context) {
+	f.clearEditorState(ctx)
 	f.Manager().Close(ctx, f.uri)
 }
 
@@ -1080,6 +1082,26 @@ func (f *file) CancelChecks(ctx context.Context) {
 	}
 }
 
+// clearEditorState cancels in-flight checks, publishes empty diagnostics to clear
+// the client's Problems panel (only when diagnostics are non-empty, to avoid a
+// no-op network write), and marks the file as no longer open in the editor by
+// setting version=-1. Called while the LSP lock is held, before the editor ref
+// is decremented.
+//
+// The publish must happen before version is set to -1 because PublishDiagnostics
+// checks IsOpenInEditor (which returns f.version != -1) and returns early if false.
+func (f *file) clearEditorState(ctx context.Context) {
+	if !f.IsOpenInEditor() {
+		return
+	}
+	f.CancelChecks(ctx)
+	if len(f.diagnostics) > 0 {
+		f.diagnostics = nil
+		f.PublishDiagnostics(ctx)
+	}
+	f.version = -1
+}
+
 // RunChecks triggers the run of checks for this file. Diagnostics are published asynchronously.
 func (f *file) RunChecks(ctx context.Context) {
 	if f.IsWKT() || !f.IsOpenInEditor() {
@@ -1174,7 +1196,7 @@ func (f *file) RunChecks(ctx context.Context) {
 			// TODO: prefer diagnostics from the old compiler to the new compiler to remove duplicates from both.
 			f.diagnostics = diagnostics
 		}
-		f.appendAnnotations("buf lint", annotations)
+		f.appendAnnotations(lintSourceName, annotations)
 		f.PublishDiagnostics(ctx)
 	}()
 }

private/buf/buflsp/lint_ignore.go

@@ -46,7 +46,7 @@ func (s *server) getLintIgnoreCodeActions(
 	// Filter diagnostics to find lint errors that overlap with the requested range
 	for _, diagnostic := range file.diagnostics {
 		// Only handle lint diagnostics (not IR diagnostics)
-		if diagnostic.Source != "buf lint" {
+		if diagnostic.Source != lintSourceName {
 			continue
 		}
 

private/buf/buflsp/server.go

@@ -33,7 +33,8 @@ import (
 )
 
 const (
-	serverName = "buf-lsp"
+	serverName     = "buf-lsp"
+	lintSourceName = "buf lint"
 
 	maxSymbolResults = 1000
 )