pub mod config;
pub mod overlay;
mod pending;
mod protocol;
mod text_model;
use self::config::{
LspCommand, ensure_rust_analyzer_config, lsp_server_config,
resolve_lsp_command,
};
use self::pending::{LspRequestKind, PendingRequest, evict_expired_requests};
use self::protocol::{
frame_message, handle_client_response, handle_server_notification,
handle_server_request, read_log_line, read_message,
};
use self::text_model::{DocumentState, TextModel, apply_changes_to_document};
use crate::canvas_editor::lsp::{
LspClient, LspDocument, LspFormattingOptions, LspPosition, LspRange,
LspTextChange,
};
use serde_json::json;
use std::collections::HashMap;
use std::io::{BufReader, Write};
use std::process::{Child, Command, Stdio};
use std::sync::atomic::{AtomicU64, Ordering};
use std::sync::{Arc, Mutex, mpsc};
use std::thread;
use std::time::Instant;
pub const LSP_EVENT_QUEUE_CAPACITY: usize = 4_096;
pub(super) fn emit(events: &mpsc::SyncSender<LspEvent>, event: LspEvent) {
let _ = events.try_send(event);
}
pub enum LspEvent {
Hover {
text: String,
},
Completion {
items: Vec<String>,
},
Definition {
uri: String,
range: crate::canvas_editor::lsp::LspRange,
},
Formatting {
uri: String,
edits: Vec<LspTextChange>,
},
Diagnostics {
uri: String,
diagnostics: Vec<crate::canvas_editor::lsp::Diagnostic>,
},
Progress {
token: String,
server_key: String,
title: String,
message: Option<String>,
percentage: Option<u32>,
done: bool,
},
Log {
server_key: String,
message: String,
},
}
pub struct LspProcessClient {
child: Child,
writer: mpsc::Sender<Vec<u8>>,
documents: Arc<Mutex<HashMap<String, DocumentState>>>,
events: mpsc::SyncSender<LspEvent>,
server_key: String,
request_id: AtomicU64,
pending_requests: Arc<Mutex<HashMap<u64, PendingRequest>>>,
_writer_thread: thread::JoinHandle<()>,
_reader_thread: thread::JoinHandle<()>,
_stderr_thread: thread::JoinHandle<()>,
}
impl LspProcessClient {
pub fn new_with_server(
root_uri: &str,
events: mpsc::SyncSender<LspEvent>,
server_key: &str,
) -> Result<Self, String> {
let config = lsp_server_config(server_key)
.ok_or_else(|| format!("Unsupported LSP server: {}", server_key))?;
if server_key == "rust-analyzer" {
ensure_rust_analyzer_config();
}
let command = resolve_lsp_command(config)?;
Self::new_with_command(root_uri, events, &command, server_key)
}
fn new_with_command(
root_uri: &str,
events: mpsc::SyncSender<LspEvent>,
command: &LspCommand,
server_key: &str,
) -> Result<Self, String> {
let mut child = Command::new(&command.program)
.args(&command.args)
.stdin(Stdio::piped())
.stdout(Stdio::piped())
.stderr(Stdio::piped())
.spawn()
.map_err(|e| {
if e.kind() == std::io::ErrorKind::NotFound {
if command.program == "rust-analyzer" {
"LSP server program rust-analyzer not found. Please install rust-analyzer or set RUST_ANALYZER/RUST_ANALYZER_PATH environment variable".to_string()
} else {
format!("LSP server program {} not found", command.program)
}
} else {
e.to_string()
}
})?;
let stdin = child.stdin.take().ok_or("stdin unavailable")?;
let stdout = child.stdout.take().ok_or("stdout unavailable")?;
let stderr = child.stderr.take().ok_or("stderr unavailable")?;
let (tx, rx) = mpsc::channel::<Vec<u8>>();
let pending_requests = Arc::new(Mutex::new(HashMap::new()));
let pending_reader = pending_requests.clone();
let documents: Arc<Mutex<HashMap<String, DocumentState>>> =
Arc::new(Mutex::new(HashMap::new()));
let documents_reader = documents.clone();
let events_reader = events.clone();
let events_log = events.clone();
let events_field = events;
let server_key = server_key.to_string();
let server_key_reader = server_key.clone();
let server_key_log = server_key.clone();
let tx_reader = tx.clone();
let writer_thread = thread::spawn(move || {
let mut input = stdin;
for bytes in rx {
if input.write_all(&bytes).is_err() {
break;
}
let _ = input.flush();
}
});
let reader_thread = thread::spawn(move || {
let mut reader = BufReader::new(stdout);
while let Some(buf) = read_message(&mut reader) {
if let Ok(value) =
serde_json::from_slice::<serde_json::Value>(&buf)
{
if let Some(id) = value.get("id").and_then(|v| v.as_u64()) {
if let Some(method) =
value.get("method").and_then(|m| m.as_str())
{
handle_server_request(id, method, &tx_reader);
} else {
handle_client_response(
id,
&value,
&pending_reader,
&events_reader,
&documents_reader,
);
}
} else if let Some(method) =
value.get("method").and_then(|m| m.as_str())
&& let Some(params) = value.get("params")
{
handle_server_notification(
method,
params,
&events_reader,
&server_key_reader,
&documents_reader,
);
}
}
}
});
let stderr_thread = thread::spawn(move || {
let mut reader = BufReader::new(stderr);
while let Some(line) = read_log_line(&mut reader) {
let line = line.trim();
if line.is_empty() {
continue;
}
emit(
&events_log,
LspEvent::Log {
server_key: server_key_log.clone(),
message: line.to_string(),
},
);
}
});
let client = Self {
child,
writer: tx,
documents,
events: events_field,
server_key,
request_id: AtomicU64::new(1),
pending_requests,
_writer_thread: writer_thread,
_reader_thread: reader_thread,
_stderr_thread: stderr_thread,
};
let initialize = json!({
"jsonrpc": "2.0",
"id": client.next_id(),
"method": "initialize",
"params": {
"processId": std::process::id(),
"rootUri": root_uri,
"capabilities": {
"textDocument": {
"synchronization": {
"dynamicRegistration": false,
"willSave": false,
"didSave": true
},
"formatting": {
"dynamicRegistration": false
},
"publishDiagnostics": {
"relatedInformation": false
}
},
"window": {
"workDoneProgress": true
}
},
"workspaceFolders": null
}
});
client.send_message(&initialize);
let initialized = json!({
"jsonrpc": "2.0",
"method": "initialized",
"params": {}
});
client.send_message(&initialized);
Ok(client)
}
fn next_id(&self) -> u64 {
self.request_id.fetch_add(1, Ordering::Relaxed)
}
fn send_message(&self, value: &serde_json::Value) {
if let Some(bytes) = frame_message(value) {
let _ = self.writer.send(bytes);
}
}
fn apply_change_and_convert(
&self,
uri: &str,
changes: &[LspTextChange],
) -> Vec<serde_json::Value> {
let mut docs = self.documents.lock().unwrap_or_else(|e| e.into_inner());
let Some(state) = docs.get_mut(uri) else { return Vec::new() };
match apply_changes_to_document(state, changes) {
Some(out) => out,
None => {
docs.remove(uri);
emit(
&self.events,
LspEvent::Log {
server_key: self.server_key.clone(),
message: format!(
"Local document mirror for {uri} desynchronized \
(a change referenced a line outside the tracked \
document); dropping it until the next open."
),
},
);
Vec::new()
}
}
}
}
impl Drop for LspProcessClient {
fn drop(&mut self) {
let shutdown = json!({
"jsonrpc": "2.0",
"id": self.next_id(),
"method": "shutdown",
"params": null
});
self.send_message(&shutdown);
let exit = json!({
"jsonrpc": "2.0",
"method": "exit",
"params": {}
});
self.send_message(&exit);
if self.child.try_wait().ok().flatten().is_none() {
let _ = self.child.kill();
}
}
}
impl LspClient for LspProcessClient {
fn did_open(&mut self, document: &LspDocument, text: &str) {
let mut docs = self.documents.lock().unwrap_or_else(|e| e.into_inner());
docs.insert(
document.uri.clone(),
DocumentState { text: TextModel::from_text(text) },
);
let msg = json!({
"jsonrpc": "2.0",
"method": "textDocument/didOpen",
"params": {
"textDocument": {
"uri": document.uri,
"languageId": document.language_id,
"version": document.version,
"text": text
}
}
});
self.send_message(&msg);
}
fn did_change(
&mut self,
document: &LspDocument,
changes: &[LspTextChange],
) {
let content_changes =
self.apply_change_and_convert(&document.uri, changes);
if content_changes.is_empty() {
return;
}
let msg = json!({
"jsonrpc": "2.0",
"method": "textDocument/didChange",
"params": {
"textDocument": {
"uri": document.uri,
"version": document.version
},
"contentChanges": content_changes
}
});
self.send_message(&msg);
}
fn did_save(&mut self, document: &LspDocument, text: &str) {
let msg = json!({
"jsonrpc": "2.0",
"method": "textDocument/didSave",
"params": {
"textDocument": { "uri": document.uri },
"text": text
}
});
self.send_message(&msg);
}
fn did_close(&mut self, document: &LspDocument) {
let mut docs = self.documents.lock().unwrap_or_else(|e| e.into_inner());
docs.remove(&document.uri);
let msg = json!({
"jsonrpc": "2.0",
"method": "textDocument/didClose",
"params": {
"textDocument": { "uri": document.uri }
}
});
self.send_message(&msg);
}
fn request_hover(&mut self, document: &LspDocument, position: LspPosition) {
let docs = self.documents.lock().unwrap_or_else(|e| e.into_inner());
let Some(state) = docs.get(&document.uri) else { return };
let pos = state.text.to_utf16_position(position);
let id = self.next_id();
{
let mut pending =
self.pending_requests.lock().unwrap_or_else(|e| e.into_inner());
evict_expired_requests(&mut pending);
pending.insert(
id,
PendingRequest {
kind: LspRequestKind::Hover,
uri: document.uri.clone(),
requested_at: Instant::now(),
},
);
}
let msg = json!({
"jsonrpc": "2.0",
"id": id,
"method": "textDocument/hover",
"params": {
"textDocument": { "uri": document.uri },
"position": { "line": pos.line, "character": pos.character }
}
});
self.send_message(&msg);
}
fn request_completion(
&mut self,
document: &LspDocument,
position: LspPosition,
) {
let docs = self.documents.lock().unwrap_or_else(|e| e.into_inner());
let Some(state) = docs.get(&document.uri) else { return };
let pos = state.text.to_utf16_position(position);
let id = self.next_id();
{
let mut pending =
self.pending_requests.lock().unwrap_or_else(|e| e.into_inner());
evict_expired_requests(&mut pending);
pending.insert(
id,
PendingRequest {
kind: LspRequestKind::Completion,
uri: document.uri.clone(),
requested_at: Instant::now(),
},
);
}
let msg = json!({
"jsonrpc": "2.0",
"id": id,
"method": "textDocument/completion",
"params": {
"textDocument": { "uri": document.uri },
"position": { "line": pos.line, "character": pos.character },
"context": { "triggerKind": 1 }
}
});
self.send_message(&msg);
}
fn request_definition(
&mut self,
document: &LspDocument,
position: LspPosition,
) {
let docs = self.documents.lock().unwrap_or_else(|e| e.into_inner());
let Some(state) = docs.get(&document.uri) else { return };
let pos = state.text.to_utf16_position(position);
let id = self.next_id();
{
let mut pending =
self.pending_requests.lock().unwrap_or_else(|e| e.into_inner());
evict_expired_requests(&mut pending);
pending.insert(
id,
PendingRequest {
kind: LspRequestKind::Definition,
uri: document.uri.clone(),
requested_at: Instant::now(),
},
);
}
let msg = json!({
"jsonrpc": "2.0",
"id": id,
"method": "textDocument/definition",
"params": {
"textDocument": { "uri": document.uri },
"position": { "line": pos.line, "character": pos.character }
}
});
self.send_message(&msg);
}
fn request_formatting(
&mut self,
document: &LspDocument,
options: LspFormattingOptions,
) {
{
let docs = self.documents.lock().unwrap_or_else(|e| e.into_inner());
if !docs.contains_key(&document.uri) {
return;
}
}
let id = self.next_id();
{
let mut pending =
self.pending_requests.lock().unwrap_or_else(|e| e.into_inner());
evict_expired_requests(&mut pending);
pending.insert(
id,
PendingRequest {
kind: LspRequestKind::Formatting,
uri: document.uri.clone(),
requested_at: Instant::now(),
},
);
}
let msg = json!({
"jsonrpc": "2.0",
"id": id,
"method": "textDocument/formatting",
"params": {
"textDocument": { "uri": document.uri },
"options": {
"tabSize": options.tab_size,
"insertSpaces": options.insert_spaces
}
}
});
self.send_message(&msg);
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::canvas_editor::lsp::{LspPosition, LspRange, LspTextChange};
#[allow(clippy::expect_used)]
fn test_client()
-> (LspProcessClient, mpsc::Receiver<Vec<u8>>, mpsc::Receiver<LspEvent>)
{
let child = Command::new("true").spawn().expect("spawn stub process");
let (writer_tx, writer_rx) = mpsc::channel::<Vec<u8>>();
let (events_tx, events_rx) = mpsc::sync_channel::<LspEvent>(16);
let client = LspProcessClient {
child,
writer: writer_tx,
documents: Arc::new(Mutex::new(HashMap::new())),
events: events_tx,
server_key: "test-server".to_string(),
request_id: AtomicU64::new(1),
pending_requests: Arc::new(Mutex::new(HashMap::new())),
_writer_thread: thread::spawn(|| {}),
_reader_thread: thread::spawn(|| {}),
_stderr_thread: thread::spawn(|| {}),
};
(client, writer_rx, events_rx)
}
#[allow(clippy::expect_used)]
fn decode_sent(data: &[u8]) -> serde_json::Value {
let header_end = data
.windows(4)
.position(|w| w == b"\r\n\r\n")
.expect("missing header separator");
let body = &data[header_end + 4..];
serde_json::from_slice(body).expect("invalid JSON body")
}
fn document(uri: &str) -> LspDocument {
LspDocument {
uri: uri.to_string(),
language_id: "rust".to_string(),
version: 1,
}
}
fn range(sl: u32, sc: u32, el: u32, ec: u32) -> LspRange {
LspRange {
start: LspPosition { line: sl, character: sc },
end: LspPosition { line: el, character: ec },
}
}
#[test]
fn test_emit_drops_events_once_the_queue_is_full() {
let (tx, rx) = mpsc::sync_channel::<LspEvent>(2);
for index in 0..5 {
emit(&tx, LspEvent::Hover { text: index.to_string() });
}
let queued: Vec<String> = std::iter::from_fn(|| rx.try_recv().ok())
.map(|event| match event {
LspEvent::Hover { text } => text,
_ => String::new(),
})
.collect();
assert_eq!(
queued,
["0", "1"],
"the queue keeps what fits and drops the rest"
);
}
#[test]
fn test_emit_accepts_events_again_once_the_queue_drains() {
let (tx, rx) = mpsc::sync_channel::<LspEvent>(1);
emit(&tx, LspEvent::Hover { text: "dropped-into".to_string() });
emit(&tx, LspEvent::Hover { text: "dropped".to_string() });
let _ = rx.try_recv();
emit(&tx, LspEvent::Hover { text: "accepted".to_string() });
let accepted = rx.try_recv().ok().and_then(|event| match event {
LspEvent::Hover { text } => Some(text),
_ => None,
});
assert_eq!(
accepted.as_deref(),
Some("accepted"),
"the drained queue must accept a new event"
);
}
#[test]
fn test_next_id_increments() {
let (client, _writer_rx, _events_rx) = test_client();
assert_eq!(client.next_id(), 1);
assert_eq!(client.next_id(), 2);
assert_eq!(client.next_id(), 3);
}
#[test]
#[allow(clippy::expect_used)]
fn test_send_message_frames_and_forwards() {
let (client, writer_rx, _events_rx) = test_client();
client.send_message(&json!({"jsonrpc": "2.0", "method": "ping"}));
let bytes = writer_rx.try_recv().expect("message forwarded to writer");
assert_eq!(decode_sent(&bytes)["method"], "ping");
}
#[test]
#[allow(clippy::expect_used, clippy::unwrap_used)]
fn test_did_open_registers_document_and_notifies_server() {
let (mut client, writer_rx, _events_rx) = test_client();
let doc = document("file:///a.rs");
client.did_open(&doc, "fn main() {}");
assert!(client.documents.lock().unwrap().contains_key("file:///a.rs"));
let bytes = writer_rx.try_recv().expect("didOpen sent");
let value = decode_sent(&bytes);
assert_eq!(value["method"], "textDocument/didOpen");
assert_eq!(value["params"]["textDocument"]["text"], "fn main() {}");
}
#[test]
#[allow(clippy::expect_used)]
fn test_did_change_converts_and_sends_content_changes() {
let (mut client, writer_rx, _events_rx) = test_client();
let doc = document("file:///a.rs");
client.did_open(&doc, "hello");
writer_rx.try_recv().expect("drain didOpen");
let changes = vec![LspTextChange {
range: range(0, 0, 0, 5),
text: "hi".to_string(),
}];
client.did_change(&doc, &changes);
let bytes = writer_rx.try_recv().expect("didChange sent");
let value = decode_sent(&bytes);
assert_eq!(value["method"], "textDocument/didChange");
assert_eq!(value["params"]["contentChanges"][0]["text"], "hi");
}
#[test]
#[allow(clippy::assertions_on_result_states)]
fn test_did_change_without_open_document_sends_nothing() {
let (mut client, writer_rx, _events_rx) = test_client();
let doc = document("file:///missing.rs");
let changes = vec![LspTextChange {
range: range(0, 0, 0, 0),
text: "x".to_string(),
}];
client.did_change(&doc, &changes);
assert!(writer_rx.try_recv().is_err());
}
#[test]
#[allow(
clippy::expect_used,
clippy::unwrap_used,
clippy::panic,
clippy::assertions_on_result_states
)]
fn test_did_change_desync_drops_document_and_logs() {
let (mut client, writer_rx, events_rx) = test_client();
let doc = document("file:///a.rs");
client.did_open(&doc, "hello");
writer_rx.try_recv().expect("drain didOpen");
let changes = vec![LspTextChange {
range: range(5, 0, 5, 0),
text: "x".to_string(),
}];
client.did_change(&doc, &changes);
assert!(writer_rx.try_recv().is_err(), "no didChange after desync");
assert!(!client.documents.lock().unwrap().contains_key("file:///a.rs"));
match events_rx.try_recv().expect("desync logged") {
LspEvent::Log { message, .. } => {
assert!(message.contains("desynchronized"));
}
_ => panic!("expected LspEvent::Log"),
}
}
#[test]
#[allow(clippy::expect_used)]
fn test_did_save_sends_notification() {
let (mut client, writer_rx, _events_rx) = test_client();
let doc = document("file:///a.rs");
client.did_save(&doc, "fn main() {}");
let bytes = writer_rx.try_recv().expect("didSave sent");
let value = decode_sent(&bytes);
assert_eq!(value["method"], "textDocument/didSave");
assert_eq!(value["params"]["text"], "fn main() {}");
}
#[test]
#[allow(clippy::expect_used, clippy::unwrap_used)]
fn test_did_close_removes_document_and_notifies_server() {
let (mut client, writer_rx, _events_rx) = test_client();
let doc = document("file:///a.rs");
client.did_open(&doc, "hello");
writer_rx.try_recv().expect("drain didOpen");
client.did_close(&doc);
assert!(!client.documents.lock().unwrap().contains_key("file:///a.rs"));
let bytes = writer_rx.try_recv().expect("didClose sent");
assert_eq!(decode_sent(&bytes)["method"], "textDocument/didClose");
}
#[test]
#[allow(clippy::expect_used, clippy::unwrap_used, clippy::panic)]
fn test_request_hover_registers_pending_and_sends_request() {
let (mut client, writer_rx, _events_rx) = test_client();
let doc = document("file:///a.rs");
client.did_open(&doc, "hello");
writer_rx.try_recv().expect("drain didOpen");
client.request_hover(&doc, LspPosition { line: 0, character: 2 });
let bytes = writer_rx.try_recv().expect("hover request sent");
let value = decode_sent(&bytes);
assert_eq!(value["method"], "textDocument/hover");
let id = value["id"].as_u64().expect("id present");
let pending = client.pending_requests.lock().unwrap();
match pending.get(&id).map(|p| &p.kind) {
Some(LspRequestKind::Hover) => {}
_ => panic!("expected a pending Hover request"),
}
}
#[test]
#[allow(clippy::unwrap_used, clippy::assertions_on_result_states)]
fn test_request_hover_without_open_document_does_nothing() {
let (mut client, writer_rx, _events_rx) = test_client();
let doc = document("file:///missing.rs");
client.request_hover(&doc, LspPosition { line: 0, character: 0 });
assert!(writer_rx.try_recv().is_err());
assert!(client.pending_requests.lock().unwrap().is_empty());
}
#[test]
#[allow(clippy::expect_used, clippy::unwrap_used, clippy::panic)]
fn test_request_completion_registers_pending_and_sends_request() {
let (mut client, writer_rx, _events_rx) = test_client();
let doc = document("file:///a.rs");
client.did_open(&doc, "hello");
writer_rx.try_recv().expect("drain didOpen");
client.request_completion(&doc, LspPosition { line: 0, character: 2 });
let bytes = writer_rx.try_recv().expect("completion request sent");
let value = decode_sent(&bytes);
assert_eq!(value["method"], "textDocument/completion");
let id = value["id"].as_u64().expect("id present");
let pending = client.pending_requests.lock().unwrap();
match pending.get(&id).map(|p| &p.kind) {
Some(LspRequestKind::Completion) => {}
_ => panic!("expected a pending Completion request"),
}
}
#[test]
#[allow(clippy::expect_used, clippy::unwrap_used, clippy::panic)]
fn test_request_definition_registers_pending_and_sends_request() {
let (mut client, writer_rx, _events_rx) = test_client();
let doc = document("file:///a.rs");
client.did_open(&doc, "hello");
writer_rx.try_recv().expect("drain didOpen");
client.request_definition(&doc, LspPosition { line: 0, character: 2 });
let bytes = writer_rx.try_recv().expect("definition request sent");
let value = decode_sent(&bytes);
assert_eq!(value["method"], "textDocument/definition");
let id = value["id"].as_u64().expect("id present");
let pending = client.pending_requests.lock().unwrap();
match pending.get(&id).map(|p| &p.kind) {
Some(LspRequestKind::Definition) => {}
_ => panic!("expected a pending Definition request"),
}
}
#[test]
#[allow(clippy::expect_used, clippy::panic, clippy::unwrap_used)]
fn test_request_formatting_registers_pending_and_sends_options() {
let (mut client, writer_rx, _events_rx) = test_client();
let doc = document("file:///a.rs");
client.did_open(&doc, "hello");
writer_rx.try_recv().expect("drain didOpen");
client.request_formatting(
&doc,
LspFormattingOptions { tab_size: 2, insert_spaces: true },
);
let bytes = writer_rx.try_recv().expect("formatting request sent");
let value = decode_sent(&bytes);
assert_eq!(value["method"], "textDocument/formatting");
assert_eq!(value["params"]["textDocument"]["uri"], "file:///a.rs");
assert_eq!(value["params"]["options"]["tabSize"], 2);
assert_eq!(value["params"]["options"]["insertSpaces"], true);
let id = value["id"].as_u64().expect("id present");
let pending = client.pending_requests.lock().unwrap();
let entry = pending.get(&id).expect("a pending request");
assert!(matches!(entry.kind, LspRequestKind::Formatting));
assert_eq!(entry.uri, "file:///a.rs");
}
#[test]
#[allow(clippy::expect_used, clippy::unwrap_used)]
fn test_request_formatting_skips_a_document_that_was_never_opened() {
let (mut client, writer_rx, _events_rx) = test_client();
client.request_formatting(
&document("file:///never-opened.rs"),
LspFormattingOptions { tab_size: 4, insert_spaces: true },
);
assert!(writer_rx.try_recv().is_err(), "nothing should be sent");
assert!(client.pending_requests.lock().unwrap().is_empty());
}
#[test]
#[allow(clippy::expect_used)]
fn test_drop_sends_shutdown_then_exit() {
let (client, writer_rx, _events_rx) = test_client();
drop(client);
let shutdown = writer_rx.try_recv().expect("shutdown sent");
assert_eq!(decode_sent(&shutdown)["method"], "shutdown");
let exit = writer_rx.try_recv().expect("exit sent");
assert_eq!(decode_sent(&exit)["method"], "exit");
}
}