bed4abd106
Two LSP freshness bugs reported by @tobific (#108882, #108881): - `_current_diags_async()` keyed the client lookup by the enclosing workspace root while `_get_or_spawn()` stores single-root servers under `srv.resolve_root(...)` (a nested package.json project). The lookup returned [] for a live client with diagnostics, so the delta baseline was refreshed from nothing. Use the same resolved-root key. - `open_or_change()` published `_DocState.version` only after awaiting the didChange write. A versionless publishDiagnostics read during that await was credited with the OLD version and judged stale once the send resumed. Bump the version before the send; a failed send (swallowed by `_send_notification`) leaves a version nothing satisfies, i.e. "no verdict", which is the existing contract. The mock server gains a push-only `versionless` script so the race is reproducible without a real language server.
659 lines
31 KiB
Python
659 lines
31 KiB
Python
"""Async LSP client over stdin/stdout — one per ``(server, workspace_root)``.
|
|
|
|
Freshness is tracked with **document versions**, not timestamps: every didChange
|
|
bumps ``version`` and each stored push/pull result is tagged with the version it
|
|
describes, so a slow server's leftovers never masquerade as a verdict on the
|
|
current content ("ghost diagnostics"). Whole-document sync is always sent, every
|
|
``open_file`` also fires ``didChangeWatchedFiles`` (clangd/eslint only re-scan on
|
|
it), and ``ContentModified`` (-32801) errors are retried with exponential backoff.
|
|
"""
|
|
from __future__ import annotations
|
|
|
|
import asyncio
|
|
import logging
|
|
import os
|
|
import sys
|
|
from dataclasses import dataclass, field
|
|
from pathlib import Path
|
|
from typing import Any, Awaitable, Callable, Dict, List, Optional, Set
|
|
from urllib.parse import quote, unquote
|
|
|
|
from hermes_cli._subprocess_compat import windows_hide_flags
|
|
|
|
from agent.lsp.protocol import (
|
|
ERROR_CONTENT_MODIFIED, ERROR_METHOD_NOT_FOUND, LSPProtocolError, LSPRequestError, classify_message,
|
|
encode_message, make_error_response, make_notification, make_request, make_response, read_message,
|
|
)
|
|
|
|
logger = logging.getLogger("agent.lsp.client")
|
|
|
|
# Timeouts (seconds).
|
|
INITIALIZE_TIMEOUT = 45.0
|
|
DIAGNOSTICS_DOCUMENT_WAIT = 5.0
|
|
DIAGNOSTICS_FULL_WAIT = 10.0
|
|
DIAGNOSTICS_REQUEST_TIMEOUT = 3.0
|
|
PUSH_DEBOUNCE = 0.15
|
|
SHUTDOWN_GRACE = 1.0 # seconds between SIGTERM and SIGKILL
|
|
# Retry policy for transient ContentModified errors: 0.5, 1.0, 2.0s.
|
|
MAX_CONTENT_MODIFIED_RETRIES = 3
|
|
RETRY_BASE_DELAY = 0.5
|
|
|
|
_WRITE_ERRORS = (BrokenPipeError, ConnectionResetError, OSError)
|
|
_LIVE_STATES = {"starting", "running"}
|
|
|
|
_CLIENT_CAPABILITIES: Dict[str, Any] = {
|
|
"window": {"workDoneProgress": True},
|
|
"workspace": {"configuration": True, "workspaceFolders": True,
|
|
"didChangeWatchedFiles": {"dynamicRegistration": True}, "diagnostics": {"refreshSupport": False}},
|
|
"textDocument": {
|
|
"synchronization": {"dynamicRegistration": False, "didOpen": True, "didChange": True,
|
|
"didSave": True, "willSave": False, "willSaveWaitUntil": False},
|
|
"diagnostic": {"dynamicRegistration": True, "relatedDocumentSupport": True},
|
|
"publishDiagnostics": {"relatedInformation": True, "tagSupport": {"valueSet": [1, 2]},
|
|
"versionSupport": True, "codeDescriptionSupport": True, "dataSupport": False},
|
|
"hover": {"contentFormat": ["markdown", "plaintext"]},
|
|
"definition": {"linkSupport": True},
|
|
"references": {},
|
|
"documentSymbol": {"hierarchicalDocumentSymbolSupport": True},
|
|
},
|
|
"general": {"positionEncodings": ["utf-16"]},
|
|
}
|
|
|
|
|
|
def file_uri(path: str) -> str:
|
|
"""Return a ``file://`` URI for a path (handles spaces, unicode, Windows drive letters)."""
|
|
abs_path = os.path.abspath(path)
|
|
if os.name == "nt":
|
|
# ``C:\foo`` → ``file:///C:/foo``: the drive letter must be a path component.
|
|
abs_path = abs_path.replace("\\", "/")
|
|
abs_path = abs_path if abs_path.startswith("/") else "/" + abs_path
|
|
return "file://" + quote(abs_path, safe="/:")
|
|
|
|
|
|
def _folder(root: str) -> Dict[str, str]:
|
|
"""Build an LSP ``WorkspaceFolder`` for ``root``."""
|
|
return {"name": os.path.basename(root.rstrip(os.sep)) or root, "uri": file_uri(root)}
|
|
|
|
|
|
def uri_to_path(uri: str) -> str:
|
|
"""Inverse of :func:`file_uri`."""
|
|
if not uri.startswith("file://"):
|
|
return uri
|
|
raw = uri[len("file://"):]
|
|
if os.name == "nt" and raw.startswith("/") and len(raw) > 2 and raw[2] == ":":
|
|
raw = raw[1:] # strip leading slash before drive letter
|
|
return os.path.normpath(unquote(raw))
|
|
|
|
|
|
def _end_position(text: str) -> Dict[str, int]:
|
|
"""LSP Position at the end of ``text`` (for a whole-document replace range)."""
|
|
if not text:
|
|
return {"line": 0, "character": 0}
|
|
lines = text.splitlines(keepends=False)
|
|
# splitlines drops a trailing newline: the end is then the start of the next (empty) line.
|
|
if text.endswith(("\n", "\r")):
|
|
return {"line": len(lines), "character": 0}
|
|
return {"line": len(lines) - 1, "character": len(lines[-1])}
|
|
|
|
|
|
@dataclass
|
|
class _DocState:
|
|
"""Per-document state. ``version`` is the LSP document version last sent (didOpen=0, +1 per
|
|
didChange) and doubles as the freshness token: ``push_version`` / ``pull_version`` tag stored
|
|
results, fresh iff tag >= version; -1 means "no data yet". Servers that echo a version in
|
|
publishDiagnostics get exact tagging; others are credited with the current version at receipt."""
|
|
version: int = 0
|
|
text: str = ""
|
|
push: List[Dict[str, Any]] = field(default_factory=list)
|
|
pull: List[Dict[str, Any]] = field(default_factory=list)
|
|
push_version: int = -1
|
|
pull_version: int = -1
|
|
seed_seen: bool = False
|
|
|
|
def fresh_push(self, version: Optional[int] = None) -> bool:
|
|
return self.push_version >= (self.version if version is None else version)
|
|
|
|
def fresh_pull(self, version: Optional[int] = None) -> bool:
|
|
return self.pull_version >= (self.version if version is None else version)
|
|
|
|
def fresh(self, version: Optional[int] = None) -> bool:
|
|
return self.fresh_push(version) or self.fresh_pull(version)
|
|
|
|
|
|
class LSPClient:
|
|
"""One server process + one workspace root. ``start()`` → ``open_file()`` → ``wait_for_diagnostics()`` →
|
|
``diagnostics_for()`` → ``shutdown()``."""
|
|
|
|
def __init__(self, *, server_id: str, workspace_root: str, command: List[str],
|
|
env: Optional[Dict[str, str]] = None, cwd: Optional[str] = None,
|
|
initialization_options: Optional[Dict[str, Any]] = None,
|
|
seed_diagnostics_on_first_push: bool = False) -> None:
|
|
self.server_id = server_id
|
|
self.workspace_root = workspace_root
|
|
# Roots this server serves. Single-root servers only ever hold ``workspace_root``;
|
|
# multi-root servers (pyright) grow this via ``add_workspace_folder`` instead of a second process.
|
|
self.workspace_folders: List[str] = [workspace_root]
|
|
self._command = list(command)
|
|
self._env = env
|
|
self._cwd = cwd or workspace_root
|
|
self._init_options = initialization_options or {}
|
|
self._seed_first_push = seed_diagnostics_on_first_push
|
|
|
|
self._proc: Optional[asyncio.subprocess.Process] = None
|
|
self._stderr_task: Optional[asyncio.Task] = None
|
|
self._reader_task: Optional[asyncio.Task] = None
|
|
self._cleanup_lock = asyncio.Lock()
|
|
self._next_id: int = 0
|
|
self._pending: Dict[int, asyncio.Future] = {}
|
|
|
|
# Server → client requests; anything else gets method-not-found. Capability (un)registration
|
|
# and diagnostic refresh are acknowledged but not acted on: we re-pull on every touch anyway.
|
|
self._request_handlers: Dict[str, Callable[[Any], Awaitable[Any]]] = {
|
|
"window/workDoneProgress/create": self._handle_null,
|
|
"workspace/configuration": self._handle_workspace_configuration,
|
|
"client/registerCapability": self._handle_null,
|
|
"client/unregisterCapability": self._handle_null,
|
|
"workspace/workspaceFolders": self._handle_workspace_folders,
|
|
"workspace/diagnostic/refresh": self._handle_null,
|
|
}
|
|
# Server → client notifications; others (showMessage, $/progress) are dropped.
|
|
self._notification_handlers: Dict[str, Callable[[Any], None]] = {
|
|
"textDocument/publishDiagnostics": self._handle_publish_diagnostics,
|
|
}
|
|
|
|
self._docs: Dict[str, _DocState] = {} # keyed by absolute path (NOT URI)
|
|
self._state: str = "stopped"
|
|
self._sync_kind: int = 1 # 1=Full, 2=Incremental
|
|
self._stopping: bool = False
|
|
# Waiters snapshot ``_push_counter`` and treat any increase as "recheck the
|
|
# predicate" — avoids the asyncio.Event sticky-state trap.
|
|
self._push_event = asyncio.Event()
|
|
self._push_counter = 0
|
|
|
|
@property
|
|
def state(self) -> str:
|
|
return self._state
|
|
|
|
@property
|
|
def is_running(self) -> bool:
|
|
return self._state == "running" and self._connection_is_open()
|
|
|
|
def _connection_is_open(self) -> bool:
|
|
proc, reader = self._proc, self._reader_task
|
|
return (
|
|
self._state in _LIVE_STATES
|
|
and proc is not None and proc.returncode is None
|
|
and proc.stdin is not None and not proc.stdin.is_closing()
|
|
and reader is not None and not reader.done()
|
|
)
|
|
|
|
# ---- lifecycle ----
|
|
|
|
async def start(self) -> None:
|
|
"""Spawn + initialize handshake. On failure the process is killed and state is ``"error"``; re-call to retry."""
|
|
if self._state in _LIVE_STATES:
|
|
return
|
|
self._state = "starting"
|
|
try:
|
|
await self._spawn()
|
|
await self._initialize()
|
|
if not self._connection_is_open():
|
|
raise LSPProtocolError("server connection closed during initialization")
|
|
self._state = "running"
|
|
except Exception:
|
|
self._state = "error"
|
|
await self._cleanup_process()
|
|
raise
|
|
|
|
async def _spawn(self) -> None:
|
|
from agent.delegation_context import delegated_child_subprocess_env
|
|
cmd = self._command
|
|
if sys.platform == "win32" and cmd[0].lower().endswith((".cmd", ".bat")):
|
|
cmd = ["cmd.exe", "/c", *cmd] # CreateProcess can't run .cmd/.bat shims directly
|
|
try:
|
|
# start_new_session=True gives the server its own process group; otherwise it inherits
|
|
# the gateway's pgid and mcp_tool's orphan sweeper can killpg() the TUI parent with it.
|
|
# windows_hide_flags() suppresses the console window a .cmd shim would flash from a
|
|
# console-less host (CREATE_NO_WINDOW; 0 on POSIX).
|
|
self._proc = await asyncio.create_subprocess_exec(
|
|
cmd[0], *cmd[1:],
|
|
stdin=asyncio.subprocess.PIPE, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE,
|
|
env=delegated_child_subprocess_env({**os.environ, **(self._env or {})}), cwd=self._cwd,
|
|
start_new_session=True, creationflags=windows_hide_flags(),
|
|
)
|
|
except FileNotFoundError as e:
|
|
raise LSPProtocolError(f"LSP server binary not found: {cmd[0]} ({e})") from e
|
|
# stderr must be drained or the pipe buffer fills and the server hangs.
|
|
self._stderr_task = asyncio.create_task(self._drain_stderr())
|
|
self._reader_task = asyncio.create_task(self._reader_loop())
|
|
|
|
async def _drain_stderr(self) -> None:
|
|
if self._proc is None or self._proc.stderr is None:
|
|
return
|
|
try:
|
|
while line := await self._proc.stderr.readline():
|
|
if text := line.decode("utf-8", errors="replace").rstrip():
|
|
logger.debug("[%s] stderr: %s", self.server_id, text[:1000])
|
|
except (asyncio.CancelledError, OSError):
|
|
pass
|
|
|
|
def _dispatch(self, msg: dict) -> None:
|
|
kind, key = classify_message(msg)
|
|
if kind == "response":
|
|
self._dispatch_response(key, msg)
|
|
elif kind == "request":
|
|
asyncio.create_task(self._dispatch_request(key, msg))
|
|
elif kind == "notification":
|
|
self._dispatch_notification(key, msg)
|
|
else:
|
|
logger.warning("[%s] dropping invalid message: %r", self.server_id, msg)
|
|
|
|
async def _reader_loop(self) -> None:
|
|
if self._proc is None or self._proc.stdout is None:
|
|
return
|
|
try:
|
|
while (msg := await read_message(self._proc.stdout)) is not None:
|
|
self._dispatch(msg)
|
|
logger.debug("[%s] server closed stdout cleanly", self.server_id)
|
|
except LSPProtocolError as e:
|
|
logger.warning("[%s] protocol error in reader loop: %s", self.server_id, e)
|
|
except (asyncio.CancelledError, OSError):
|
|
pass
|
|
finally:
|
|
unexpected_close = not self._stopping and self._state in _LIVE_STATES
|
|
if unexpected_close:
|
|
self._state = "error"
|
|
for fut in list(self._pending.values()): # fail pending requests fast
|
|
if not fut.done():
|
|
fut.set_exception(LSPProtocolError("server connection closed"))
|
|
self._pending.clear()
|
|
if unexpected_close:
|
|
await self._cleanup_process()
|
|
|
|
def _workspace_folders(self) -> List[Dict[str, str]]:
|
|
return [_folder(r) for r in self.workspace_folders]
|
|
|
|
async def add_workspace_folder(self, root: str) -> None:
|
|
"""Attach another root to a running multi-root server. Idempotent; the folder is recorded
|
|
before the notification is sent so concurrent callers for the same root only announce once."""
|
|
if root in self.workspace_folders:
|
|
return
|
|
self.workspace_folders.append(root)
|
|
await self._send_notification(
|
|
"workspace/didChangeWorkspaceFolders", {"event": {"added": [_folder(root)], "removed": []}},
|
|
)
|
|
|
|
async def _initialize(self) -> None:
|
|
params = {
|
|
"rootUri": file_uri(self.workspace_root), "rootPath": self.workspace_root, "processId": os.getpid(),
|
|
"workspaceFolders": self._workspace_folders(),
|
|
"initializationOptions": self._init_options, "capabilities": _CLIENT_CAPABILITIES,
|
|
}
|
|
result = await asyncio.wait_for(self._send_request("initialize", params), timeout=INITIALIZE_TIMEOUT)
|
|
sync = (result.get("capabilities") or {}).get("textDocumentSync")
|
|
if isinstance(sync, dict):
|
|
sync = sync.get("change")
|
|
self._sync_kind = sync if isinstance(sync, int) else 1 # default to Full
|
|
await self._send_notification("initialized", {})
|
|
if self._init_options: # vtsls/eslint only pick config up via didChangeConfiguration
|
|
await self._send_notification("workspace/didChangeConfiguration", {"settings": self._init_options})
|
|
|
|
async def shutdown(self) -> None:
|
|
"""Best-effort graceful shutdown: ``shutdown`` + ``exit``, then SIGTERM/SIGKILL. Idempotent."""
|
|
if self._stopping:
|
|
return
|
|
self._stopping = True
|
|
try:
|
|
if self.is_running:
|
|
try:
|
|
await asyncio.wait_for(self._send_request("shutdown", None), timeout=2.0)
|
|
except (asyncio.TimeoutError, LSPRequestError, LSPProtocolError):
|
|
pass
|
|
try:
|
|
await self._send_notification("exit", None)
|
|
except Exception: # noqa: BLE001
|
|
pass
|
|
finally:
|
|
self._state = "stopped"
|
|
await self._cleanup_process()
|
|
|
|
async def _cleanup_process(self) -> None:
|
|
async with self._cleanup_lock:
|
|
tasks = [self._reader_task, self._stderr_task]
|
|
self._reader_task = self._stderr_task = None
|
|
proc, self._proc = self._proc, None
|
|
live = [t for t in tasks if t is not None and not t.done() and t is not asyncio.current_task()]
|
|
for t in live:
|
|
t.cancel()
|
|
await asyncio.gather(*live, return_exceptions=True)
|
|
if proc is None or proc.returncode is not None:
|
|
return
|
|
try:
|
|
proc.terminate()
|
|
try:
|
|
await asyncio.wait_for(proc.wait(), timeout=SHUTDOWN_GRACE)
|
|
except asyncio.TimeoutError:
|
|
proc.kill()
|
|
await proc.wait()
|
|
except ProcessLookupError:
|
|
pass
|
|
|
|
# ---- request / notification plumbing ----
|
|
|
|
async def _write(self, msg: dict) -> None:
|
|
assert self._proc is not None and self._proc.stdin is not None
|
|
self._proc.stdin.write(encode_message(msg))
|
|
await self._proc.stdin.drain()
|
|
|
|
def _require_open(self, method: str) -> None:
|
|
if not self._connection_is_open():
|
|
raise LSPProtocolError(f"cannot send {method!r}: server connection closed")
|
|
|
|
async def _send_request(self, method: str, params: Any) -> Any:
|
|
self._require_open(method)
|
|
req_id, self._next_id = self._next_id, self._next_id + 1
|
|
fut: asyncio.Future = asyncio.get_running_loop().create_future()
|
|
self._pending[req_id] = fut
|
|
try:
|
|
await self._write(make_request(req_id, method, params))
|
|
except _WRITE_ERRORS as e:
|
|
self._pending.pop(req_id, None)
|
|
raise LSPProtocolError(f"send failed for {method!r}: {e}") from e
|
|
try:
|
|
return await fut
|
|
finally:
|
|
self._pending.pop(req_id, None)
|
|
|
|
async def _send_request_with_retry(self, method: str, params: Any, *, timeout: float) -> Any:
|
|
"""Send a request, retrying ``ContentModified`` (-32801) with backoff; other errors propagate."""
|
|
for attempt in range(MAX_CONTENT_MODIFIED_RETRIES + 1):
|
|
try:
|
|
return await asyncio.wait_for(self._send_request(method, params), timeout=timeout)
|
|
except LSPRequestError as e:
|
|
if e.code != ERROR_CONTENT_MODIFIED or attempt >= MAX_CONTENT_MODIFIED_RETRIES:
|
|
raise
|
|
await asyncio.sleep(RETRY_BASE_DELAY * (2 ** attempt))
|
|
|
|
async def _send_notification(self, method: str, params: Any) -> None:
|
|
self._require_open(method)
|
|
try:
|
|
await self._write(make_notification(method, params))
|
|
except _WRITE_ERRORS as e:
|
|
logger.debug("[%s] notify %s failed: %s", self.server_id, method, e)
|
|
|
|
async def _send_reply(self, msg: dict) -> None:
|
|
"""Send a response to a server→client request; silently no-ops when the pipe is gone."""
|
|
if self._proc is not None and self._proc.stdin is not None and not self._proc.stdin.is_closing():
|
|
try:
|
|
await self._write(msg)
|
|
except _WRITE_ERRORS:
|
|
pass
|
|
|
|
def _dispatch_response(self, req_id: int, msg: dict) -> None:
|
|
fut = self._pending.get(req_id)
|
|
if fut is None or fut.done():
|
|
return
|
|
if "error" not in msg:
|
|
fut.set_result(msg.get("result"))
|
|
return
|
|
err = msg["error"] or {}
|
|
fut.set_exception(LSPRequestError(int(err.get("code", -32000)), str(err.get("message", "unknown")), err.get("data")))
|
|
|
|
async def _dispatch_request(self, req_id: Any, msg: dict) -> None:
|
|
method = msg.get("method", "")
|
|
handler = self._request_handlers.get(method)
|
|
if handler is None:
|
|
reply = make_error_response(req_id, ERROR_METHOD_NOT_FOUND, f"method not found: {method}")
|
|
else:
|
|
try:
|
|
reply = make_response(req_id, await handler(msg.get("params")))
|
|
except Exception as e: # noqa: BLE001 — protocol must not blow up
|
|
logger.warning("[%s] request handler %s failed: %s", self.server_id, method, e)
|
|
reply = make_error_response(req_id, -32000, f"handler failed: {e}")
|
|
await self._send_reply(reply)
|
|
|
|
def _dispatch_notification(self, method: str, msg: dict) -> None:
|
|
handler = self._notification_handlers.get(method)
|
|
if handler is None:
|
|
return
|
|
try:
|
|
handler(msg.get("params"))
|
|
except Exception as e: # noqa: BLE001
|
|
logger.debug("[%s] notification handler %s failed: %s", self.server_id, method, e)
|
|
|
|
# ---- built-in server-→-client request handlers ----
|
|
|
|
async def _handle_null(self, params: Any) -> Any:
|
|
return None
|
|
|
|
async def _handle_workspace_folders(self, params: Any) -> Any:
|
|
return self._workspace_folders()
|
|
|
|
async def _handle_workspace_configuration(self, params: Any) -> Any:
|
|
"""Walk dotted ``section`` paths through initializationOptions; null when missing."""
|
|
if not isinstance(params, dict):
|
|
return [None]
|
|
return [self._config_section(item) for item in params.get("items") or []]
|
|
|
|
def _config_section(self, item: Any) -> Any:
|
|
if not isinstance(item, dict):
|
|
return None
|
|
section = item.get("section")
|
|
if not section or not self._init_options:
|
|
return self._init_options or None
|
|
cur: Any = self._init_options
|
|
for part in str(section).split("."):
|
|
if not (isinstance(cur, dict) and part in cur):
|
|
return None
|
|
cur = cur[part]
|
|
return cur
|
|
|
|
def _handle_publish_diagnostics(self, params: Any) -> None:
|
|
if not isinstance(params, dict) or not isinstance(params.get("uri"), str):
|
|
return
|
|
diagnostics = params.get("diagnostics") or []
|
|
version = params.get("version")
|
|
doc = self._docs.setdefault(uri_to_path(params["uri"]), _DocState(version=-1))
|
|
is_seed = self._seed_first_push and not doc.seed_seen
|
|
doc.seed_seen = True
|
|
doc.push = diagnostics if isinstance(diagnostics, list) else []
|
|
if is_seed:
|
|
# First push is baseline data only: it predates any didChange we sent,
|
|
# so it's stored WITHOUT a freshness tag and never satisfies a waiter.
|
|
return
|
|
# Tag with the echoed version when provided; otherwise credit the current
|
|
# version (a push observed after our change describes it or newer). doc.version
|
|
# is -1 for never-opened paths (relatedDocuments spillover), keeping them unfresh.
|
|
doc.push_version = version if isinstance(version, int) else doc.version
|
|
# Keep the Event sticky-set so in-progress waits resolve; waiters
|
|
# compare ``_push_counter`` to detect a genuinely new push.
|
|
self._push_counter += 1
|
|
self._push_event.set()
|
|
|
|
# ---- public file-sync API ----
|
|
|
|
async def open_file(self, path: str, *, language_id: str = "plaintext") -> int:
|
|
"""Send didOpen (first time) or didChange (subsequent); return the new document version."""
|
|
if not self.is_running:
|
|
raise LSPProtocolError("client not running")
|
|
abs_path = os.path.abspath(path)
|
|
try:
|
|
text = Path(abs_path).read_text(encoding="utf-8", errors="replace")
|
|
except OSError as e:
|
|
raise LSPProtocolError(f"cannot read {abs_path}: {e}") from e
|
|
uri = file_uri(abs_path)
|
|
doc = self._docs.get(abs_path)
|
|
if doc is not None and doc.version < 0:
|
|
doc = None # never opened (relatedDocuments spillover): treat as new
|
|
# FileChangeType: 1 = CREATED, 2 = CHANGED.
|
|
await self._send_notification(
|
|
"workspace/didChangeWatchedFiles", {"changes": [{"uri": uri, "type": 1 if doc is None else 2}]}
|
|
)
|
|
if doc is None:
|
|
# Fresh state: anything a pre-open push stashed under this path (relatedDocuments spillover) is discarded.
|
|
self._docs[abs_path] = _DocState(version=0, text=text)
|
|
await self._send_notification(
|
|
"textDocument/didOpen",
|
|
{"textDocument": {"uri": uri, "languageId": language_id, "version": 0, "text": text}},
|
|
)
|
|
return 0
|
|
change: Dict[str, Any] = {"text": text}
|
|
if self._sync_kind == 2:
|
|
change["range"] = {"start": {"line": 0, "character": 0}, "end": _end_position(doc.text)}
|
|
new_version = doc.version + 1
|
|
# Bumping the version is the whole invalidation story (see _DocState). It happens
|
|
# BEFORE the send: the write awaits, and a versionless publishDiagnostics read during
|
|
# that await is credited with doc.version -- tagged with the old number it would be
|
|
# judged stale the moment the send resumes. A failed send is swallowed by
|
|
# _send_notification, leaving a version nothing ever satisfies (= "no verdict").
|
|
doc.version, doc.text = new_version, text
|
|
await self._send_notification(
|
|
"textDocument/didChange",
|
|
{"textDocument": {"uri": uri, "version": new_version}, "contentChanges": [change]},
|
|
)
|
|
return new_version
|
|
|
|
async def save_file(self, path: str) -> None:
|
|
"""Send didSave for ``path``. Some linters re-scan only on save."""
|
|
if self.is_running:
|
|
await self._send_notification(
|
|
"textDocument/didSave", {"textDocument": {"uri": file_uri(os.path.abspath(path))}}
|
|
)
|
|
|
|
# ---- diagnostics: pull + wait ----
|
|
|
|
async def _pull_document_diagnostics(self, path: str) -> None:
|
|
"""Send ``textDocument/diagnostic`` for one file into the pull store. Results are tagged with the
|
|
version captured at send time, so a didChange racing past the request makes them stale
|
|
automatically. Silently no-ops on errors (server may not support pull)."""
|
|
abs_path = os.path.abspath(path)
|
|
doc = self._docs.get(abs_path)
|
|
sent_version = doc.version if doc else -1
|
|
try:
|
|
result = await self._send_request_with_retry(
|
|
"textDocument/diagnostic", {"textDocument": {"uri": file_uri(abs_path)}},
|
|
timeout=DIAGNOSTICS_REQUEST_TIMEOUT,
|
|
)
|
|
except (LSPRequestError, LSPProtocolError, asyncio.TimeoutError) as e:
|
|
logger.debug("[%s] document diagnostic pull failed: %s", self.server_id, e)
|
|
return
|
|
if not isinstance(result, dict):
|
|
return
|
|
related = result.get("relatedDocuments")
|
|
reports = [(abs_path, result, sent_version)]
|
|
if isinstance(related, dict):
|
|
# Related docs get the same send-anchored tagging: fresh only if unchanged since.
|
|
reports += [(uri_to_path(uri), sub, None) for uri, sub in related.items()]
|
|
for doc_path, report, tag in reports:
|
|
items = report.get("items") if isinstance(report, dict) else None
|
|
if isinstance(items, list):
|
|
d = self._docs.setdefault(doc_path, _DocState(version=-1))
|
|
d.pull = items
|
|
d.pull_version = d.version if tag is None else tag
|
|
|
|
async def wait_for_diagnostics(self, path: str, version: int, *, mode: str = "document",
|
|
timeout: Optional[float] = None) -> bool:
|
|
"""Wait for fresh diagnostics for ``path`` at ``version``; True iff fresh data arrived in budget.
|
|
|
|
``mode`` is ``"document"`` (5s) or ``"full"`` (10s); ``timeout`` overrides the budget (how
|
|
``lsp.wait_timeout`` reaches the loop). Callers must treat False as "no data", NOT "no errors" —
|
|
the stores may still hold stale entries. Never throws for servers lacking pull support.
|
|
"""
|
|
if not (timeout is not None and timeout > 0):
|
|
timeout = DIAGNOSTICS_FULL_WAIT if mode == "full" else DIAGNOSTICS_DOCUMENT_WAIT
|
|
now = asyncio.get_event_loop().time
|
|
deadline = now() + timeout
|
|
abs_path = os.path.abspath(path)
|
|
while True:
|
|
if not self._connection_is_open():
|
|
raise LSPProtocolError("server connection closed while waiting for diagnostics")
|
|
remaining = deadline - now()
|
|
if remaining <= 0:
|
|
return False
|
|
# Concurrent: document pull + push wait.
|
|
tasks = {
|
|
asyncio.create_task(self._pull_document_diagnostics(abs_path)),
|
|
asyncio.create_task(self._wait_for_fresh_push(abs_path, version, remaining)),
|
|
}
|
|
_done, pending = await asyncio.wait(tasks, timeout=remaining, return_when=asyncio.FIRST_COMPLETED)
|
|
for t in pending:
|
|
t.cancel()
|
|
await asyncio.gather(*pending, return_exceptions=True)
|
|
doc = self._docs.get(abs_path)
|
|
if doc and doc.fresh(version):
|
|
return True
|
|
|
|
async def _await_push(self, timeout: float) -> bool:
|
|
"""Block until the next publishDiagnostics or ``timeout``; True iff a push woke us."""
|
|
self._push_event.clear()
|
|
try:
|
|
await asyncio.wait_for(self._push_event.wait(), timeout=timeout)
|
|
except asyncio.TimeoutError:
|
|
return False
|
|
return True
|
|
|
|
async def _wait_for_fresh_push(self, path: str, version: int, timeout: float) -> None:
|
|
"""Wait until a fresh publishDiagnostics arrives for ``path`` at ``version``+."""
|
|
now = asyncio.get_event_loop().time
|
|
deadline = now() + timeout
|
|
baseline = self._push_counter
|
|
while True:
|
|
doc = self._docs.get(path)
|
|
if doc and doc.fresh_push(version):
|
|
# Debounce: TS often emits in pairs. Snapshot the counter so
|
|
# we wake on a *new* push, not the one that just satisfied us.
|
|
debounce_baseline = self._push_counter
|
|
debounce_deadline = now() + PUSH_DEBOUNCE
|
|
while self._push_counter == debounce_baseline:
|
|
remaining = debounce_deadline - now()
|
|
if remaining <= 0 or not await self._await_push(remaining):
|
|
break
|
|
return
|
|
remaining = deadline - now()
|
|
if remaining <= 0:
|
|
return
|
|
if self._push_counter > baseline:
|
|
# New push but predicate still false — re-check without waiting.
|
|
baseline = self._push_counter
|
|
continue
|
|
await self._await_push(min(remaining, 0.5))
|
|
|
|
def diagnostics_for(self, path: str, *, fresh_only: bool = False) -> List[Dict[str, Any]]:
|
|
"""Merged + deduped push/pull diagnostics for one file. With ``fresh_only=True`` a store only
|
|
contributes once its version tag has caught up to the document's — report paths must use this
|
|
so "stale" and "clean" aren't conflated."""
|
|
doc = self._docs.get(os.path.abspath(path))
|
|
if doc is None:
|
|
return []
|
|
push = doc.push if not fresh_only or doc.fresh_push() else []
|
|
pull = doc.pull if not fresh_only or doc.fresh_pull() else []
|
|
return _dedupe(push, pull)
|
|
|
|
|
|
def _dedupe(*lists: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
|
|
seen: Set[str] = set()
|
|
out: List[Dict[str, Any]] = []
|
|
for d in (d for lst in lists for d in lst if isinstance(d, dict)):
|
|
if (key := _diagnostic_key(d)) not in seen:
|
|
seen.add(key)
|
|
out.append(d)
|
|
return out
|
|
|
|
|
|
def _diagnostic_key(d: Dict[str, Any]) -> str:
|
|
"""Content-equality key: severity + code + source + message + range. Shared with the manager's
|
|
cross-edit delta filter (``_diag_key``) so both layers agree on identity. Range is included so an
|
|
identical error at a second site still surfaces as new (the manager line-shifts its baseline first)."""
|
|
rng = d.get("range") or {}
|
|
start = rng.get("start") or {}
|
|
end = rng.get("end") or {}
|
|
code = d.get("code")
|
|
return "\x00".join([
|
|
str(d.get("severity") or 1), "" if code is None else str(code), str(d.get("source") or ""),
|
|
str(d.get("message") or "").strip(),
|
|
f"{start.get('line', 0)}:{start.get('character', 0)}-{end.get('line', 0)}:{end.get('character', 0)}",
|
|
])
|
|
|
|
|
|
__all__ = ["LSPClient", "file_uri", "uri_to_path", "INITIALIZE_TIMEOUT", "DIAGNOSTICS_DOCUMENT_WAIT", "DIAGNOSTICS_FULL_WAIT"]
|