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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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))+ );+ }+}