Yehowshua/ZIm
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Use new language server info on remote servers (#35682)

Browse source 
* Straightens out the `*_ext.rs` workflow for clangd and rust-analyzer:
no need to asynchronously query for the language server, as we sync that
information already.
* Fixes inlay hints editor menu toggle not being shown in the remote
sessions

Release Notes:

- Fixed inlay hints editor menu toggle not being shown in the remote
sessions
This commit is contained in:
Kirill Bulatov 2025-08-06 02:24:40 +03:00 • committed by GitHub
parent cc93175256
commit 9caa9d042a
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
14 changed files with 176 additions and 291 deletions
Download patch file Download diff file Expand all files Collapse all files

12
crates/editor/src/clangd_ext.rs
View file

@ -29,16 +29,14 @@ pub fn switch_source_header(
return;
};
let server_lookup =
find_specific_language_server_in_selection(editor, cx, is_c_language, CLANGD_SERVER_NAME);
let Some((_, _, server_to_query, buffer)) =
find_specific_language_server_in_selection(editor, cx, is_c_language, CLANGD_SERVER_NAME)
else {
return;
};
let project = project.clone();
let upstream_client = project.read(cx).lsp_store().read(cx).upstream_client();
cx.spawn_in(window, async move |_editor, cx| {
let Some((_, _, server_to_query, buffer)) =
server_lookup.await
else {
return Ok(());
};
let source_file = buffer.read_with(cx, |buffer, _| {
buffer.file().map(|file| file.path()).map(|path| path.to_string_lossy().to_string()).unwrap_or_else(|| "Unknown".to_string())
})?;

1
crates/editor/src/editor.rs
View file

@ -22192,7 +22192,6 @@ impl SemanticsProvider for Entity<Project> {
}
fn supports_inlay_hints(&self, buffer: &Entity<Buffer>, cx: &mut App) -> bool {
// TODO: make this work for remote projects
self.update(cx, |project, cx| {
if project
.active_debug_session(cx)

168
crates/editor/src/lsp_ext.rs
View file

@ -3,9 +3,8 @@ use std::time::Duration;
use crate::Editor;
use collections::HashMap;
use futures::stream::FuturesUnordered;
use gpui::AsyncApp;
use gpui::{App, AppContext as _, Entity, Task};
use gpui::{App, Entity, Task};
use itertools::Itertools;
use language::Buffer;
use language::Language;
@ -18,7 +17,6 @@ use project::Project;
use project::TaskSourceKind;
use project::lsp_store::lsp_ext_command::GetLspRunnables;
use smol::future::FutureExt as _;
use smol::stream::StreamExt;
use task::ResolvedTask;
use task::TaskContext;
use text::BufferId;
@ -29,52 +27,32 @@ pub(crate) fn find_specific_language_server_in_selection<F>(
editor: &Editor,
cx: &mut App,
filter_language: F,
language_server_name: &str,
) -> Task<Option<(Anchor, Arc<Language>, LanguageServerId, Entity<Buffer>)>>
language_server_name: LanguageServerName,
) -> Option<(Anchor, Arc<Language>, LanguageServerId, Entity<Buffer>)>
where
F: Fn(&Language) -> bool,
{
let Some(project) = &editor.project else {
return Task::ready(None);
};
let applicable_buffers = editor
let project = editor.project.clone()?;
editor
.selections
.disjoint_anchors()
.iter()
.filter_map(|selection| Some((selection.head(), selection.head().buffer_id?)))
.unique_by(|(_, buffer_id)| *buffer_id)
.filter_map(|(trigger_anchor, buffer_id)| {
.find_map(|(trigger_anchor, buffer_id)| {
let buffer = editor.buffer().read(cx).buffer(buffer_id)?;
let language = buffer.read(cx).language_at(trigger_anchor.text_anchor)?;
if filter_language(&language) {
Some((trigger_anchor, buffer, language))
let server_id = buffer.update(cx, |buffer, cx| {
project
.read(cx)
.language_server_id_for_name(buffer, &language_server_name, cx)
})?;
Some((trigger_anchor, language, server_id, buffer))
} else {
None
}
})
.collect::<Vec<_>>();
let applicable_buffer_tasks = applicable_buffers
.into_iter()
.map(|(trigger_anchor, buffer, language)| {
let task = buffer.update(cx, |buffer, cx| {
project.update(cx, |project, cx| {
project.language_server_id_for_name(buffer, language_server_name, cx)
})
});
(trigger_anchor, buffer, language, task)
})
.collect::<Vec<_>>();
cx.background_spawn(async move {
for (trigger_anchor, buffer, language, task) in applicable_buffer_tasks {
if let Some(server_id) = task.await {
return Some((trigger_anchor, language, server_id, buffer));
}
}
None
})
}
async fn lsp_task_context(
@ -116,9 +94,9 @@ pub fn lsp_tasks(
for_position: Option<text::Anchor>,
cx: &mut App,
) -> Task<Vec<(TaskSourceKind, Vec<(Option<LocationLink>, ResolvedTask)>)>> {
let mut lsp_task_sources = task_sources
let lsp_task_sources = task_sources
.iter()
.map(|(name, buffer_ids)| {
.filter_map(|(name, buffer_ids)| {
let buffers = buffer_ids
.iter()
.filter(|&&buffer_id| match for_position {
@ -127,61 +105,63 @@ pub fn lsp_tasks(
})
.filter_map(|&buffer_id| project.read(cx).buffer_for_id(buffer_id, cx))
.collect::<Vec<_>>();
language_server_for_buffers(project.clone(), name.clone(), buffers, cx)
let server_id = buffers.iter().find_map(|buffer| {
project.read_with(cx, |project, cx| {
project.language_server_id_for_name(buffer.read(cx), name, cx)
})
});
server_id.zip(Some(buffers))
})
.collect::<FuturesUnordered<_>>();
.collect::<Vec<_>>();
cx.spawn(async move |cx| {
cx.spawn(async move |cx| {
let mut lsp_tasks = HashMap::default();
while let Some(server_to_query) = lsp_task_sources.next().await {
if let Some((server_id, buffers)) = server_to_query {
let mut new_lsp_tasks = Vec::new();
for buffer in buffers {
let source_kind = match buffer.update(cx, |buffer, _| {
buffer.language().map(|language| language.name())
}) {
Ok(Some(language_name)) => TaskSourceKind::Lsp {
server: server_id,
language_name: SharedString::from(language_name),
},
Ok(None) => continue,
Err(_) => return Vec::new(),
};
let id_base = source_kind.to_id_base();
let lsp_buffer_context = lsp_task_context(&project, &buffer, cx)
.await
.unwrap_or_default();
for (server_id, buffers) in lsp_task_sources {
let mut new_lsp_tasks = Vec::new();
for buffer in buffers {
let source_kind = match buffer.update(cx, |buffer, _| {
buffer.language().map(|language| language.name())
}) {
Ok(Some(language_name)) => TaskSourceKind::Lsp {
server: server_id,
language_name: SharedString::from(language_name),
},
Ok(None) => continue,
Err(_) => return Vec::new(),
};
let id_base = source_kind.to_id_base();
let lsp_buffer_context = lsp_task_context(&project, &buffer, cx)
.await
.unwrap_or_default();
if let Ok(runnables_task) = project.update(cx, |project, cx| {
let buffer_id = buffer.read(cx).remote_id();
project.request_lsp(
buffer,
LanguageServerToQuery::Other(server_id),
GetLspRunnables {
buffer_id,
position: for_position,
if let Ok(runnables_task) = project.update(cx, |project, cx| {
let buffer_id = buffer.read(cx).remote_id();
project.request_lsp(
buffer,
LanguageServerToQuery::Other(server_id),
GetLspRunnables {
buffer_id,
position: for_position,
},
cx,
)
}) {
if let Some(new_runnables) = runnables_task.await.log_err() {
new_lsp_tasks.extend(new_runnables.runnables.into_iter().filter_map(
|(location, runnable)| {
let resolved_task =
runnable.resolve_task(&id_base, &lsp_buffer_context)?;
Some((location, resolved_task))
},
cx,
)
}) {
if let Some(new_runnables) = runnables_task.await.log_err() {
new_lsp_tasks.extend(
new_runnables.runnables.into_iter().filter_map(
|(location, runnable)| {
let resolved_task = runnable
.resolve_task(&id_base, &lsp_buffer_context)?;
Some((location, resolved_task))
},
),
);
}
));
}
lsp_tasks
.entry(source_kind)
.or_insert_with(Vec::new)
.append(&mut new_lsp_tasks);
}
lsp_tasks
.entry(source_kind)
.or_insert_with(Vec::new)
.append(&mut new_lsp_tasks);
}
}
lsp_tasks.into_iter().collect()
@ -198,27 +178,3 @@ pub fn lsp_tasks(
.await
})
}
fn language_server_for_buffers(
project: Entity<Project>,
name: LanguageServerName,
candidates: Vec<Entity<Buffer>>,
cx: &mut App,
) -> Task<Option<(LanguageServerId, Vec<Entity<Buffer>>)>> {
cx.spawn(async move |cx| {
for buffer in &candidates {
let server_id = buffer
.update(cx, |buffer, cx| {
project.update(cx, |project, cx| {
project.language_server_id_for_name(buffer, &name.0, cx)
})
})
.ok()?
.await;
if let Some(server_id) = server_id {
return Some((server_id, candidates));
}
}
None
})
}

64
crates/editor/src/rust_analyzer_ext.rs
View file

@ -57,21 +57,21 @@ pub fn go_to_parent_module(
return;
};
let server_lookup = find_specific_language_server_in_selection(
editor,
cx,
is_rust_language,
RUST_ANALYZER_NAME,
);
let Some((trigger_anchor, _, server_to_query, buffer)) =
find_specific_language_server_in_selection(
editor,
cx,
is_rust_language,
RUST_ANALYZER_NAME,
)
else {
return;
};
let project = project.clone();
let lsp_store = project.read(cx).lsp_store();
let upstream_client = lsp_store.read(cx).upstream_client();
cx.spawn_in(window, async move |editor, cx| {
let Some((trigger_anchor, _, server_to_query, buffer)) = server_lookup.await else {
return anyhow::Ok(());
};
let location_links = if let Some((client, project_id)) = upstream_client {
let buffer_id = buffer.read_with(cx, |buffer, _| buffer.remote_id())?;
@ -121,7 +121,7 @@ pub fn go_to_parent_module(
)
})?
.await?;
Ok(())
anyhow::Ok(())
})
.detach_and_log_err(cx);
}
@ -139,21 +139,19 @@ pub fn expand_macro_recursively(
return;
};
let server_lookup = find_specific_language_server_in_selection(
editor,
cx,
is_rust_language,
RUST_ANALYZER_NAME,
);
let Some((trigger_anchor, rust_language, server_to_query, buffer)) =
find_specific_language_server_in_selection(
editor,
cx,
is_rust_language,
RUST_ANALYZER_NAME,
)
else {
return;
};
let project = project.clone();
let upstream_client = project.read(cx).lsp_store().read(cx).upstream_client();
cx.spawn_in(window, async move |_editor, cx| {
let Some((trigger_anchor, rust_language, server_to_query, buffer)) = server_lookup.await
else {
return Ok(());
};
let macro_expansion = if let Some((client, project_id)) = upstream_client {
let buffer_id = buffer.update(cx, |buffer, _| buffer.remote_id())?;
let request = proto::LspExtExpandMacro {
@ -231,20 +229,20 @@ pub fn open_docs(editor: &mut Editor, _: &OpenDocs, window: &mut Window, cx: &mu
return;
};
let server_lookup = find_specific_language_server_in_selection(
editor,
cx,
is_rust_language,
RUST_ANALYZER_NAME,
);
let Some((trigger_anchor, _, server_to_query, buffer)) =
find_specific_language_server_in_selection(
editor,
cx,
is_rust_language,
RUST_ANALYZER_NAME,
)
else {
return;
};
let project = project.clone();
let upstream_client = project.read(cx).lsp_store().read(cx).upstream_client();
cx.spawn_in(window, async move |_editor, cx| {
let Some((trigger_anchor, _, server_to_query, buffer)) = server_lookup.await else {
return Ok(());
};
let docs_urls = if let Some((client, project_id)) = upstream_client {
let buffer_id = buffer.read_with(cx, |buffer, _| buffer.remote_id())?;
let request = proto::LspExtOpenDocs {