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.

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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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))
- );
- }
-}