Files
rexlang/tests/lsp.rs
T
Your NameandClaude Sonnet 5.5 eaf9567a36 Dino compiler: language, formatter, language server, docs, editor support
Compiler in Rust (lexer, parser, checker, C codegen), maps, chars,
dino fmt, dino lsp (diagnostics, formatting, outline, definition,
hover, completion, signature help), docs, examples, VS Code/Vim files.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-07 23:46:12 +01:00

228 lines
9.2 KiB
Rust

//! Tests of the language server: feed it editor messages, read what it answers.
use dino::json::{self, Json};
use dino::lsp;
fn frame(v: &Json) -> Vec<u8> {
let body = v.to_string();
format!("Content-Length: {}\r\n\r\n{}", body.len(), body).into_bytes()
}
fn request(id: i64, method: &str, params: Json) -> Json {
Json::obj(vec![("jsonrpc", Json::str("2.0")), ("id", Json::Num(id as f64)), ("method", Json::str(method)), ("params", params)])
}
fn notify(method: &str, params: Json) -> Json {
Json::obj(vec![("jsonrpc", Json::str("2.0")), ("method", Json::str(method)), ("params", params)])
}
fn open(uri: &str, text: &str) -> Json {
notify(
"textDocument/didOpen",
Json::obj(vec![("textDocument", Json::obj(vec![("uri", Json::str(uri)), ("text", Json::str(text))]))]),
)
}
/// Run a whole conversation and return every message the server sent.
fn talk(messages: Vec<Json>) -> (Vec<Json>, i32) {
let mut input = Vec::new();
for m in &messages {
input.extend(frame(m));
}
let mut output = Vec::new();
let code = lsp::run(std::io::Cursor::new(input), &mut output);
let text = String::from_utf8(output).unwrap();
let mut out = Vec::new();
let mut rest = text.as_str();
while let Some(i) = rest.find("\r\n\r\n") {
let len: usize = rest[..i].trim().strip_prefix("Content-Length: ").unwrap().parse().unwrap();
out.push(json::parse(&rest[i + 4..i + 4 + len]).unwrap());
rest = &rest[i + 4 + len..];
}
(out, code)
}
fn exit_messages() -> Vec<Json> {
vec![request(99, "shutdown", Json::Null), notify("exit", Json::Null)]
}
#[test]
fn json_round_trip() {
let src = r#"{"a":[1,2.5,"x\n\"y\" é 😀"],"b":null,"c":true}"#;
let v = json::parse(src).unwrap();
assert_eq!(json::parse(&v.to_string()).unwrap(), v);
assert_eq!(v.get("a"), Some(&Json::Arr(vec![Json::Num(1.0), Json::Num(2.5), Json::str("x\n\"y\" é 😀")])));
}
#[test]
fn initialize_announces_features() {
let mut msgs = vec![request(1, "initialize", Json::obj(vec![]))];
msgs.extend(exit_messages());
let (out, code) = talk(msgs);
assert_eq!(code, 0);
let caps = out[0].path(&["result", "capabilities"]).unwrap();
assert_eq!(caps.get("documentFormattingProvider"), Some(&Json::Bool(true)));
assert_eq!(out[0].get("id"), Some(&Json::Num(1.0)));
}
#[test]
fn errors_show_up_as_diagnostics() {
let src = "func main() {\n var x: int = \"no\"\n}\n";
let mut msgs = vec![open("file:///tmp/dino-lsp-test/a.dino", src)];
msgs.extend(exit_messages());
let (out, _) = talk(msgs);
let d = match out[0].path(&["params", "diagnostics"]) {
Some(Json::Arr(items)) => items.clone(),
other => panic!("{other:?}"),
};
assert_eq!(d.len(), 1);
let line = d[0].path(&["range", "start", "line"]).and_then(Json::as_i64).unwrap();
assert_eq!(line, 1);
assert!(d[0].get("message").and_then(Json::as_str).unwrap().contains("string"), "{:?}", d[0]);
}
#[test]
fn fixing_the_code_clears_the_diagnostics() {
let uri = "file:///tmp/dino-lsp-test/b.dino";
let change = notify(
"textDocument/didChange",
Json::obj(vec![
("textDocument", Json::obj(vec![("uri", Json::str(uri))])),
("contentChanges", Json::Arr(vec![Json::obj(vec![("text", Json::str("func main() {\n print(1)\n}\n"))])])),
]),
);
let mut msgs = vec![open(uri, "func main() {\n print(nope)\n}\n"), change];
msgs.extend(exit_messages());
let (out, _) = talk(msgs);
assert_eq!(out[0].path(&["params", "diagnostics"]).map(|d| matches!(d, Json::Arr(a) if a.len() == 1)), Some(true));
assert_eq!(out[1].path(&["params", "diagnostics"]), Some(&Json::Arr(vec![])));
}
#[test]
fn error_columns_count_utf16_units() {
// the emoji takes two units in the editor's counting
let src = "func main() {\n print(\"😀\", nope)\n}\n";
let mut msgs = vec![open("file:///tmp/dino-lsp-test/c.dino", src)];
msgs.extend(exit_messages());
let (out, _) = talk(msgs);
let d = match out[0].path(&["params", "diagnostics"]) {
Some(Json::Arr(items)) => items[0].clone(),
other => panic!("{other:?}"),
};
let start = d.path(&["range", "start", "character"]).and_then(Json::as_i64).unwrap();
let end = d.path(&["range", "end", "character"]).and_then(Json::as_i64).unwrap();
// ` print("😀", ` is 4 + 6 + 4 + 2 = 16 units before `nope`
assert_eq!((start, end), (16, 20));
}
#[test]
fn formatting_returns_the_tidy_text() {
let uri = "file:///tmp/dino-lsp-test/d.dino";
let fmt_req = request(
2,
"textDocument/formatting",
Json::obj(vec![("textDocument", Json::obj(vec![("uri", Json::str(uri))]))]),
);
let mut msgs = vec![open(uri, "func main(){\nprint( 1 )\n}\n"), fmt_req];
msgs.extend(exit_messages());
let (out, _) = talk(msgs);
let reply = out.iter().find(|m| m.get("id") == Some(&Json::Num(2.0))).unwrap();
let edit = match reply.get("result") {
Some(Json::Arr(e)) => e[0].clone(),
other => panic!("{other:?}"),
};
assert_eq!(edit.get("newText").and_then(Json::as_str), Some("func main() {\n print(1)\n}\n"));
}
#[test]
fn imports_are_read_next_to_the_file() {
let dir = std::env::temp_dir().join(format!("dino-lsp-{}", std::process::id()));
std::fs::create_dir_all(&dir).unwrap();
std::fs::write(dir.join("util.dino"), "pub func twice(x: int): int { return x * 2 }\n").unwrap();
let uri = format!("file://{}/main.dino", dir.display());
let src = "import util\nfunc main() {\n print(util.twice(2))\n}\n";
let mut msgs = vec![open(&uri, src)];
msgs.extend(exit_messages());
let (out, _) = talk(msgs);
let _ = std::fs::remove_dir_all(&dir);
assert_eq!(out[0].path(&["params", "diagnostics"]), Some(&Json::Arr(vec![])), "{:?}", out[0]);
}
#[test]
fn unknown_requests_get_an_error() {
let mut msgs = vec![request(5, "textDocument/codeLens", Json::obj(vec![]))];
msgs.extend(exit_messages());
let (out, _) = talk(msgs);
assert!(out[0].path(&["error", "message"]).is_some());
}
#[test]
fn editor_files_are_valid_json() {
let dir = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("editors/vscode");
for f in ["package.json", "language-configuration.json", "syntaxes/dino.tmLanguage.json"] {
let text = std::fs::read_to_string(dir.join(f)).unwrap();
json::parse(&text).unwrap_or_else(|e| panic!("{f}: {e}"));
}
}
// ---------- code intelligence ----------
const SRC: &str = "// Adds two numbers.\nfunc add(a: int, b: int): int {\n var sum = a + b\n return sum\n}\n\nstruct P {\n x: int\n}\n\nfunc main() {\n var t = add(1, 2)\n print(t)\n}\n";
fn at(uri: &str, line: i64, ch: i64) -> Json {
Json::obj(vec![
("textDocument", Json::obj(vec![("uri", Json::str(uri))])),
("position", Json::obj(vec![("line", Json::Num(line as f64)), ("character", Json::Num(ch as f64))])),
])
}
fn ask(method: &str, params: Json) -> Json {
let mut msgs = vec![request(1, "initialize", Json::obj(vec![])), open("file:///x/a.dino", SRC), request(2, method, params)];
msgs.extend(exit_messages());
let (out, _) = talk(msgs);
out.into_iter().find(|m| m.get("id") == Some(&Json::Num(2.0))).unwrap().get("result").cloned().unwrap_or(Json::Null)
}
#[test]
fn outline_lists_top_level_names() {
let r = ask("textDocument/documentSymbol", Json::obj(vec![("textDocument", Json::obj(vec![("uri", Json::str("file:///x/a.dino"))]))]));
let text = r.to_string();
assert!(text.contains("\"add\"") && text.contains("\"P\"") && text.contains("\"main\"") && text.contains("\"x\""), "{text}");
}
#[test]
fn definition_jumps_to_the_function() {
let r = ask("textDocument/definition", at("file:///x/a.dino", 11, 14));
assert_eq!(r.path(&["range", "start", "line"]).and_then(Json::as_i64), Some(1), "{r:?}");
}
#[test]
fn definition_finds_a_local() {
let r = ask("textDocument/definition", at("file:///x/a.dino", 3, 12));
assert_eq!(r.path(&["range", "start", "line"]).and_then(Json::as_i64), Some(2), "{r:?}");
}
#[test]
fn hover_shows_the_signature_and_comment() {
let r = ask("textDocument/hover", at("file:///x/a.dino", 11, 14));
let v = r.path(&["contents", "value"]).and_then(Json::as_str).unwrap_or("").to_string();
assert!(v.contains("func add(a: int, b: int): int") && v.contains("Adds two numbers."), "{v}");
}
#[test]
fn completion_offers_names_and_keywords() {
let r = ask("textDocument/completion", at("file:///x/a.dino", 12, 4)).to_string();
assert!(r.contains("\"add\"") && r.contains("\"t\"") && r.contains("\"func\"") && r.contains("\"string\""), "{r:?}");
}
#[test]
fn signature_help_marks_the_parameter() {
let src = "func add(a: int, b: int): int {\n return a + b\n}\nfunc main() {\n add(1, \n}\n";
let mut msgs = vec![request(1, "initialize", Json::obj(vec![])), open("file:///x/b.dino", src), request(2, "textDocument/signatureHelp", at("file:///x/b.dino", 4, 11))];
msgs.extend(exit_messages());
let (out, _) = talk(msgs);
let r = out.into_iter().find(|m| m.get("id") == Some(&Json::Num(2.0))).unwrap().get("result").cloned().unwrap();
assert_eq!(r.get("activeParameter").and_then(Json::as_i64), Some(1), "{r:?}");
assert!(r.to_string().contains("add(a: int, b: int): int"), "{r:?}");
}