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

3
crates/collab/src/rpc.rs
View file

@ -340,9 +340,6 @@ impl Server {
.add_request_handler(forward_read_only_project_request::<proto::LspExtCancelFlycheck>) .add_request_handler(forward_read_only_project_request::<proto::LspExtCancelFlycheck>)
.add_request_handler(forward_read_only_project_request::<proto::LspExtRunFlycheck>) .add_request_handler(forward_read_only_project_request::<proto::LspExtRunFlycheck>)
.add_request_handler(forward_read_only_project_request::<proto::LspExtClearFlycheck>) .add_request_handler(forward_read_only_project_request::<proto::LspExtClearFlycheck>)
.add_request_handler(
forward_read_only_project_request::<proto::LanguageServerIdForName>,
)
.add_request_handler(forward_read_only_project_request::<proto::GetDocumentDiagnostics>) .add_request_handler(forward_read_only_project_request::<proto::GetDocumentDiagnostics>)
.add_request_handler( .add_request_handler(
forward_mutating_project_request::<proto::RegisterBufferWithLanguageServers>, forward_mutating_project_request::<proto::RegisterBufferWithLanguageServers>,

16
crates/collab/src/tests/editor_tests.rs
View file

@ -24,10 +24,7 @@ use language::{
}; };
use project::{ use project::{
ProjectPath, SERVER_PROGRESS_THROTTLE_TIMEOUT, ProjectPath, SERVER_PROGRESS_THROTTLE_TIMEOUT,
lsp_store::{ lsp_store::lsp_ext_command::{ExpandedMacro, LspExtExpandMacro},
lsp_ext_command::{ExpandedMacro, LspExtExpandMacro},
rust_analyzer_ext::RUST_ANALYZER_NAME,
},
project_settings::{InlineBlameSettings, ProjectSettings}, project_settings::{InlineBlameSettings, ProjectSettings},
}; };
use recent_projects::disconnected_overlay::DisconnectedOverlay; use recent_projects::disconnected_overlay::DisconnectedOverlay;
@ -3786,11 +3783,18 @@ async fn test_client_can_query_lsp_ext(cx_a: &mut TestAppContext, cx_b: &mut Tes
cx_b.update(editor::init); cx_b.update(editor::init);
client_a.language_registry().add(rust_lang()); client_a.language_registry().add(rust_lang());
client_b.language_registry().add(rust_lang());
let mut fake_language_servers = client_a.language_registry().register_fake_lsp( let mut fake_language_servers = client_a.language_registry().register_fake_lsp(
"Rust", "Rust",
FakeLspAdapter { FakeLspAdapter {
name: RUST_ANALYZER_NAME, name: "rust-analyzer",
..FakeLspAdapter::default()
},
);
client_b.language_registry().add(rust_lang());
client_b.language_registry().register_fake_lsp_adapter(
"Rust",
FakeLspAdapter {
name: "rust-analyzer",
..FakeLspAdapter::default() ..FakeLspAdapter::default()
}, },
); );

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

@ -29,16 +29,14 @@ pub fn switch_source_header(
return; return;
}; };
let server_lookup = let Some((_, _, server_to_query, buffer)) =
find_specific_language_server_in_selection(editor, cx, is_c_language, CLANGD_SERVER_NAME); find_specific_language_server_in_selection(editor, cx, is_c_language, CLANGD_SERVER_NAME)
else {
return;
};
let project = project.clone(); let project = project.clone();
let upstream_client = project.read(cx).lsp_store().read(cx).upstream_client(); let upstream_client = project.read(cx).lsp_store().read(cx).upstream_client();
cx.spawn_in(window, async move |_editor, cx| { 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, _| { 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()) 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 { fn supports_inlay_hints(&self, buffer: &Entity<Buffer>, cx: &mut App) -> bool {
// TODO: make this work for remote projects
self.update(cx, |project, cx| { self.update(cx, |project, cx| {
if project if project
.active_debug_session(cx) .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 crate::Editor;
use collections::HashMap; use collections::HashMap;
use futures::stream::FuturesUnordered;
use gpui::AsyncApp; use gpui::AsyncApp;
use gpui::{App, AppContext as _, Entity, Task}; use gpui::{App, Entity, Task};
use itertools::Itertools; use itertools::Itertools;
use language::Buffer; use language::Buffer;
use language::Language; use language::Language;
@ -18,7 +17,6 @@ use project::Project;
use project::TaskSourceKind; use project::TaskSourceKind;
use project::lsp_store::lsp_ext_command::GetLspRunnables; use project::lsp_store::lsp_ext_command::GetLspRunnables;
use smol::future::FutureExt as _; use smol::future::FutureExt as _;
use smol::stream::StreamExt;
use task::ResolvedTask; use task::ResolvedTask;
use task::TaskContext; use task::TaskContext;
use text::BufferId; use text::BufferId;
@ -29,52 +27,32 @@ pub(crate) fn find_specific_language_server_in_selection<F>(
editor: &Editor, editor: &Editor,
cx: &mut App, cx: &mut App,
filter_language: F, filter_language: F,
language_server_name: &str, language_server_name: LanguageServerName,
) -> Task<Option<(Anchor, Arc<Language>, LanguageServerId, Entity<Buffer>)>> ) -> Option<(Anchor, Arc<Language>, LanguageServerId, Entity<Buffer>)>
where where
F: Fn(&Language) -> bool, F: Fn(&Language) -> bool,
{ {
let Some(project) = &editor.project else { let project = editor.project.clone()?;
return Task::ready(None); editor
};
let applicable_buffers = editor
.selections .selections
.disjoint_anchors() .disjoint_anchors()
.iter() .iter()
.filter_map(|selection| Some((selection.head(), selection.head().buffer_id?))) .filter_map(|selection| Some((selection.head(), selection.head().buffer_id?)))
.unique_by(|(_, buffer_id)| *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 buffer = editor.buffer().read(cx).buffer(buffer_id)?;
let language = buffer.read(cx).language_at(trigger_anchor.text_anchor)?; let language = buffer.read(cx).language_at(trigger_anchor.text_anchor)?;
if filter_language(&language) { 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 { } else {
None 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( async fn lsp_task_context(
@ -116,9 +94,9 @@ pub fn lsp_tasks(
for_position: Option<text::Anchor>, for_position: Option<text::Anchor>,
cx: &mut App, cx: &mut App,
) -> Task<Vec<(TaskSourceKind, Vec<(Option<LocationLink>, ResolvedTask)>)>> { ) -> Task<Vec<(TaskSourceKind, Vec<(Option<LocationLink>, ResolvedTask)>)>> {
let mut lsp_task_sources = task_sources let lsp_task_sources = task_sources
.iter() .iter()
.map(|(name, buffer_ids)| { .filter_map(|(name, buffer_ids)| {
let buffers = buffer_ids let buffers = buffer_ids
.iter() .iter()
.filter(|&&buffer_id| match for_position { .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)) .filter_map(|&buffer_id| project.read(cx).buffer_for_id(buffer_id, cx))
.collect::<Vec<_>>(); .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| {
cx.spawn(async move |cx| { cx.spawn(async move |cx| {
let mut lsp_tasks = HashMap::default(); let mut lsp_tasks = HashMap::default();
while let Some(server_to_query) = lsp_task_sources.next().await { for (server_id, buffers) in lsp_task_sources {
if let Some((server_id, buffers)) = server_to_query { let mut new_lsp_tasks = Vec::new();
let mut new_lsp_tasks = Vec::new(); for buffer in buffers {
for buffer in buffers { let source_kind = match buffer.update(cx, |buffer, _| {
let source_kind = match buffer.update(cx, |buffer, _| { buffer.language().map(|language| language.name())
buffer.language().map(|language| language.name()) }) {
}) { Ok(Some(language_name)) => TaskSourceKind::Lsp {
Ok(Some(language_name)) => TaskSourceKind::Lsp { server: server_id,
server: server_id, language_name: SharedString::from(language_name),
language_name: SharedString::from(language_name), },
}, Ok(None) => continue,
Ok(None) => continue, Err(_) => return Vec::new(),
Err(_) => return Vec::new(), };
}; let id_base = source_kind.to_id_base();
let id_base = source_kind.to_id_base(); let lsp_buffer_context = lsp_task_context(&project, &buffer, cx)
let lsp_buffer_context = lsp_task_context(&project, &buffer, cx) .await
.await .unwrap_or_default();
.unwrap_or_default();
if let Ok(runnables_task) = project.update(cx, |project, cx| { if let Ok(runnables_task) = project.update(cx, |project, cx| {
let buffer_id = buffer.read(cx).remote_id(); let buffer_id = buffer.read(cx).remote_id();
project.request_lsp( project.request_lsp(
buffer, buffer,
LanguageServerToQuery::Other(server_id), LanguageServerToQuery::Other(server_id),
GetLspRunnables { GetLspRunnables {
buffer_id, buffer_id,
position: for_position, 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() lsp_tasks.into_iter().collect()
@ -198,27 +178,3 @@ pub fn lsp_tasks(
.await .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; return;
}; };
let server_lookup = find_specific_language_server_in_selection( let Some((trigger_anchor, _, server_to_query, buffer)) =
editor, find_specific_language_server_in_selection(
cx, editor,
is_rust_language, cx,
RUST_ANALYZER_NAME, is_rust_language,
); RUST_ANALYZER_NAME,
)
else {
return;
};
let project = project.clone(); let project = project.clone();
let lsp_store = project.read(cx).lsp_store(); let lsp_store = project.read(cx).lsp_store();
let upstream_client = lsp_store.read(cx).upstream_client(); let upstream_client = lsp_store.read(cx).upstream_client();
cx.spawn_in(window, async move |editor, cx| { 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 location_links = if let Some((client, project_id)) = upstream_client {
let buffer_id = buffer.read_with(cx, |buffer, _| buffer.remote_id())?; let buffer_id = buffer.read_with(cx, |buffer, _| buffer.remote_id())?;
@ -121,7 +121,7 @@ pub fn go_to_parent_module(
) )
})? })?
.await?; .await?;
Ok(()) anyhow::Ok(())
}) })
.detach_and_log_err(cx); .detach_and_log_err(cx);
} }
@ -139,21 +139,19 @@ pub fn expand_macro_recursively(
return; return;
}; };
let server_lookup = find_specific_language_server_in_selection( let Some((trigger_anchor, rust_language, server_to_query, buffer)) =
editor, find_specific_language_server_in_selection(
cx, editor,
is_rust_language, cx,
RUST_ANALYZER_NAME, is_rust_language,
); RUST_ANALYZER_NAME,
)
else {
return;
};
let project = project.clone(); let project = project.clone();
let upstream_client = project.read(cx).lsp_store().read(cx).upstream_client(); let upstream_client = project.read(cx).lsp_store().read(cx).upstream_client();
cx.spawn_in(window, async move |_editor, cx| { 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 macro_expansion = if let Some((client, project_id)) = upstream_client {
let buffer_id = buffer.update(cx, |buffer, _| buffer.remote_id())?; let buffer_id = buffer.update(cx, |buffer, _| buffer.remote_id())?;
let request = proto::LspExtExpandMacro { let request = proto::LspExtExpandMacro {
@ -231,20 +229,20 @@ pub fn open_docs(editor: &mut Editor, _: &OpenDocs, window: &mut Window, cx: &mu
return; return;
}; };
let server_lookup = find_specific_language_server_in_selection( let Some((trigger_anchor, _, server_to_query, buffer)) =
editor, find_specific_language_server_in_selection(
cx, editor,
is_rust_language, cx,
RUST_ANALYZER_NAME, is_rust_language,
); RUST_ANALYZER_NAME,
)
else {
return;
};
let project = project.clone(); let project = project.clone();
let upstream_client = project.read(cx).lsp_store().read(cx).upstream_client(); let upstream_client = project.read(cx).lsp_store().read(cx).upstream_client();
cx.spawn_in(window, async move |_editor, cx| { 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 docs_urls = if let Some((client, project_id)) = upstream_client {
let buffer_id = buffer.read_with(cx, |buffer, _| buffer.remote_id())?; let buffer_id = buffer.read_with(cx, |buffer, _| buffer.remote_id())?;
let request = proto::LspExtOpenDocs { let request = proto::LspExtOpenDocs {

22
crates/project/src/lsp_command.rs
View file

@ -3284,6 +3284,16 @@ impl InlayHints {
}) })
.unwrap_or(false) .unwrap_or(false)
} }
pub fn check_capabilities(capabilities: &ServerCapabilities) -> bool {
capabilities
.inlay_hint_provider
.as_ref()
.is_some_and(|inlay_hint_provider| match inlay_hint_provider {
lsp::OneOf::Left(enabled) => *enabled,
lsp::OneOf::Right(_) => true,
})
}
} }
#[async_trait(?Send)] #[async_trait(?Send)]
@ -3297,17 +3307,7 @@ impl LspCommand for InlayHints {
} }
fn check_capabilities(&self, capabilities: AdapterServerCapabilities) -> bool { fn check_capabilities(&self, capabilities: AdapterServerCapabilities) -> bool {
let Some(inlay_hint_provider) = &capabilities.server_capabilities.inlay_hint_provider Self::check_capabilities(&capabilities.server_capabilities)
else {
return false;
};
match inlay_hint_provider {
lsp::OneOf::Left(enabled) => *enabled,
lsp::OneOf::Right(inlay_hint_capabilities) => match inlay_hint_capabilities {
lsp::InlayHintServerCapabilities::Options(_) => true,
lsp::InlayHintServerCapabilities::RegistrationOptions(_) => false,
},
}
} }
fn to_lsp( fn to_lsp(

29
crates/project/src/lsp_store.rs
View file

@ -3671,7 +3671,6 @@ impl LspStore {
client.add_entity_request_handler(Self::handle_apply_additional_edits_for_completion); client.add_entity_request_handler(Self::handle_apply_additional_edits_for_completion);
client.add_entity_request_handler(Self::handle_register_buffer_with_language_servers); client.add_entity_request_handler(Self::handle_register_buffer_with_language_servers);
client.add_entity_request_handler(Self::handle_rename_project_entry); client.add_entity_request_handler(Self::handle_rename_project_entry);
client.add_entity_request_handler(Self::handle_language_server_id_for_name);
client.add_entity_request_handler(Self::handle_pull_workspace_diagnostics); client.add_entity_request_handler(Self::handle_pull_workspace_diagnostics);
client.add_entity_request_handler(Self::handle_lsp_command::<GetCodeActions>); client.add_entity_request_handler(Self::handle_lsp_command::<GetCodeActions>);
client.add_entity_request_handler(Self::handle_lsp_command::<GetCompletions>); client.add_entity_request_handler(Self::handle_lsp_command::<GetCompletions>);
@ -8745,34 +8744,6 @@ impl LspStore {
Ok(proto::Ack {}) Ok(proto::Ack {})
} }
async fn handle_language_server_id_for_name(
lsp_store: Entity<Self>,
envelope: TypedEnvelope<proto::LanguageServerIdForName>,
mut cx: AsyncApp,
) -> Result<proto::LanguageServerIdForNameResponse> {
let name = &envelope.payload.name;
let buffer_id = BufferId::new(envelope.payload.buffer_id)?;
lsp_store
.update(&mut cx, |lsp_store, cx| {
let buffer = lsp_store.buffer_store.read(cx).get_existing(buffer_id)?;
let server_id = buffer.update(cx, |buffer, cx| {
lsp_store
.language_servers_for_local_buffer(buffer, cx)
.find_map(|(adapter, server)| {
if adapter.name.0.as_ref() == name {
Some(server.server_id())
} else {
None
}
})
});
Ok(server_id)
})?
.map(|server_id| proto::LanguageServerIdForNameResponse {
server_id: server_id.map(|id| id.to_proto()),
})
}
async fn handle_rename_project_entry( async fn handle_rename_project_entry(
this: Entity<Self>, this: Entity<Self>,
envelope: TypedEnvelope<proto::RenameProjectEntry>, envelope: TypedEnvelope<proto::RenameProjectEntry>,

10
crates/project/src/lsp_store/clangd_ext.rs
View file

@ -3,12 +3,12 @@ use std::sync::Arc;
use ::serde::{Deserialize, Serialize}; use ::serde::{Deserialize, Serialize};
use gpui::WeakEntity; use gpui::WeakEntity;
use language::{CachedLspAdapter, Diagnostic, DiagnosticSourceKind}; use language::{CachedLspAdapter, Diagnostic, DiagnosticSourceKind};
use lsp::LanguageServer; use lsp::{LanguageServer, LanguageServerName};
use util::ResultExt as _; use util::ResultExt as _;
use crate::LspStore; use crate::LspStore;
pub const CLANGD_SERVER_NAME: &str = "clangd"; pub const CLANGD_SERVER_NAME: LanguageServerName = LanguageServerName::new_static("clangd");
const INACTIVE_REGION_MESSAGE: &str = "inactive region"; const INACTIVE_REGION_MESSAGE: &str = "inactive region";
const INACTIVE_DIAGNOSTIC_SEVERITY: lsp::DiagnosticSeverity = lsp::DiagnosticSeverity::INFORMATION; const INACTIVE_DIAGNOSTIC_SEVERITY: lsp::DiagnosticSeverity = lsp::DiagnosticSeverity::INFORMATION;
@ -34,7 +34,7 @@ pub fn is_inactive_region(diag: &Diagnostic) -> bool {
&& diag && diag
.source .source
.as_ref() .as_ref()
.is_some_and(|v| v == CLANGD_SERVER_NAME) .is_some_and(|v| v == &CLANGD_SERVER_NAME.0)
} }
pub fn is_lsp_inactive_region(diag: &lsp::Diagnostic) -> bool { pub fn is_lsp_inactive_region(diag: &lsp::Diagnostic) -> bool {
@ -43,7 +43,7 @@ pub fn is_lsp_inactive_region(diag: &lsp::Diagnostic) -> bool {
&& diag && diag
.source .source
.as_ref() .as_ref()
.is_some_and(|v| v == CLANGD_SERVER_NAME) .is_some_and(|v| v == &CLANGD_SERVER_NAME.0)
} }
pub fn register_notifications( pub fn register_notifications(
@ -51,7 +51,7 @@ pub fn register_notifications(
language_server: &LanguageServer, language_server: &LanguageServer,
adapter: Arc<CachedLspAdapter>, adapter: Arc<CachedLspAdapter>,
) { ) {
if language_server.name().0 != CLANGD_SERVER_NAME { if language_server.name() != CLANGD_SERVER_NAME {
return; return;
} }
let server_id = language_server.server_id(); let server_id = language_server.server_id();

34
crates/project/src/lsp_store/rust_analyzer_ext.rs
View file

@ -2,12 +2,12 @@ use ::serde::{Deserialize, Serialize};
use anyhow::Context as _; use anyhow::Context as _;
use gpui::{App, Entity, Task, WeakEntity}; use gpui::{App, Entity, Task, WeakEntity};
use language::ServerHealth; use language::ServerHealth;
use lsp::LanguageServer; use lsp::{LanguageServer, LanguageServerName};
use rpc::proto; use rpc::proto;
use crate::{LspStore, LspStoreEvent, Project, ProjectPath, lsp_store}; use crate::{LspStore, LspStoreEvent, Project, ProjectPath, lsp_store};
pub const RUST_ANALYZER_NAME: &str = "rust-analyzer"; pub const RUST_ANALYZER_NAME: LanguageServerName = LanguageServerName::new_static("rust-analyzer");
pub const CARGO_DIAGNOSTICS_SOURCE_NAME: &str = "rustc"; pub const CARGO_DIAGNOSTICS_SOURCE_NAME: &str = "rustc";
/// Experimental: Informs the end user about the state of the server /// Experimental: Informs the end user about the state of the server
@ -97,13 +97,9 @@ pub fn cancel_flycheck(
cx.spawn(async move |cx| { cx.spawn(async move |cx| {
let buffer = buffer.await?; let buffer = buffer.await?;
let Some(rust_analyzer_server) = project let Some(rust_analyzer_server) = project.read_with(cx, |project, cx| {
.update(cx, |project, cx| { project.language_server_id_for_name(buffer.read(cx), &RUST_ANALYZER_NAME, cx)
buffer.update(cx, |buffer, cx| { })?
project.language_server_id_for_name(buffer, RUST_ANALYZER_NAME, cx)
})
})?
.await
else { else {
return Ok(()); return Ok(());
}; };
@ -148,13 +144,9 @@ pub fn run_flycheck(
cx.spawn(async move |cx| { cx.spawn(async move |cx| {
let buffer = buffer.await?; let buffer = buffer.await?;
let Some(rust_analyzer_server) = project let Some(rust_analyzer_server) = project.read_with(cx, |project, cx| {
.update(cx, |project, cx| { project.language_server_id_for_name(buffer.read(cx), &RUST_ANALYZER_NAME, cx)
buffer.update(cx, |buffer, cx| { })?
project.language_server_id_for_name(buffer, RUST_ANALYZER_NAME, cx)
})
})?
.await
else { else {
return Ok(()); return Ok(());
}; };
@ -204,13 +196,9 @@ pub fn clear_flycheck(
cx.spawn(async move |cx| { cx.spawn(async move |cx| {
let buffer = buffer.await?; let buffer = buffer.await?;
let Some(rust_analyzer_server) = project let Some(rust_analyzer_server) = project.read_with(cx, |project, cx| {
.update(cx, |project, cx| { project.language_server_id_for_name(buffer.read(cx), &RUST_ANALYZER_NAME, cx)
buffer.update(cx, |buffer, cx| { })?
project.language_server_id_for_name(buffer, RUST_ANALYZER_NAME, cx)
})
})?
.await
else { else {
return Ok(()); return Ok(());
}; };

90
crates/project/src/project.rs
View file

@ -5002,63 +5002,53 @@ impl Project {
} }
pub fn any_language_server_supports_inlay_hints(&self, buffer: &Buffer, cx: &mut App) -> bool { pub fn any_language_server_supports_inlay_hints(&self, buffer: &Buffer, cx: &mut App) -> bool {
self.lsp_store.update(cx, |this, cx| { let Some(language) = buffer.language().cloned() else {
this.language_servers_for_local_buffer(buffer, cx) return false;
.any( };
|(_, server)| match server.capabilities().inlay_hint_provider { self.lsp_store.update(cx, |lsp_store, _| {
Some(lsp::OneOf::Left(enabled)) => enabled, let relevant_language_servers = lsp_store
Some(lsp::OneOf::Right(_)) => true, .languages
None => false, .lsp_adapters(&language.name())
}, .into_iter()
) .map(|lsp_adapter| lsp_adapter.name())
.collect::<HashSet<_>>();
lsp_store
.language_server_statuses()
.filter_map(|(server_id, server_status)| {
relevant_language_servers
.contains(&server_status.name)
.then_some(server_id)
})
.filter_map(|server_id| lsp_store.lsp_server_capabilities.get(&server_id))
.any(InlayHints::check_capabilities)
}) })
} }
pub fn language_server_id_for_name( pub fn language_server_id_for_name(
&self, &self,
buffer: &Buffer, buffer: &Buffer,
name: &str, name: &LanguageServerName,
cx: &mut App, cx: &App,
) -> Task<Option<LanguageServerId>> { ) -> Option<LanguageServerId> {
if self.is_local() { let language = buffer.language()?;
Task::ready(self.lsp_store.update(cx, |lsp_store, cx| { let relevant_language_servers = self
lsp_store .languages
.language_servers_for_local_buffer(buffer, cx) .lsp_adapters(&language.name())
.find_map(|(adapter, server)| { .into_iter()
if adapter.name.0 == name { .map(|lsp_adapter| lsp_adapter.name())
Some(server.server_id()) .collect::<HashSet<_>>();
} else { if !relevant_language_servers.contains(name) {
None return None;
}
})
}))
} else if let Some(project_id) = self.remote_id() {
let request = self.client.request(proto::LanguageServerIdForName {
project_id,
buffer_id: buffer.remote_id().to_proto(),
name: name.to_string(),
});
cx.background_spawn(async move {
let response = request.await.log_err()?;
response.server_id.map(LanguageServerId::from_proto)
})
} else if let Some(ssh_client) = self.ssh_client.as_ref() {
let request =
ssh_client
.read(cx)
.proto_client()
.request(proto::LanguageServerIdForName {
project_id: SSH_PROJECT_ID,
buffer_id: buffer.remote_id().to_proto(),
name: name.to_string(),
});
cx.background_spawn(async move {
let response = request.await.log_err()?;
response.server_id.map(LanguageServerId::from_proto)
})
} else {
Task::ready(None)
} }
self.language_server_statuses(cx)
.filter(|(_, server_status)| relevant_language_servers.contains(&server_status.name))
.find_map(|(server_id, server_status)| {
if &server_status.name == name {
Some(server_id)
} else {
None
}
})
} }
pub fn has_language_servers_for(&self, buffer: &Buffer, cx: &mut App) -> bool { pub fn has_language_servers_for(&self, buffer: &Buffer, cx: &mut App) -> bool {

10
crates/proto/proto/lsp.proto
View file

@ -818,16 +818,6 @@ message LspResponse {
uint64 server_id = 7; uint64 server_id = 7;
} }
message LanguageServerIdForName {
uint64 project_id = 1;
uint64 buffer_id = 2;
string name = 3;
}
message LanguageServerIdForNameResponse {
optional uint64 server_id = 1;
}
message LspExtRunnables { message LspExtRunnables {
uint64 project_id = 1; uint64 project_id = 1;
uint64 buffer_id = 2; uint64 buffer_id = 2;

4
crates/proto/proto/zed.proto
View file

@ -362,9 +362,6 @@ message Envelope {
GetDocumentSymbols get_document_symbols = 330; GetDocumentSymbols get_document_symbols = 330;
GetDocumentSymbolsResponse get_document_symbols_response = 331; GetDocumentSymbolsResponse get_document_symbols_response = 331;
LanguageServerIdForName language_server_id_for_name = 332;
LanguageServerIdForNameResponse language_server_id_for_name_response = 333;
LoadCommitDiff load_commit_diff = 334; LoadCommitDiff load_commit_diff = 334;
LoadCommitDiffResponse load_commit_diff_response = 335; LoadCommitDiffResponse load_commit_diff_response = 335;
@ -424,6 +421,7 @@ message Envelope {
reserved 247 to 254; reserved 247 to 254;
reserved 255 to 256; reserved 255 to 256;
reserved 280 to 281; reserved 280 to 281;
reserved 332 to 333;
} }
message Hello { message Hello {

4
crates/proto/src/proto.rs
View file

@ -121,8 +121,6 @@ messages!(
(GetImplementationResponse, Background), (GetImplementationResponse, Background),
(GetLlmToken, Background), (GetLlmToken, Background),
(GetLlmTokenResponse, Background), (GetLlmTokenResponse, Background),
(LanguageServerIdForName, Background),
(LanguageServerIdForNameResponse, Background),
(OpenUnstagedDiff, Foreground), (OpenUnstagedDiff, Foreground),
(OpenUnstagedDiffResponse, Foreground), (OpenUnstagedDiffResponse, Foreground),
(OpenUncommittedDiff, Foreground), (OpenUncommittedDiff, Foreground),
@ -431,7 +429,6 @@ request_messages!(
(UpdateWorktree, Ack), (UpdateWorktree, Ack),
(UpdateRepository, Ack), (UpdateRepository, Ack),
(RemoveRepository, Ack), (RemoveRepository, Ack),
(LanguageServerIdForName, LanguageServerIdForNameResponse),
(LspExtExpandMacro, LspExtExpandMacroResponse), (LspExtExpandMacro, LspExtExpandMacroResponse),
(LspExtOpenDocs, LspExtOpenDocsResponse), (LspExtOpenDocs, LspExtOpenDocsResponse),
(LspExtRunnables, LspExtRunnablesResponse), (LspExtRunnables, LspExtRunnablesResponse),
@ -588,7 +585,6 @@ entity_messages!(
OpenServerSettings, OpenServerSettings,
GetPermalinkToLine, GetPermalinkToLine,
LanguageServerPromptRequest, LanguageServerPromptRequest,
LanguageServerIdForName,
GitGetBranches, GitGetBranches,
UpdateGitBranch, UpdateGitBranch,
ListToolchains, ListToolchains,