Skip to content

armgit / zed

Public Imported from GitHub
0

Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.

Reduce waits for navigation, suggestions, and file comparisons (#66487)

morgankrey7e7311ad2039
diff --git a/crates/fs/src/fs.rs b/crates/fs/src/fs.rs
index e6ef06beb70..a61a995ef3e 100644
--- a/crates/fs/src/fs.rs
+++ b/crates/fs/src/fs.rs
@@ -1471,6 +1471,7 @@ struct FakeFsState {
job_event_subscribers: Arc<Mutex<Vec<JobEventSender>>>,
trash: Mutex<SlotMap<TrashId, (TrashedEntry, FakeFsEntry)>>,
remove_dir_errors: std::collections::HashMap<PathBuf, String>,
+ load_delays: std::collections::HashMap<PathBuf, Duration>,
case_sensitive: bool,
}
@@ -1867,6 +1868,7 @@ impl FakeFs {
job_event_subscribers: Arc::new(Mutex::new(Vec::new())),
trash: Mutex::new(SlotMap::with_key()),
remove_dir_errors: Default::default(),
+ load_delays: Default::default(),
case_sensitive: true,
}));
let native_watcher = fs_watcher::OsWatcher::with_backend(
@@ -2039,10 +2041,21 @@ impl FakeFs {
entry.file_content(&path).cloned()
}
+ pub fn set_load_delay(&self, path: impl AsRef<Path>, delay: Duration) {
+ self.state
+ .lock()
+ .load_delays
+ .insert(normalize_path(path.as_ref()), delay);
+ }
+
async fn load_internal(&self, path: impl AsRef<Path>) -> Result<Vec<u8>> {
let path = path.as_ref();
let path = normalize_path(path);
self.simulate_random_delay().await;
+ let delay = self.state.lock().load_delays.get(&path).copied();
+ if let Some(delay) = delay {
+ self.executor.timer(delay).await;
+ }
let mut state = self.state.lock();
let entry = state.entry(&path)?;
entry.file_content(&path).cloned()
diff --git a/crates/git_ui/src/multi_diff_view.rs b/crates/git_ui/src/multi_diff_view.rs
index 15f296a4113..6e51148deeb 100644
--- a/crates/git_ui/src/multi_diff_view.rs
+++ b/crates/git_ui/src/multi_diff_view.rs
@@ -4,6 +4,7 @@ use editor::{
Editor, EditorEvent, EditorSettings, HiddenUnstagedDiffHunkRenderer, MultiBuffer,
SplittableEditor, multibuffer_context_lines,
};
+use futures::{StreamExt as _, TryStreamExt as _, stream};
use git_ui_core::file_diff_view::build_buffer_diff;
use gpui::{
App, AppContext as _, AsyncApp, Context, Entity, EventEmitter, FocusHandle, Focusable, Font,
@@ -46,30 +47,37 @@ async fn load_entries(
project: &Entity<Project>,
cx: &mut AsyncApp,
) -> Result<(Vec<Entry>, Option<PathBuf>)> {
- let mut entries = Vec::with_capacity(diff_pairs.len());
- let mut all_paths = Vec::with_capacity(diff_pairs.len());
-
- for (ix, pair) in diff_pairs.into_iter().enumerate() {
- let old_path = PathBuf::from(&pair[0]);
- let new_path = PathBuf::from(&pair[1]);
-
- let old_buffer = project
- .update(cx, |project, cx| project.open_local_buffer(&old_path, cx))
- .await?;
- let new_buffer = project
- .update(cx, |project, cx| project.open_local_buffer(&new_path, cx))
- .await?;
-
- let diff = build_buffer_diff(&old_buffer, &new_buffer, cx).await?;
-
- all_paths.push(new_path.clone());
- entries.push(Entry {
- index: ix,
- new_path,
- new_buffer: new_buffer.clone(),
- diff,
- });
- }
+ let entries = stream::iter(diff_pairs.into_iter().enumerate())
+ .map(|(index, pair)| {
+ let project = project.clone();
+ let mut cx = cx.clone();
+ async move {
+ let old_path = PathBuf::from(&pair[0]);
+ let new_path = PathBuf::from(&pair[1]);
+ let old_buffer = project.update(&mut cx, |project, cx| {
+ project.open_local_buffer(&old_path, cx)
+ });
+ let new_buffer = project.update(&mut cx, |project, cx| {
+ project.open_local_buffer(&new_path, cx)
+ });
+ let (old_buffer, new_buffer) =
+ futures::future::try_join(old_buffer, new_buffer).await?;
+ let diff = build_buffer_diff(&old_buffer, &new_buffer, &mut cx).await?;
+ anyhow::Ok(Entry {
+ index,
+ new_path,
+ new_buffer,
+ diff,
+ })
+ }
+ })
+ .buffered(16)
+ .try_collect::<Vec<_>>()
+ .await?;
+ let all_paths = entries
+ .iter()
+ .map(|entry| entry.new_path.clone())
+ .collect::<Vec<_>>();
let common_root = common_prefix(&all_paths);
Ok((entries, common_root))
@@ -392,14 +400,78 @@ impl Render for MultiDiffView {
#[cfg(test)]
mod tests {
use super::*;
+ use futures::FutureExt as _;
use gpui::BorrowAppContext;
use gpui::TestAppContext;
use language::{Language, LanguageConfig};
use project::{FakeFs, Project};
use settings::{DiffViewStyle, SettingsStore};
+ use std::time::Duration;
use util::path;
use workspace::MultiWorkspace;
+ #[gpui::test(iterations = 10)]
+ async fn test_multi_diff_loads_files_concurrently(cx: &mut TestAppContext) {
+ cx.update(|cx| {
+ let settings = SettingsStore::test(cx);
+ cx.set_global(settings);
+ });
+ let fs = FakeFs::new(cx.executor());
+ fs.insert_tree(
+ path!("/test"),
+ serde_json::json!({
+ "old1.txt": "old one", "new1.txt": "new one",
+ "old2.txt": "old two", "new2.txt": "new two",
+ "old3.txt": "old three", "new3.txt": "new three"
+ }),
+ )
+ .await;
+ let project = Project::test(fs.clone(), [path!("/test").as_ref()], cx).await;
+ let pairs = [3, 1, 2]
+ .into_iter()
+ .map(|index| {
+ [
+ format!("{}/old{index}.txt", path!("/test")),
+ format!("{}/new{index}.txt", path!("/test")),
+ ]
+ })
+ .collect::<Vec<_>>();
+ for pair in &pairs {
+ for path in pair {
+ fs.set_load_delay(path, Duration::from_millis(40));
+ }
+ }
+ let mut task = cx.spawn(async move |mut cx| load_entries(pairs, &project, &mut cx).await);
+ cx.run_until_parked();
+ let mut elapsed_ms = 0;
+ let (entries, common_root) = loop {
+ cx.executor().advance_clock(Duration::from_millis(40));
+ elapsed_ms += 40;
+ cx.run_until_parked();
+ if let Some(result) = (&mut task).now_or_never() {
+ break result.unwrap();
+ }
+ assert!(elapsed_ms < 400, "multi-file diff did not finish loading");
+ };
+ assert_eq!(elapsed_ms, 40, "independent file reads must overlap");
+ assert_eq!(common_root, Some(PathBuf::from(path!("/test"))));
+ assert_eq!(entries.len(), 3);
+ for ((entry, index), word) in entries.iter().zip([3, 1, 2]).zip(["three", "one", "two"]) {
+ assert_eq!(
+ entry.new_path,
+ PathBuf::from(format!("{}/new{index}.txt", path!("/test")))
+ );
+ assert_eq!(
+ entry.new_buffer.read_with(cx, |buffer, _| buffer.text()),
+ format!("new {word}")
+ );
+ }
+ assert_eq!(
+ entries.iter().map(|entry| entry.index).collect::<Vec<_>>(),
+ vec![0, 1, 2]
+ );
+ }
+
async fn test_init(
cx: &mut TestAppContext,
diff_style: DiffViewStyle,
diff --git a/crates/git_ui_core/src/file_diff_view.rs b/crates/git_ui_core/src/file_diff_view.rs
index d5fa761b8ff..830d3998bd5 100644
--- a/crates/git_ui_core/src/file_diff_view.rs
+++ b/crates/git_ui_core/src/file_diff_view.rs
@@ -52,12 +52,12 @@ impl FileDiffView {
) -> Task<Result<Entity<Self>>> {
window.spawn(cx, async move |cx| {
let project = workspace.update(cx, |workspace, _| workspace.project().clone())?;
- let old_buffer = project
- .update(cx, |project, cx| project.open_local_buffer(&old_path, cx))
- .await?;
- let new_buffer = project
- .update(cx, |project, cx| project.open_local_buffer(&new_path, cx))
- .await?;
+ let old_buffer =
+ project.update(cx, |project, cx| project.open_local_buffer(&old_path, cx));
+ let new_buffer =
+ project.update(cx, |project, cx| project.open_local_buffer(&new_path, cx));
+ let (old_buffer, new_buffer) =
+ futures::future::try_join(old_buffer, new_buffer).await?;
let buffer_diff = build_buffer_diff(&old_buffer, &new_buffer, cx).await?;
@@ -489,6 +489,52 @@ mod tests {
});
}
+ #[gpui::test(iterations = 10)]
+ async fn test_diff_view_loads_both_files_concurrently(cx: &mut TestAppContext) {
+ init_test(cx);
+ let fs = FakeFs::new(cx.executor());
+ fs.insert_tree(
+ path!("/test"),
+ serde_json::json!({
+ "old.txt": "old text", "new.txt": "new text"
+ }),
+ )
+ .await;
+ let project = Project::test(fs.clone(), [path!("/test").as_ref()], cx).await;
+ let executor = cx.executor();
+ let (multi_workspace, cx) =
+ cx.add_window_view(|window, cx| MultiWorkspace::test_new(project.clone(), window, cx));
+ let workspace = multi_workspace.read_with(cx, |workspace, _| workspace.workspace().clone());
+ fs.set_load_delay(path!("/test/old.txt"), Duration::from_millis(40));
+ fs.set_load_delay(path!("/test/new.txt"), Duration::from_millis(40));
+ let mut task = workspace.update_in(cx, |workspace, window, cx| {
+ FileDiffView::open(
+ path!("/test/old.txt").into(),
+ path!("/test/new.txt").into(),
+ None,
+ workspace.weak_handle(),
+ window,
+ cx,
+ )
+ });
+ executor.run_until_parked();
+ let mut elapsed_ms = 0;
+ let view = loop {
+ executor.advance_clock(Duration::from_millis(40));
+ elapsed_ms += 40;
+ executor.run_until_parked();
+ if let Some(result) = (&mut task).now_or_never() {
+ break result.unwrap();
+ }
+ assert!(elapsed_ms < 400, "diff did not finish loading");
+ };
+ assert_eq!(elapsed_ms, 40, "both file reads must overlap");
+ view.read_with(cx, |view, cx| {
+ assert_eq!(view.old_buffer.read(cx).text(), "old text");
+ assert_eq!(view.new_buffer.read(cx).text(), "new text");
+ });
+ }
+
#[gpui::test]
async fn test_diff_view(cx: &mut TestAppContext) {
init_test(cx);
diff --git a/crates/project/src/lsp_command.rs b/crates/project/src/lsp_command.rs
index d8b973cf15f..b0d6d40bc1e 100644
--- a/crates/project/src/lsp_command.rs
+++ b/crates/project/src/lsp_command.rs
@@ -13,6 +13,7 @@ use async_trait::async_trait;
use client::proto::{self, PeerId};
use clock::Global;
use collections::HashMap;
+use futures::{FutureExt as _, StreamExt as _, TryStreamExt as _, stream};
use gpui::{App, AsyncApp, Entity, SharedString, Task, TaskExt, prelude::FluentBuilder};
use language::{
Anchor, Bias, Buffer, BufferSnapshot, CachedLspAdapter, CharKind, CharScopeContext,
@@ -31,6 +32,7 @@ use lsp::{
DocumentHighlightKind, LanguageServer, LanguageServerId, LinkedEditingRangeServerCapabilities,
OneOf, RenameOptions, ServerCapabilities,
};
+use rpc::ErrorExt as _;
use serde_json::Value;
use signature_help::{lsp_to_proto_signature, proto_to_lsp_signature};
@@ -1984,46 +1986,67 @@ pub async fn location_links_from_lsp(
mut cx: AsyncApp,
) -> Result<Vec<LocationLink>> {
let unresolved_links = definition_locations_from_lsp(message);
-
let (_, language_server) = language_server_for_buffer(&lsp_store, &buffer, server_id, &mut cx)?;
- let mut definitions = Vec::new();
- for (origin_range, target_uri, target_range) in unresolved_links {
- let target_buffer_handle = lsp_store
- .update(&mut cx, |this, cx| {
- this.open_local_buffer_via_lsp(target_uri, language_server.server_id(), cx)
- })
- .await?;
-
- cx.update(|cx| {
- let origin_location = origin_range.map(|origin_range| {
- let origin_buffer = buffer.read(cx);
- let origin_range = range_from_lsp(origin_range);
- let origin_start = origin_buffer.clip_point_utf16(origin_range.start, Bias::Left);
- let origin_end = origin_buffer.clip_point_utf16(origin_range.end, Bias::Left);
- Location {
- buffer: buffer.clone(),
- range: origin_buffer.anchor_after(origin_start)
- ..origin_buffer.anchor_before(origin_end),
- }
- });
+ // Concurrent opens of the same file outside the project can each create an invisible
+ // worktree, producing duplicate buffers, so share one open per URI.
+ let mut buffer_tasks = HashMap::default();
+ let links = unresolved_links
+ .into_iter()
+ .map(|(origin_range, target_uri, target_range)| {
+ let target_buffer = buffer_tasks
+ .entry(target_uri.clone())
+ .or_insert_with(|| {
+ lsp_store
+ .update(&mut cx, |store, cx| {
+ store.open_local_buffer_via_lsp(
+ target_uri,
+ language_server.server_id(),
+ cx,
+ )
+ })
+ .map(|result| result.map_err(Arc::new))
+ .shared()
+ })
+ .clone();
+ let buffer = buffer.clone();
+ let cx = cx.clone();
+ async move {
+ let target_buffer_handle =
+ target_buffer.await.map_err(|error| (*error).cloned())?;
+ Ok(cx.update(|cx| {
+ let origin_location = origin_range.map(|origin_range| {
+ let origin_buffer = buffer.read(cx);
+ let origin_range = range_from_lsp(origin_range);
+ let origin_start =
+ origin_buffer.clip_point_utf16(origin_range.start, Bias::Left);
+ let origin_end =
+ origin_buffer.clip_point_utf16(origin_range.end, Bias::Left);
+ Location {
+ buffer: buffer.clone(),
+ range: origin_buffer.anchor_after(origin_start)
+ ..origin_buffer.anchor_before(origin_end),
+ }
+ });
- let target_buffer = target_buffer_handle.read(cx);
- let target_range = range_from_lsp(target_range);
- let target_start = target_buffer.clip_point_utf16(target_range.start, Bias::Left);
- let target_end = target_buffer.clip_point_utf16(target_range.end, Bias::Left);
- let target_location = Location {
- buffer: target_buffer_handle,
- range: target_buffer.anchor_after(target_start)
- ..target_buffer.anchor_before(target_end),
- };
+ let target_buffer = target_buffer_handle.read(cx);
+ let target_range = range_from_lsp(target_range);
+ let target_start =
+ target_buffer.clip_point_utf16(target_range.start, Bias::Left);
+ let target_end = target_buffer.clip_point_utf16(target_range.end, Bias::Left);
+ let target_location = Location {
+ buffer: target_buffer_handle,
+ range: target_buffer.anchor_after(target_start)
+ ..target_buffer.anchor_before(target_end),
+ };
- definitions.push(LocationLink {
- origin: origin_location,
- target: target_location,
- })
+ LocationLink {
+ origin: origin_location,
+ target: target_location,
+ }
+ }))
+ }
});
- }
- Ok(definitions)
+ stream::iter(links).buffered(16).try_collect().await
}
fn definition_locations_from_lsp(
@@ -2308,38 +2331,45 @@ impl LspCommand for GetReferences {
server_id: LanguageServerId,
mut cx: AsyncApp,
) -> Result<Vec<Location>> {
- let mut references = Vec::new();
let (_, language_server) =
language_server_for_buffer(&lsp_store, &buffer, server_id, &mut cx)?;
-
- if let Some(locations) = locations {
- for lsp_location in locations {
- let target_buffer_handle = lsp_store
- .update(&mut cx, |lsp_store, cx| {
- lsp_store.open_local_buffer_via_lsp(
- lsp_location.uri,
- language_server.server_id(),
- cx,
- )
- })
- .await?;
-
- target_buffer_handle
+ // See `location_links_from_lsp` for why opens are shared per URI.
+ let mut buffer_tasks = HashMap::default();
+ let references = locations.into_iter().flatten().map(|location| {
+ let target_buffer = buffer_tasks
+ .entry(location.uri.clone())
+ .or_insert_with(|| {
+ lsp_store
+ .update(&mut cx, |store, cx| {
+ store.open_local_buffer_via_lsp(
+ location.uri,
+ language_server.server_id(),
+ cx,
+ )
+ })
+ .map(|result| result.map_err(Arc::new))
+ .shared()
+ })
+ .clone();
+ let cx = cx.clone();
+ async move {
+ let target_buffer_handle =
+ target_buffer.await.map_err(|error| (*error).cloned())?;
+ Ok(target_buffer_handle
.clone()
.read_with(&cx, |target_buffer, _| {
- let range = range_from_lsp(lsp_location.range);
+ let range = range_from_lsp(location.range);
let target_start = target_buffer.clip_point_utf16(range.start, Bias::Left);
let target_end = target_buffer.clip_point_utf16(range.end, Bias::Left);
- references.push(Location {
+ Location {
buffer: target_buffer_handle,
range: target_buffer.anchor_after(target_start)
..target_buffer.anchor_before(target_end),
- });
- });
+ }
+ }))
}
- }
-
- Ok(references)
+ });
+ stream::iter(references).buffered(16).try_collect().await
}
fn to_proto(&self, project_id: u64, buffer: &Buffer) -> proto::GetReferences {
diff --git a/crates/project/src/lsp_store.rs b/crates/project/src/lsp_store.rs
index 7580df2345b..6b2e17957d6 100644
--- a/crates/project/src/lsp_store.rs
+++ b/crates/project/src/lsp_store.rs
@@ -8145,90 +8145,85 @@ impl LspStore {
.get_request_timeout()
});
- let mut did_resolve = false;
- if let Some((client, project_id)) = client {
- for completion_index in completion_indices {
- let server_id = {
- let completion = &completions.borrow()[completion_index];
- completion.source.server_id()
- };
- if let Some(server_id) = server_id {
- if !resolvable_servers.contains(&server_id) {
- continue;
- }
- if Self::resolve_completion_remote(
- project_id,
- server_id,
- buffer_id,
- completions.clone(),
- completion_index,
- client.clone(),
- )
- .await
- .log_err()
- .is_some()
- {
- did_resolve = true;
- }
- } else {
- resolve_word_completion(
- &buffer_snapshot,
- &mut completions.borrow_mut()[completion_index],
- );
- }
- }
- } else {
- for completion_index in completion_indices {
- let server_id = {
- let completion = &completions.borrow()[completion_index];
- completion.source.server_id()
- };
- if let Some(server_id) = server_id {
- if !resolvable_servers.contains(&server_id) {
- continue;
- }
- let server_and_adapter = lsp_store
- .read_with(cx, |lsp_store, _| {
- let server = lsp_store.language_server_for_id(server_id)?;
- let adapter =
- lsp_store.language_server_adapter_for_id(server.server_id())?;
- Some((server, adapter))
- })
- .ok()
- .flatten();
- let Some((server, adapter)) = server_and_adapter else {
- continue;
+ let resolutions = futures::stream::iter(completion_indices.into_iter().unique()).map(
+ |completion_index| {
+ let completions = completions.clone();
+ let resolvable_servers = resolvable_servers.clone();
+ let client = client.clone();
+ let lsp_store = lsp_store.clone();
+ let buffer_snapshot = buffer_snapshot.clone();
+ let mut cx = cx.clone();
+ async move {
+ let server_id = {
+ let completion = &completions.borrow()[completion_index];
+ completion.source.server_id()
};
-
- let resolved = Self::resolve_completion_local(
- server,
- completions.clone(),
- completion_index,
- request_timeout,
- true,
- )
- .await
- .log_err()
- .is_some();
- if resolved {
- Self::regenerate_completion_labels(
- adapter,
+ let Some(server_id) = server_id else {
+ resolve_word_completion(
&buffer_snapshot,
+ &mut completions.borrow_mut()[completion_index],
+ );
+ return false;
+ };
+ if !resolvable_servers.contains(&server_id) {
+ return false;
+ }
+ if let Some((client, project_id)) = client {
+ Self::resolve_completion_remote(
+ project_id,
+ server_id,
+ buffer_id,
+ completions,
+ completion_index,
+ client,
+ )
+ .await
+ .log_err()
+ .is_some()
+ } else {
+ let server_and_adapter = lsp_store
+ .read_with(&mut cx, |lsp_store, _| {
+ let server = lsp_store.language_server_for_id(server_id)?;
+ let adapter = lsp_store
+ .language_server_adapter_for_id(server.server_id())?;
+ Some((server, adapter))
+ })
+ .ok()
+ .flatten();
+ let Some((server, adapter)) = server_and_adapter else {
+ return false;
+ };
+ let resolved = Self::resolve_completion_local(
+ server,
completions.clone(),
completion_index,
+ request_timeout,
+ true,
)
.await
- .log_err();
- did_resolve = true;
+ .log_err()
+ .is_some();
+ if resolved {
+ Self::regenerate_completion_labels(
+ adapter,
+ &buffer_snapshot,
+ completions,
+ completion_index,
+ )
+ .await
+ .log_err();
+ }
+ resolved
}
- } else {
- resolve_word_completion(
- &buffer_snapshot,
- &mut completions.borrow_mut()[completion_index],
- );
}
- }
- }
+ },
+ );
+ let did_resolve = resolutions
+ .buffer_unordered(16)
+ .fold(false, |did_resolve, resolved| async move {
+ did_resolve || resolved
+ })
+ .await;
Ok(did_resolve)
})
diff --git a/crates/project/tests/integration/lsp_command.rs b/crates/project/tests/integration/lsp_command.rs
index fbfcb7311a8..9f76f6c0c2c 100644
--- a/crates/project/tests/integration/lsp_command.rs
+++ b/crates/project/tests/integration/lsp_command.rs
@@ -163,3 +163,208 @@ fn test_invalid_ranges() {
let result = GetDocumentDiagnostics::deserialize_lsp_diagnostic(proto_diagnostic);
assert!(result.is_err());
}
+
+#[gpui::test(iterations = 10)]
+async fn test_definitions_load_independent_targets_concurrently(cx: &mut gpui::TestAppContext) {
+ check_navigation_loads_independent_targets_concurrently(false, cx).await;
+}
+
+#[gpui::test(iterations = 10)]
+async fn test_references_load_independent_targets_concurrently(cx: &mut gpui::TestAppContext) {
+ check_navigation_loads_independent_targets_concurrently(true, cx).await;
+}
+
+async fn check_navigation_loads_independent_targets_concurrently(
+ references: bool,
+ cx: &mut gpui::TestAppContext,
+) {
+ use crate::init_test;
+ use fs::FakeFs;
+ use futures::{FutureExt as _, StreamExt as _};
+ use language::{FakeLspAdapter, OffsetRangeExt as _, rust_lang};
+ use project::Project;
+ use std::time::Duration;
+ use util::path;
+
+ init_test(cx);
+ let fs = FakeFs::new(cx.executor());
+ fs.insert_tree(
+ path!("/dir"),
+ json!({
+ "main.rs": "fn main() {}",
+ "first.rs": "pub fn first() {}",
+ "second.rs": "pub fn second() {}",
+ "third.rs": "pub fn third() {}",
+ }),
+ )
+ .await;
+ let root = path!("/dir/main.rs");
+ let project = Project::test(fs.clone(), [root.as_ref()], cx).await;
+ let registry = project.read_with(cx, |project, _| project.languages().clone());
+ registry.add(rust_lang());
+ let mut servers = registry.register_fake_lsp(
+ "Rust",
+ FakeLspAdapter {
+ capabilities: lsp::ServerCapabilities {
+ references_provider: Some(lsp::OneOf::Left(true)),
+ ..lsp::LanguageServer::full_capabilities()
+ },
+ ..Default::default()
+ },
+ );
+ let (buffer, _handle) = project
+ .update(cx, |project, cx| {
+ project.open_local_buffer_with_lsp(path!("/dir/main.rs"), cx)
+ })
+ .await
+ .unwrap();
+ let server = servers.next().await.unwrap();
+ cx.run_until_parked();
+ let server_id = project.read_with(cx, |project, cx| {
+ project
+ .lsp_store()
+ .read(cx)
+ .language_server_statuses()
+ .next()
+ .unwrap()
+ .0
+ });
+
+ let names = ["third.rs", "first.rs", "second.rs", "first.rs"];
+ for name in names {
+ fs.set_load_delay(
+ std::path::Path::new(path!("/dir")).join(name),
+ Duration::from_millis(40),
+ );
+ }
+ let locations = names
+ .into_iter()
+ .map(|name| {
+ lsp::Location::new(
+ lsp::Uri::from_file_path(std::path::Path::new(path!("/dir")).join(name)).unwrap(),
+ lsp::Range::new(lsp::Position::new(0, 7), lsp::Position::new(0, 9)),
+ )
+ })
+ .collect::<Vec<_>>();
+ let store = project.read_with(cx, |project, _| project.lsp_store());
+ server.set_request_handler::<lsp::request::References, _, _>({
+ let locations = locations.clone();
+ move |_, _| {
+ let locations = locations.clone();
+ async move { Ok(Some(locations)) }
+ }
+ });
+ let mut task = cx.spawn({
+ let buffer = buffer.clone();
+ let project = project.clone();
+ async move |mut cx| {
+ if references {
+ project
+ .update(&mut cx, |project, cx| project.references(&buffer, 0, cx))
+ .await
+ .map(|locations| locations.unwrap())
+ } else {
+ location_links_from_lsp(
+ Some(lsp::GotoDefinitionResponse::Link(
+ locations
+ .into_iter()
+ .map(|location| lsp::LocationLink {
+ origin_selection_range: Some(lsp::Range::new(
+ lsp::Position::new(0, 3),
+ lsp::Position::new(0, 5),
+ )),
+ target_uri: location.uri,
+ target_range: lsp::Range::new(
+ lsp::Position::new(0, 0),
+ lsp::Position::new(0, 16),
+ ),
+ target_selection_range: location.range,
+ })
+ .collect(),
+ )),
+ store,
+ buffer,
+ server_id,
+ cx.clone(),
+ )
+ .await
+ .map(|links| {
+ for link in &links {
+ let origin = link.origin.as_ref().unwrap();
+ origin.buffer.read_with(&cx, |buffer, _| {
+ assert_eq!(origin.range.to_offset(buffer), 3..5);
+ });
+ }
+ links.into_iter().map(|link| link.target).collect()
+ })
+ }
+ }
+ });
+ cx.run_until_parked();
+ let mut elapsed_ms = 0;
+ let locations = loop {
+ cx.executor().advance_clock(Duration::from_millis(40));
+ elapsed_ms += 40;
+ cx.run_until_parked();
+ if let Some(locations) = (&mut task).now_or_never() {
+ break locations.unwrap();
+ }
+ assert!(elapsed_ms < 400, "navigation did not finish");
+ };
+ assert_eq!(elapsed_ms, 40, "independent target reads must overlap");
+ assert_eq!(locations.len(), names.len());
+ for (location, name) in locations.iter().zip(names) {
+ location.buffer.read_with(cx, |buffer, cx| {
+ assert_eq!(
+ buffer
+ .file()
+ .unwrap()
+ .as_local()
+ .unwrap()
+ .abs_path(cx)
+ .file_name()
+ .unwrap(),
+ name
+ );
+ assert_eq!(location.range.to_offset(buffer), 7..9);
+ });
+ }
+ assert_eq!(locations[1].buffer, locations[3].buffer);
+ cx.run_until_parked();
+ assert!(
+ servers.try_recv().is_err(),
+ "target files must reuse the language server"
+ );
+ drop(task);
+ cx.update(|_| drop(locations));
+ cx.run_until_parked();
+ assert_eq!(
+ project.read_with(cx, |project, cx| project.worktrees(cx).count()),
+ 1
+ );
+ if !references {
+ let store = project.read_with(cx, |project, _| project.lsp_store());
+ let result = cx
+ .spawn(async move |cx| {
+ location_links_from_lsp(
+ Some(lsp::GotoDefinitionResponse::Array(vec![
+ lsp::Location::new(
+ lsp::Uri::from_str("https://example.invalid/unsupported.rs").unwrap(),
+ lsp::Range::default(),
+ ),
+ ])),
+ store,
+ buffer,
+ server_id,
+ cx,
+ )
+ .await
+ })
+ .await;
+ assert!(
+ result.is_err(),
+ "invalid target errors must reach the caller"
+ );
+ }
+ drop(server);
+}
diff --git a/crates/project/tests/integration/lsp_store.rs b/crates/project/tests/integration/lsp_store.rs
index 3bfeb1aa2f3..b94bd2c2502 100644
--- a/crates/project/tests/integration/lsp_store.rs
+++ b/crates/project/tests/integration/lsp_store.rs
@@ -1248,3 +1248,157 @@ fn worktree_entries(project: &Entity<Project>, cx: &TestAppContext) -> Vec<Strin
.collect()
})
}
+
+#[gpui::test(iterations = 10)]
+async fn test_resolve_completions_concurrently(cx: &mut TestAppContext) {
+ check_resolve_completions_concurrently(3, false, cx).await;
+}
+
+#[gpui::test(iterations = 10)]
+async fn test_resolve_completions_concurrently_limits_requests(cx: &mut TestAppContext) {
+ check_resolve_completions_concurrently(20, false, cx).await;
+}
+
+#[gpui::test(iterations = 10)]
+async fn test_resolve_completions_concurrently_preserves_successes_after_error(
+ cx: &mut TestAppContext,
+) {
+ check_resolve_completions_concurrently(3, true, cx).await;
+}
+
+async fn check_resolve_completions_concurrently(
+ count: usize,
+ fail_one: bool,
+ cx: &mut TestAppContext,
+) {
+ use futures::FutureExt as _;
+ use project::{CompletionSource, DEFAULT_COMPLETION_CONTEXT};
+ use std::{
+ cell::RefCell,
+ rc::Rc,
+ sync::{
+ Arc,
+ atomic::{AtomicUsize, Ordering},
+ },
+ time::Duration,
+ };
+
+ init_test(cx);
+ let fs = FakeFs::new(cx.executor());
+ fs.insert_tree(path!("/dir"), json!({"main.rs": ""})).await;
+ let project = Project::test(fs, [path!("/dir").as_ref()], cx).await;
+ let registry = project.read_with(cx, |project, _| project.languages().clone());
+ registry.add(rust_lang());
+ let mut servers = registry.register_fake_lsp(
+ "Rust",
+ FakeLspAdapter {
+ capabilities: lsp::ServerCapabilities {
+ completion_provider: Some(lsp::CompletionOptions {
+ resolve_provider: Some(true),
+ ..Default::default()
+ }),
+ ..Default::default()
+ },
+ ..Default::default()
+ },
+ );
+ let (buffer, _handle) = project
+ .update(cx, |project, cx| {
+ project.open_local_buffer_with_lsp(path!("/dir/main.rs"), cx)
+ })
+ .await
+ .unwrap();
+ let server = servers.next().await.unwrap();
+ cx.run_until_parked();
+ server.set_request_handler::<lsp::request::Completion, _, _>(move |_, _| async move {
+ Ok(Some(lsp::CompletionResponse::Array(
+ (0..count)
+ .map(|index| lsp::CompletionItem {
+ label: format!("item_{index}"),
+ ..Default::default()
+ })
+ .collect(),
+ )))
+ });
+ let completions = project
+ .update(cx, |project, cx| {
+ project.completions(&buffer, 0, DEFAULT_COMPLETION_CONTEXT, cx)
+ })
+ .await
+ .unwrap()
+ .into_iter()
+ .flat_map(|response| response.completions)
+ .collect::<Vec<_>>();
+ let completions = Rc::new(RefCell::new(completions.into_boxed_slice()));
+ assert_eq!(completions.borrow().len(), count);
+ let active = Arc::new(AtomicUsize::new(0));
+ let peak = Arc::new(AtomicUsize::new(0));
+ let requests = Arc::new(AtomicUsize::new(0));
+ server.set_request_handler::<lsp::request::ResolveCompletionItem, _, _>({
+ let peak = peak.clone();
+ let requests = requests.clone();
+ move |mut item, cx| {
+ let active = active.clone();
+ let peak = peak.clone();
+ let requests = requests.clone();
+ async move {
+ requests.fetch_add(1, Ordering::SeqCst);
+ let count = active.fetch_add(1, Ordering::SeqCst) + 1;
+ peak.fetch_max(count, Ordering::SeqCst);
+ let _guard = util::defer(move || {
+ active.fetch_sub(1, Ordering::SeqCst);
+ });
+ cx.background_executor()
+ .timer(Duration::from_millis(40))
+ .await;
+ anyhow::ensure!(!fail_one || item.label != "item_1", "test resolve failure");
+ item.detail = Some(format!("resolved {}", item.label));
+ Ok(item)
+ }
+ }
+ });
+ let store = project.read_with(cx, |project, _| project.lsp_store());
+ let mut task = store.update(cx, |store, cx| {
+ let indices = (0..count).chain(0..count).collect();
+ store.resolve_completions(buffer, indices, completions.clone(), cx)
+ });
+ cx.run_until_parked();
+ let mut elapsed_ms = 0;
+ let did_resolve = loop {
+ cx.executor().advance_clock(Duration::from_millis(40));
+ elapsed_ms += 40;
+ cx.run_until_parked();
+ if let Some(result) = (&mut task).now_or_never() {
+ break result.unwrap();
+ }
+ assert!(elapsed_ms < 400, "completion resolution did not finish");
+ };
+ assert_eq!(
+ elapsed_ms,
+ 40 * count.div_ceil(16),
+ "independent resolve requests must overlap"
+ );
+ assert_eq!(peak.load(Ordering::SeqCst), count.min(16));
+ assert_eq!(requests.load(Ordering::SeqCst), count);
+ assert!(did_resolve);
+ for completion in completions.borrow().iter() {
+ let CompletionSource::Lsp {
+ lsp_completion,
+ resolved,
+ ..
+ } = &completion.source
+ else {
+ panic!("expected an LSP completion");
+ };
+ if fail_one && lsp_completion.label == "item_1" {
+ assert!(!*resolved);
+ assert!(lsp_completion.detail.is_none());
+ continue;
+ }
+ assert!(*resolved);
+ assert_eq!(
+ lsp_completion.detail,
+ Some(format!("resolved {}", lsp_completion.label))
+ );
+ }
+}