Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.
Revert "Reduce waits for navigation, suggestions, and file comparisons (#66487)" (#66517)
Piotr Osiewiczba36af2050bd
diff --git a/crates/fs/src/fs.rs b/crates/fs/src/fs.rsindex a61a995ef3e..e6ef06beb70 100644--- a/crates/fs/src/fs.rs+++ b/crates/fs/src/fs.rs@@ -1471,7 +1471,6 @@ 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,}@@ -1868,7 +1867,6 @@ 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(@@ -2041,21 +2039,10 @@ 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 6e51148deeb..15f296a4113 100644--- a/crates/git_ui/src/multi_diff_view.rs+++ b/crates/git_ui/src/multi_diff_view.rs@@ -4,7 +4,6 @@ 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,@@ -47,37 +46,30 @@ async fn load_entries(project: &Entity<Project>,cx: &mut AsyncApp,) -> Result<(Vec<Entry>, Option<PathBuf>)> {- 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 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 common_root = common_prefix(&all_paths);Ok((entries, common_root))@@ -400,78 +392,14 @@ 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 830d3998bd5..d5fa761b8ff 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));- 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 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 buffer_diff = build_buffer_diff(&old_buffer, &new_buffer, cx).await?;@@ -489,52 +489,6 @@ 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 b0d6d40bc1e..d8b973cf15f 100644--- a/crates/project/src/lsp_command.rs+++ b/crates/project/src/lsp_command.rs@@ -13,7 +13,6 @@ 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,@@ -32,7 +31,6 @@ 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};@@ -1986,67 +1984,46 @@ 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)?;- // 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 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?;- 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),- };+ 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),+ }+ });- LocationLink {- origin: origin_location,- target: target_location,- }- }))- }+ 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,+ })});- stream::iter(links).buffered(16).try_collect().await+ }+ Ok(definitions)}fn definition_locations_from_lsp(@@ -2331,45 +2308,38 @@ 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)?;- // 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++ 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.clone().read_with(&cx, |target_buffer, _| {- let range = range_from_lsp(location.range);+ let range = range_from_lsp(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);- Location {+ references.push(Location {buffer: target_buffer_handle,range: target_buffer.anchor_after(target_start)..target_buffer.anchor_before(target_end),- }- }))+ });+ });}- });- stream::iter(references).buffered(16).try_collect().await+ }++ Ok(references)}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 6b2e17957d6..7580df2345b 100644--- a/crates/project/src/lsp_store.rs+++ b/crates/project/src/lsp_store.rs@@ -8145,85 +8145,90 @@ impl LspStore {.get_request_timeout()});- 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 Some(server_id) = server_id else {- resolve_word_completion(- &buffer_snapshot,- &mut completions.borrow_mut()[completion_index],- );- return false;- };+ 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) {- return false;+ continue;}- 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,+ 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 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,+ &buffer_snapshot,completions.clone(),completion_index,- request_timeout,- true,).await- .log_err()- .is_some();- if resolved {- Self::regenerate_completion_labels(- adapter,- &buffer_snapshot,- completions,- completion_index,- )- .await- .log_err();- }- resolved+ .log_err();+ did_resolve = true;}+ } 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 9f76f6c0c2c..fbfcb7311a8 100644--- a/crates/project/tests/integration/lsp_command.rs+++ b/crates/project/tests/integration/lsp_command.rs@@ -163,208 +163,3 @@ 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 b94bd2c2502..3bfeb1aa2f3 100644--- a/crates/project/tests/integration/lsp_store.rs+++ b/crates/project/tests/integration/lsp_store.rs@@ -1248,157 +1248,3 @@ 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))- );- }-}