M3.2: LSP client core (framing, supervision, requests, document sync)
crates/lsp is now a library: Content-Length JSON-RPC framing over stdio (32 MiB cap, malformed frames dropped and reported, fuzzed), Server::spawn with initialize/initialized (utf-16, incremental sync, completion, hover, signatureHelp, definition, references, rename, publishDiagnostics), typed requests with timeouts and $/cancelRequest, answers to server requests (configuration nulls, MethodNotFound), events on a bounded channel, supervision with backoff restarts that reopen documents and give up after 5 crashes in 2 min, shutdown/exit, and incremental document sync from lutra_text edits. Tested against a scripted fake server binary; docs: architecture, G6. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
parent
9ccfc1bf6a
commit
81831c90e0
15 changed files with 4089 additions and 2 deletions
240
crates/lsp/src/uri.rs
Normal file
240
crates/lsp/src/uri.rs
Normal file
|
|
@ -0,0 +1,240 @@
|
|||
//! Conversion between file paths and `file:` URIs.
|
||||
//!
|
||||
//! LSP addresses documents by URI (RFC 3986). Paths become
|
||||
//! `file:///C:/dir/a%20b.php` on Windows and `file:///dir/a%20b.php` on Unix:
|
||||
//! every byte outside the unreserved set, `/` and a drive letter's `:` is
|
||||
//! percent-encoded as UTF-8. URIs from the server are untrusted and are
|
||||
//! decoded leniently (any case of escapes, an encoded drive colon, a
|
||||
//! `localhost` authority) but strictly enough that a bad escape or a
|
||||
//! non-`file` scheme yields `None` rather than a wrong path.
|
||||
|
||||
use std::path::{Path, PathBuf};
|
||||
|
||||
use crate::LspError;
|
||||
|
||||
/// Converts an absolute path to a `file:` URI.
|
||||
///
|
||||
/// On Windows the verbatim prefix (`\\?\`) is removed, `\` becomes `/`, and a
|
||||
/// UNC path `\\server\share\x` becomes `file://server/share/x`.
|
||||
///
|
||||
/// # Errors
|
||||
/// [`LspError::InvalidPath`] when the path is relative or not valid UTF-8.
|
||||
pub fn path_to_uri(path: &Path) -> Result<String, LspError> {
|
||||
let invalid = || LspError::InvalidPath {
|
||||
path: path.display().to_string(),
|
||||
};
|
||||
if !path.is_absolute() {
|
||||
return Err(invalid());
|
||||
}
|
||||
let text = path.to_str().ok_or_else(invalid)?;
|
||||
if cfg!(windows) {
|
||||
let text = text
|
||||
.strip_prefix(r"\\?\UNC\")
|
||||
.map(|rest| format!(r"\\{rest}"))
|
||||
.unwrap_or_else(|| text.strip_prefix(r"\\?\").unwrap_or(text).to_string());
|
||||
let slashed = text.replace('\\', "/");
|
||||
if let Some(unc) = slashed.strip_prefix("//") {
|
||||
let (host, rest) = unc.split_once('/').unwrap_or((unc, ""));
|
||||
return Ok(format!(
|
||||
"file://{}/{}",
|
||||
encode(host, false),
|
||||
encode(rest, false)
|
||||
));
|
||||
}
|
||||
return Ok(format!("file:///{}", encode(&slashed, true)));
|
||||
}
|
||||
Ok(format!("file://{}", encode(text, false)))
|
||||
}
|
||||
|
||||
/// Converts a `file:` URI to a path.
|
||||
///
|
||||
/// A query or fragment is ignored. On Windows a drive letter is returned in
|
||||
/// upper case, so `file:///c%3A/x` and `file:///C:/x` give the same path.
|
||||
///
|
||||
/// # Returns
|
||||
/// `None` for another scheme, a bad percent escape, a decoded path that is
|
||||
/// not UTF-8 or contains a NUL, or (on Unix) a host other than `localhost`.
|
||||
pub fn uri_to_path(uri: &str) -> Option<PathBuf> {
|
||||
let scheme = uri.get(..7)?;
|
||||
if !scheme.eq_ignore_ascii_case("file://") {
|
||||
return None;
|
||||
}
|
||||
let rest = uri.get(7..)?;
|
||||
let rest = rest.split(['?', '#']).next().unwrap_or_default();
|
||||
let (host, path) = match rest.find('/') {
|
||||
Some(at) => (rest.get(..at)?, rest.get(at..)?),
|
||||
None => (rest, ""),
|
||||
};
|
||||
let host = decode(host)?;
|
||||
let path = decode(path)?;
|
||||
if path.contains('\0') || host.contains(['\0', '/', '\\']) {
|
||||
return None;
|
||||
}
|
||||
let host = if host.eq_ignore_ascii_case("localhost") {
|
||||
String::new()
|
||||
} else {
|
||||
host
|
||||
};
|
||||
if cfg!(windows) {
|
||||
if !host.is_empty() {
|
||||
return Some(PathBuf::from(format!(
|
||||
r"\\{host}{}",
|
||||
path.replace('/', "\\")
|
||||
)));
|
||||
}
|
||||
let trimmed = path.strip_prefix('/').unwrap_or(&path);
|
||||
let mut chars = trimmed.chars();
|
||||
if let (Some(letter), Some(':')) = (chars.next(), chars.next())
|
||||
&& letter.is_ascii_alphabetic()
|
||||
{
|
||||
let tail = chars.as_str().replace('/', "\\");
|
||||
let tail = if tail.is_empty() {
|
||||
"\\".to_string()
|
||||
} else {
|
||||
tail
|
||||
};
|
||||
return Some(PathBuf::from(format!(
|
||||
"{}:{tail}",
|
||||
letter.to_ascii_uppercase()
|
||||
)));
|
||||
}
|
||||
return None;
|
||||
}
|
||||
if !host.is_empty() || !path.starts_with('/') {
|
||||
return None;
|
||||
}
|
||||
Some(PathBuf::from(path))
|
||||
}
|
||||
|
||||
/// Percent-encodes `text`, keeping unreserved characters and `/`; with
|
||||
/// `drive` set, a `:` right after a leading drive letter is kept too.
|
||||
fn encode(text: &str, drive: bool) -> String {
|
||||
let keep_colon_at = if drive
|
||||
&& text.len() >= 2
|
||||
&& text.as_bytes().first().is_some_and(u8::is_ascii_alphabetic)
|
||||
&& text.as_bytes().get(1) == Some(&b':')
|
||||
{
|
||||
Some(1)
|
||||
} else {
|
||||
None
|
||||
};
|
||||
let mut out = String::with_capacity(text.len());
|
||||
for (index, byte) in text.bytes().enumerate() {
|
||||
let keep = byte.is_ascii_alphanumeric()
|
||||
|| matches!(byte, b'-' | b'.' | b'_' | b'~' | b'/')
|
||||
|| keep_colon_at == Some(index);
|
||||
if keep {
|
||||
out.push(char::from(byte));
|
||||
} else {
|
||||
out.push_str(&format!("%{byte:02X}"));
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// Decodes percent escapes; `None` for a malformed escape or bytes that are
|
||||
/// not UTF-8.
|
||||
fn decode(text: &str) -> Option<String> {
|
||||
let bytes = text.as_bytes();
|
||||
let mut out = Vec::with_capacity(bytes.len());
|
||||
let mut index = 0;
|
||||
while let Some(&byte) = bytes.get(index) {
|
||||
if byte == b'%' {
|
||||
let high = hex(*bytes.get(index + 1)?)?;
|
||||
let low = hex(*bytes.get(index + 2)?)?;
|
||||
out.push(high * 16 + low);
|
||||
index += 3;
|
||||
} else {
|
||||
out.push(byte);
|
||||
index += 1;
|
||||
}
|
||||
}
|
||||
String::from_utf8(out).ok()
|
||||
}
|
||||
|
||||
/// The value of one hex digit.
|
||||
fn hex(digit: u8) -> Option<u8> {
|
||||
char::from(digit)
|
||||
.to_digit(16)
|
||||
.and_then(|d| u8::try_from(d).ok())
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use proptest::prelude::*;
|
||||
|
||||
fn root() -> PathBuf {
|
||||
if cfg!(windows) {
|
||||
PathBuf::from(r"C:\")
|
||||
} else {
|
||||
PathBuf::from("/")
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn encodes_spaces_and_unicode() {
|
||||
let path = root().join("my dir").join("ä#.php");
|
||||
let uri = path_to_uri(&path).unwrap();
|
||||
if cfg!(windows) {
|
||||
assert_eq!(uri, "file:///C:/my%20dir/%C3%A4%23.php");
|
||||
} else {
|
||||
assert_eq!(uri, "file:///my%20dir/%C3%A4%23.php");
|
||||
}
|
||||
assert_eq!(uri_to_path(&uri), Some(path));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rejects_relative_and_foreign() {
|
||||
assert!(path_to_uri(Path::new("a/b")).is_err());
|
||||
assert_eq!(uri_to_path("http://x/y"), None);
|
||||
assert_eq!(uri_to_path("file:///a%zz"), None);
|
||||
assert_eq!(uri_to_path("file:///a%"), None);
|
||||
assert_eq!(uri_to_path("file:///a%00"), None);
|
||||
assert_eq!(uri_to_path("fi"), None);
|
||||
}
|
||||
|
||||
#[cfg(windows)]
|
||||
#[test]
|
||||
fn windows_forms() {
|
||||
assert_eq!(
|
||||
uri_to_path("file:///c%3A/x/y.php"),
|
||||
Some(PathBuf::from(r"C:\x\y.php"))
|
||||
);
|
||||
assert_eq!(
|
||||
uri_to_path("FILE://localhost/C:/x"),
|
||||
Some(PathBuf::from(r"C:\x"))
|
||||
);
|
||||
assert_eq!(
|
||||
uri_to_path("file://server/share/a"),
|
||||
Some(PathBuf::from(r"\\server\share\a"))
|
||||
);
|
||||
assert_eq!(path_to_uri(Path::new(r"\\?\C:\x")).unwrap(), "file:///C:/x");
|
||||
assert_eq!(
|
||||
path_to_uri(Path::new(r"\\server\share\a b")).unwrap(),
|
||||
"file://server/share/a%20b"
|
||||
);
|
||||
}
|
||||
|
||||
proptest! {
|
||||
#[test]
|
||||
fn round_trips(segments in proptest::collection::vec("[^/\\\\:*?\"<>|\u{0}]{1,8}", 1..5)) {
|
||||
let mut path = root();
|
||||
for segment in &segments {
|
||||
let segment = segment.trim_end_matches(['.', ' ']);
|
||||
if segment.is_empty() || segment == ".." || segment == "." {
|
||||
continue;
|
||||
}
|
||||
path.push(segment);
|
||||
}
|
||||
let uri = path_to_uri(&path).unwrap();
|
||||
prop_assert_eq!(uri_to_path(&uri), Some(path));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn never_panics(input in ".{0,40}") {
|
||||
let _ = uri_to_path(&input);
|
||||
let _ = uri_to_path(&format!("file://{input}"));
|
||||
}
|
||||
}
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue