use std::collections::HashMap;
use std::io::{BufRead, Read};
use std::sync::{Arc, Mutex, mpsc};
use serde_json::json;
use super::pending::{LspRequestKind, PendingRequest};
use super::text_model::DocumentState;
use super::{LspEvent, LspPosition, LspRange};
use crate::canvas_editor::lsp::{
Diagnostic, DiagnosticSeverity, LspTextChange,
};
const METHOD_PROGRESS: &str = "$/progress";
const METHOD_PUBLISH_DIAGNOSTICS: &str = "textDocument/publishDiagnostics";
const METHOD_WORK_DONE_PROGRESS_CREATE: &str = "window/workDoneProgress/create";
const PROGRESS_KIND_END: &str = "end";
const MAX_MESSAGE_BYTES: usize = 64 * 1024 * 1024;
const MAX_HEADER_LINE_BYTES: u64 = 8 * 1024;
const MAX_HEADER_LINES: usize = 64;
const MAX_LOG_LINE_BYTES: u64 = 8 * 1024;
const MAX_LOG_SKIP_BYTES: u64 = 1024 * 1024;
pub(super) fn read_message(reader: &mut impl BufRead) -> Option<Vec<u8>> {
let mut content_length: Option<usize> = None;
let mut line = String::new();
for _ in 0..MAX_HEADER_LINES {
line.clear();
let read = Read::take(&mut *reader, MAX_HEADER_LINE_BYTES)
.read_line(&mut line)
.ok()?;
if read == 0 {
return None;
}
if !line.ends_with('\n') {
return None;
}
let trimmed = line.trim();
if trimmed.is_empty() {
return read_body(reader, content_length);
}
if let Some(value) = trimmed.strip_prefix("Content-Length:")
&& let Ok(len) = value.trim().parse::<usize>()
{
content_length = Some(len);
}
}
None
}
pub(super) fn read_log_line(reader: &mut impl BufRead) -> Option<String> {
let mut buf = Vec::new();
let read = Read::take(&mut *reader, MAX_LOG_LINE_BYTES)
.read_until(b'\n', &mut buf)
.ok()?;
if read == 0 {
return None;
}
let truncated = !buf.ends_with(b"\n");
let mut line = String::from_utf8_lossy(&buf).into_owned();
if truncated {
skip_to_newline(reader);
line.push('…');
}
Some(line)
}
fn skip_to_newline(reader: &mut impl BufRead) {
let mut skipped: u64 = 0;
while skipped < MAX_LOG_SKIP_BYTES {
let Ok(available) = reader.fill_buf() else { return };
if available.is_empty() {
return;
}
if let Some(index) = available.iter().position(|byte| *byte == b'\n') {
reader.consume(index + 1);
return;
}
let len = available.len();
reader.consume(len);
skipped = skipped.saturating_add(len as u64);
}
}
fn read_body(
reader: &mut impl BufRead,
content_length: Option<usize>,
) -> Option<Vec<u8>> {
let len = content_length.unwrap_or(0);
if len > MAX_MESSAGE_BYTES {
return None;
}
let mut buf = vec![0u8; len];
if reader.read_exact(&mut buf).is_err() {
return None;
}
Some(buf)
}
pub(super) fn frame_message(value: &serde_json::Value) -> Option<Vec<u8>> {
let data = serde_json::to_vec(value).ok()?;
let mut framed =
format!("Content-Length: {}\r\n\r\n", data.len()).into_bytes();
framed.extend_from_slice(&data);
Some(framed)
}
pub(super) fn handle_server_request(
id: u64,
method: &str,
tx: &mpsc::Sender<Vec<u8>>,
) {
if method == METHOD_WORK_DONE_PROGRESS_CREATE {
let response = json!({
"jsonrpc": "2.0",
"id": id,
"result": null
});
if let Some(bytes) = frame_message(&response) {
let _ = tx.send(bytes);
}
}
}
pub(super) fn handle_client_response(
id: u64,
value: &serde_json::Value,
pending: &Arc<Mutex<HashMap<u64, PendingRequest>>>,
events: &mpsc::SyncSender<LspEvent>,
documents: &Arc<Mutex<HashMap<String, DocumentState>>>,
) {
let request = {
let mut map = pending.lock().unwrap_or_else(|e| e.into_inner());
map.remove(&id)
};
let Some(request) = request else { return };
let result = value.get("result").unwrap_or(&serde_json::Value::Null);
match request.kind {
LspRequestKind::Hover => {
let text = parse_hover_text(result).unwrap_or_default();
super::emit(events, LspEvent::Hover { text });
}
LspRequestKind::Completion => {
let items = parse_completion_items(result);
if !items.is_empty() {
super::emit(events, LspEvent::Completion { items });
}
}
LspRequestKind::Definition => {
if let Some((uri, range)) = parse_definition_location(result) {
super::emit(events, LspEvent::Definition { uri, range });
}
}
LspRequestKind::Formatting => {
let edits = parse_text_edits(result);
if edits.is_empty() {
return;
}
let docs = documents.lock().unwrap_or_else(|e| e.into_inner());
let Some(state) = docs.get(&request.uri) else { return };
let edits = edits
.into_iter()
.map(|edit| LspTextChange {
range: LspRange {
start: state.text.to_char_position(edit.range.start),
end: state.text.to_char_position(edit.range.end),
},
text: edit.text,
})
.collect();
drop(docs);
super::emit(
events,
LspEvent::Formatting { uri: request.uri, edits },
);
}
}
}
pub(super) fn handle_server_notification(
method: &str,
params: &serde_json::Value,
events: &mpsc::SyncSender<LspEvent>,
server_key: &str,
documents: &Arc<Mutex<HashMap<String, DocumentState>>>,
) {
match method {
METHOD_PROGRESS => handle_progress(params, events, server_key),
METHOD_PUBLISH_DIAGNOSTICS => {
handle_publish_diagnostics(params, events, documents);
}
_ => {}
}
}
fn handle_progress(
params: &serde_json::Value,
events: &mpsc::SyncSender<LspEvent>,
server_key: &str,
) {
let Some(token) = params.get("token").and_then(|t| {
t.as_str()
.map(String::from)
.or_else(|| t.as_i64().map(|i| i.to_string()))
}) else {
return;
};
let Some(val) = params.get("value") else { return };
let kind = val.get("kind").and_then(|k| k.as_str()).unwrap_or("");
let title = val
.get("title")
.and_then(|t| t.as_str())
.map(String::from)
.unwrap_or_default();
let message = val.get("message").and_then(|m| m.as_str()).map(String::from);
let percentage =
val.get("percentage").and_then(|p| p.as_u64()).map(|p| p as u32);
let done = kind == PROGRESS_KIND_END;
super::emit(
events,
LspEvent::Progress {
token,
server_key: server_key.to_string(),
title,
message,
percentage,
done,
},
);
}
fn handle_publish_diagnostics(
params: &serde_json::Value,
events: &mpsc::SyncSender<LspEvent>,
documents: &Arc<Mutex<HashMap<String, DocumentState>>>,
) {
let Some((uri, diagnostics)) = parse_publish_diagnostics(params) else {
return;
};
let docs = documents.lock().unwrap_or_else(|e| e.into_inner());
let Some(state) = docs.get(&uri) else { return };
let diagnostics = diagnostics
.into_iter()
.map(|diagnostic| Diagnostic {
range: LspRange {
start: state.text.to_char_position(diagnostic.range.start),
end: state.text.to_char_position(diagnostic.range.end),
},
..diagnostic
})
.collect();
drop(docs);
super::emit(events, LspEvent::Diagnostics { uri, diagnostics });
}
fn parse_publish_diagnostics(
params: &serde_json::Value,
) -> Option<(String, Vec<Diagnostic>)> {
let uri = params.get("uri")?.as_str()?.to_string();
let diagnostics = params
.get("diagnostics")?
.as_array()?
.iter()
.filter_map(|diagnostic| {
Some(Diagnostic {
range: extract_range(diagnostic.get("range")?)?,
severity: parse_diagnostic_severity(diagnostic.get("severity")),
message: diagnostic
.get("message")
.and_then(serde_json::Value::as_str)
.unwrap_or_default()
.to_string(),
source: diagnostic
.get("source")
.and_then(serde_json::Value::as_str)
.filter(|source| !source.trim().is_empty())
.map(String::from),
})
})
.collect();
Some((uri, diagnostics))
}
fn parse_diagnostic_severity(
value: Option<&serde_json::Value>,
) -> DiagnosticSeverity {
match value.and_then(serde_json::Value::as_u64) {
Some(2) => DiagnosticSeverity::Warning,
Some(3) => DiagnosticSeverity::Information,
Some(4) => DiagnosticSeverity::Hint,
_ => DiagnosticSeverity::Error,
}
}
fn parse_hover_text(result: &serde_json::Value) -> Option<String> {
let contents = result.get("contents")?;
hover_text_from_contents(contents)
}
fn hover_text_from_contents(value: &serde_json::Value) -> Option<String> {
match value {
serde_json::Value::String(text) => Some(text.clone()),
serde_json::Value::Array(items) => {
let parts: Vec<String> =
items.iter().filter_map(hover_text_from_contents).collect();
if parts.is_empty() { None } else { Some(parts.join("\n")) }
}
serde_json::Value::Object(map) => {
map.get("value").and_then(|v| v.as_str()).map(String::from)
}
_ => None,
}
}
fn parse_completion_items(result: &serde_json::Value) -> Vec<String> {
let mut items = Vec::new();
if let Some(array) = result.as_array() {
items.extend(array.iter());
} else if let Some(array) = result.get("items").and_then(|v| v.as_array()) {
items.extend(array.iter());
}
items
.iter()
.filter_map(|item| item.get("label").and_then(|v| v.as_str()))
.map(String::from)
.collect()
}
fn extract_range(range_val: &serde_json::Value) -> Option<LspRange> {
let start = range_val.get("start")?;
let end = range_val.get("end")?;
Some(LspRange {
start: LspPosition {
line: start.get("line")?.as_u64()? as u32,
character: start.get("character")?.as_u64()? as u32,
},
end: LspPosition {
line: end.get("line")?.as_u64()? as u32,
character: end.get("character")?.as_u64()? as u32,
},
})
}
fn extract_location(loc: &serde_json::Value) -> Option<(String, LspRange)> {
let uri = loc.get("uri")?.as_str()?.to_string();
let range = extract_range(loc.get("range")?)?;
Some((uri, range))
}
fn extract_link(link: &serde_json::Value) -> Option<(String, LspRange)> {
let uri = link.get("targetUri")?.as_str()?.to_string();
let range_val =
link.get("targetSelectionRange").or(link.get("targetRange"))?;
let range = extract_range(range_val)?;
Some((uri, range))
}
fn parse_text_edits(result: &serde_json::Value) -> Vec<LspTextChange> {
let Some(array) = result.as_array() else {
return Vec::new();
};
array
.iter()
.filter_map(|edit| {
Some(LspTextChange {
range: extract_range(edit.get("range")?)?,
text: edit.get("newText")?.as_str()?.to_string(),
})
})
.collect()
}
fn parse_definition_location(
result: &serde_json::Value,
) -> Option<(String, LspRange)> {
if let Some(array) = result.as_array() {
if let Some(first) = array.first() {
if first.get("targetUri").is_some() {
extract_link(first)
} else {
extract_location(first)
}
} else {
None
}
} else if result.is_object() {
extract_location(result)
} else {
None
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::canvas_editor::lsp::LspPosition;
use std::io::BufReader;
use std::time::Instant;
#[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 pending_request(kind: LspRequestKind) -> PendingRequest {
PendingRequest {
kind,
uri: "file:///test.rs".to_string(),
requested_at: Instant::now(),
}
}
fn no_documents() -> Arc<Mutex<HashMap<String, DocumentState>>> {
Arc::new(Mutex::new(HashMap::new()))
}
#[test]
fn test_read_message_reads_framed_body() {
let mut stream = std::io::Cursor::new(
b"Content-Length: 9\r\n\r\n{\"id\":42}".to_vec(),
);
assert_eq!(
read_message(&mut stream).as_deref(),
Some(&b"{\"id\":42}"[..])
);
}
#[test]
fn test_read_message_ignores_other_headers() {
let mut stream = std::io::Cursor::new(
b"Content-Type: application/vscode-jsonrpc\r\nContent-Length: 2\r\n\r\n{}"
.to_vec(),
);
assert_eq!(read_message(&mut stream).as_deref(), Some(&b"{}"[..]));
}
#[test]
fn test_read_message_reads_consecutive_frames() {
let mut stream = std::io::Cursor::new(
b"Content-Length: 2\r\n\r\n{}Content-Length: 4\r\n\r\n[1,]"
.to_vec(),
);
assert_eq!(read_message(&mut stream).as_deref(), Some(&b"{}"[..]));
assert_eq!(read_message(&mut stream).as_deref(), Some(&b"[1,]"[..]));
assert!(read_message(&mut stream).is_none(), "stream is exhausted");
}
#[test]
fn test_read_message_rejects_oversized_frame() {
let header =
format!("Content-Length: {}\r\n\r\n", MAX_MESSAGE_BYTES + 1);
let mut stream = std::io::Cursor::new(header.into_bytes());
assert!(read_message(&mut stream).is_none());
}
#[test]
fn test_read_message_rejects_truncated_body() {
let mut stream =
std::io::Cursor::new(b"Content-Length: 10\r\n\r\nabc".to_vec());
assert!(read_message(&mut stream).is_none());
}
#[test]
fn test_read_message_ends_on_empty_stream() {
let mut stream = std::io::Cursor::new(Vec::new());
assert!(read_message(&mut stream).is_none());
}
#[test]
fn test_read_message_without_content_length_yields_empty_body() {
let mut stream = std::io::Cursor::new(b"X-Unknown: 1\r\n\r\n".to_vec());
assert_eq!(read_message(&mut stream).as_deref(), Some(&b""[..]));
}
struct EndlessHeaderReader {
served: std::rc::Rc<std::cell::Cell<usize>>,
}
impl Read for EndlessHeaderReader {
fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
buf.fill(b'a');
self.served.set(self.served.get() + buf.len());
Ok(buf.len())
}
}
#[test]
fn test_read_message_stops_reading_an_unterminated_header_line() {
let served = std::rc::Rc::new(std::cell::Cell::new(0));
let mut stream = BufReader::new(EndlessHeaderReader {
served: std::rc::Rc::clone(&served),
});
assert!(read_message(&mut stream).is_none());
let cap = MAX_HEADER_LINE_BYTES as usize;
assert!(
served.get() <= cap * 4,
"read {} bytes for one header line, cap is {cap}",
served.get()
);
}
#[test]
fn test_read_message_rejects_a_header_block_that_never_ends() {
let flood = "X-Pad: 1\r\n".repeat(MAX_HEADER_LINES + 10);
let mut stream = std::io::Cursor::new(flood.into_bytes());
assert!(read_message(&mut stream).is_none());
}
#[test]
fn test_read_log_line_reads_lines_in_order() {
let mut reader =
BufReader::new(std::io::Cursor::new(b"first\nsecond\n".to_vec()));
assert_eq!(read_log_line(&mut reader).as_deref(), Some("first\n"));
assert_eq!(read_log_line(&mut reader).as_deref(), Some("second\n"));
assert_eq!(read_log_line(&mut reader), None, "stream is exhausted");
}
#[test]
fn test_read_log_line_truncates_an_oversized_line_and_resyncs() {
let cap = MAX_LOG_LINE_BYTES as usize;
let flood = "a".repeat(cap * 3);
let stream = format!("{flood}\nnext\n");
let mut reader =
BufReader::new(std::io::Cursor::new(stream.into_bytes()));
let line = read_log_line(&mut reader);
assert!(
line.as_ref().is_some_and(|line| line.len() <= cap + 8),
"the kept prefix must be bounded by the cap"
);
assert!(
line.as_ref().is_some_and(|line| line.ends_with('…')),
"a truncated line must say so"
);
assert_eq!(read_log_line(&mut reader).as_deref(), Some("next\n"));
}
#[test]
fn test_read_log_line_replaces_invalid_utf8_instead_of_ending_the_stream() {
let mut reader = BufReader::new(std::io::Cursor::new(
b"bad \xff byte\nnext\n".to_vec(),
));
let line = read_log_line(&mut reader);
assert!(
line.as_ref().is_some_and(|line| line.contains('\u{fffd}')),
"the invalid byte should become a replacement character, got {line:?}"
);
assert_eq!(read_log_line(&mut reader).as_deref(), Some("next\n"));
}
#[test]
fn test_read_log_line_stops_reading_an_unterminated_line() {
let served = std::rc::Rc::new(std::cell::Cell::new(0));
let mut reader = BufReader::new(EndlessHeaderReader {
served: std::rc::Rc::clone(&served),
});
let line = read_log_line(&mut reader);
let cap = MAX_LOG_LINE_BYTES as usize;
assert!(line.is_some_and(|line| line.len() <= cap + 8));
}
#[test]
fn test_read_message_accepts_headers_just_inside_the_caps() {
let padding = "x".repeat(MAX_HEADER_LINE_BYTES as usize / 2);
let mut frame = format!("X-Pad: {padding}\r\n");
for _ in 0..MAX_HEADER_LINES - 3 {
frame.push_str("X-Small: 1\r\n");
}
frame.push_str("Content-Length: 2\r\n\r\n{}");
let mut stream = std::io::Cursor::new(frame.into_bytes());
assert_eq!(read_message(&mut stream).as_deref(), Some(&b"{}"[..]));
}
#[test]
#[allow(clippy::unwrap_used)]
fn test_frame_message_builds_content_length_header() {
let value = serde_json::json!({"jsonrpc": "2.0", "id": 1});
let data = serde_json::to_vec(&value).unwrap();
let framed = frame_message(&value).unwrap();
let expected_header = format!("Content-Length: {}\r\n\r\n", data.len());
assert!(framed.starts_with(expected_header.as_bytes()));
assert_eq!(&framed[expected_header.len()..], data.as_slice());
}
#[test]
#[allow(clippy::unwrap_used)]
fn test_extract_range_parses_start_and_end() {
let range_val = serde_json::json!({
"start": { "line": 1, "character": 2 },
"end": { "line": 3, "character": 4 }
});
let range = extract_range(&range_val).unwrap();
assert_eq!(range.start, LspPosition { line: 1, character: 2 });
assert_eq!(range.end, LspPosition { line: 3, character: 4 });
}
#[test]
fn test_extract_range_missing_end_returns_none() {
let range_val = serde_json::json!({
"start": { "line": 1, "character": 2 }
});
assert!(extract_range(&range_val).is_none());
}
#[test]
#[allow(clippy::unwrap_used)]
fn test_extract_location_reads_uri_and_range() {
let loc = serde_json::json!({
"uri": "file:///a.rs",
"range": {
"start": { "line": 0, "character": 0 },
"end": { "line": 0, "character": 1 }
}
});
let (uri, range) = extract_location(&loc).unwrap();
assert_eq!(uri, "file:///a.rs");
assert_eq!(range.start, LspPosition { line: 0, character: 0 });
}
#[test]
#[allow(clippy::unwrap_used)]
fn test_extract_link_prefers_target_selection_range() {
let link = serde_json::json!({
"targetUri": "file:///b.rs",
"targetRange": {
"start": { "line": 10, "character": 0 },
"end": { "line": 20, "character": 0 }
},
"targetSelectionRange": {
"start": { "line": 12, "character": 4 },
"end": { "line": 12, "character": 8 }
}
});
let (uri, range) = extract_link(&link).unwrap();
assert_eq!(uri, "file:///b.rs");
assert_eq!(range.start, LspPosition { line: 12, character: 4 });
}
#[test]
#[allow(clippy::unwrap_used)]
fn test_extract_link_falls_back_to_target_range() {
let link = serde_json::json!({
"targetUri": "file:///c.rs",
"targetRange": {
"start": { "line": 5, "character": 0 },
"end": { "line": 6, "character": 0 }
}
});
let (uri, range) = extract_link(&link).unwrap();
assert_eq!(uri, "file:///c.rs");
assert_eq!(range.start, LspPosition { line: 5, character: 0 });
}
#[test]
#[allow(clippy::expect_used)]
fn test_handle_server_request_work_done_progress_create() {
let (tx, rx) = mpsc::channel::<Vec<u8>>();
handle_server_request(42, METHOD_WORK_DONE_PROGRESS_CREATE, &tx);
let bytes = rx.try_recv().expect("expected a response on the channel");
let value = decode_sent(&bytes);
assert_eq!(value["id"], 42);
assert_eq!(value["jsonrpc"], "2.0");
assert!(value["result"].is_null());
}
#[test]
fn test_handle_server_request_unknown_method_ignored() {
let (tx, rx) = mpsc::channel::<Vec<u8>>();
handle_server_request(1, "unknown/method", &tx);
assert!(
rx.try_recv().is_err(),
"unknown methods must not send a reply"
);
}
#[test]
#[allow(clippy::expect_used, clippy::panic, clippy::unwrap_used)]
fn test_handle_client_response_hover() {
let (events_tx, events_rx) = mpsc::sync_channel::<LspEvent>(16);
let pending = Arc::new(Mutex::new(HashMap::new()));
pending
.lock()
.unwrap()
.insert(1u64, pending_request(LspRequestKind::Hover));
let value = serde_json::json!({
"id": 1,
"result": { "contents": { "value": "hover info" } }
});
handle_client_response(
1,
&value,
&pending,
&events_tx,
&no_documents(),
);
match events_rx.try_recv().expect("expected a Hover event") {
LspEvent::Hover { text } => assert_eq!(text, "hover info"),
_ => panic!("expected LspEvent::Hover"),
}
assert!(pending.lock().unwrap().is_empty());
}
#[test]
#[allow(clippy::expect_used, clippy::panic, clippy::unwrap_used)]
fn test_handle_client_response_completion() {
let (events_tx, events_rx) = mpsc::sync_channel::<LspEvent>(16);
let pending = Arc::new(Mutex::new(HashMap::new()));
pending
.lock()
.unwrap()
.insert(2u64, pending_request(LspRequestKind::Completion));
let value = serde_json::json!({
"id": 2,
"result": { "items": [{ "label": "foo" }, { "label": "bar" }] }
});
handle_client_response(
2,
&value,
&pending,
&events_tx,
&no_documents(),
);
match events_rx.try_recv().expect("expected a Completion event") {
LspEvent::Completion { items } => {
assert_eq!(items, vec!["foo", "bar"]);
}
_ => panic!("expected LspEvent::Completion"),
}
}
#[test]
#[allow(clippy::expect_used, clippy::panic, clippy::unwrap_used)]
fn test_handle_client_response_definition() {
let (events_tx, events_rx) = mpsc::sync_channel::<LspEvent>(16);
let pending = Arc::new(Mutex::new(HashMap::new()));
pending
.lock()
.unwrap()
.insert(3u64, pending_request(LspRequestKind::Definition));
let value = serde_json::json!({
"id": 3,
"result": {
"uri": "file:///foo/bar.rs",
"range": {
"start": { "line": 0, "character": 0 },
"end": { "line": 0, "character": 5 }
}
}
});
handle_client_response(
3,
&value,
&pending,
&events_tx,
&no_documents(),
);
match events_rx.try_recv().expect("expected a Definition event") {
LspEvent::Definition { uri, .. } => {
assert_eq!(uri, "file:///foo/bar.rs");
}
_ => panic!("expected LspEvent::Definition"),
}
}
#[test]
#[allow(clippy::unwrap_used)]
fn test_a_dropped_response_still_clears_its_pending_request() {
let (events_tx, _events_rx) = mpsc::sync_channel::<LspEvent>(0);
let pending = Arc::new(Mutex::new(HashMap::new()));
pending
.lock()
.unwrap()
.insert(7u64, pending_request(LspRequestKind::Hover));
let value = serde_json::json!({
"id": 7,
"result": { "contents": "fn main()" }
});
handle_client_response(
7,
&value,
&pending,
&events_tx,
&no_documents(),
);
assert!(
pending.lock().unwrap().is_empty(),
"a response the queue dropped must still retire its request"
);
}
#[test]
fn test_handle_client_response_unknown_id_ignored() {
let (events_tx, events_rx) = mpsc::sync_channel::<LspEvent>(16);
let pending = Arc::new(Mutex::new(HashMap::new()));
let value = serde_json::json!({ "id": 99, "result": null });
handle_client_response(
99,
&value,
&pending,
&events_tx,
&no_documents(),
);
assert!(
events_rx.try_recv().is_err(),
"unknown IDs must not emit events"
);
}
fn documents_with(
text: &str,
) -> Arc<Mutex<HashMap<String, DocumentState>>> {
let mut map = HashMap::new();
map.insert(
"file:///test.rs".to_string(),
DocumentState {
text: super::super::text_model::TextModel::from_text(text),
},
);
Arc::new(Mutex::new(map))
}
#[test]
fn test_parse_text_edits_reads_every_edit() {
let result = serde_json::json!([
{
"range": {
"start": { "line": 0, "character": 0 },
"end": { "line": 1, "character": 0 }
},
"newText": "fn main() {}\n"
},
{
"range": {
"start": { "line": 4, "character": 2 },
"end": { "line": 4, "character": 6 }
},
"newText": ""
}
]);
let edits = parse_text_edits(&result);
assert_eq!(edits.len(), 2);
assert_eq!(edits[0].text, "fn main() {}\n");
assert_eq!(edits[0].range.end, LspPosition { line: 1, character: 0 });
assert_eq!(edits[1].text, "");
}
#[test]
fn test_parse_text_edits_of_a_null_result_is_empty() {
assert!(parse_text_edits(&serde_json::Value::Null).is_empty());
}
#[test]
fn test_parse_text_edits_skips_malformed_entries() {
let result = serde_json::json!([
{ "newText": "x" },
{
"range": {
"start": { "line": 0, "character": 0 },
"end": { "line": 0, "character": 1 }
}
}
]);
assert!(parse_text_edits(&result).is_empty());
}
#[test]
#[allow(clippy::expect_used, clippy::panic, clippy::unwrap_used)]
fn test_handle_client_response_formatting_converts_utf16_columns() {
let (events_tx, events_rx) = mpsc::sync_channel::<LspEvent>(16);
let pending = Arc::new(Mutex::new(HashMap::new()));
pending
.lock()
.unwrap()
.insert(4u64, pending_request(LspRequestKind::Formatting));
let value = serde_json::json!({
"id": 4,
"result": [{
"range": {
"start": { "line": 0, "character": 3 },
"end": { "line": 0, "character": 4 }
},
"newText": "Z"
}]
});
handle_client_response(
4,
&value,
&pending,
&events_tx,
&documents_with("🚀ab"),
);
match events_rx.try_recv().expect("expected a Formatting event") {
LspEvent::Formatting { uri, edits } => {
assert_eq!(uri, "file:///test.rs");
assert_eq!(edits.len(), 1);
assert_eq!(
edits[0].range.start,
LspPosition { line: 0, character: 2 }
);
assert_eq!(
edits[0].range.end,
LspPosition { line: 0, character: 3 }
);
}
_ => panic!("expected LspEvent::Formatting"),
}
}
#[test]
#[allow(clippy::unwrap_used)]
fn test_handle_client_response_formatting_without_a_mirror_emits_nothing() {
let (events_tx, events_rx) = mpsc::sync_channel::<LspEvent>(16);
let pending = Arc::new(Mutex::new(HashMap::new()));
pending
.lock()
.unwrap()
.insert(5u64, pending_request(LspRequestKind::Formatting));
let value = serde_json::json!({
"id": 5,
"result": [{
"range": {
"start": { "line": 0, "character": 0 },
"end": { "line": 0, "character": 1 }
},
"newText": "x"
}]
});
handle_client_response(
5,
&value,
&pending,
&events_tx,
&no_documents(),
);
assert!(events_rx.try_recv().is_err());
assert!(pending.lock().unwrap().is_empty());
}
#[test]
#[allow(clippy::unwrap_used)]
fn test_handle_client_response_formatting_of_an_empty_reply_emits_nothing()
{
let (events_tx, events_rx) = mpsc::sync_channel::<LspEvent>(16);
let pending = Arc::new(Mutex::new(HashMap::new()));
pending
.lock()
.unwrap()
.insert(6u64, pending_request(LspRequestKind::Formatting));
let value = serde_json::json!({ "id": 6, "result": null });
handle_client_response(
6,
&value,
&pending,
&events_tx,
&documents_with("fn main() {}"),
);
assert!(events_rx.try_recv().is_err());
}
#[test]
#[allow(clippy::expect_used, clippy::panic)]
fn test_handle_server_notification_progress_done() {
let (events_tx, events_rx) = mpsc::sync_channel::<LspEvent>(16);
let params = serde_json::json!({
"token": "my-token",
"value": {
"kind": "end",
"title": "Indexing",
"message": "done"
}
});
handle_server_notification(
METHOD_PROGRESS,
¶ms,
&events_tx,
"lua-ls",
&no_documents(),
);
match events_rx.try_recv().expect("expected a Progress event") {
LspEvent::Progress { token, done, server_key, .. } => {
assert_eq!(token, "my-token");
assert!(done);
assert_eq!(server_key, "lua-ls");
}
_ => panic!("expected LspEvent::Progress"),
}
}
#[test]
#[allow(clippy::expect_used, clippy::panic)]
fn test_handle_server_notification_progress_not_done() {
let (events_tx, events_rx) = mpsc::sync_channel::<LspEvent>(16);
let params = serde_json::json!({
"token": "tok",
"value": { "kind": "report", "title": "Building" }
});
handle_server_notification(
METHOD_PROGRESS,
¶ms,
&events_tx,
"rust-analyzer",
&no_documents(),
);
match events_rx.try_recv().expect("expected a Progress event") {
LspEvent::Progress { done, .. } => assert!(!done),
_ => panic!("expected LspEvent::Progress"),
}
}
#[test]
fn test_handle_server_notification_unknown_method_ignored() {
let (events_tx, events_rx) = mpsc::sync_channel::<LspEvent>(16);
let params = serde_json::json!({});
handle_server_notification(
"$/somethingElse",
¶ms,
&events_tx,
"server",
&no_documents(),
);
assert!(events_rx.try_recv().is_err());
}
fn diagnostics_params(
diagnostics: &serde_json::Value,
) -> serde_json::Value {
serde_json::json!({ "uri": "file:///test.rs", "diagnostics": diagnostics })
}
#[test]
#[allow(clippy::expect_used, clippy::panic)]
fn test_publish_diagnostics_converts_utf16_columns_and_severity() {
let (events_tx, events_rx) = mpsc::sync_channel::<LspEvent>(16);
let params = diagnostics_params(&serde_json::json!([
{
"range": {
"start": { "line": 0, "character": 3 },
"end": { "line": 0, "character": 5 }
},
"severity": 2,
"message": "unused",
"source": "rustc"
},
{
"range": {
"start": { "line": 0, "character": 0 },
"end": { "line": 0, "character": 2 }
},
"message": "no severity"
}
]));
handle_server_notification(
METHOD_PUBLISH_DIAGNOSTICS,
¶ms,
&events_tx,
"server",
&documents_with("🚀abc"),
);
match events_rx.try_recv().expect("expected a Diagnostics event") {
LspEvent::Diagnostics { uri, diagnostics } => {
assert_eq!(uri, "file:///test.rs");
assert_eq!(diagnostics.len(), 2);
assert_eq!(
diagnostics[0].range,
LspRange {
start: LspPosition { line: 0, character: 2 },
end: LspPosition { line: 0, character: 4 },
}
);
assert_eq!(
diagnostics[0].severity,
DiagnosticSeverity::Warning
);
assert_eq!(diagnostics[0].message, "unused");
assert_eq!(diagnostics[0].source.as_deref(), Some("rustc"));
assert_eq!(diagnostics[1].source, None);
assert_eq!(
diagnostics[1].range.end,
LspPosition { line: 0, character: 1 }
);
assert_eq!(diagnostics[1].severity, DiagnosticSeverity::Error);
}
_ => panic!("expected LspEvent::Diagnostics"),
}
}
#[test]
#[allow(clippy::expect_used, clippy::panic)]
fn test_publish_diagnostics_empty_list_is_emitted() {
let (events_tx, events_rx) = mpsc::sync_channel::<LspEvent>(16);
handle_server_notification(
METHOD_PUBLISH_DIAGNOSTICS,
&diagnostics_params(&serde_json::json!([])),
&events_tx,
"server",
&documents_with("abc"),
);
match events_rx.try_recv().expect("expected a Diagnostics event") {
LspEvent::Diagnostics { diagnostics, .. } => {
assert!(diagnostics.is_empty());
}
_ => panic!("expected LspEvent::Diagnostics"),
}
}
#[test]
fn test_publish_diagnostics_without_a_mirror_emits_nothing() {
let (events_tx, events_rx) = mpsc::sync_channel::<LspEvent>(16);
handle_server_notification(
METHOD_PUBLISH_DIAGNOSTICS,
&diagnostics_params(&serde_json::json!([])),
&events_tx,
"server",
&no_documents(),
);
assert!(events_rx.try_recv().is_err());
}
#[test]
#[allow(clippy::expect_used)]
fn test_parse_publish_diagnostics_skips_entries_without_a_range() {
let params = diagnostics_params(&serde_json::json!([
{ "message": "no range", "severity": 1 },
{
"range": {
"start": { "line": 1, "character": 0 },
"end": { "line": 1, "character": 1 }
},
"severity": 4
}
]));
let (_, diagnostics) =
parse_publish_diagnostics(¶ms).expect("valid payload");
assert_eq!(diagnostics.len(), 1);
assert_eq!(diagnostics[0].severity, DiagnosticSeverity::Hint);
assert_eq!(diagnostics[0].message, "");
}
#[test]
fn test_parse_publish_diagnostics_requires_uri_and_array() {
assert!(
parse_publish_diagnostics(
&serde_json::json!({ "diagnostics": [] })
)
.is_none()
);
assert!(
parse_publish_diagnostics(
&serde_json::json!({ "uri": "file:///a.rs" })
)
.is_none()
);
}
#[test]
fn test_parse_diagnostic_severity_maps_lsp_numbers() {
let severity =
|value: serde_json::Value| parse_diagnostic_severity(Some(&value));
assert_eq!(severity(serde_json::json!(1)), DiagnosticSeverity::Error);
assert_eq!(severity(serde_json::json!(2)), DiagnosticSeverity::Warning);
assert_eq!(
severity(serde_json::json!(3)),
DiagnosticSeverity::Information
);
assert_eq!(severity(serde_json::json!(4)), DiagnosticSeverity::Hint);
assert_eq!(severity(serde_json::json!(9)), DiagnosticSeverity::Error);
assert_eq!(parse_diagnostic_severity(None), DiagnosticSeverity::Error);
}
}