Yehowshua/ZIm
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Restructure fake language server to setup request handlers in advance

Browse source 
Co-Authored-By: Antonio Scandurra <me@as-cii.com>
Co-Authored-By: Nathan Sobo <nathan@zed.dev>
This commit is contained in:
Max Brunsfeld 2022-02-11 15:08:56 -08:00
parent 680d1fedc2
commit 01664d494c
4 changed files with 314 additions and 282 deletions
Download patch file Download diff file Expand all files Collapse all files

78
crates/editor/src/editor.rs
View file

@ -5442,6 +5442,7 @@ mod tests {
use super::*; use super::*;
use language::LanguageConfig; use language::LanguageConfig;
use lsp::FakeLanguageServer; use lsp::FakeLanguageServer;
use postage::prelude::Stream;
use project::{FakeFs, ProjectPath}; use project::{FakeFs, ProjectPath};
use std::{cell::RefCell, rc::Rc, time::Instant}; use std::{cell::RefCell, rc::Rc, time::Instant};
use text::Point; use text::Point;
@ -7780,7 +7781,7 @@ mod tests {
&mut fake, &mut fake,
"/file", "/file",
Point::new(0, 4), Point::new(0, 4),
&[ vec![
(Point::new(0, 4)..Point::new(0, 4), "first_completion"), (Point::new(0, 4)..Point::new(0, 4), "first_completion"),
(Point::new(0, 4)..Point::new(0, 4), "second_completion"), (Point::new(0, 4)..Point::new(0, 4), "second_completion"),
], ],
@ -7842,7 +7843,7 @@ mod tests {
&mut fake, &mut fake,
"/file", "/file",
Point::new(2, 7), Point::new(2, 7),
&[ vec![
(Point::new(2, 6)..Point::new(2, 7), "fourth_completion"), (Point::new(2, 6)..Point::new(2, 7), "fourth_completion"),
(Point::new(2, 6)..Point::new(2, 7), "fifth_completion"), (Point::new(2, 6)..Point::new(2, 7), "fifth_completion"),
(Point::new(2, 6)..Point::new(2, 7), "sixth_completion"), (Point::new(2, 6)..Point::new(2, 7), "sixth_completion"),
@ -7861,7 +7862,7 @@ mod tests {
&mut fake, &mut fake,
"/file", "/file",
Point::new(2, 8), Point::new(2, 8),
&[ vec![
(Point::new(2, 6)..Point::new(2, 8), "fourth_completion"), (Point::new(2, 6)..Point::new(2, 8), "fourth_completion"),
(Point::new(2, 6)..Point::new(2, 8), "fifth_completion"), (Point::new(2, 6)..Point::new(2, 8), "fifth_completion"),
(Point::new(2, 6)..Point::new(2, 8), "sixth_completion"), (Point::new(2, 6)..Point::new(2, 8), "sixth_completion"),
@ -7891,47 +7892,45 @@ mod tests {
async fn handle_completion_request( async fn handle_completion_request(
fake: &mut FakeLanguageServer, fake: &mut FakeLanguageServer,
path: &str, path: &'static str,
position: Point, position: Point,
completions: &[(Range<Point>, &str)], completions: Vec<(Range<Point>, &'static str)>,
) { ) {
let (id, params) = fake.receive_request::<lsp::request::Completion>().await; fake.handle_request::<lsp::request::Completion, _>(move |params| {
assert_eq!( assert_eq!(
params.text_document_position.text_document.uri, params.text_document_position.text_document.uri,
lsp::Url::from_file_path(path).unwrap() lsp::Url::from_file_path(path).unwrap()
); );
assert_eq!( assert_eq!(
params.text_document_position.position, params.text_document_position.position,
lsp::Position::new(position.row, position.column) lsp::Position::new(position.row, position.column)
); );
Some(lsp::CompletionResponse::Array(
let completions = completions completions
.iter() .into_iter()
.map(|(range, new_text)| lsp::CompletionItem { .map(|(range, new_text)| lsp::CompletionItem {
label: new_text.to_string(), label: new_text.to_string(),
text_edit: Some(lsp::CompletionTextEdit::Edit(lsp::TextEdit { text_edit: Some(lsp::CompletionTextEdit::Edit(lsp::TextEdit {
range: lsp::Range::new( range: lsp::Range::new(
lsp::Position::new(range.start.row, range.start.column), lsp::Position::new(range.start.row, range.start.column),
lsp::Position::new(range.start.row, range.start.column), lsp::Position::new(range.start.row, range.start.column),
), ),
new_text: new_text.to_string(), new_text: new_text.to_string(),
})), })),
..Default::default() ..Default::default()
}) })
.collect(); .collect(),
fake.respond(id, Some(lsp::CompletionResponse::Array(completions))) ))
.await; })
.recv()
.await;
} }
async fn handle_resolve_completion_request( async fn handle_resolve_completion_request(
fake: &mut FakeLanguageServer, fake: &mut FakeLanguageServer,
edit: Option<(Range<Point>, &str)>, edit: Option<(Range<Point>, &'static str)>,
) { ) {
let (id, _) = fake fake.handle_request::<lsp::request::ResolveCompletionItem, _>(move |_| {
.receive_request::<lsp::request::ResolveCompletionItem>()
.await;
fake.respond(
id,
lsp::CompletionItem { lsp::CompletionItem {
additional_text_edits: edit.map(|(range, new_text)| { additional_text_edits: edit.map(|(range, new_text)| {
vec![lsp::TextEdit::new( vec![lsp::TextEdit::new(
@ -7943,8 +7942,9 @@ mod tests {
)] )]
}), }),
..Default::default() ..Default::default()
}, }
) })
.recv()
.await; .await;
} }
} }

242
crates/lsp/src/lsp.rs
View file

@ -56,6 +56,18 @@ struct Request<'a, T> {
params: T, params: T,
} }
#[cfg(any(test, feature = "test-support"))]
#[derive(Deserialize)]
struct AnyRequest<'a> {
id: usize,
#[serde(borrow)]
jsonrpc: &'a str,
#[serde(borrow)]
method: &'a str,
#[serde(borrow)]
params: &'a RawValue,
}
#[derive(Serialize, Deserialize)] #[derive(Serialize, Deserialize)]
struct AnyResponse<'a> { struct AnyResponse<'a> {
id: usize, id: usize,
@ -469,19 +481,19 @@ impl Drop for Subscription {
#[cfg(any(test, feature = "test-support"))] #[cfg(any(test, feature = "test-support"))]
pub struct FakeLanguageServer { pub struct FakeLanguageServer {
buffer: Vec<u8>, handlers: Arc<
stdin: smol::io::BufReader<async_pipe::PipeReader>, Mutex<
stdout: smol::io::BufWriter<async_pipe::PipeWriter>, HashMap<
executor: std::rc::Rc<executor::Foreground>, &'static str,
Box<dyn Send + FnOnce(usize, &[u8]) -> (Vec<u8>, barrier::Sender)>,
>,
>,
>,
outgoing_tx: channel::Sender<Vec<u8>>,
incoming_rx: channel::Receiver<Vec<u8>>,
pub started: Arc<std::sync::atomic::AtomicBool>, pub started: Arc<std::sync::atomic::AtomicBool>,
} }
#[cfg(any(test, feature = "test-support"))]
pub struct RequestId<T> {
id: usize,
_type: std::marker::PhantomData<T>,
}
#[cfg(any(test, feature = "test-support"))] #[cfg(any(test, feature = "test-support"))]
impl LanguageServer { impl LanguageServer {
pub async fn fake(cx: &gpui::TestAppContext) -> (Arc<Self>, FakeLanguageServer) { pub async fn fake(cx: &gpui::TestAppContext) -> (Arc<Self>, FakeLanguageServer) {
@ -492,28 +504,18 @@ impl LanguageServer {
capabilities: ServerCapabilities, capabilities: ServerCapabilities,
cx: &gpui::TestAppContext, cx: &gpui::TestAppContext,
) -> (Arc<Self>, FakeLanguageServer) { ) -> (Arc<Self>, FakeLanguageServer) {
let stdin = async_pipe::pipe(); let (stdin_writer, stdin_reader) = async_pipe::pipe();
let stdout = async_pipe::pipe(); let (stdout_writer, stdout_reader) = async_pipe::pipe();
let mut fake = FakeLanguageServer {
stdin: smol::io::BufReader::new(stdin.1), let mut fake = FakeLanguageServer::new(cx, stdin_reader, stdout_writer);
stdout: smol::io::BufWriter::new(stdout.0), fake.handle_request::<request::Initialize, _>(move |_| InitializeResult {
buffer: Vec::new(), capabilities,
executor: cx.foreground(), ..Default::default()
started: Arc::new(std::sync::atomic::AtomicBool::new(true)), });
};
let server = let server =
Self::new_internal(stdin.0, stdout.1, Path::new("/"), cx.background()).unwrap(); Self::new_internal(stdin_writer, stdout_reader, Path::new("/"), cx.background())
.unwrap();
let (init_id, _) = fake.receive_request::<request::Initialize>().await;
fake.respond(
init_id,
InitializeResult {
capabilities,
..Default::default()
},
)
.await;
fake.receive_notification::<notification::Initialized>() fake.receive_notification::<notification::Initialized>()
.await; .await;
@ -523,6 +525,75 @@ impl LanguageServer {
#[cfg(any(test, feature = "test-support"))] #[cfg(any(test, feature = "test-support"))]
impl FakeLanguageServer { impl FakeLanguageServer {
fn new(
cx: &gpui::TestAppContext,
stdin: async_pipe::PipeReader,
stdout: async_pipe::PipeWriter,
) -> Self {
use futures::StreamExt as _;
let (incoming_tx, incoming_rx) = channel::unbounded();
let (outgoing_tx, mut outgoing_rx) = channel::unbounded();
let this = Self {
outgoing_tx: outgoing_tx.clone(),
incoming_rx,
handlers: Default::default(),
started: Arc::new(std::sync::atomic::AtomicBool::new(true)),
};
// Receive incoming messages
let handlers = this.handlers.clone();
cx.background()
.spawn(async move {
let mut buffer = Vec::new();
let mut stdin = smol::io::BufReader::new(stdin);
while Self::receive(&mut stdin, &mut buffer).await.is_ok() {
if let Ok(request) = serde_json::from_slice::<AnyRequest>(&mut buffer) {
assert_eq!(request.jsonrpc, JSON_RPC_VERSION);
let handler = handlers.lock().remove(request.method);
if let Some(handler) = handler {
let (response, sent) =
handler(request.id, request.params.get().as_bytes());
log::debug!("handled lsp request. method:{}", request.method);
outgoing_tx.send(response).await.unwrap();
drop(sent);
} else {
log::debug!("unhandled lsp request. method:{}", request.method);
outgoing_tx
.send(
serde_json::to_vec(&AnyResponse {
id: request.id,
error: Some(Error {
message: "no handler".to_string(),
}),
result: None,
})
.unwrap(),
)
.await
.unwrap();
}
} else {
incoming_tx.send(buffer.clone()).await.unwrap();
}
}
})
.detach();
// Send outgoing messages
cx.background()
.spawn(async move {
let mut stdout = smol::io::BufWriter::new(stdout);
while let Some(notification) = outgoing_rx.next().await {
Self::send(&mut stdout, &notification).await;
}
})
.detach();
this
}
pub async fn notify<T: notification::Notification>(&mut self, params: T::Params) { pub async fn notify<T: notification::Notification>(&mut self, params: T::Params) {
if !self.started.load(std::sync::atomic::Ordering::SeqCst) { if !self.started.load(std::sync::atomic::Ordering::SeqCst) {
panic!("can't simulate an LSP notification before the server has been started"); panic!("can't simulate an LSP notification before the server has been started");
@ -533,54 +604,53 @@ impl FakeLanguageServer {
params, params,
}) })
.unwrap(); .unwrap();
self.send(message).await; self.outgoing_tx.send(message).await.unwrap();
} }
pub async fn respond<'a, T: request::Request>( pub async fn receive_notification<T: notification::Notification>(&mut self) -> T::Params {
&mut self, use futures::StreamExt as _;
request_id: RequestId<T>,
result: T::Result,
) {
let result = serde_json::to_string(&result).unwrap();
let message = serde_json::to_vec(&AnyResponse {
id: request_id.id,
error: None,
result: Some(&RawValue::from_string(result).unwrap()),
})
.unwrap();
self.send(message).await;
}
pub async fn receive_request<T: request::Request>(&mut self) -> (RequestId<T>, T::Params) {
let executor = self.executor.clone();
executor.start_waiting();
loop { loop {
self.receive().await; let bytes = self.incoming_rx.next().await.unwrap();
if let Ok(request) = serde_json::from_slice::<Request<T::Params>>(&self.buffer) { if let Ok(notification) = serde_json::from_slice::<Notification<T::Params>>(&bytes) {
assert_eq!(request.method, T::METHOD); assert_eq!(notification.method, T::METHOD);
assert_eq!(request.jsonrpc, JSON_RPC_VERSION); return notification.params;
executor.finish_waiting();
return (
RequestId {
id: request.id,
_type: std::marker::PhantomData,
},
request.params,
);
} else { } else {
log::info!( log::info!(
"skipping message in fake language server {:?}", "skipping message in fake language server {:?}",
std::str::from_utf8(&self.buffer) std::str::from_utf8(&bytes)
); );
} }
} }
} }
pub async fn receive_notification<T: notification::Notification>(&mut self) -> T::Params { pub fn handle_request<T, F>(&mut self, handler: F) -> barrier::Receiver
self.receive().await; where
let notification = serde_json::from_slice::<Notification<T::Params>>(&self.buffer).unwrap(); T: 'static + request::Request,
assert_eq!(notification.method, T::METHOD); F: 'static + Send + FnOnce(T::Params) -> T::Result,
notification.params {
let (responded_tx, responded_rx) = barrier::channel();
let prev_handler = self.handlers.lock().insert(
T::METHOD,
Box::new(|id, params| {
let result = handler(serde_json::from_slice::<T::Params>(params).unwrap());
let result = serde_json::to_string(&result).unwrap();
let result = serde_json::from_str::<&RawValue>(&result).unwrap();
let response = AnyResponse {
id,
error: None,
result: Some(result),
};
(serde_json::to_vec(&response).unwrap(), responded_tx)
}),
);
if prev_handler.is_some() {
panic!(
"registered a new handler for LSP method '{}' before the previous handler was called",
T::METHOD
);
}
responded_rx
} }
pub async fn start_progress(&mut self, token: impl Into<String>) { pub async fn start_progress(&mut self, token: impl Into<String>) {
@ -599,39 +669,37 @@ impl FakeLanguageServer {
.await; .await;
} }
async fn send(&mut self, message: Vec<u8>) { async fn send(stdout: &mut smol::io::BufWriter<async_pipe::PipeWriter>, message: &[u8]) {
self.stdout stdout
.write_all(CONTENT_LEN_HEADER.as_bytes()) .write_all(CONTENT_LEN_HEADER.as_bytes())
.await .await
.unwrap(); .unwrap();
self.stdout stdout
.write_all((format!("{}", message.len())).as_bytes()) .write_all((format!("{}", message.len())).as_bytes())
.await .await
.unwrap(); .unwrap();
self.stdout.write_all("\r\n\r\n".as_bytes()).await.unwrap(); stdout.write_all("\r\n\r\n".as_bytes()).await.unwrap();
self.stdout.write_all(&message).await.unwrap(); stdout.write_all(&message).await.unwrap();
self.stdout.flush().await.unwrap(); stdout.flush().await.unwrap();
} }
async fn receive(&mut self) { async fn receive(
self.buffer.clear(); stdin: &mut smol::io::BufReader<async_pipe::PipeReader>,
self.stdin buffer: &mut Vec<u8>,
.read_until(b'\n', &mut self.buffer) ) -> Result<()> {
.await buffer.clear();
.unwrap(); stdin.read_until(b'\n', buffer).await?;
self.stdin stdin.read_until(b'\n', buffer).await?;
.read_until(b'\n', &mut self.buffer) let message_len: usize = std::str::from_utf8(buffer)
.await
.unwrap();
let message_len: usize = std::str::from_utf8(&self.buffer)
.unwrap() .unwrap()
.strip_prefix(CONTENT_LEN_HEADER) .strip_prefix(CONTENT_LEN_HEADER)
.unwrap() .unwrap()
.trim_end() .trim_end()
.parse() .parse()
.unwrap(); .unwrap();
self.buffer.resize(message_len, 0); buffer.resize(message_len, 0);
self.stdin.read_exact(&mut self.buffer).await.unwrap(); stdin.read_exact(buffer).await?;
Ok(())
} }
} }
@ -757,9 +825,9 @@ mod tests {
"file://b/c" "file://b/c"
); );
fake.handle_request::<request::Shutdown, _>(|_| ());
drop(server); drop(server);
let (shutdown_request, _) = fake.receive_request::<request::Shutdown>().await;
fake.respond(shutdown_request, ()).await;
fake.receive_notification::<notification::Exit>().await; fake.receive_notification::<notification::Exit>().await;
} }

50
crates/project/src/project.rs
View file

@ -2368,6 +2368,7 @@ impl Project {
.ok_or_else(|| anyhow!("invalid completion"))?, .ok_or_else(|| anyhow!("invalid completion"))?,
language, language,
)?; )?;
dbg!(&completion);
cx.spawn(|this, mut cx| async move { cx.spawn(|this, mut cx| async move {
match this match this
.update(&mut cx, |this, cx| { .update(&mut cx, |this, cx| {
@ -2414,14 +2415,15 @@ impl Project {
.and_then(language::proto::deserialize_anchor) .and_then(language::proto::deserialize_anchor)
.ok_or_else(|| anyhow!("invalid position"))?; .ok_or_else(|| anyhow!("invalid position"))?;
cx.spawn(|this, mut cx| async move { cx.spawn(|this, mut cx| async move {
eprintln!("getting code actions");
match this match this
.update(&mut cx, |this, cx| this.code_actions(&buffer, position, cx)) .update(&mut cx, |this, cx| this.code_actions(&buffer, position, cx))
.await .await
{ {
Ok(completions) => rpc.respond( Ok(actions) => rpc.respond(
receipt, receipt,
proto::GetCodeActionsResponse { proto::GetCodeActionsResponse {
actions: completions actions: dbg!(actions)
.iter() .iter()
.map(language::proto::serialize_code_action) .map(language::proto::serialize_code_action)
.collect(), .collect(),
@ -2430,7 +2432,7 @@ impl Project {
Err(error) => rpc.respond_with_error( Err(error) => rpc.respond_with_error(
receipt, receipt,
proto::Error { proto::Error {
message: error.to_string(), message: dbg!(error.to_string()),
}, },
), ),
} }
@ -3205,6 +3207,7 @@ mod tests {
"a.rs": "const fn a() { A }", "a.rs": "const fn a() { A }",
"b.rs": "const y: i32 = crate::a()", "b.rs": "const y: i32 = crate::a()",
})); }));
let dir_path = dir.path().to_path_buf();
let http_client = FakeHttpClient::with_404_response(); let http_client = FakeHttpClient::with_404_response();
let client = Client::new(http_client.clone()); let client = Client::new(http_client.clone());
@ -3229,7 +3232,6 @@ mod tests {
cx.read(|cx| tree.read(cx).as_local().unwrap().scan_complete()) cx.read(|cx| tree.read(cx).as_local().unwrap().scan_complete())
.await; .await;
// Cause worktree to start the fake language server
let buffer = project let buffer = project
.update(&mut cx, |project, cx| { .update(&mut cx, |project, cx| {
project.open_buffer( project.open_buffer(
@ -3242,28 +3244,26 @@ mod tests {
}) })
.await .await
.unwrap(); .unwrap();
let definitions =
project.update(&mut cx, |project, cx| project.definition(&buffer, 22, cx));
let (request_id, request) = fake_server
.receive_request::<lsp::request::GotoDefinition>()
.await;
let request_params = request.text_document_position_params;
assert_eq!(
request_params.text_document.uri.to_file_path().unwrap(),
dir.path().join("b.rs")
);
assert_eq!(request_params.position, lsp::Position::new(0, 22));
fake_server fake_server.handle_request::<lsp::request::GotoDefinition, _>(move |params| {
.respond( let params = params.text_document_position_params;
request_id, assert_eq!(
Some(lsp::GotoDefinitionResponse::Scalar(lsp::Location::new( params.text_document.uri.to_file_path().unwrap(),
lsp::Url::from_file_path(dir.path().join("a.rs")).unwrap(), dir_path.join("b.rs")
lsp::Range::new(lsp::Position::new(0, 9), lsp::Position::new(0, 10)), );
))), assert_eq!(params.position, lsp::Position::new(0, 22));
)
.await; Some(lsp::GotoDefinitionResponse::Scalar(lsp::Location::new(
let mut definitions = definitions.await.unwrap(); lsp::Url::from_file_path(dir_path.join("a.rs")).unwrap(),
lsp::Range::new(lsp::Position::new(0, 9), lsp::Position::new(0, 10)),
)))
});
let mut definitions = project
.update(&mut cx, |project, cx| project.definition(&buffer, 22, cx))
.await
.unwrap();
assert_eq!(definitions.len(), 1); assert_eq!(definitions.len(), 1);
let definition = definitions.pop().unwrap(); let definition = definitions.pop().unwrap();
cx.update(|cx| { cx.update(|cx| {

226
crates/server/src/rpc.rs
View file

@ -2414,52 +2414,46 @@ mod tests {
}); });
// Receive a completion request as the host's language server. // Receive a completion request as the host's language server.
let (request_id, params) = fake_language_server
.receive_request::<lsp::request::Completion>()
.await;
assert_eq!(
params.text_document_position.text_document.uri,
lsp::Url::from_file_path("/a/main.rs").unwrap(),
);
assert_eq!(
params.text_document_position.position,
lsp::Position::new(0, 14),
);
// Return some completions from the host's language server. // Return some completions from the host's language server.
fake_language_server fake_language_server.handle_request::<lsp::request::Completion, _>(|params| {
.respond( assert_eq!(
request_id, params.text_document_position.text_document.uri,
Some(lsp::CompletionResponse::Array(vec![ lsp::Url::from_file_path("/a/main.rs").unwrap(),
lsp::CompletionItem { );
label: "first_method(…)".into(), assert_eq!(
detail: Some("fn(&mut self, B) -> C".into()), params.text_document_position.position,
text_edit: Some(lsp::CompletionTextEdit::Edit(lsp::TextEdit { lsp::Position::new(0, 14),
new_text: "first_method($1)".to_string(), );
range: lsp::Range::new(
lsp::Position::new(0, 14), Some(lsp::CompletionResponse::Array(vec![
lsp::Position::new(0, 14), lsp::CompletionItem {
), label: "first_method(…)".into(),
})), detail: Some("fn(&mut self, B) -> C".into()),
insert_text_format: Some(lsp::InsertTextFormat::SNIPPET), text_edit: Some(lsp::CompletionTextEdit::Edit(lsp::TextEdit {
..Default::default() new_text: "first_method($1)".to_string(),
}, range: lsp::Range::new(
lsp::CompletionItem { lsp::Position::new(0, 14),
label: "second_method(…)".into(), lsp::Position::new(0, 14),
detail: Some("fn(&mut self, C) -> D<E>".into()), ),
text_edit: Some(lsp::CompletionTextEdit::Edit(lsp::TextEdit { })),
new_text: "second_method()".to_string(), insert_text_format: Some(lsp::InsertTextFormat::SNIPPET),
range: lsp::Range::new( ..Default::default()
lsp::Position::new(0, 14), },
lsp::Position::new(0, 14), lsp::CompletionItem {
), label: "second_method(…)".into(),
})), detail: Some("fn(&mut self, C) -> D<E>".into()),
insert_text_format: Some(lsp::InsertTextFormat::SNIPPET), text_edit: Some(lsp::CompletionTextEdit::Edit(lsp::TextEdit {
..Default::default() new_text: "second_method()".to_string(),
}, range: lsp::Range::new(
])), lsp::Position::new(0, 14),
) lsp::Position::new(0, 14),
.await; ),
})),
insert_text_format: Some(lsp::InsertTextFormat::SNIPPET),
..Default::default()
},
]))
});
// Open the buffer on the host. // Open the buffer on the host.
let buffer_a = project_a let buffer_a = project_a
@ -2480,43 +2474,32 @@ mod tests {
assert_eq!(editor.text(cx), "fn main() { a.first_method() }"); assert_eq!(editor.text(cx), "fn main() { a.first_method() }");
}); });
// Return a resolved completion from the host's language server.
// The resolved completion has an additional text edit.
fake_language_server.handle_request::<lsp::request::ResolveCompletionItem, _>(|params| {
assert_eq!(params.label, "first_method(…)");
lsp::CompletionItem {
label: "first_method(…)".into(),
detail: Some("fn(&mut self, B) -> C".into()),
text_edit: Some(lsp::CompletionTextEdit::Edit(lsp::TextEdit {
new_text: "first_method($1)".to_string(),
range: lsp::Range::new(lsp::Position::new(0, 14), lsp::Position::new(0, 14)),
})),
additional_text_edits: Some(vec![lsp::TextEdit {
new_text: "use d::SomeTrait;\n".to_string(),
range: lsp::Range::new(lsp::Position::new(0, 0), lsp::Position::new(0, 0)),
}]),
insert_text_format: Some(lsp::InsertTextFormat::SNIPPET),
..Default::default()
}
});
buffer_a buffer_a
.condition(&cx_a, |buffer, _| { .condition(&cx_a, |buffer, _| {
buffer.text() == "fn main() { a.first_method() }" buffer.text() == "fn main() { a.first_method() }"
}) })
.await; .await;
// Receive a request resolve the selected completion on the host's language server.
let (request_id, params) = fake_language_server
.receive_request::<lsp::request::ResolveCompletionItem>()
.await;
assert_eq!(params.label, "first_method(…)");
// Return a resolved completion from the host's language server.
// The resolved completion has an additional text edit.
fake_language_server
.respond(
request_id,
lsp::CompletionItem {
label: "first_method(…)".into(),
detail: Some("fn(&mut self, B) -> C".into()),
text_edit: Some(lsp::CompletionTextEdit::Edit(lsp::TextEdit {
new_text: "first_method($1)".to_string(),
range: lsp::Range::new(
lsp::Position::new(0, 14),
lsp::Position::new(0, 14),
),
})),
additional_text_edits: Some(vec![lsp::TextEdit {
new_text: "use d::SomeTrait;\n".to_string(),
range: lsp::Range::new(lsp::Position::new(0, 0), lsp::Position::new(0, 0)),
}]),
insert_text_format: Some(lsp::InsertTextFormat::SNIPPET),
..Default::default()
},
)
.await;
// The additional edit is applied. // The additional edit is applied.
buffer_b buffer_b
.condition(&cx_b, |buffer, _| { .condition(&cx_b, |buffer, _| {
@ -2610,24 +2593,20 @@ mod tests {
let format = project_b.update(&mut cx_b, |project, cx| { let format = project_b.update(&mut cx_b, |project, cx| {
project.format(HashSet::from_iter([buffer_b.clone()]), true, cx) project.format(HashSet::from_iter([buffer_b.clone()]), true, cx)
}); });
let (request_id, _) = fake_language_server
.receive_request::<lsp::request::Formatting>() fake_language_server.handle_request::<lsp::request::Formatting, _>(|_| {
.await; Some(vec![
fake_language_server lsp::TextEdit {
.respond( range: lsp::Range::new(lsp::Position::new(0, 4), lsp::Position::new(0, 4)),
request_id, new_text: "h".to_string(),
Some(vec![ },
lsp::TextEdit { lsp::TextEdit {
range: lsp::Range::new(lsp::Position::new(0, 4), lsp::Position::new(0, 4)), range: lsp::Range::new(lsp::Position::new(0, 7), lsp::Position::new(0, 7)),
new_text: "h".to_string(), new_text: "y".to_string(),
}, },
lsp::TextEdit { ])
range: lsp::Range::new(lsp::Position::new(0, 7), lsp::Position::new(0, 7)), });
new_text: "y".to_string(),
},
]),
)
.await;
format.await.unwrap(); format.await.unwrap();
assert_eq!( assert_eq!(
buffer_b.read_with(&cx_b, |buffer, _| buffer.text()), buffer_b.read_with(&cx_b, |buffer, _| buffer.text()),
@ -2714,26 +2693,22 @@ mod tests {
.await .await
.unwrap(); .unwrap();
// Open the file to be formatted on client B. // Open the file on client B.
let buffer_b = cx_b let buffer_b = cx_b
.background() .background()
.spawn(project_b.update(&mut cx_b, |p, cx| p.open_buffer((worktree_id, "a.rs"), cx))) .spawn(project_b.update(&mut cx_b, |p, cx| p.open_buffer((worktree_id, "a.rs"), cx)))
.await .await
.unwrap(); .unwrap();
// Request the definition of a symbol as the guest.
let definitions_1 = project_b.update(&mut cx_b, |p, cx| p.definition(&buffer_b, 23, cx)); let definitions_1 = project_b.update(&mut cx_b, |p, cx| p.definition(&buffer_b, 23, cx));
let (request_id, _) = fake_language_server fake_language_server.handle_request::<lsp::request::GotoDefinition, _>(|_| {
.receive_request::<lsp::request::GotoDefinition>() Some(lsp::GotoDefinitionResponse::Scalar(lsp::Location::new(
.await; lsp::Url::from_file_path("/root-2/b.rs").unwrap(),
fake_language_server lsp::Range::new(lsp::Position::new(0, 6), lsp::Position::new(0, 9)),
.respond( )))
request_id, });
Some(lsp::GotoDefinitionResponse::Scalar(lsp::Location::new(
lsp::Url::from_file_path("/root-2/b.rs").unwrap(),
lsp::Range::new(lsp::Position::new(0, 6), lsp::Position::new(0, 9)),
))),
)
.await;
let definitions_1 = definitions_1.await.unwrap(); let definitions_1 = definitions_1.await.unwrap();
cx_b.read(|cx| { cx_b.read(|cx| {
assert_eq!(definitions_1.len(), 1); assert_eq!(definitions_1.len(), 1);
@ -2752,18 +2727,13 @@ mod tests {
// Try getting more definitions for the same buffer, ensuring the buffer gets reused from // Try getting more definitions for the same buffer, ensuring the buffer gets reused from
// the previous call to `definition`. // the previous call to `definition`.
let definitions_2 = project_b.update(&mut cx_b, |p, cx| p.definition(&buffer_b, 33, cx)); let definitions_2 = project_b.update(&mut cx_b, |p, cx| p.definition(&buffer_b, 33, cx));
let (request_id, _) = fake_language_server fake_language_server.handle_request::<lsp::request::GotoDefinition, _>(|_| {
.receive_request::<lsp::request::GotoDefinition>() Some(lsp::GotoDefinitionResponse::Scalar(lsp::Location::new(
.await; lsp::Url::from_file_path("/root-2/b.rs").unwrap(),
fake_language_server lsp::Range::new(lsp::Position::new(1, 6), lsp::Position::new(1, 11)),
.respond( )))
request_id, });
Some(lsp::GotoDefinitionResponse::Scalar(lsp::Location::new(
lsp::Url::from_file_path("/root-2/b.rs").unwrap(),
lsp::Range::new(lsp::Position::new(1, 6), lsp::Position::new(1, 11)),
))),
)
.await;
let definitions_2 = definitions_2.await.unwrap(); let definitions_2 = definitions_2.await.unwrap();
cx_b.read(|cx| { cx_b.read(|cx| {
assert_eq!(definitions_2.len(), 1); assert_eq!(definitions_2.len(), 1);
@ -2887,18 +2857,12 @@ mod tests {
definitions = project_b.update(&mut cx_b, |p, cx| p.definition(&buffer_b1, 23, cx)); definitions = project_b.update(&mut cx_b, |p, cx| p.definition(&buffer_b1, 23, cx));
} }
let (request_id, _) = fake_language_server fake_language_server.handle_request::<lsp::request::GotoDefinition, _>(|_| {
.receive_request::<lsp::request::GotoDefinition>() Some(lsp::GotoDefinitionResponse::Scalar(lsp::Location::new(
.await; lsp::Url::from_file_path("/root/b.rs").unwrap(),
fake_language_server lsp::Range::new(lsp::Position::new(0, 6), lsp::Position::new(0, 9)),
.respond( )))
request_id, });
Some(lsp::GotoDefinitionResponse::Scalar(lsp::Location::new(
lsp::Url::from_file_path("/root/b.rs").unwrap(),
lsp::Range::new(lsp::Position::new(0, 6), lsp::Position::new(0, 9)),
))),
)
.await;
let buffer_b2 = buffer_b2.await.unwrap(); let buffer_b2 = buffer_b2.await.unwrap();
let definitions = definitions.await.unwrap(); let definitions = definitions.await.unwrap();