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

Allow FakeLanguageServer handlers to handle multiple requests

Browse source 
Co-Authored-By: Nathan Sobo <nathan@zed.dev>
This commit is contained in:
Max Brunsfeld 2022-02-16 16:19:27 -08:00
parent c4dff12d69
commit 90f31bb123
3 changed files with 170 additions and 145 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -5447,8 +5447,8 @@ 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 smol::stream::StreamExt;
use std::{cell::RefCell, rc::Rc, time::Instant}; use std::{cell::RefCell, rc::Rc, time::Instant};
use text::Point; use text::Point;
use unindent::Unindent; use unindent::Unindent;
@ -7911,7 +7911,7 @@ mod tests {
); );
Some(lsp::CompletionResponse::Array( Some(lsp::CompletionResponse::Array(
completions completions
.into_iter() .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 {
@ -7926,7 +7926,7 @@ mod tests {
.collect(), .collect(),
)) ))
}) })
.recv() .next()
.await; .await;
} }
@ -7936,7 +7936,7 @@ mod tests {
) { ) {
fake.handle_request::<lsp::request::ResolveCompletionItem, _>(move |_| { fake.handle_request::<lsp::request::ResolveCompletionItem, _>(move |_| {
lsp::CompletionItem { lsp::CompletionItem {
additional_text_edits: edit.map(|(range, new_text)| { additional_text_edits: edit.clone().map(|(range, new_text)| {
vec![lsp::TextEdit::new( vec![lsp::TextEdit::new(
lsp::Range::new( lsp::Range::new(
lsp::Position::new(range.start.row, range.start.column), lsp::Position::new(range.start.row, range.start.column),
@ -7948,7 +7948,7 @@ mod tests {
..Default::default() ..Default::default()
} }
}) })
.recv() .next()
.await; .await;
} }
} }

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

@ -1,5 +1,5 @@
use anyhow::{anyhow, Context, Result}; use anyhow::{anyhow, Context, Result};
use futures::{io::BufWriter, AsyncRead, AsyncWrite}; use futures::{channel::mpsc, io::BufWriter, AsyncRead, AsyncWrite};
use gpui::{executor, Task}; use gpui::{executor, Task};
use parking_lot::{Mutex, RwLock}; use parking_lot::{Mutex, RwLock};
use postage::{barrier, oneshot, prelude::Stream, sink::Sink, watch}; use postage::{barrier, oneshot, prelude::Stream, sink::Sink, watch};
@ -481,16 +481,10 @@ impl Drop for Subscription {
#[cfg(any(test, feature = "test-support"))] #[cfg(any(test, feature = "test-support"))]
pub struct FakeLanguageServer { pub struct FakeLanguageServer {
handlers: Arc< handlers:
Mutex< Arc<Mutex<HashMap<&'static str, Box<dyn Send + Sync + FnMut(usize, &[u8]) -> Vec<u8>>>>>,
HashMap< outgoing_tx: mpsc::UnboundedSender<Vec<u8>>,
&'static str, incoming_rx: mpsc::UnboundedReceiver<Vec<u8>>,
Box<dyn Send + FnOnce(usize, &[u8]) -> (Vec<u8>, barrier::Sender)>,
>,
>,
>,
outgoing_tx: channel::Sender<Vec<u8>>,
incoming_rx: channel::Receiver<Vec<u8>>,
} }
#[cfg(any(test, feature = "test-support"))] #[cfg(any(test, feature = "test-support"))]
@ -508,8 +502,9 @@ impl LanguageServer {
let mut fake = FakeLanguageServer::new(executor.clone(), stdin_reader, stdout_writer); let mut fake = FakeLanguageServer::new(executor.clone(), stdin_reader, stdout_writer);
fake.handle_request::<request::Initialize, _>({ fake.handle_request::<request::Initialize, _>({
let capabilities = capabilities.clone();
move |_| InitializeResult { move |_| InitializeResult {
capabilities, capabilities: capabilities.clone(),
..Default::default() ..Default::default()
} }
}); });
@ -530,8 +525,8 @@ impl FakeLanguageServer {
) -> Self { ) -> Self {
use futures::StreamExt as _; use futures::StreamExt as _;
let (incoming_tx, incoming_rx) = channel::unbounded(); let (incoming_tx, incoming_rx) = mpsc::unbounded();
let (outgoing_tx, mut outgoing_rx) = channel::unbounded(); let (outgoing_tx, mut outgoing_rx) = mpsc::unbounded();
let this = Self { let this = Self {
outgoing_tx: outgoing_tx.clone(), outgoing_tx: outgoing_tx.clone(),
incoming_rx, incoming_rx,
@ -545,36 +540,31 @@ impl FakeLanguageServer {
let mut buffer = Vec::new(); let mut buffer = Vec::new();
let mut stdin = smol::io::BufReader::new(stdin); let mut stdin = smol::io::BufReader::new(stdin);
while Self::receive(&mut stdin, &mut buffer).await.is_ok() { while Self::receive(&mut stdin, &mut buffer).await.is_ok() {
if let Ok(request) = serde_json::from_slice::<AnyRequest>(&mut buffer) { if let Ok(request) = serde_json::from_slice::<AnyRequest>(&buffer) {
assert_eq!(request.jsonrpc, JSON_RPC_VERSION); assert_eq!(request.jsonrpc, JSON_RPC_VERSION);
let handler = handlers.lock().remove(request.method); if let Some(handler) = handlers.lock().get_mut(request.method) {
if let Some(handler) = handler { let response = handler(request.id, request.params.get().as_bytes());
let (response, sent) =
handler(request.id, request.params.get().as_bytes());
log::debug!("handled lsp request. method:{}", request.method); log::debug!("handled lsp request. method:{}", request.method);
outgoing_tx.send(response).await.unwrap(); outgoing_tx.unbounded_send(response)?;
drop(sent);
} else { } else {
log::debug!("unhandled lsp request. method:{}", request.method); log::debug!("unhandled lsp request. method:{}", request.method);
outgoing_tx outgoing_tx.unbounded_send(
.send( serde_json::to_vec(&AnyResponse {
serde_json::to_vec(&AnyResponse { id: request.id,
id: request.id, error: Some(Error {
error: Some(Error { message: "no handler".to_string(),
message: "no handler".to_string(), }),
}), result: None,
result: None, })
}) .unwrap(),
.unwrap(), )?;
)
.await
.unwrap();
} }
} else { } else {
incoming_tx.send(buffer.clone()).await.unwrap(); incoming_tx.unbounded_send(buffer.clone())?;
} }
} }
Ok::<_, anyhow::Error>(())
}) })
.detach(); .detach();
@ -598,7 +588,7 @@ impl FakeLanguageServer {
params, params,
}) })
.unwrap(); .unwrap();
self.outgoing_tx.send(message).await.unwrap(); self.outgoing_tx.unbounded_send(message).unwrap();
} }
pub async fn receive_notification<T: notification::Notification>(&mut self) -> T::Params { pub async fn receive_notification<T: notification::Notification>(&mut self) -> T::Params {
@ -618,15 +608,15 @@ impl FakeLanguageServer {
} }
} }
pub fn handle_request<T, F>(&mut self, handler: F) -> barrier::Receiver pub fn handle_request<T, F>(&mut self, mut handler: F) -> mpsc::UnboundedReceiver<()>
where where
T: 'static + request::Request, T: 'static + request::Request,
F: 'static + Send + FnOnce(T::Params) -> T::Result, F: 'static + Send + Sync + FnMut(T::Params) -> T::Result,
{ {
let (responded_tx, responded_rx) = barrier::channel(); let (responded_tx, responded_rx) = mpsc::unbounded();
let prev_handler = self.handlers.lock().insert( self.handlers.lock().insert(
T::METHOD, T::METHOD,
Box::new(|id, params| { Box::new(move |id, params| {
let result = handler(serde_json::from_slice::<T::Params>(params).unwrap()); let result = handler(serde_json::from_slice::<T::Params>(params).unwrap());
let result = serde_json::to_string(&result).unwrap(); let result = serde_json::to_string(&result).unwrap();
let result = serde_json::from_str::<&RawValue>(&result).unwrap(); let result = serde_json::from_str::<&RawValue>(&result).unwrap();
@ -635,18 +625,20 @@ impl FakeLanguageServer {
error: None, error: None,
result: Some(result), result: Some(result),
}; };
(serde_json::to_vec(&response).unwrap(), responded_tx) responded_tx.unbounded_send(()).ok();
serde_json::to_vec(&response).unwrap()
}), }),
); );
if prev_handler.is_some() {
panic!(
"registered a new handler for LSP method '{}' before the previous handler was called",
T::METHOD
);
}
responded_rx responded_rx
} }
pub fn remove_request_handler<T>(&mut self)
where
T: 'static + request::Request,
{
self.handlers.lock().remove(T::METHOD);
}
pub async fn start_progress(&mut self, token: impl Into<String>) { pub async fn start_progress(&mut self, token: impl Into<String>) {
self.notify::<notification::Progress>(ProgressParams { self.notify::<notification::Progress>(ProgressParams {
token: NumberOrString::String(token.into()), token: NumberOrString::String(token.into()),

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

@ -1093,6 +1093,7 @@ mod tests {
}; };
use ::rpc::Peer; use ::rpc::Peer;
use collections::BTreeMap; use collections::BTreeMap;
use futures::channel::mpsc::UnboundedReceiver;
use gpui::{executor, ModelHandle, TestAppContext}; use gpui::{executor, ModelHandle, TestAppContext};
use parking_lot::Mutex; use parking_lot::Mutex;
use postage::{mpsc, watch}; use postage::{mpsc, watch};
@ -1126,7 +1127,7 @@ mod tests {
tree_sitter_rust, AnchorRangeExt, Diagnostic, DiagnosticEntry, Language, tree_sitter_rust, AnchorRangeExt, Diagnostic, DiagnosticEntry, Language,
LanguageConfig, LanguageRegistry, LanguageServerConfig, Point, LanguageConfig, LanguageRegistry, LanguageServerConfig, Point,
}, },
lsp, lsp::{self, FakeLanguageServer},
project::{DiagnosticSummary, Project, ProjectPath}, project::{DiagnosticSummary, Project, ProjectPath},
workspace::{Workspace, WorkspaceParams}, workspace::{Workspace, WorkspaceParams},
}; };
@ -2320,45 +2321,51 @@ mod tests {
// Receive a completion request as the host's language server. // Receive a completion request as the host's language server.
// Return some completions from the host's language server. // Return some completions from the host's language server.
fake_language_server.handle_request::<lsp::request::Completion, _>(|params| { cx_a.foreground().start_waiting();
assert_eq!( fake_language_server
params.text_document_position.text_document.uri, .handle_request::<lsp::request::Completion, _>(|params| {
lsp::Url::from_file_path("/a/main.rs").unwrap(), assert_eq!(
); params.text_document_position.text_document.uri,
assert_eq!( lsp::Url::from_file_path("/a/main.rs").unwrap(),
params.text_document_position.position, );
lsp::Position::new(0, 14), assert_eq!(
); params.text_document_position.position,
lsp::Position::new(0, 14),
);
Some(lsp::CompletionResponse::Array(vec![ Some(lsp::CompletionResponse::Array(vec![
lsp::CompletionItem { lsp::CompletionItem {
label: "first_method(…)".into(), label: "first_method(…)".into(),
detail: Some("fn(&mut self, B) -> C".into()), detail: Some("fn(&mut self, B) -> C".into()),
text_edit: Some(lsp::CompletionTextEdit::Edit(lsp::TextEdit { text_edit: Some(lsp::CompletionTextEdit::Edit(lsp::TextEdit {
new_text: "first_method($1)".to_string(), new_text: "first_method($1)".to_string(),
range: lsp::Range::new( range: lsp::Range::new(
lsp::Position::new(0, 14), lsp::Position::new(0, 14),
lsp::Position::new(0, 14), lsp::Position::new(0, 14),
), ),
})), })),
insert_text_format: Some(lsp::InsertTextFormat::SNIPPET), insert_text_format: Some(lsp::InsertTextFormat::SNIPPET),
..Default::default() ..Default::default()
}, },
lsp::CompletionItem { lsp::CompletionItem {
label: "second_method(…)".into(), label: "second_method(…)".into(),
detail: Some("fn(&mut self, C) -> D<E>".into()), detail: Some("fn(&mut self, C) -> D<E>".into()),
text_edit: Some(lsp::CompletionTextEdit::Edit(lsp::TextEdit { text_edit: Some(lsp::CompletionTextEdit::Edit(lsp::TextEdit {
new_text: "second_method()".to_string(), new_text: "second_method()".to_string(),
range: lsp::Range::new( range: lsp::Range::new(
lsp::Position::new(0, 14), lsp::Position::new(0, 14),
lsp::Position::new(0, 14), lsp::Position::new(0, 14),
), ),
})), })),
insert_text_format: Some(lsp::InsertTextFormat::SNIPPET), insert_text_format: Some(lsp::InsertTextFormat::SNIPPET),
..Default::default() ..Default::default()
}, },
])) ]))
}); })
.next()
.await
.unwrap();
cx_a.foreground().finish_waiting();
// Open the buffer on the host. // Open the buffer on the host.
let buffer_a = project_a let buffer_a = project_a
@ -2896,58 +2903,62 @@ mod tests {
editor.select_ranges([Point::new(1, 31)..Point::new(1, 31)], None, cx); editor.select_ranges([Point::new(1, 31)..Point::new(1, 31)], None, cx);
cx.focus(&editor_b); cx.focus(&editor_b);
}); });
fake_language_server.handle_request::<lsp::request::CodeActionRequest, _>(|params| {
assert_eq!(
params.text_document.uri,
lsp::Url::from_file_path("/a/main.rs").unwrap(),
);
assert_eq!(params.range.start, lsp::Position::new(1, 31));
assert_eq!(params.range.end, lsp::Position::new(1, 31));
Some(vec![lsp::CodeActionOrCommand::CodeAction( fake_language_server
lsp::CodeAction { .handle_request::<lsp::request::CodeActionRequest, _>(|params| {
title: "Inline into all callers".to_string(), assert_eq!(
edit: Some(lsp::WorkspaceEdit { params.text_document.uri,
changes: Some( lsp::Url::from_file_path("/a/main.rs").unwrap(),
[ );
( assert_eq!(params.range.start, lsp::Position::new(1, 31));
lsp::Url::from_file_path("/a/main.rs").unwrap(), assert_eq!(params.range.end, lsp::Position::new(1, 31));
vec![lsp::TextEdit::new(
lsp::Range::new( Some(vec![lsp::CodeActionOrCommand::CodeAction(
lsp::Position::new(1, 22), lsp::CodeAction {
lsp::Position::new(1, 34), title: "Inline into all callers".to_string(),
), edit: Some(lsp::WorkspaceEdit {
"4".to_string(), changes: Some(
)], [
), (
( lsp::Url::from_file_path("/a/main.rs").unwrap(),
lsp::Url::from_file_path("/a/other.rs").unwrap(), vec![lsp::TextEdit::new(
vec![lsp::TextEdit::new( lsp::Range::new(
lsp::Range::new( lsp::Position::new(1, 22),
lsp::Position::new(0, 0), lsp::Position::new(1, 34),
lsp::Position::new(0, 27), ),
), "4".to_string(),
"".to_string(), )],
)], ),
), (
] lsp::Url::from_file_path("/a/other.rs").unwrap(),
.into_iter() vec![lsp::TextEdit::new(
.collect(), lsp::Range::new(
), lsp::Position::new(0, 0),
..Default::default() lsp::Position::new(0, 27),
}), ),
data: Some(json!({ "".to_string(),
"codeActionParams": { )],
"range": { ),
"start": {"line": 1, "column": 31}, ]
"end": {"line": 1, "column": 31}, .into_iter()
.collect(),
),
..Default::default()
}),
data: Some(json!({
"codeActionParams": {
"range": {
"start": {"line": 1, "column": 31},
"end": {"line": 1, "column": 31},
}
} }
} })),
})), ..Default::default()
..Default::default() },
}, )])
)]) })
}); .next()
.await;
// Toggle code actions and wait for them to display. // Toggle code actions and wait for them to display.
editor_b.update(&mut cx_b, |editor, cx| { editor_b.update(&mut cx_b, |editor, cx| {
@ -2957,6 +2968,8 @@ mod tests {
.condition(&cx_b, |editor, _| editor.context_menu_visible()) .condition(&cx_b, |editor, _| editor.context_menu_visible())
.await; .await;
fake_language_server.remove_request_handler::<lsp::request::CodeActionRequest>();
// Confirming the code action will trigger a resolve request. // Confirming the code action will trigger a resolve request.
let confirm_action = workspace_b let confirm_action = workspace_b
.update(&mut cx_b, |workspace, cx| { .update(&mut cx_b, |workspace, cx| {
@ -3594,7 +3607,24 @@ mod tests {
.unwrap_or(10); .unwrap_or(10);
let rng = Rc::new(RefCell::new(rng)); let rng = Rc::new(RefCell::new(rng));
let lang_registry = Arc::new(LanguageRegistry::new());
let mut host_lang_registry = Arc::new(LanguageRegistry::new());
let guest_lang_registry = Arc::new(LanguageRegistry::new());
// Set up a fake language server.
let (language_server_config, fake_language_servers) = LanguageServerConfig::fake();
Arc::get_mut(&mut host_lang_registry)
.unwrap()
.add(Arc::new(Language::new(
LanguageConfig {
name: "Rust".to_string(),
path_suffixes: vec!["rs".to_string()],
language_server: Some(language_server_config),
..Default::default()
},
Some(tree_sitter_rust::language()),
)));
let fs = Arc::new(FakeFs::new(cx.background())); let fs = Arc::new(FakeFs::new(cx.background()));
fs.insert_tree( fs.insert_tree(
"/_collab", "/_collab",
@ -3622,7 +3652,7 @@ mod tests {
Project::local( Project::local(
host.client.clone(), host.client.clone(),
host.user_store.clone(), host.user_store.clone(),
lang_registry.clone(), host_lang_registry.clone(),
fs.clone(), fs.clone(),
cx, cx,
) )
@ -3647,6 +3677,7 @@ mod tests {
clients.push(cx.foreground().spawn(host.simulate_host( clients.push(cx.foreground().spawn(host.simulate_host(
host_project.clone(), host_project.clone(),
fake_language_servers,
operations.clone(), operations.clone(),
max_operations, max_operations,
rng.clone(), rng.clone(),
@ -3676,7 +3707,7 @@ mod tests {
host_project_id, host_project_id,
guest.client.clone(), guest.client.clone(),
guest.user_store.clone(), guest.user_store.clone(),
lang_registry.clone(), guest_lang_registry.clone(),
fs.clone(), fs.clone(),
&mut guest_cx.to_async(), &mut guest_cx.to_async(),
) )
@ -3971,6 +4002,7 @@ mod tests {
async fn simulate_host( async fn simulate_host(
mut self, mut self,
project: ModelHandle<Project>, project: ModelHandle<Project>,
fake_language_servers: UnboundedReceiver<FakeLanguageServer>,
operations: Rc<Cell<usize>>, operations: Rc<Cell<usize>>,
max_operations: usize, max_operations: usize,
rng: Rc<RefCell<StdRng>>, rng: Rc<RefCell<StdRng>>,
@ -4055,6 +4087,7 @@ mod tests {
let letter = rng.borrow_mut().gen_range(b'a'..=b'z'); let letter = rng.borrow_mut().gen_range(b'a'..=b'z');
path.push(std::str::from_utf8(&[letter]).unwrap()); path.push(std::str::from_utf8(&[letter]).unwrap());
} }
path.set_extension("rs");
let parent_path = path.parent().unwrap(); let parent_path = path.parent().unwrap();
log::info!("Host: creating file {:?}", path); log::info!("Host: creating file {:?}", path);