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

Remove unnecessary waiting during completion RPC requests

Browse source 
Also, add completion requests to the randomized collaboration integration test,
to demonstrate that this is valid.

Co-Authored-By: Nathan Sobo <nathan@zed.dev>
This commit is contained in:
Max Brunsfeld 2022-02-16 17:23:16 -08:00
parent 90f31bb123
commit 41ba980c9b
5 changed files with 99 additions and 53 deletions
Download patch file Download diff file Expand all files Collapse all files

28
crates/language/src/language.rs
View file

@ -11,6 +11,7 @@ use collections::HashSet;
use gpui::AppContext; use gpui::AppContext;
use highlight_map::HighlightMap; use highlight_map::HighlightMap;
use lazy_static::lazy_static; use lazy_static::lazy_static;
use lsp::FakeLanguageServer;
use parking_lot::Mutex; use parking_lot::Mutex;
use postage::prelude::Stream; use postage::prelude::Stream;
use serde::Deserialize; use serde::Deserialize;
@ -90,6 +91,7 @@ pub struct LanguageServerConfig {
struct FakeLanguageServerConfig { struct FakeLanguageServerConfig {
servers_tx: mpsc::UnboundedSender<lsp::FakeLanguageServer>, servers_tx: mpsc::UnboundedSender<lsp::FakeLanguageServer>,
capabilities: lsp::ServerCapabilities, capabilities: lsp::ServerCapabilities,
initializer: Option<Box<dyn 'static + Send + Sync + Fn(&mut lsp::FakeLanguageServer)>>,
} }
#[derive(Clone, Debug, Deserialize)] #[derive(Clone, Debug, Deserialize)]
@ -235,11 +237,15 @@ impl Language {
if let Some(config) = &self.config.language_server { if let Some(config) = &self.config.language_server {
#[cfg(any(test, feature = "test-support"))] #[cfg(any(test, feature = "test-support"))]
if let Some(fake_config) = &config.fake_config { if let Some(fake_config) = &config.fake_config {
let (server, fake_server) = lsp::LanguageServer::fake_with_capabilities( let (server, mut fake_server) = lsp::LanguageServer::fake_with_capabilities(
fake_config.capabilities.clone(), fake_config.capabilities.clone(),
cx.background().clone(), cx.background().clone(),
); );
if let Some(initalizer) = &fake_config.initializer {
initalizer(&mut fake_server);
}
let servers_tx = fake_config.servers_tx.clone(); let servers_tx = fake_config.servers_tx.clone();
let mut initialized = server.capabilities(); let mut initialized = server.capabilities();
cx.background() cx.background()
@ -381,18 +387,13 @@ impl CompletionLabel {
#[cfg(any(test, feature = "test-support"))] #[cfg(any(test, feature = "test-support"))]
impl LanguageServerConfig { impl LanguageServerConfig {
pub fn fake() -> (Self, mpsc::UnboundedReceiver<lsp::FakeLanguageServer>) { pub fn fake() -> (Self, mpsc::UnboundedReceiver<lsp::FakeLanguageServer>) {
Self::fake_with_capabilities(Default::default())
}
pub fn fake_with_capabilities(
capabilities: lsp::ServerCapabilities,
) -> (Self, mpsc::UnboundedReceiver<lsp::FakeLanguageServer>) {
let (servers_tx, servers_rx) = mpsc::unbounded(); let (servers_tx, servers_rx) = mpsc::unbounded();
( (
Self { Self {
fake_config: Some(FakeLanguageServerConfig { fake_config: Some(FakeLanguageServerConfig {
servers_tx, servers_tx,
capabilities, capabilities: Default::default(),
initializer: None,
}), }),
disk_based_diagnostics_progress_token: Some("fakeServer/check".to_string()), disk_based_diagnostics_progress_token: Some("fakeServer/check".to_string()),
..Default::default() ..Default::default()
@ -400,6 +401,17 @@ impl LanguageServerConfig {
servers_rx, servers_rx,
) )
} }
pub fn set_fake_capabilities(&mut self, capabilities: lsp::ServerCapabilities) {
self.fake_config.as_mut().unwrap().capabilities = capabilities;
}
pub fn set_fake_initializer(
&mut self,
initializer: impl 'static + Send + Sync + Fn(&mut FakeLanguageServer),
) {
self.fake_config.as_mut().unwrap().initializer = Some(Box::new(initializer));
}
} }
impl ToLspPosition for PointUtf16 { impl ToLspPosition for PointUtf16 {

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

@ -420,7 +420,9 @@ impl LanguageServer {
anyhow!("tried to send a request to a language server that has been shut down") anyhow!("tried to send a request to a language server that has been shut down")
}) })
.and_then(|outbound_tx| { .and_then(|outbound_tx| {
outbound_tx.try_send(message)?; outbound_tx
.try_send(message)
.context("failed to write to language server's stdin")?;
Ok(()) Ok(())
}); });
async move { async move {

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

@ -2,7 +2,7 @@ pub mod fs;
mod ignore; mod ignore;
pub mod worktree; pub mod worktree;
use anyhow::{anyhow, Result}; use anyhow::{anyhow, Context, Result};
use client::{proto, Client, PeerId, TypedEnvelope, User, UserStore}; use client::{proto, Client, PeerId, TypedEnvelope, User, UserStore};
use clock::ReplicaId; use clock::ReplicaId;
use collections::{hash_map, HashMap, HashSet}; use collections::{hash_map, HashMap, HashSet};
@ -1347,7 +1347,8 @@ impl Project {
work_done_progress_params: Default::default(), work_done_progress_params: Default::default(),
partial_result_params: Default::default(), partial_result_params: Default::default(),
}) })
.await?; .await
.context("lsp completion request failed")?;
let completions = if let Some(completions) = completions { let completions = if let Some(completions) = completions {
match completions { match completions {
@ -1400,13 +1401,16 @@ impl Project {
position: Some(language::proto::serialize_anchor(&anchor)), position: Some(language::proto::serialize_anchor(&anchor)),
version: (&source_buffer.version()).into(), version: (&source_buffer.version()).into(),
}; };
cx.spawn_weak(|_, mut cx| async move { cx.spawn_weak(|_, cx| async move {
let response = rpc.request(message).await?; let response = rpc.request(message).await?;
source_buffer_handle
.update(&mut cx, |buffer, _| { if !source_buffer_handle
buffer.wait_for_version(response.version.into()) .read_with(&cx, |buffer, _| buffer.version())
}) .observed_all(&response.version.into())
.await; {
Err(anyhow!("completion response depends on unreceived edits"))?;
}
response response
.completions .completions
.into_iter() .into_iter()
@ -2352,9 +2356,12 @@ impl Project {
.and_then(|shared_buffers| shared_buffers.get(&envelope.payload.buffer_id).cloned()) .and_then(|shared_buffers| shared_buffers.get(&envelope.payload.buffer_id).cloned())
.ok_or_else(|| anyhow!("unknown buffer id {}", envelope.payload.buffer_id)) .ok_or_else(|| anyhow!("unknown buffer id {}", envelope.payload.buffer_id))
})?; })?;
buffer if !buffer
.update(&mut cx, |buffer, _| buffer.wait_for_version(version)) .read_with(&cx, |buffer, _| buffer.version())
.await; .observed_all(&version)
{
Err(anyhow!("completion request depends on unreceived edits"))?;
}
let version = buffer.read_with(&cx, |buffer, _| buffer.version()); let version = buffer.read_with(&cx, |buffer, _| buffer.version());
let completions = this let completions = this
.update(&mut cx, |this, cx| this.completions(&buffer, position, cx)) .update(&mut cx, |this, cx| this.completions(&buffer, position, cx))

2
crates/rpc/src/peer.rs
View file

@ -265,7 +265,7 @@ impl Peer {
.await .await
.ok_or_else(|| anyhow!("connection was closed"))?; .ok_or_else(|| anyhow!("connection was closed"))?;
if let Some(proto::envelope::Payload::Error(error)) = &response.payload { if let Some(proto::envelope::Payload::Error(error)) = &response.payload {
Err(anyhow!("request failed").context(error.message.clone())) Err(anyhow!("RPC request failed - {}", error.message))
} else { } else {
T::Response::from_envelope(response) T::Response::from_envelope(response)
.ok_or_else(|| anyhow!("received response of the wrong type")) .ok_or_else(|| anyhow!("received response of the wrong type"))

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

@ -1093,7 +1093,6 @@ 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};
@ -1127,7 +1126,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::{self, FakeLanguageServer}, lsp,
project::{DiagnosticSummary, Project, ProjectPath}, project::{DiagnosticSummary, Project, ProjectPath},
workspace::{Workspace, WorkspaceParams}, workspace::{Workspace, WorkspaceParams},
}; };
@ -2218,8 +2217,8 @@ mod tests {
let fs = Arc::new(FakeFs::new(cx_a.background())); let fs = Arc::new(FakeFs::new(cx_a.background()));
// Set up a fake language server. // Set up a fake language server.
let (language_server_config, mut fake_language_servers) = let (mut language_server_config, mut fake_language_servers) = LanguageServerConfig::fake();
LanguageServerConfig::fake_with_capabilities(lsp::ServerCapabilities { language_server_config.set_fake_capabilities(lsp::ServerCapabilities {
completion_provider: Some(lsp::CompletionOptions { completion_provider: Some(lsp::CompletionOptions {
trigger_characters: Some(vec![".".to_string()]), trigger_characters: Some(vec![".".to_string()]),
..Default::default() ..Default::default()
@ -3612,7 +3611,19 @@ mod tests {
let guest_lang_registry = Arc::new(LanguageRegistry::new()); let guest_lang_registry = Arc::new(LanguageRegistry::new());
// Set up a fake language server. // Set up a fake language server.
let (language_server_config, fake_language_servers) = LanguageServerConfig::fake(); let (mut language_server_config, _fake_language_servers) = LanguageServerConfig::fake();
language_server_config.set_fake_initializer(|fake_server| {
fake_server.handle_request::<lsp::request::Completion, _>(|_| {
Some(lsp::CompletionResponse::Array(vec![lsp::CompletionItem {
text_edit: Some(lsp::CompletionTextEdit::Edit(lsp::TextEdit {
range: lsp::Range::new(lsp::Position::new(0, 0), lsp::Position::new(0, 0)),
new_text: "the-new-text".to_string(),
})),
..Default::default()
}]))
});
});
Arc::get_mut(&mut host_lang_registry) Arc::get_mut(&mut host_lang_registry)
.unwrap() .unwrap()
.add(Arc::new(Language::new( .add(Arc::new(Language::new(
@ -3677,7 +3688,6 @@ 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(),
@ -4002,7 +4012,6 @@ 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>>,
@ -4158,7 +4167,9 @@ mod tests {
.clone() .clone()
}; };
if rng.borrow_mut().gen_bool(0.1) { let choice = rng.borrow_mut().gen_range(0..100);
match choice {
0..=9 => {
cx.update(|cx| { cx.update(|cx| {
log::info!( log::info!(
"Guest {}: dropping buffer {:?}", "Guest {}: dropping buffer {:?}",
@ -4168,7 +4179,21 @@ mod tests {
self.buffers.remove(&buffer); self.buffers.remove(&buffer);
drop(buffer); drop(buffer);
}); });
} else { }
10..=19 => {
project
.update(&mut cx, |project, cx| {
log::info!(
"Guest {}: requesting completions for buffer {:?}",
guest_id,
buffer.read(cx).file().unwrap().full_path(cx)
);
project.completions(&buffer, 0, cx)
})
.await
.expect("completion request failed");
}
_ => {
buffer.update(&mut cx, |buffer, cx| { buffer.update(&mut cx, |buffer, cx| {
log::info!( log::info!(
"Guest {}: updating buffer {:?}", "Guest {}: updating buffer {:?}",
@ -4178,7 +4203,7 @@ mod tests {
buffer.randomly_edit(&mut *rng.borrow_mut(), 5, cx) buffer.randomly_edit(&mut *rng.borrow_mut(), 5, cx)
}); });
} }
}
cx.background().simulate_random_delay().await; cx.background().simulate_random_delay().await;
} }