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.

Fix code lens not being resolved in remote workflows (#59999)

Kirill Bulatov0deb6c0deaa9
diff --git a/Cargo.lock b/Cargo.lock
index ad39bf4af7b..f43363e23c2 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -15171,6 +15171,7 @@ dependencies = [
"uuid",
"watch",
"windows 0.61.3",
+ "workspace",
"worktree",
"zlog",
]
diff --git a/crates/collab/src/rpc.rs b/crates/collab/src/rpc.rs
index e74aea147da..074735d82d2 100644
--- a/crates/collab/src/rpc.rs
+++ b/crates/collab/src/rpc.rs
@@ -363,6 +363,7 @@ impl Server {
.add_request_handler(forward_read_only_project_request::<proto::OpenBufferById>)
.add_request_handler(forward_read_only_project_request::<proto::SynchronizeBuffers>)
.add_request_handler(forward_read_only_project_request::<proto::ResolveInlayHint>)
+ .add_request_handler(forward_read_only_project_request::<proto::ResolveCodeAction>)
.add_request_handler(forward_read_only_project_request::<proto::ResolveDocumentLink>)
.add_request_handler(forward_read_only_project_request::<proto::GetColorPresentation>)
.add_request_handler(forward_read_only_project_request::<proto::OpenBufferByPath>)
diff --git a/crates/collab/tests/integration/editor_tests.rs b/crates/collab/tests/integration/editor_tests.rs
index e4e8fbfae01..142c00cff5d 100644
--- a/crates/collab/tests/integration/editor_tests.rs
+++ b/crates/collab/tests/integration/editor_tests.rs
@@ -10,6 +10,7 @@ use editor::{
CopyFileName, CopyFileNameWithoutExtension, ExpandMacroRecursively, MoveToEnd, Redo,
Rename, SelectAll, ToggleCodeActions, Undo,
},
+ code_context_menus::CodeContextMenu,
test::{
editor_test_context::{AssertionContextManager, EditorTestContext},
expand_macro_recursively,
@@ -1411,6 +1412,142 @@ async fn test_slow_lsp_server(cx_a: &mut TestAppContext, cx_b: &mut TestAppConte
)
}
+#[gpui::test]
+async fn test_collaborating_with_code_lens_resolve(
+ cx_a: &mut TestAppContext,
+ cx_b: &mut TestAppContext,
+) {
+ let mut server = TestServer::start(cx_a.executor()).await;
+ let client_a = server.create_client(cx_a, "user_a").await;
+ let client_b = server.create_client(cx_b, "user_b").await;
+ server
+ .create_room(&mut [(&client_a, cx_a), (&client_b, cx_b)])
+ .await;
+ let active_call_a = cx_a.read(ActiveCall::global);
+ cx_b.update(editor::init);
+ cx_b.update(|cx| {
+ SettingsStore::update_global(cx, |store, cx| {
+ store.update_user_settings(cx, |settings| {
+ settings.editor.code_lens = Some(settings::CodeLens::Menu);
+ });
+ });
+ });
+
+ let capabilities = lsp::ServerCapabilities {
+ code_lens_provider: Some(lsp::CodeLensOptions {
+ resolve_provider: Some(true),
+ }),
+ ..lsp::ServerCapabilities::default()
+ };
+ client_a.language_registry().add(rust_lang());
+ client_a.language_registry().register_fake_lsp(
+ "Rust",
+ FakeLspAdapter {
+ capabilities: capabilities.clone(),
+ initializer: Some(Box::new(|fake_lsp| {
+ fake_lsp.set_request_handler::<lsp::request::CodeLensRequest, _, _>(
+ |_, _| async move {
+ Ok(Some(vec![lsp::CodeLens {
+ range: lsp::Range::new(
+ lsp::Position::new(0, 0),
+ lsp::Position::new(0, 9),
+ ),
+ command: None,
+ data: Some(serde_json::json!({ "id": "lens" })),
+ }]))
+ },
+ );
+ fake_lsp.set_request_handler::<lsp::request::CodeLensResolve, _, _>(
+ |lens, _| async move {
+ Ok(lsp::CodeLens {
+ command: Some(lsp::Command {
+ title: "1 reference".to_string(),
+ command: "noop".to_string(),
+ arguments: None,
+ }),
+ ..lens
+ })
+ },
+ );
+ })),
+ ..FakeLspAdapter::default()
+ },
+ );
+ client_b.language_registry().add(rust_lang());
+ client_b.language_registry().register_fake_lsp_adapter(
+ "Rust",
+ FakeLspAdapter {
+ capabilities,
+ ..FakeLspAdapter::default()
+ },
+ );
+
+ client_a
+ .fs()
+ .insert_tree(
+ path!("/dir"),
+ json!({
+ "one.rs": "const ONE: usize = 1;"
+ }),
+ )
+ .await;
+ let (project_a, worktree_id) = client_a.build_local_project(path!("/dir"), cx_a).await;
+ let project_id = active_call_a
+ .update(cx_a, |call, cx| call.share_project(project_a.clone(), cx))
+ .await
+ .unwrap();
+ let project_b = client_b.join_remote_project(project_id, cx_b).await;
+
+ let (workspace_b, cx_b) = client_b.build_workspace(&project_b, cx_b);
+ let editor_b = workspace_b
+ .update_in(cx_b, |workspace, window, cx| {
+ workspace.open_path((worktree_id, rel_path("one.rs")), None, true, window, cx)
+ })
+ .await
+ .unwrap()
+ .downcast::<Editor>()
+ .unwrap();
+ cx_a.run_until_parked();
+ cx_b.run_until_parked();
+
+ editor_b.update_in(cx_b, |editor, window, cx| {
+ editor.change_selections(SelectionEffects::no_scroll(), window, cx, |s| {
+ s.select_ranges([Point::new(0, 0)..Point::new(0, 0)]);
+ });
+ });
+ cx_a.background_executor
+ .advance_clock(editor::CODE_ACTIONS_DEBOUNCE_TIMEOUT * 2);
+ cx_a.run_until_parked();
+ cx_b.run_until_parked();
+
+ editor_b.update_in(cx_b, |editor, window, cx| {
+ editor.toggle_code_actions(
+ &ToggleCodeActions {
+ deployed_from: None,
+ quick_launch: false,
+ },
+ window,
+ cx,
+ );
+ });
+ cx_a.run_until_parked();
+ cx_b.run_until_parked();
+
+ editor_b.update(cx_b, |editor, _| {
+ assert!(editor.context_menu_visible());
+ let menu = editor.context_menu().borrow();
+ let actions_menu = match menu.as_ref() {
+ Some(CodeContextMenu::CodeActions(m)) => m,
+ _ => panic!("Expected code actions menu to be visible"),
+ };
+ let item = actions_menu
+ .actions
+ .get(0)
+ .expect("Expected at least one item in menu");
+ assert_eq!(item.label(), "1 reference");
+ });
+}
+
#[gpui::test(iterations = 10)]
async fn test_language_server_statuses(cx_a: &mut TestAppContext, cx_b: &mut TestAppContext) {
let mut server = TestServer::start(cx_a.executor()).await;
diff --git a/crates/project/src/lsp_store.rs b/crates/project/src/lsp_store.rs
index 24df7f5434a..feb1936c47a 100644
--- a/crates/project/src/lsp_store.rs
+++ b/crates/project/src/lsp_store.rs
@@ -4218,6 +4218,7 @@ impl LspStore {
client.add_entity_request_handler(Self::handle_apply_code_action);
client.add_entity_request_handler(Self::handle_get_project_symbols);
client.add_entity_request_handler(Self::handle_resolve_inlay_hint);
+ client.add_entity_request_handler(Self::handle_resolve_code_action);
client.add_entity_request_handler(Self::handle_resolve_document_link);
client.add_entity_request_handler(Self::handle_get_color_presentation);
client.add_entity_request_handler(Self::handle_open_buffer_for_symbol);
@@ -5710,6 +5711,73 @@ impl LspStore {
}
}
+ pub fn resolve_code_action(
+ &self,
+ buffer: &Entity<Buffer>,
+ mut action: CodeAction,
+ cx: &mut Context<Self>,
+ ) -> Task<Result<CodeAction>> {
+ if action.resolved {
+ return Task::ready(Ok(action));
+ }
+ if let Some((upstream_client, project_id)) = self.upstream_client() {
+ let request = proto::ResolveCodeAction {
+ project_id,
+ buffer_id: buffer.read(cx).remote_id().into(),
+ action: Some(Self::serialize_code_action(&action)),
+ };
+ cx.background_spawn(async move {
+ let response = upstream_client
+ .request(request)
+ .await
+ .context("resolve code action proto request")?;
+ let action = response.action.context("missing resolved action")?;
+ Self::deserialize_code_action(action)
+ })
+ } else if self.mode.is_local() {
+ let server_id = action.server_id;
+ let Some(lang_server) = buffer.update(cx, |buffer, cx| {
+ self.language_server_for_local_buffer(buffer, server_id, cx)
+ .map(|(_, server)| server.clone())
+ }) else {
+ return Task::ready(Ok(action));
+ };
+ let request_timeout = ProjectSettings::get_global(cx)
+ .global_lsp_settings
+ .get_request_timeout();
+ cx.background_spawn(async move {
+ LocalLspStore::try_resolve_code_action(&lang_server, &mut action, request_timeout)
+ .await
+ .context("resolving a code action")?;
+ Ok(action)
+ })
+ } else {
+ Task::ready(Err(anyhow!("no upstream client and not local")))
+ }
+ }
+
+ pub(super) async fn handle_resolve_code_action(
+ lsp_store: Entity<Self>,
+ envelope: TypedEnvelope<proto::ResolveCodeAction>,
+ mut cx: AsyncApp,
+ ) -> Result<proto::ResolveCodeActionResponse> {
+ let action =
+ Self::deserialize_code_action(envelope.payload.action.context("invalid action")?)?;
+ let buffer = lsp_store.update(&mut cx, |lsp_store, cx| {
+ let buffer_id = BufferId::new(envelope.payload.buffer_id)?;
+ lsp_store.buffer_store.read(cx).get_existing(buffer_id)
+ })?;
+ let resolved = lsp_store
+ .update(&mut cx, |lsp_store, cx| {
+ lsp_store.resolve_code_action(&buffer, action, cx)
+ })
+ .await
+ .context("resolving code action")?;
+ Ok(proto::ResolveCodeActionResponse {
+ action: Some(Self::serialize_code_action(&resolved)),
+ })
+ }
+
pub fn apply_code_action_kind(
&mut self,
buffers: HashSet<Entity<Buffer>>,
diff --git a/crates/project/src/lsp_store/code_lens.rs b/crates/project/src/lsp_store/code_lens.rs
index f21fb2ebb6b..6616e4f8a42 100644
--- a/crates/project/src/lsp_store/code_lens.rs
+++ b/crates/project/src/lsp_store/code_lens.rs
@@ -3,7 +3,7 @@ use std::sync::Arc;
use anyhow::{Context as _, Result};
use clock::Global;
-use collections::HashMap;
+use collections::{HashMap, HashSet};
use futures::{
FutureExt as _,
future::{Shared, join_all},
@@ -122,21 +122,23 @@ impl LspStore {
) -> CodeLensTask {
let version_queried_for = buffer.read(cx).version();
let buffer_id = buffer.read(cx).remote_id();
- let existing_servers = self.as_local().map(|local| {
+ let existing_servers = if let Some(local) = self.as_local() {
local
.buffers_opened_in_servers
.get(&buffer_id)
.cloned()
.unwrap_or_default()
- });
+ } else {
+ self.relevant_server_ids_for_capability_check(buffer, cx)
+ .into_iter()
+ .collect()
+ };
if let Some(lsp_data) = self.current_lsp_data(buffer_id) {
if let Some(cached_lens) = &lsp_data.code_lens {
if !version_queried_for.changed_since(&lsp_data.buffer_version) {
- let has_different_servers = existing_servers.is_some_and(|existing_servers| {
- existing_servers != cached_lens.lens.keys().copied().collect()
- });
- if !has_different_servers {
+ let cached_servers = cached_lens.lens.keys().copied().collect::<HashSet<_>>();
+ if existing_servers == cached_servers {
return Task::ready(Ok(Some(flatten_cache(&cached_lens.lens)))).shared();
}
} else if let Some((updating_for, running_update)) = cached_lens.update.as_ref() {
@@ -304,7 +306,7 @@ impl LspStore {
/// `(id, resolved_action)` pair is returned.
///
/// All visibility / batching policy lives in the caller. Remote (proto)
- /// resolves are not yet supported and currently yield `None`.
+ /// resolves are forwarded to the host via [`Self::resolve_code_action`].
pub fn resolve_code_lens(
&mut self,
buffer: &Entity<Buffer>,
@@ -339,6 +341,47 @@ impl LspStore {
return Task::ready(None).shared();
};
let lens = lens.clone();
+ let action = cached.clone();
+
+ if self.upstream_client().is_some() {
+ if !self.check_if_capable_for_proto_request(buffer, GetCodeLens::can_resolve_lens, cx) {
+ return Task::ready(None).shared();
+ }
+ let resolve = self.resolve_code_action(buffer, action, cx);
+ let task = cx
+ .spawn(async move |lsp_store, cx| {
+ let resolved = resolve
+ .await
+ .context("resolving remote code lens")
+ .log_err()?;
+ lsp_store
+ .update(cx, |lsp_store, _| {
+ let code_lens = lsp_store
+ .lsp_data
+ .get_mut(&buffer_id)
+ .and_then(|data| data.code_lens.as_mut())?;
+ code_lens.resolving.remove(&key);
+ let action = code_lens
+ .lens
+ .get_mut(&server_id)
+ .and_then(|cache| cache.get_mut(&lens_id))?;
+ action.resolved = true;
+ action.lsp_action = resolved.lsp_action;
+ Some((lens_id, action.clone()))
+ })
+ .ok()
+ .flatten()
+ })
+ .shared();
+ if let Some(code_lens) = self
+ .lsp_data
+ .get_mut(&buffer_id)
+ .and_then(|data| data.code_lens.as_mut())
+ {
+ code_lens.resolving.insert(key, task.clone());
+ }
+ return task;
+ }
let Some(server) = self.language_server_for_id(server_id) else {
return Task::ready(None).shared();
diff --git a/crates/proto/proto/lsp.proto b/crates/proto/proto/lsp.proto
index 2c91b41f634..33198b30acd 100644
--- a/crates/proto/proto/lsp.proto
+++ b/crates/proto/proto/lsp.proto
@@ -378,6 +378,16 @@ message ApplyCodeAction {
CodeAction action = 3;
}
+message ResolveCodeAction {
+ uint64 project_id = 1;
+ uint64 buffer_id = 2;
+ CodeAction action = 3;
+}
+
+message ResolveCodeActionResponse {
+ CodeAction action = 1;
+}
+
message ApplyCodeActionResponse {
ProjectTransaction transaction = 1;
}
diff --git a/crates/proto/proto/zed.proto b/crates/proto/proto/zed.proto
index f87c0444c68..2a196e86e86 100644
--- a/crates/proto/proto/zed.proto
+++ b/crates/proto/proto/zed.proto
@@ -487,7 +487,9 @@ message Envelope {
ResolveDocumentLinkResponse resolve_document_link_response = 456;
GitWorktreeCreatedAt git_worktree_created_at = 457;
GitWorktreeCreatedAtResponse git_worktree_created_at_response = 458;
- TelemetryEvent telemetry_event = 459; // current max
+ TelemetryEvent telemetry_event = 459;
+ ResolveCodeAction resolve_code_action = 460;
+ ResolveCodeActionResponse resolve_code_action_response = 461; // current max
}
reserved 87 to 88;
diff --git a/crates/proto/src/proto.rs b/crates/proto/src/proto.rs
index 89867785537..b998300f065 100644
--- a/crates/proto/src/proto.rs
+++ b/crates/proto/src/proto.rs
@@ -233,6 +233,8 @@ messages!(
(RefreshCodeLens, Background),
(GetCodeLens, Background),
(GetCodeLensResponse, Background),
+ (ResolveCodeAction, Background),
+ (ResolveCodeActionResponse, Background),
(RespondToChannelInvite, Foreground),
(RespondToContactRequest, Foreground),
(RestartLanguageServers, Foreground),
@@ -472,6 +474,7 @@ request_messages!(
ResolveCompletionDocumentationResponse
),
(ResolveInlayHint, ResolveInlayHintResponse),
+ (ResolveCodeAction, ResolveCodeActionResponse),
(GetDocumentColor, GetDocumentColorResponse),
(GetDocumentLinks, GetDocumentLinksResponse),
(ResolveDocumentLink, ResolveDocumentLinkResponse),
@@ -687,6 +690,7 @@ entity_messages!(
RenameProjectEntry,
ResolveCompletionDocumentation,
ResolveInlayHint,
+ ResolveCodeAction,
SaveBuffer,
Stage,
StartLanguageServer,
diff --git a/crates/remote_server/Cargo.toml b/crates/remote_server/Cargo.toml
index 66cb46688ec..89b0dfef67d 100644
--- a/crates/remote_server/Cargo.toml
+++ b/crates/remote_server/Cargo.toml
@@ -97,17 +97,18 @@ fs = { workspace = true, features = ["test-support"] }
gpui = { workspace = true, features = ["test-support"] }
http_client = { workspace = true, features = ["test-support"] }
language = { workspace = true, features = ["test-support"] }
+language_model = { workspace = true, features = ["test-support"] }
+lsp = { workspace = true, features = ["test-support"] }
node_runtime = { workspace = true, features = ["test-support"] }
pretty_assertions.workspace = true
project = { workspace = true, features = ["test-support"] }
remote = { workspace = true, features = ["test-support"] }
-theme_settings.workspace = true
-theme = { workspace = true, features = ["test-support"] }
-language_model = { workspace = true, features = ["test-support"] }
-lsp = { workspace = true, features = ["test-support"] }
-unindent.workspace = true
serde_json.workspace = true
tempfile.workspace = true
+theme = { workspace = true, features = ["test-support"] }
+theme_settings.workspace = true
+unindent.workspace = true
+workspace = { workspace = true, features = ["test-support"] }
zlog.workspace = true
[build-dependencies]
diff --git a/crates/remote_server/src/remote_editing_tests.rs b/crates/remote_server/src/remote_editing_tests.rs
index 0233057260a..cd70c9c2914 100644
--- a/crates/remote_server/src/remote_editing_tests.rs
+++ b/crates/remote_server/src/remote_editing_tests.rs
@@ -13,16 +13,21 @@ use collections::{HashMap, HashSet};
use language_model::{LanguageModelRegistry, LanguageModelToolResultContent};
use languages::rust_lang;
+use editor::{
+ Editor, SelectionEffects,
+ actions::{ConfirmCodeAction, ToggleCodeActions},
+ code_context_menus::CodeContextMenu,
+};
use extension::ExtensionHostProxy;
use fs::{FakeFs, Fs};
use git::{
Oid,
repository::{CommitData, Worktree as GitWorktree},
};
-use gpui::{AppContext as _, Entity, SharedString, TestAppContext};
+use gpui::{AppContext as _, Entity, SharedString, TestAppContext, UpdateGlobal, VisualContext};
use http_client::{BlockedHttpClient, FakeHttpClient};
use language::{
- Buffer, FakeLspAdapter, LanguageConfig, LanguageMatcher, LanguageRegistry, LineEnding,
+ Buffer, FakeLspAdapter, LanguageConfig, LanguageMatcher, LanguageRegistry, LineEnding, Point,
language_settings::{AllLanguageSettings, LanguageSettings},
};
use lsp::{
@@ -882,6 +887,465 @@ async fn test_remote_lsp(cx: &mut TestAppContext, server_cx: &mut TestAppContext
})
}
+#[gpui::test]
+async fn test_remote_code_action_resolve(cx: &mut TestAppContext, server_cx: &mut TestAppContext) {
+ cx.update(|cx| {
+ let settings_store = SettingsStore::test(cx);
+ cx.set_global(settings_store);
+ theme_settings::init(theme::LoadThemes::JustBase, cx);
+ release_channel::init(semver::Version::new(0, 0, 0), cx);
+ editor::init(cx);
+ });
+
+ let fs = FakeFs::new(server_cx.executor());
+ fs.insert_tree(
+ path!("/code"),
+ json!({
+ "project1": {
+ ".git": {},
+ "src": {
+ "lib.rs": "fn one() -> usize { 1 }"
+ }
+ },
+ }),
+ )
+ .await;
+
+ let (project, headless) = init_test(&fs, cx, server_cx).await;
+
+ let capabilities = lsp::ServerCapabilities {
+ code_action_provider: Some(lsp::CodeActionProviderCapability::Options(
+ lsp::CodeActionOptions {
+ resolve_provider: Some(true),
+ ..lsp::CodeActionOptions::default()
+ },
+ )),
+ ..lsp::ServerCapabilities::default()
+ };
+
+ cx.update_entity(&project, |project, _| {
+ project.languages().register_test_language(LanguageConfig {
+ name: "Rust".into(),
+ matcher: LanguageMatcher {
+ path_suffixes: vec!["rs".into()],
+ ..Default::default()
+ },
+ ..Default::default()
+ });
+ project.languages().register_fake_lsp_adapter(
+ "Rust",
+ FakeLspAdapter {
+ name: "rust-analyzer",
+ capabilities: capabilities.clone(),
+ ..FakeLspAdapter::default()
+ },
+ );
+ });
+
+ server_cx.update(|cx| {
+ headless.read(cx).languages.register_fake_lsp_server(
+ LanguageServerName("rust-analyzer".into()),
+ capabilities,
+ Some(Box::new(|fake_lsp| {
+ fake_lsp.set_request_handler::<lsp::request::CodeActionRequest, _, _>(
+ |_, _| async move {
+ Ok(Some(vec![lsp::CodeActionOrCommand::CodeAction(
+ lsp::CodeAction {
+ title: "Use two".to_string(),
+ data: Some(serde_json::json!({ "id": "action" })),
+ ..lsp::CodeAction::default()
+ },
+ )]))
+ },
+ );
+ fake_lsp.set_request_handler::<lsp::request::CodeActionResolveRequest, _, _>(
+ |mut action, _| async move {
+ action.edit = Some(lsp::WorkspaceEdit {
+ changes: Some(
+ [(
+ lsp::Uri::from_file_path(path!("/code/project1/src/lib.rs"))
+ .unwrap(),
+ vec![lsp::TextEdit::new(
+ lsp::Range::new(
+ lsp::Position::new(0, 3),
+ lsp::Position::new(0, 6),
+ ),
+ "two".to_string(),
+ )],
+ )]
+ .into_iter()
+ .collect(),
+ ),
+ ..lsp::WorkspaceEdit::default()
+ });
+ Ok(action)
+ },
+ );
+ })),
+ );
+ });
+
+ cx.run_until_parked();
+
+ let worktree_id = project
+ .update(cx, |project, cx| {
+ project.languages().add(rust_lang());
+ project.find_or_create_worktree(path!("/code/project1"), true, cx)
+ })
+ .await
+ .unwrap()
+ .0
+ .read_with(cx, |worktree, _| worktree.id());
+ cx.run_until_parked();
+
+ let (buffer, _handle) = project
+ .update(cx, |project, cx| {
+ project.open_buffer_with_lsp((worktree_id, rel_path("src/lib.rs")), cx)
+ })
+ .await
+ .unwrap();
+ cx.run_until_parked();
+
+ let cx = cx.add_empty_window();
+ let workspace = cx.new_window_entity(|window, cx| {
+ workspace::Workspace::test_new(project.clone(), window, cx)
+ });
+ let editor = cx.new_window_entity(|window, cx| {
+ Editor::for_buffer(buffer.clone(), Some(project.clone()), window, cx)
+ });
+ workspace.update_in(cx, |workspace, window, cx| {
+ workspace.add_item_to_active_pane(Box::new(editor.clone()), None, true, window, cx);
+ });
+ cx.run_until_parked();
+
+ editor.update_in(cx, |editor, window, cx| {
+ editor.change_selections(SelectionEffects::default(), window, cx, |s| {
+ s.select_ranges([Point::new(0, 0)..Point::new(0, 0)]);
+ });
+ });
+ cx.executor()
+ .advance_clock(editor::CODE_ACTIONS_DEBOUNCE_TIMEOUT * 2);
+ cx.run_until_parked();
+
+ editor.update_in(cx, |editor, window, cx| {
+ editor.toggle_code_actions(
+ &ToggleCodeActions {
+ deployed_from: None,
+ quick_launch: false,
+ },
+ window,
+ cx,
+ );
+ });
+ cx.run_until_parked();
+
+ editor.update(cx, |editor, _| assert!(editor.context_menu_visible()));
+
+ let confirm_action = editor
+ .update_in(cx, |editor, window, cx| {
+ Editor::confirm_code_action(editor, &ConfirmCodeAction { item_ix: Some(0) }, window, cx)
+ })
+ .unwrap();
+ confirm_action.await.unwrap();
+
+ buffer.read_with(cx, |buffer, _| {
+ assert_eq!(buffer.text(), "fn two() -> usize { 1 }");
+ });
+}
+
+#[gpui::test]
+async fn test_remote_code_lens_fetch_after_lsp_starts(
+ cx: &mut TestAppContext,
+ server_cx: &mut TestAppContext,
+) {
+ let fs = FakeFs::new(server_cx.executor());
+ fs.insert_tree(
+ path!("/code"),
+ json!({
+ "project1": {
+ ".git": {},
+ "src": {
+ "lib.rs": "fn one() -> usize { 1 }"
+ }
+ },
+ }),
+ )
+ .await;
+
+ let (project, headless) = init_test(&fs, cx, server_cx).await;
+
+ let capabilities = lsp::ServerCapabilities {
+ code_lens_provider: Some(lsp::CodeLensOptions {
+ resolve_provider: None,
+ }),
+ ..lsp::ServerCapabilities::default()
+ };
+
+ cx.update_entity(&project, |project, _| {
+ project.languages().register_test_language(LanguageConfig {
+ name: "Rust".into(),
+ matcher: LanguageMatcher {
+ path_suffixes: vec!["rs".into()],
+ ..Default::default()
+ },
+ ..Default::default()
+ });
+ project.languages().register_fake_lsp_adapter(
+ "Rust",
+ FakeLspAdapter {
+ name: "rust-analyzer",
+ capabilities: capabilities.clone(),
+ ..FakeLspAdapter::default()
+ },
+ );
+ });
+
+ cx.run_until_parked();
+
+ let worktree_id = project
+ .update(cx, |project, cx| {
+ project.languages().add(rust_lang());
+ project.find_or_create_worktree(path!("/code/project1"), true, cx)
+ })
+ .await
+ .unwrap()
+ .0
+ .read_with(cx, |worktree, _| worktree.id());
+ cx.run_until_parked();
+
+ let (buffer, _handle) = project
+ .update(cx, |project, cx| {
+ project.open_buffer_with_lsp((worktree_id, rel_path("src/lib.rs")), cx)
+ })
+ .await
+ .unwrap();
+ cx.run_until_parked();
+
+ // Prime the code lens cache while no LSP server exists on the host.
+ // This simulates the race where the editor fetches code lenses during
+ // initial paint before the language server has started.
+ let lsp_store = project.read_with(cx, |project, _| project.lsp_store());
+ let initial_actions = lsp_store
+ .update(cx, |lsp_store, cx| lsp_store.code_lens_actions(&buffer, cx))
+ .await
+ .unwrap();
+ assert_eq!(
+ initial_actions.map(|a| a.len()),
+ Some(0),
+ "Before any LSP starts, code lenses should be empty"
+ );
+
+ // Now register the LSP on the host. This triggers server startup and
+ // buffer registration, propagating capabilities to the client.
+ server_cx.update(|cx| {
+ headless.read(cx).languages.register_fake_lsp_server(
+ LanguageServerName("rust-analyzer".into()),
+ capabilities,
+ Some(Box::new(|fake_lsp| {
+ fake_lsp.set_request_handler::<lsp::request::CodeLensRequest, _, _>(
+ |_, _| async move {
+ Ok(Some(vec![lsp::CodeLens {
+ range: lsp::Range::new(
+ lsp::Position::new(0, 0),
+ lsp::Position::new(0, 9),
+ ),
+ command: Some(lsp::Command {
+ title: "1 reference".to_string(),
+ command: "lens_cmd".to_string(),
+ arguments: None,
+ }),
+ data: None,
+ }]))
+ },
+ );
+ })),
+ );
+ });
+
+ // Trigger re-evaluation of language servers for the already-open buffer.
+ server_cx.update_entity(&headless, |headless, cx| {
+ headless.lsp_store.update(cx, |lsp_store, cx| {
+ lsp_store.restart_all_language_servers(cx);
+ });
+ });
+ cx.run_until_parked();
+
+ // A subsequent fetch must bypass the stale (empty) cache now that a
+ // new server is available.
+ let actions = lsp_store
+ .update(cx, |lsp_store, cx| lsp_store.code_lens_actions(&buffer, cx))
+ .await
+ .unwrap();
+ let actions = actions.expect("Should have code lens actions after LSP starts");
+ assert_eq!(
+ actions.len(),
+ 1,
+ "Should have fetched one code lens from the newly started LSP"
+ );
+ assert_eq!(
+ actions.values().next().unwrap().lsp_action.title(),
+ "1 reference",
+ );
+}
+
+#[gpui::test]
+async fn test_remote_code_lens_resolve(cx: &mut TestAppContext, server_cx: &mut TestAppContext) {
+ cx.update(|cx| {
+ let settings_store = SettingsStore::test(cx);
+ cx.set_global(settings_store);
+ theme_settings::init(theme::LoadThemes::JustBase, cx);
+ release_channel::init(semver::Version::new(0, 0, 0), cx);
+ editor::init(cx);
+ SettingsStore::update_global(cx, |store, cx| {
+ store.update_user_settings(cx, |settings| {
+ settings.editor.code_lens = Some(settings::CodeLens::Menu);
+ });
+ });
+ });
+
+ let fs = FakeFs::new(server_cx.executor());
+ fs.insert_tree(
+ path!("/code"),
+ json!({
+ "project1": {
+ ".git": {},
+ "src": {
+ "lib.rs": "fn one() -> usize { 1 }"
+ }
+ },
+ }),
+ )
+ .await;
+
+ let (project, headless) = init_test(&fs, cx, server_cx).await;
+
+ let capabilities = lsp::ServerCapabilities {
+ code_lens_provider: Some(lsp::CodeLensOptions {
+ resolve_provider: Some(true),
+ }),
+ ..lsp::ServerCapabilities::default()
+ };
+
+ cx.update_entity(&project, |project, _| {
+ project.languages().register_test_language(LanguageConfig {
+ name: "Rust".into(),
+ matcher: LanguageMatcher {
+ path_suffixes: vec!["rs".into()],
+ ..Default::default()
+ },
+ ..Default::default()
+ });
+ project.languages().register_fake_lsp_adapter(
+ "Rust",
+ FakeLspAdapter {
+ name: "rust-analyzer",
+ capabilities: capabilities.clone(),
+ ..FakeLspAdapter::default()
+ },
+ );
+ });
+
+ server_cx.update(|cx| {
+ headless.read(cx).languages.register_fake_lsp_server(
+ LanguageServerName("rust-analyzer".into()),
+ capabilities,
+ Some(Box::new(|fake_lsp| {
+ fake_lsp.set_request_handler::<lsp::request::CodeLensRequest, _, _>(
+ |_, _| async move {
+ Ok(Some(vec![lsp::CodeLens {
+ range: lsp::Range::new(
+ lsp::Position::new(0, 0),
+ lsp::Position::new(0, 9),
+ ),
+ command: None,
+ data: Some(serde_json::json!({ "id": "lens" })),
+ }]))
+ },
+ );
+ fake_lsp.set_request_handler::<lsp::request::CodeLensResolve, _, _>(
+ |lens, _| async move {
+ Ok(lsp::CodeLens {
+ command: Some(lsp::Command {
+ title: "1 reference".to_string(),
+ command: "noop".to_string(),
+ arguments: None,
+ }),
+ ..lens
+ })
+ },
+ );
+ })),
+ );
+ });
+
+ cx.run_until_parked();
+
+ let worktree_id = project
+ .update(cx, |project, cx| {
+ project.languages().add(rust_lang());
+ project.find_or_create_worktree(path!("/code/project1"), true, cx)
+ })
+ .await
+ .unwrap()
+ .0
+ .read_with(cx, |worktree, _| worktree.id());
+ cx.run_until_parked();
+
+ let (buffer, _handle) = project
+ .update(cx, |project, cx| {
+ project.open_buffer_with_lsp((worktree_id, rel_path("src/lib.rs")), cx)
+ })
+ .await
+ .unwrap();
+ cx.run_until_parked();
+
+ let cx = cx.add_empty_window();
+ let workspace = cx.new_window_entity(|window, cx| {
+ workspace::Workspace::test_new(project.clone(), window, cx)
+ });
+ let editor = cx.new_window_entity(|window, cx| {
+ Editor::for_buffer(buffer.clone(), Some(project.clone()), window, cx)
+ });
+ workspace.update_in(cx, |workspace, window, cx| {
+ workspace.add_item_to_active_pane(Box::new(editor.clone()), None, true, window, cx);
+ });
+
+ editor.update_in(cx, |editor, window, cx| {
+ editor.change_selections(SelectionEffects::default(), window, cx, |s| {
+ s.select_ranges([Point::new(0, 0)..Point::new(0, 0)]);
+ });
+ });
+ cx.executor()
+ .advance_clock(editor::CODE_ACTIONS_DEBOUNCE_TIMEOUT * 2);
+ cx.run_until_parked();
+
+ editor.update_in(cx, |editor, window, cx| {
+ editor.toggle_code_actions(
+ &ToggleCodeActions {
+ deployed_from: None,
+ quick_launch: false,
+ },
+ window,
+ cx,
+ );
+ });
+ cx.run_until_parked();
+
+ editor.update(cx, |editor, _| {
+ assert!(editor.context_menu_visible());
+ let menu = editor.context_menu().borrow();
+ let actions_menu = match menu.as_ref() {
+ Some(CodeContextMenu::CodeActions(m)) => m,
+ _ => panic!("Expected code actions menu to be visible"),
+ };
+ let item = actions_menu
+ .actions
+ .get(0)
+ .expect("Expected at least one item in menu");
+ assert_eq!(item.label(), "1 reference");
+ });
+}
+
#[gpui::test]
async fn test_remote_cancel_language_server_work(
cx: &mut TestAppContext,