M3.3: engine wiring for Phpactor and diagnostics
- One Phpactor per open project on its own session thread, started when the toolchain is ready; ordered document sync from buffer.edit and the pump; lspStatus, diagnosticsChanged, diagnostics.list, lsp.status, lsp.restart; app.quit stops the server synchronously. - Phpactor 2026.06.25.0 on Windows: keep-alive $/lutra/tick (its event loop only runs on stdin input), in-process diagnostics and a polling watcher through initializationOptions (amphp subprocesses fail), 500 ms shutdown timeout. - Editor lint extension (underlines, gutter dots, hover; tokens only) and a Problems tab in the bottom panel; problems.open Mod+Alt+P. - Tests: engine tests against the fake server (incl. sync proptest), an ignored real-Phpactor test, a TCP test, Vitest for lint and Problems. - Docs: architecture, gaps G6, parity (Inspections 4% est.), ui-parity, roadmap, ROADMAP. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
parent
65c6966588
commit
13c76d3046
34 changed files with 3562 additions and 37 deletions
868
crates/engine/src/lsp/mod.rs
Normal file
868
crates/engine/src/lsp/mod.rs
Normal file
|
|
@ -0,0 +1,868 @@
|
|||
//! Engine ↔ language server wiring (M3.3): one Phpactor per open project,
|
||||
//! document sync of PHP buffers, `lspStatus` and diagnostics.
|
||||
//!
|
||||
//! Lifecycle, all decided in [`pump`] (called by
|
||||
//! [`crate::Engine::pump_vfs`]):
|
||||
//! - A session starts when a project is open and the toolchain reports a
|
||||
//! usable PHP and a ready Phpactor (`toolchain.status`), or at once when
|
||||
//! the host set its own server ([`Lsp::set_launch`], tests and the fake
|
||||
//! server). The server runs `php <phar> language-server` in the project
|
||||
//! root.
|
||||
//! - It stops when the project closes, when the PHP or Phpactor path
|
||||
//! changes (a new session starts with the new ones), on `lsp.restart`,
|
||||
//! and when the engine is dropped. The stop happens on the session thread
|
||||
//! ([`session`]), never under the engine lock.
|
||||
//!
|
||||
//! Document sync: [`record_edits`] (called by `buffer.edit`) queues the
|
||||
//! edit batch as a `didChange`; the pump opens newly opened PHP buffers,
|
||||
//! closes closed ones, sends `didSave` when a buffer's saved version moves
|
||||
//! and resends the whole text when the version moved without a recorded
|
||||
//! edit (a reload from disk, a restore) or a `didChange` no longer fit.
|
||||
//! Under the lock that is a cheap rope clone and a channel send; the text
|
||||
//! is built on the session thread.
|
||||
//!
|
||||
//! The pump drains the server's events: status changes become `lspStatus`
|
||||
//! (`starting`, `ready`, `restarting`, `failed`, `stopped`), published
|
||||
//! diagnostics of project files become `diagnosticsChanged` and are kept
|
||||
//! for `diagnostics.list`. Diagnostics are dropped when the session ends or
|
||||
//! the server gives up, so stale ones never stay on screen.
|
||||
//!
|
||||
//! Requests (completion, hover, definition, … in M3.4/M3.5) go through
|
||||
//! [`submit`], on the same queue as document sync, so they never overtake
|
||||
//! an edit.
|
||||
|
||||
pub mod session;
|
||||
|
||||
use std::collections::BTreeMap;
|
||||
use std::ffi::OsString;
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::sync::Arc;
|
||||
use std::sync::mpsc::Receiver;
|
||||
use std::time::{Duration, Instant};
|
||||
|
||||
use lutra_lsp::{PublishDiagnostics, Server, ServerEvent, Severity, Status};
|
||||
use lutra_text::{Edit, Position};
|
||||
use serde::Serialize;
|
||||
use serde_json::{Map, Value};
|
||||
|
||||
pub use lutra_lsp::{RestartPolicy, ServerOptions};
|
||||
pub use session::Launch;
|
||||
use session::{Job, Report, Session};
|
||||
|
||||
use crate::buffers::BufferId;
|
||||
use crate::cmd::toolchain::PhpactorState;
|
||||
use crate::workspace::path_string;
|
||||
use crate::{Event, NotificationLevel, State};
|
||||
|
||||
/// Most server events handled per pump; the rest wait for the next one,
|
||||
/// so a chatty server cannot hold the engine lock.
|
||||
pub const MAX_EVENTS_PER_PUMP: usize = 2_000;
|
||||
|
||||
/// Most files with diagnostics kept; publications for further files are
|
||||
/// ignored until others clear.
|
||||
pub const MAX_FILES: usize = 10_000;
|
||||
|
||||
/// The state of the language server as `lspStatus` and `lsp.status`
|
||||
/// report it.
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub enum LspState {
|
||||
/// The process runs and `initialize` is in flight.
|
||||
Starting,
|
||||
/// Initialized; diagnostics and requests work.
|
||||
Ready,
|
||||
/// The server crashed and is restarted after a delay.
|
||||
Restarting,
|
||||
/// The server could not be started or crashed too often.
|
||||
Failed,
|
||||
/// No server runs (no project, toolchain not ready, or shut down).
|
||||
Stopped,
|
||||
}
|
||||
|
||||
/// The payload of `lspStatus`.
|
||||
#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
|
||||
pub struct LspStatus {
|
||||
/// The state.
|
||||
pub state: LspState,
|
||||
/// Why it is restarting or failed.
|
||||
#[serde(skip_serializing_if = "Option::is_none")]
|
||||
pub message: Option<String>,
|
||||
}
|
||||
|
||||
impl LspStatus {
|
||||
/// No server.
|
||||
fn stopped() -> Self {
|
||||
Self {
|
||||
state: LspState::Stopped,
|
||||
message: None,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// How severe a diagnostic is, as the UI shows it.
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Serialize)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub enum DiagnosticSeverity {
|
||||
/// An error (also when the server gave no severity).
|
||||
Error,
|
||||
/// A warning.
|
||||
Warning,
|
||||
/// Information.
|
||||
Info,
|
||||
/// A hint.
|
||||
Hint,
|
||||
}
|
||||
|
||||
impl From<Option<Severity>> for DiagnosticSeverity {
|
||||
fn from(severity: Option<Severity>) -> Self {
|
||||
match severity {
|
||||
Some(Severity::Warning) => Self::Warning,
|
||||
Some(Severity::Information) => Self::Info,
|
||||
Some(Severity::Hint) => Self::Hint,
|
||||
Some(Severity::Error) | None => Self::Error,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// A position with a UTF-16 column, as everywhere in Lutra's protocol.
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
|
||||
pub struct LinePosition {
|
||||
/// 0-based line.
|
||||
pub line: usize,
|
||||
/// 0-based column in UTF-16 code units.
|
||||
pub column: usize,
|
||||
}
|
||||
|
||||
impl From<Position> for LinePosition {
|
||||
fn from(p: Position) -> Self {
|
||||
Self {
|
||||
line: p.line,
|
||||
column: p.column,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// A range between two positions, end exclusive.
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
|
||||
pub struct LineRange {
|
||||
/// Start.
|
||||
pub start: LinePosition,
|
||||
/// End.
|
||||
pub end: LinePosition,
|
||||
}
|
||||
|
||||
/// One diagnostic of a file.
|
||||
#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
|
||||
pub struct DiagnosticItem {
|
||||
/// Where it applies.
|
||||
pub range: LineRange,
|
||||
/// How severe it is.
|
||||
pub severity: DiagnosticSeverity,
|
||||
/// The message (at most 8 KiB).
|
||||
pub message: String,
|
||||
/// Who produced it (`phpactor`, `php-lint`, …).
|
||||
#[serde(skip_serializing_if = "Option::is_none")]
|
||||
pub source: Option<String>,
|
||||
/// The diagnostic code.
|
||||
#[serde(skip_serializing_if = "Option::is_none")]
|
||||
pub code: Option<String>,
|
||||
}
|
||||
|
||||
/// The payload of `diagnosticsChanged`, and one file of
|
||||
/// `diagnostics.list`.
|
||||
#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
|
||||
pub struct FileDiagnostics {
|
||||
/// Project-relative path with `/`.
|
||||
pub path: String,
|
||||
/// The diagnostics, in the server's order; empty when they cleared.
|
||||
pub items: Vec<DiagnosticItem>,
|
||||
}
|
||||
|
||||
/// The language server part of the engine state.
|
||||
#[derive(Default)]
|
||||
pub struct Lsp {
|
||||
/// A server the host chose instead of Phpactor from the toolchain.
|
||||
launch: Option<Launch>,
|
||||
/// The running session.
|
||||
active: Option<Active>,
|
||||
/// Status as last reported.
|
||||
status: Option<LspStatus>,
|
||||
/// Diagnostics by project-relative path; files without any are absent.
|
||||
diagnostics: BTreeMap<String, Vec<DiagnosticItem>>,
|
||||
/// Set by [`shutdown_now`] (`app.quit`): no session starts any more.
|
||||
quitting: bool,
|
||||
}
|
||||
|
||||
impl std::fmt::Debug for Lsp {
|
||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||
f.debug_struct("Lsp")
|
||||
.field("launch", &self.launch)
|
||||
.field("running", &self.active.is_some())
|
||||
.field("status", &self.status)
|
||||
.field("files_with_diagnostics", &self.diagnostics.len())
|
||||
.finish()
|
||||
}
|
||||
}
|
||||
|
||||
impl Lsp {
|
||||
/// Makes sessions start `launch` instead of Phpactor from the toolchain
|
||||
/// (`None` goes back to the toolchain). A running session is replaced
|
||||
/// at the next pump.
|
||||
pub fn set_launch(&mut self, launch: Option<Launch>) {
|
||||
self.launch = launch;
|
||||
}
|
||||
|
||||
/// The status as last reported; stopped without a session.
|
||||
pub fn status(&self) -> LspStatus {
|
||||
self.status.clone().unwrap_or_else(LspStatus::stopped)
|
||||
}
|
||||
|
||||
/// Milliseconds from the start of the session to the server's first
|
||||
/// `ready`, once it was reached.
|
||||
pub fn startup_ms(&self) -> Option<u64> {
|
||||
self.active.as_ref().and_then(|a| a.ready_ms)
|
||||
}
|
||||
|
||||
/// The diagnostics of one file (project-relative, `/`), or of every
|
||||
/// file, sorted by path.
|
||||
pub fn diagnostics(&self, path: Option<&str>) -> Vec<FileDiagnostics> {
|
||||
self.diagnostics
|
||||
.iter()
|
||||
.filter(|(p, _)| path.is_none_or(|want| want == p.as_str()))
|
||||
.map(|(p, items)| FileDiagnostics {
|
||||
path: p.clone(),
|
||||
items: items.clone(),
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// The server of the running session, once its process started. For
|
||||
/// reading its status and capabilities; send requests with [`submit`].
|
||||
pub fn server(&self) -> Option<&Arc<Server>> {
|
||||
self.active.as_ref().and_then(|a| a.server.as_ref())
|
||||
}
|
||||
}
|
||||
|
||||
/// What a session was started for; a change replaces the session.
|
||||
#[derive(Debug, Clone, PartialEq)]
|
||||
struct Key {
|
||||
/// The project root.
|
||||
root: PathBuf,
|
||||
/// The server command line and options.
|
||||
launch: Launch,
|
||||
}
|
||||
|
||||
/// A PHP buffer as the server knows it.
|
||||
#[derive(Debug, Clone)]
|
||||
struct Doc {
|
||||
/// Absolute path.
|
||||
path: PathBuf,
|
||||
/// The buffer version the server has (after the queued jobs).
|
||||
version: u64,
|
||||
/// The buffer's saved version last seen.
|
||||
saved_version: u64,
|
||||
/// The whole text must be resent.
|
||||
stale: bool,
|
||||
}
|
||||
|
||||
/// The running session and what the engine knows about it.
|
||||
struct Active {
|
||||
/// Why it runs.
|
||||
key: Key,
|
||||
/// The session thread.
|
||||
session: Session,
|
||||
/// The server, once started.
|
||||
server: Option<Arc<Server>>,
|
||||
/// Its events, once started.
|
||||
events: Option<Receiver<ServerEvent>>,
|
||||
/// When the session started.
|
||||
started: Instant,
|
||||
/// Milliseconds to the first `ready`.
|
||||
ready_ms: Option<u64>,
|
||||
/// Synced buffers.
|
||||
docs: BTreeMap<BufferId, Doc>,
|
||||
}
|
||||
|
||||
/// Queues `f` on the session thread, after every document change queued
|
||||
/// so far. It runs with the server and must not block (use
|
||||
/// [`Server::request_with`] or keep the [`lutra_lsp::RequestHandle`] and
|
||||
/// poll it from the pump); without a running session it is dropped
|
||||
/// unrun, which a caller notices through a dropped channel sender it
|
||||
/// captured.
|
||||
///
|
||||
/// # Returns
|
||||
/// Whether it was queued.
|
||||
pub fn submit(state: &mut State, f: impl FnOnce(&Server) + Send + 'static) -> bool {
|
||||
state
|
||||
.lsp
|
||||
.active
|
||||
.as_ref()
|
||||
.is_some_and(|a| a.session.send(Job::Run(Box::new(f))))
|
||||
}
|
||||
|
||||
/// Records an edit batch `buffer.edit` applied to buffer `id` (moving it
|
||||
/// from version `base` to `base + 1`) and queues it as a `didChange`. A
|
||||
/// buffer the server does not have yet, or whose synced version is not
|
||||
/// `base`, is resent whole by the next pump instead.
|
||||
pub fn record_edits(state: &mut State, id: BufferId, base: u64, edits: &[Edit]) {
|
||||
let Some(active) = state.lsp.active.as_mut() else {
|
||||
return;
|
||||
};
|
||||
let Some(doc) = active.docs.get_mut(&id) else {
|
||||
return;
|
||||
};
|
||||
if doc.stale || doc.version != base {
|
||||
doc.stale = true;
|
||||
return;
|
||||
}
|
||||
let job = Job::Change {
|
||||
path: doc.path.clone(),
|
||||
edits: edits.to_vec(),
|
||||
};
|
||||
if active.session.send(job) {
|
||||
doc.version = base.saturating_add(1);
|
||||
} else {
|
||||
doc.stale = true;
|
||||
}
|
||||
}
|
||||
|
||||
/// Starts, replaces or stops the session, applies the session thread's
|
||||
/// reports and the server's events, and syncs open PHP buffers. See the
|
||||
/// module docs. Never blocks.
|
||||
pub fn pump(state: &mut State) {
|
||||
let wanted = wanted(state);
|
||||
let current = state.lsp.active.as_ref().map(|a| a.key.clone());
|
||||
if current != wanted {
|
||||
if current.is_some() {
|
||||
stop(state);
|
||||
}
|
||||
if let Some(key) = wanted {
|
||||
start(state, key);
|
||||
}
|
||||
}
|
||||
if state.lsp.active.is_none() {
|
||||
return;
|
||||
}
|
||||
drain_reports(state);
|
||||
drain_events(state);
|
||||
sync_docs(state);
|
||||
}
|
||||
|
||||
/// Stops the running session at the next pump and lets the pump start a
|
||||
/// fresh one if the project and toolchain still allow it.
|
||||
pub fn restart(state: &mut State) {
|
||||
if state.lsp.active.is_some() {
|
||||
stop(state);
|
||||
}
|
||||
}
|
||||
|
||||
/// Stops the language server now and waits for it (at most about 3 s), for
|
||||
/// `app.quit`: the host exits right after, which would cut a background
|
||||
/// shutdown short and leave the Phpactor process running. Clears the
|
||||
/// diagnostics and reports `stopped`.
|
||||
pub fn shutdown_now(state: &mut State) {
|
||||
state.lsp.quitting = true;
|
||||
let Some(active) = state.lsp.active.take() else {
|
||||
return;
|
||||
};
|
||||
let Active {
|
||||
session,
|
||||
server,
|
||||
events,
|
||||
..
|
||||
} = active;
|
||||
drop(server);
|
||||
drop(events);
|
||||
session.join();
|
||||
clear_diagnostics(state);
|
||||
set_status(state, LspState::Stopped, None);
|
||||
}
|
||||
|
||||
/// The session the state calls for: none without a project; the host's
|
||||
/// server if it set one; otherwise Phpactor once the toolchain found PHP
|
||||
/// and has the PHAR ready.
|
||||
fn wanted(state: &State) -> Option<Key> {
|
||||
if state.lsp.quitting {
|
||||
return None;
|
||||
}
|
||||
let root = state.project.as_ref()?.project.root().to_path_buf();
|
||||
if let Some(launch) = &state.lsp.launch {
|
||||
return Some(Key {
|
||||
root,
|
||||
launch: launch.clone(),
|
||||
});
|
||||
}
|
||||
let status = state.toolchain.status();
|
||||
if !status.php.found || status.phpactor.state != PhpactorState::Ready {
|
||||
return None;
|
||||
}
|
||||
let php = status.php.path.as_ref()?;
|
||||
let phar = status.phpactor.path.as_ref()?;
|
||||
Some(Key {
|
||||
root,
|
||||
launch: phpactor_launch(php, phar, cfg!(windows)),
|
||||
})
|
||||
}
|
||||
|
||||
/// How Lutra starts Phpactor: `php <phar> language-server`.
|
||||
///
|
||||
/// On Windows, Phpactor 2026.06.25.0 needs two adjustments (found in the
|
||||
/// M3.3 live check, see `docs/architecture.md` › Engine wiring):
|
||||
/// - Every subprocess it starts through amphp fails there with
|
||||
/// `CreateProcess failed` (outsourced diagnostics, the PHP lint provider,
|
||||
/// the `find` file watcher of the indexer). The `initializationOptions`
|
||||
/// run diagnostics in the server process
|
||||
/// (`language_server.diagnostic_outsource: false`) and let the indexer
|
||||
/// poll in PHP (`indexer.enabled_watchers: ["php"]`). The PHP lint
|
||||
/// provider still fails once and removes itself; its warning arrives as
|
||||
/// `window/showMessage`, which Lutra does not show.
|
||||
/// - Its event loop only runs when a message arrives on stdin, so timers
|
||||
/// (the diagnostics debounce, the watcher) stall while the client is
|
||||
/// quiet. The session thread sends [`TICK_METHOD`] every 25 ms while
|
||||
/// busy; Phpactor's analysis advances one step per message, so the
|
||||
/// interval sets the latency (edit to diagnostics with its 1 s debounce:
|
||||
/// 5.9 s at 200 ms, 2.5 s at 50 ms, 1.5 s at 20 ms, measured). For the
|
||||
/// same reason it rarely answers `shutdown` in time, so the shutdown
|
||||
/// timeout is 500 ms instead of 2 s before the process is killed (quit
|
||||
/// took 3 s otherwise).
|
||||
///
|
||||
/// Nothing is written into the user's project.
|
||||
///
|
||||
/// # Parameters
|
||||
/// - `php`, `phar`: the executables from `toolchain.status`.
|
||||
/// - `windows`: whether to apply the Windows adjustments.
|
||||
pub fn phpactor_launch(php: &str, phar: &str, windows: bool) -> Launch {
|
||||
let options = ServerOptions {
|
||||
initialization_options: windows.then(|| {
|
||||
serde_json::json!({
|
||||
"language_server.diagnostic_outsource": false,
|
||||
"indexer.enabled_watchers": ["php"],
|
||||
})
|
||||
}),
|
||||
shutdown_timeout: if windows {
|
||||
Duration::from_millis(500)
|
||||
} else {
|
||||
ServerOptions::default().shutdown_timeout
|
||||
},
|
||||
..ServerOptions::default()
|
||||
};
|
||||
Launch {
|
||||
command: OsString::from(php),
|
||||
args: vec![OsString::from(phar), OsString::from("language-server")],
|
||||
options,
|
||||
tick: windows.then_some(TICK_INTERVAL),
|
||||
}
|
||||
}
|
||||
|
||||
/// The no-op notification that keeps a server's event loop turning
|
||||
/// ([`Launch::tick`]). Servers ignore `$/` notifications they do not know.
|
||||
pub const TICK_METHOD: &str = "$/lutra/tick";
|
||||
|
||||
/// How often a busy session sends [`TICK_METHOD`] to Phpactor on Windows
|
||||
/// (from its own thread, independent of the host's pump).
|
||||
pub const TICK_INTERVAL: Duration = Duration::from_millis(25);
|
||||
|
||||
/// How long a session counts as busy after its last document change,
|
||||
/// open, save or submitted request. Long enough for Phpactor's first
|
||||
/// analysis of a project on a cold cache (16 s measured in M3.3).
|
||||
pub const TICK_WINDOW: Duration = Duration::from_secs(60);
|
||||
|
||||
/// Whether a session with tick interval `interval` sends a tick at `now`.
|
||||
///
|
||||
/// # Parameters
|
||||
/// - `ready`: whether the server is ready.
|
||||
/// - `last_activity`: the last change, open, save or request, if any.
|
||||
/// - `last_tick`: when the last tick was sent, if any.
|
||||
pub fn tick_due(
|
||||
interval: Option<Duration>,
|
||||
ready: bool,
|
||||
last_activity: Option<Instant>,
|
||||
last_tick: Option<Instant>,
|
||||
now: Instant,
|
||||
) -> bool {
|
||||
let Some(interval) = interval else {
|
||||
return false;
|
||||
};
|
||||
let busy = last_activity.is_some_and(|t| now.saturating_duration_since(t) <= TICK_WINDOW);
|
||||
let due = last_tick.is_none_or(|t| now.saturating_duration_since(t) >= interval);
|
||||
ready && busy && due
|
||||
}
|
||||
|
||||
/// Starts a session for `key` and reports `starting`, or `failed` if the
|
||||
/// thread cannot be started.
|
||||
fn start(state: &mut State, key: Key) {
|
||||
match Session::start(key.launch.clone(), key.root.clone()) {
|
||||
Ok(session) => {
|
||||
state.lsp.active = Some(Active {
|
||||
key,
|
||||
session,
|
||||
server: None,
|
||||
events: None,
|
||||
started: Instant::now(),
|
||||
ready_ms: None,
|
||||
docs: BTreeMap::new(),
|
||||
});
|
||||
set_status(state, LspState::Starting, None);
|
||||
}
|
||||
Err(message) => fail(state, message),
|
||||
}
|
||||
}
|
||||
|
||||
/// Drops the session (its thread shuts the server down), clears the
|
||||
/// diagnostics and reports `stopped`.
|
||||
fn stop(state: &mut State) {
|
||||
state.lsp.active = None;
|
||||
clear_diagnostics(state);
|
||||
set_status(state, LspState::Stopped, None);
|
||||
}
|
||||
|
||||
/// Reports `failed` with `message`, clears the diagnostics and tells the
|
||||
/// user once.
|
||||
fn fail(state: &mut State, message: String) {
|
||||
clear_diagnostics(state);
|
||||
let changed = set_status(state, LspState::Failed, Some(message.clone()));
|
||||
if changed {
|
||||
let mut params = Map::new();
|
||||
params.insert("reason".into(), Value::from(message.clone()));
|
||||
state.notify(
|
||||
NotificationLevel::Error,
|
||||
Some("notification.lsp.failed"),
|
||||
Some(format!(
|
||||
"The PHP language server stopped: {message}. Run \"Restart Language Server\" to try again."
|
||||
)),
|
||||
Some(params),
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/// Stores the status and queues `lspStatus` if it changed.
|
||||
///
|
||||
/// # Returns
|
||||
/// Whether it changed.
|
||||
fn set_status(state: &mut State, lsp_state: LspState, message: Option<String>) -> bool {
|
||||
let status = LspStatus {
|
||||
state: lsp_state,
|
||||
message,
|
||||
};
|
||||
if state.lsp.status.as_ref() == Some(&status) {
|
||||
return false;
|
||||
}
|
||||
state.lsp.status = Some(status.clone());
|
||||
state.emit(Event::LspStatus(status));
|
||||
true
|
||||
}
|
||||
|
||||
/// Applies the session thread's reports.
|
||||
fn drain_reports(state: &mut State) {
|
||||
let mut reports = Vec::new();
|
||||
if let Some(active) = &state.lsp.active {
|
||||
while let Ok(report) = active.session.reports.try_recv() {
|
||||
reports.push(report);
|
||||
}
|
||||
}
|
||||
for report in reports {
|
||||
match report {
|
||||
Report::Started { server, events } => {
|
||||
if let Some(active) = state.lsp.active.as_mut() {
|
||||
active.server = Some(server);
|
||||
active.events = Some(events);
|
||||
}
|
||||
}
|
||||
Report::SpawnFailed(message) => fail(state, message),
|
||||
Report::Desync(path) => {
|
||||
if let Some(active) = state.lsp.active.as_mut() {
|
||||
for doc in active.docs.values_mut().filter(|d| d.path == path) {
|
||||
doc.stale = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Handles up to [`MAX_EVENTS_PER_PUMP`] server events.
|
||||
fn drain_events(state: &mut State) {
|
||||
let mut events = Vec::new();
|
||||
if let Some(receiver) = state.lsp.active.as_ref().and_then(|a| a.events.as_ref()) {
|
||||
while events.len() < MAX_EVENTS_PER_PUMP {
|
||||
let Ok(event) = receiver.try_recv() else {
|
||||
break;
|
||||
};
|
||||
events.push(event);
|
||||
}
|
||||
}
|
||||
for event in events {
|
||||
match event {
|
||||
ServerEvent::Status(status) => apply_status(state, status),
|
||||
ServerEvent::Diagnostics(published) => publish(state, published),
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Maps a client status onto `lspStatus`.
|
||||
fn apply_status(state: &mut State, status: Status) {
|
||||
match status {
|
||||
Status::Starting => {
|
||||
set_status(state, LspState::Starting, None);
|
||||
}
|
||||
Status::Ready => {
|
||||
if let Some(active) = state.lsp.active.as_mut()
|
||||
&& active.ready_ms.is_none()
|
||||
{
|
||||
active.ready_ms =
|
||||
Some(u64::try_from(active.started.elapsed().as_millis()).unwrap_or(u64::MAX));
|
||||
}
|
||||
set_status(state, LspState::Ready, None);
|
||||
}
|
||||
Status::Restarting { reason, .. } => {
|
||||
set_status(state, LspState::Restarting, Some(reason));
|
||||
}
|
||||
Status::Failed { message } => fail(state, message),
|
||||
Status::Stopped => {
|
||||
clear_diagnostics(state);
|
||||
set_status(state, LspState::Stopped, None);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Stores the diagnostics of one file and queues `diagnosticsChanged`.
|
||||
/// Files outside the project are ignored.
|
||||
fn publish(state: &mut State, published: PublishDiagnostics) {
|
||||
let Some(root) = state.lsp.active.as_ref().map(|a| a.key.root.clone()) else {
|
||||
return;
|
||||
};
|
||||
let Some(relative) = published.path.as_deref().and_then(|p| relative(&root, p)) else {
|
||||
return;
|
||||
};
|
||||
let path = path_string(&relative);
|
||||
let items: Vec<DiagnosticItem> = published
|
||||
.diagnostics
|
||||
.into_iter()
|
||||
.map(|d| DiagnosticItem {
|
||||
range: LineRange {
|
||||
start: d.range.start.into(),
|
||||
end: d.range.end.into(),
|
||||
},
|
||||
severity: d.severity.into(),
|
||||
message: d.message,
|
||||
source: d.source,
|
||||
code: d.code,
|
||||
})
|
||||
.collect();
|
||||
let diagnostics = &mut state.lsp.diagnostics;
|
||||
if items.is_empty() {
|
||||
if diagnostics.remove(&path).is_none() {
|
||||
return;
|
||||
}
|
||||
} else {
|
||||
if diagnostics.get(&path) == Some(&items) {
|
||||
return;
|
||||
}
|
||||
if !diagnostics.contains_key(&path) && diagnostics.len() >= MAX_FILES {
|
||||
return;
|
||||
}
|
||||
diagnostics.insert(path.clone(), items.clone());
|
||||
}
|
||||
state.emit(Event::DiagnosticsChanged(FileDiagnostics { path, items }));
|
||||
}
|
||||
|
||||
/// Drops every diagnostic, queuing an empty `diagnosticsChanged` per file
|
||||
/// that had some.
|
||||
fn clear_diagnostics(state: &mut State) {
|
||||
let files = std::mem::take(&mut state.lsp.diagnostics);
|
||||
for path in files.into_keys() {
|
||||
state.emit(Event::DiagnosticsChanged(FileDiagnostics {
|
||||
path,
|
||||
items: Vec::new(),
|
||||
}));
|
||||
}
|
||||
}
|
||||
|
||||
/// `path` relative to `root`; `None` outside it. Windows paths compare
|
||||
/// without regard to case, as the file system does.
|
||||
fn relative(root: &Path, path: &Path) -> Option<PathBuf> {
|
||||
if let Ok(rel) = path.strip_prefix(root) {
|
||||
return Some(rel.to_path_buf());
|
||||
}
|
||||
if !cfg!(windows) {
|
||||
return None;
|
||||
}
|
||||
let root_text = root.to_str()?.trim_end_matches(['\\', '/']);
|
||||
let text = path.to_str()?;
|
||||
let head = text.get(..root_text.len())?;
|
||||
let rest = text.get(root_text.len()..)?;
|
||||
if !head.eq_ignore_ascii_case(root_text) || !rest.starts_with(['\\', '/']) {
|
||||
return None;
|
||||
}
|
||||
Some(PathBuf::from(rest.trim_start_matches(['\\', '/'])))
|
||||
}
|
||||
|
||||
/// Whether a project-relative path is synced as PHP.
|
||||
fn is_php(path: &Path) -> bool {
|
||||
path.extension().and_then(|e| e.to_str()).is_some_and(|e| {
|
||||
["php", "phtml", "inc"]
|
||||
.iter()
|
||||
.any(|x| e.eq_ignore_ascii_case(x))
|
||||
})
|
||||
}
|
||||
|
||||
/// Opens new PHP buffers, closes closed ones, resends stale texts and
|
||||
/// reports saves.
|
||||
fn sync_docs(state: &mut State) {
|
||||
let State { buffers, lsp, .. } = state;
|
||||
let Some(active) = lsp.active.as_mut() else {
|
||||
return;
|
||||
};
|
||||
let gone: Vec<BufferId> = active
|
||||
.docs
|
||||
.keys()
|
||||
.copied()
|
||||
.filter(|id| !buffers.get(*id).is_some_and(|b| is_php(&b.path)))
|
||||
.collect();
|
||||
for id in gone {
|
||||
if let Some(doc) = active.docs.remove(&id) {
|
||||
active.session.send(Job::Close { path: doc.path });
|
||||
}
|
||||
}
|
||||
for id in buffers.ids() {
|
||||
let Some(open) = buffers.get(id) else {
|
||||
continue;
|
||||
};
|
||||
if !is_php(&open.path) {
|
||||
continue;
|
||||
}
|
||||
let path = active.key.root.join(&open.path);
|
||||
let Some(doc) = active.docs.get_mut(&id) else {
|
||||
active.session.send(Job::Open {
|
||||
path: path.clone(),
|
||||
text: open.buffer.clone(),
|
||||
});
|
||||
active.docs.insert(
|
||||
id,
|
||||
Doc {
|
||||
path,
|
||||
version: open.version,
|
||||
saved_version: open.saved_version,
|
||||
stale: false,
|
||||
},
|
||||
);
|
||||
continue;
|
||||
};
|
||||
if doc.path != path {
|
||||
active.session.send(Job::Close {
|
||||
path: std::mem::replace(&mut doc.path, path.clone()),
|
||||
});
|
||||
active.session.send(Job::Open {
|
||||
path,
|
||||
text: open.buffer.clone(),
|
||||
});
|
||||
doc.version = open.version;
|
||||
doc.stale = false;
|
||||
} else if doc.stale || doc.version != open.version {
|
||||
active.session.send(Job::Full {
|
||||
path: doc.path.clone(),
|
||||
text: open.buffer.clone(),
|
||||
});
|
||||
doc.version = open.version;
|
||||
doc.stale = false;
|
||||
}
|
||||
if doc.saved_version != open.saved_version {
|
||||
doc.saved_version = open.saved_version;
|
||||
if !open.dirty() {
|
||||
active.session.send(Job::Save {
|
||||
path: doc.path.clone(),
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use std::path::{Path, PathBuf};
|
||||
|
||||
use std::time::{Duration, Instant};
|
||||
|
||||
use super::{
|
||||
DiagnosticSeverity, TICK_INTERVAL, TICK_WINDOW, phpactor_launch, relative, tick_due,
|
||||
};
|
||||
use lutra_lsp::Severity;
|
||||
|
||||
#[test]
|
||||
fn severity_defaults_to_error() {
|
||||
assert_eq!(DiagnosticSeverity::from(None), DiagnosticSeverity::Error);
|
||||
assert_eq!(
|
||||
DiagnosticSeverity::from(Some(Severity::Information)),
|
||||
DiagnosticSeverity::Info
|
||||
);
|
||||
assert_eq!(
|
||||
DiagnosticSeverity::from(Some(Severity::Hint)),
|
||||
DiagnosticSeverity::Hint
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn relative_paths_stay_inside_the_root() {
|
||||
let root = if cfg!(windows) {
|
||||
PathBuf::from(r"C:\work\demo")
|
||||
} else {
|
||||
PathBuf::from("/work/demo")
|
||||
};
|
||||
let inside = root.join("src").join("a.php");
|
||||
assert_eq!(
|
||||
relative(&root, &inside),
|
||||
Some(Path::new("src").join("a.php"))
|
||||
);
|
||||
let sibling = if cfg!(windows) {
|
||||
PathBuf::from(r"C:\work\demo2\a.php")
|
||||
} else {
|
||||
PathBuf::from("/work/demo2/a.php")
|
||||
};
|
||||
assert_eq!(relative(&root, &sibling), None);
|
||||
if cfg!(windows) {
|
||||
assert_eq!(
|
||||
relative(&root, Path::new(r"c:\WORK\demo\b.php")),
|
||||
Some(PathBuf::from("b.php"))
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn phpactor_gets_the_windows_adjustments_only_there() {
|
||||
let windows = phpactor_launch("php.exe", r"C: \phpactor.phar", true);
|
||||
assert_eq!(windows.tick, Some(TICK_INTERVAL));
|
||||
let options = windows.options.initialization_options.unwrap();
|
||||
assert_eq!(options["language_server.diagnostic_outsource"], false);
|
||||
assert_eq!(
|
||||
options["indexer.enabled_watchers"],
|
||||
serde_json::json!(["php"])
|
||||
);
|
||||
assert_eq!(windows.args.len(), 2);
|
||||
let unix = phpactor_launch("php", "/t/phpactor.phar", false);
|
||||
assert_eq!(unix.tick, None);
|
||||
assert_eq!(unix.options.initialization_options, None);
|
||||
assert_eq!(windows.options.shutdown_timeout, Duration::from_millis(500));
|
||||
assert_eq!(unix.options.shutdown_timeout, Duration::from_secs(2));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ticks_only_while_ready_and_busy() {
|
||||
let now = Instant::now() + Duration::from_secs(3600);
|
||||
let tick = Some(TICK_INTERVAL);
|
||||
let recent = Some(now - Duration::from_secs(1));
|
||||
assert!(tick_due(tick, true, recent, None, now));
|
||||
assert!(!tick_due(None, true, recent, None, now));
|
||||
assert!(!tick_due(tick, false, recent, None, now));
|
||||
let quiet = Some(now - TICK_WINDOW - Duration::from_secs(1));
|
||||
assert!(!tick_due(tick, true, quiet, None, now));
|
||||
assert!(!tick_due(
|
||||
tick,
|
||||
true,
|
||||
recent,
|
||||
Some(now - TICK_INTERVAL / 2),
|
||||
now
|
||||
));
|
||||
assert!(tick_due(tick, true, recent, Some(now - TICK_INTERVAL), now));
|
||||
}
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue