fix: honor incremental LSP didChange sync mode

Author: Hona

packages/opencode/src/lsp/client.ts

@@ -14,6 +14,10 @@ import { withTimeout } from "../util/timeout"
 import { Filesystem } from "../util"
 
 const DIAGNOSTICS_DEBOUNCE_MS = 150
+const DIAGNOSTICS_POLL_MS = 500
+const DIAGNOSTICS_REQUEST_TIMEOUT_MS = 2_000
+const DIAGNOSTICS_WAIT_TIMEOUT_MS = 10_000
+const DIAGNOSTICS_SETTLE_MS = 1_500
 
 const log = Log.create({ service: "lsp.client" })
 
@@ -38,6 +42,65 @@ export const Event = {
   ),
 }
 
+type DocumentDiagnosticReport = {
+  items?: Diagnostic[]
+  relatedDocuments?: Record<string, DocumentDiagnosticReport>
+}
+
+type CapabilityRegistration = {
+  id: string
+  method: string
+  registerOptions?: {
+    identifier?: string
+    workspaceDiagnostics?: boolean
+  }
+}
+
+type ServerCapabilities = {
+  textDocumentSync?:
+    | number
+    | {
+        change?: number
+      }
+  [key: string]: unknown
+}
+
+function getFilePath(uri: string) {
+  if (!uri.startsWith("file://")) return
+  return Filesystem.normalizePath(fileURLToPath(uri))
+}
+
+function getSyncKind(capabilities?: ServerCapabilities) {
+  if (!capabilities) return
+  const sync = capabilities.textDocumentSync
+  if (typeof sync === "number") return sync
+  return sync?.change
+}
+
+function endPosition(text: string) {
+  const lines = text.split(/\r\n|\r|\n/)
+  return {
+    line: lines.length - 1,
+    character: lines.at(-1)?.length ?? 0,
+  }
+}
+
+function dedupeDiagnostics(items: Diagnostic[]) {
+  const seen = new Set<string>()
+  return items.filter((item) => {
+    const key = JSON.stringify({
+      code: item.code,
+      severity: item.severity,
+      message: item.message,
+      source: item.source,
+      range: item.range,
+    })
+    if (seen.has(key)) return false
+    seen.add(key)
+    return true
+  })
+}
+
 export async function create(input: { serverID: string; server: LSPServer.Handle; root: string; directory: string }) {
   const l = log.clone().tag("serverID", input.serverID)
   l.info("starting client")
@@ -48,16 +111,21 @@ export async function create(input: { serverID: string; server: LSPServer.Handle
   )
 
   const diagnostics = new Map<string, Diagnostic[]>()
+  const diagnosticRegistrations = new Map<string, CapabilityRegistration>()
+  function updateDiagnostics(filePath: string, next: Diagnostic[]) {
+    const exists = diagnostics.has(filePath)
+    diagnostics.set(filePath, next)
+    if (!exists && input.serverID === "typescript") return
+    Bus.publish(Event.Diagnostics, { path: filePath, serverID: input.serverID })
+  }
   connection.onNotification("textDocument/publishDiagnostics", (params) => {
-    const filePath = Filesystem.normalizePath(fileURLToPath(params.uri))
+    const filePath = getFilePath(params.uri)
+    if (!filePath) return
     l.info("textDocument/publishDiagnostics", {
       path: filePath,
       count: params.diagnostics.length,
     })
-    const exists = diagnostics.has(filePath)
-    diagnostics.set(filePath, params.diagnostics)
-    if (!exists && input.serverID === "typescript") return
-    Bus.publish(Event.Diagnostics, { path: filePath, serverID: input.serverID })
+    updateDiagnostics(filePath, params.diagnostics)
   })
   connection.onRequest("window/workDoneProgress/create", (params) => {
     l.info("window/workDoneProgress/create", params)
@@ -67,8 +135,20 @@ export async function create(input: { serverID: string; server: LSPServer.Handle
     // Return server initialization options
     return [input.server.initialization ?? {}]
   })
-  connection.onRequest("client/registerCapability", async () => {})
-  connection.onRequest("client/unregisterCapability", async () => {})
+  connection.onRequest("client/registerCapability", async (params) => {
+    const registrations = (params as { registrations?: CapabilityRegistration[] }).registrations ?? []
+    for (const registration of registrations) {
+      if (registration.method !== "textDocument/diagnostic") continue
+      diagnosticRegistrations.set(registration.id, registration)
+    }
+  })
+  connection.onRequest("client/unregisterCapability", async (params) => {
+    const registrations = (params as { unregisterations?: { id: string; method: string }[] }).unregisterations ?? []
+    for (const registration of registrations) {
+      if (registration.method !== "textDocument/diagnostic") continue
+      diagnosticRegistrations.delete(registration.id)
+    }
+  })
   connection.onRequest("workspace/workspaceFolders", async () => [
     {
       name: "workspace",
@@ -78,8 +158,8 @@ export async function create(input: { serverID: string; server: LSPServer.Handle
   connection.listen()
 
   l.info("sending initialize")
-  await withTimeout(
-    connection.sendRequest("initialize", {
+  const initialized = await withTimeout(
+    connection.sendRequest<{ capabilities?: ServerCapabilities }>("initialize", {
       rootUri: pathToFileURL(input.root).href,
       processId: input.server.process.pid,
       workspaceFolders: [
@@ -100,12 +180,19 @@ export async function create(input: { serverID: string; server: LSPServer.Handle
           didChangeWatchedFiles: {
             dynamicRegistration: true,
           },
+          diagnostics: {
+            refreshSupport: true,
+          },
         },
         textDocument: {
           synchronization: {
             didOpen: true,
             didChange: true,
           },
+          diagnostic: {
+            dynamicRegistration: true,
+            relatedDocumentSupport: true,
+          },
           publishDiagnostics: {
             versionSupport: true,
           },
@@ -122,6 +209,7 @@ export async function create(input: { serverID: string; server: LSPServer.Handle
       },
     )
   })
+  const syncKind = getSyncKind(initialized.capabilities)
 
   await connection.sendNotification("initialized", {})
 
@@ -132,9 +220,73 @@ export async function create(input: { serverID: string; server: LSPServer.Handle
   }
 
   const files: {
-    [path: string]: number
+    [path: string]: { version: number; text: string }
   } = {}
 
+  async function requestDiagnosticReport(filePath: string, identifier?: string) {
+    const report = await withTimeout(
+      connection.sendRequest<DocumentDiagnosticReport | null>("textDocument/diagnostic", {
+        ...(identifier ? { identifier } : {}),
+        textDocument: {
+          uri: pathToFileURL(filePath).href,
+        },
+      }),
+      DIAGNOSTICS_REQUEST_TIMEOUT_MS,
+    ).catch(() => null)
+    if (!report) return { handled: false, byFile: new Map<string, Diagnostic[]>() }
+
+    const byFile = new Map<string, Diagnostic[]>()
+    const push = (target: string, items: Diagnostic[]) => {
+      const existing = byFile.get(target) ?? []
+      byFile.set(target, existing.concat(items))
+    }
+
+    let handled = false
+    if (Array.isArray(report.items)) {
+      push(filePath, report.items)
+      handled = true
+    }
+    for (const [uri, related] of Object.entries(report.relatedDocuments ?? {})) {
+      const relatedPath = getFilePath(uri)
+      if (!relatedPath || !Array.isArray(related.items)) continue
+      push(relatedPath, related.items)
+      handled = true
+    }
+
+    return { handled, byFile }
+  }
+
+  async function requestDiagnostics(filePath: string) {
+    const results = [await requestDiagnosticReport(filePath)]
+    const identifiers = new Set(
+      [...diagnosticRegistrations.values()]
+        .filter((registration) => registration.registerOptions?.workspaceDiagnostics !== true)
+        .map((registration) => registration.registerOptions?.identifier)
+        .filter((identifier): identifier is string => Boolean(identifier)),
+    )
+    for (const identifier of identifiers) {
+      results.push(await requestDiagnosticReport(filePath, identifier))
+    }
+
+    const handled = results.some((result) => result.handled)
+    if (!handled) return false
+
+    const merged = new Map<string, Diagnostic[]>()
+    for (const result of results) {
+      for (const [target, items] of result.byFile.entries()) {
+        const existing = merged.get(target) ?? []
+        merged.set(target, existing.concat(items))
+      }
+    }
+
+    if (!merged.has(filePath)) merged.set(filePath, [])
+    for (const [target, items] of merged.entries()) {
+      updateDiagnostics(target, dedupeDiagnostics(items))
+    }
+
+    return true
+  }
+
   const result = {
     root: input.root,
     get serverID() {
@@ -150,8 +302,8 @@ export async function create(input: { serverID: string; server: LSPServer.Handle
         const extension = path.extname(request.path)
         const languageId = LANGUAGE_EXTENSIONS[extension] ?? "plaintext"
 
-        const version = files[request.path]
-        if (version !== undefined) {
+        const document = files[request.path]
+        if (document !== undefined) {
           log.info("workspace/didChangeWatchedFiles", request)
           await connection.sendNotification("workspace/didChangeWatchedFiles", {
             changes: [
@@ -162,8 +314,8 @@ export async function create(input: { serverID: string; server: LSPServer.Handle
             ],
           })
 
-          const next = version + 1
-          files[request.path] = next
+          const next = document.version + 1
+          files[request.path] = { version: next, text }
           log.info("textDocument/didChange", {
             path: request.path,
             version: next,
@@ -173,7 +325,19 @@ export async function create(input: { serverID: string; server: LSPServer.Handle
               uri: pathToFileURL(request.path).href,
               version: next,
             },
-            contentChanges: [{ text }],
+            contentChanges:
+              syncKind === 2
+                ? [
+                    {
+                      range: {
+                        start: { line: 0, character: 0 },
+                        end: endPosition(document.text),
+                      },
+                      rangeLength: document.text.length,
+                      text,
+                    },
+                  ]
+                : [{ text }],
           })
           return
         }
@@ -198,7 +362,7 @@ export async function create(input: { serverID: string; server: LSPServer.Handle
             text,
           },
         })
-        files[request.path] = 0
+        files[request.path] = { version: 0, text }
         return
       },
     },
@@ -212,21 +376,35 @@ export async function create(input: { serverID: string; server: LSPServer.Handle
       log.info("waiting for diagnostics", { path: normalizedPath })
       let unsub: () => void
       let debounceTimer: ReturnType<typeof setTimeout> | undefined
+      let pushed = false
+      let firstHandledAt: number | undefined
       return await withTimeout(
-        new Promise<void>((resolve) => {
+        (async () => {
           unsub = Bus.subscribe(Event.Diagnostics, (event) => {
-            if (event.properties.path === normalizedPath && event.properties.serverID === result.serverID) {
-              // Debounce to allow LSP to send follow-up diagnostics (e.g., semantic after syntax)
-              if (debounceTimer) clearTimeout(debounceTimer)
-              debounceTimer = setTimeout(() => {
+            if (event.properties.path !== normalizedPath || event.properties.serverID !== result.serverID) return
+            if (debounceTimer) clearTimeout(debounceTimer)
+            debounceTimer = setTimeout(() => {
+              pushed = true
+            }, DIAGNOSTICS_DEBOUNCE_MS)
+          })
+          await new Promise((resolve) => setTimeout(resolve, DIAGNOSTICS_DEBOUNCE_MS))
+          while (true) {
+            if (pushed) {
+              log.info("got diagnostics", { path: normalizedPath })
+              return
+            }
+            const handled = await requestDiagnostics(normalizedPath)
+            if (handled) {
+              firstHandledAt = firstHandledAt ?? Date.now()
+              if (Date.now() - firstHandledAt >= DIAGNOSTICS_SETTLE_MS) {
                 log.info("got diagnostics", { path: normalizedPath })
-                unsub?.()
-                resolve()
-              }, DIAGNOSTICS_DEBOUNCE_MS)
+                return
+              }
             }
-          })
-        }),
-        3000,
+            await new Promise((resolve) => setTimeout(resolve, DIAGNOSTICS_POLL_MS))
+          }
+        })(),
+        DIAGNOSTICS_WAIT_TIMEOUT_MS,
       )
         .catch(() => {})
         .finally(() => {

packages/opencode/test/fixture/lsp/fake-lsp-server.js

@@ -2,6 +2,7 @@
 // Implements a minimal LSP handshake and triggers a request upon notification
 
 let nextId = 1
+let lastDidChange = null
 
 function encode(message) {
   const json = JSON.stringify(message)
@@ -53,7 +54,18 @@ function handle(raw) {
     return
   }
   if (data.method === "initialize") {
-    send({ jsonrpc: "2.0", id: data.id, result: { capabilities: {} } })
+    send({
+      jsonrpc: "2.0",
+      id: data.id,
+      result: {
+        capabilities: {
+          textDocumentSync: {
+            openClose: true,
+            change: 2,
+          },
+        },
+      },
+    })
     return
   }
   if (data.method === "initialized") {
@@ -62,6 +74,14 @@ function handle(raw) {
   if (data.method === "workspace/didChangeConfiguration") {
     return
   }
+  if (data.method === "textDocument/didChange") {
+    lastDidChange = data.params
+    return
+  }
+  if (data.method === "test/get-last-change") {
+    send({ jsonrpc: "2.0", id: data.id, result: lastDidChange })
+    return
+  }
   if (data.method === "test/trigger") {
     const method = data.params && data.params.method
     if (method) sendRequest(method, {})