Detailed changes
@@ -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::LspExtRunFlycheck>)
.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_mutating_project_request::<proto::RegisterBufferWithLanguageServers>,
@@ -24,10 +24,7 @@ use language::{
};
use project::{
ProjectPath, SERVER_PROGRESS_THROTTLE_TIMEOUT,
- lsp_store::{
- lsp_ext_command::{ExpandedMacro, LspExtExpandMacro},
- rust_analyzer_ext::RUST_ANALYZER_NAME,
- },
+ lsp_store::lsp_ext_command::{ExpandedMacro, LspExtExpandMacro},
project_settings::{InlineBlameSettings, ProjectSettings},
};
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);
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(
"Rust",
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()
},
);
@@ -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())
})?;
@@ -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)
@@ -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
- })
-}
@@ -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 {
@@ -3284,6 +3284,16 @@ impl InlayHints {
})
.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)]
@@ -3297,17 +3307,7 @@ impl LspCommand for InlayHints {
}
fn check_capabilities(&self, capabilities: AdapterServerCapabilities) -> bool {
- let Some(inlay_hint_provider) = &capabilities.server_capabilities.inlay_hint_provider
- 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,
- },
- }
+ Self::check_capabilities(&capabilities.server_capabilities)
}
fn to_lsp(
@@ -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_register_buffer_with_language_servers);
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_lsp_command::<GetCodeActions>);
client.add_entity_request_handler(Self::handle_lsp_command::<GetCompletions>);
@@ -8745,34 +8744,6 @@ impl LspStore {
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(
this: Entity<Self>,
envelope: TypedEnvelope<proto::RenameProjectEntry>,
@@ -3,12 +3,12 @@ use std::sync::Arc;
use ::serde::{Deserialize, Serialize};
use gpui::WeakEntity;
use language::{CachedLspAdapter, Diagnostic, DiagnosticSourceKind};
-use lsp::LanguageServer;
+use lsp::{LanguageServer, LanguageServerName};
use util::ResultExt as _;
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_DIAGNOSTIC_SEVERITY: lsp::DiagnosticSeverity = lsp::DiagnosticSeverity::INFORMATION;
@@ -34,7 +34,7 @@ pub fn is_inactive_region(diag: &Diagnostic) -> bool {
&& diag
.source
.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 {
@@ -43,7 +43,7 @@ pub fn is_lsp_inactive_region(diag: &lsp::Diagnostic) -> bool {
&& diag
.source
.as_ref()
- .is_some_and(|v| v == CLANGD_SERVER_NAME)
+ .is_some_and(|v| v == &CLANGD_SERVER_NAME.0)
}
pub fn register_notifications(
@@ -51,7 +51,7 @@ pub fn register_notifications(
language_server: &LanguageServer,
adapter: Arc<CachedLspAdapter>,
) {
- if language_server.name().0 != CLANGD_SERVER_NAME {
+ if language_server.name() != CLANGD_SERVER_NAME {
return;
}
let server_id = language_server.server_id();
@@ -2,12 +2,12 @@ use ::serde::{Deserialize, Serialize};
use anyhow::Context as _;
use gpui::{App, Entity, Task, WeakEntity};
use language::ServerHealth;
-use lsp::LanguageServer;
+use lsp::{LanguageServer, LanguageServerName};
use rpc::proto;
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";
/// Experimental: Informs the end user about the state of the server
@@ -97,13 +97,9 @@ pub fn cancel_flycheck(
cx.spawn(async move |cx| {
let buffer = buffer.await?;
- let Some(rust_analyzer_server) = project
- .update(cx, |project, cx| {
- buffer.update(cx, |buffer, cx| {
- project.language_server_id_for_name(buffer, RUST_ANALYZER_NAME, cx)
- })
- })?
- .await
+ let Some(rust_analyzer_server) = project.read_with(cx, |project, cx| {
+ project.language_server_id_for_name(buffer.read(cx), &RUST_ANALYZER_NAME, cx)
+ })?
else {
return Ok(());
};
@@ -148,13 +144,9 @@ pub fn run_flycheck(
cx.spawn(async move |cx| {
let buffer = buffer.await?;
- let Some(rust_analyzer_server) = project
- .update(cx, |project, cx| {
- buffer.update(cx, |buffer, cx| {
- project.language_server_id_for_name(buffer, RUST_ANALYZER_NAME, cx)
- })
- })?
- .await
+ let Some(rust_analyzer_server) = project.read_with(cx, |project, cx| {
+ project.language_server_id_for_name(buffer.read(cx), &RUST_ANALYZER_NAME, cx)
+ })?
else {
return Ok(());
};
@@ -204,13 +196,9 @@ pub fn clear_flycheck(
cx.spawn(async move |cx| {
let buffer = buffer.await?;
- let Some(rust_analyzer_server) = project
- .update(cx, |project, cx| {
- buffer.update(cx, |buffer, cx| {
- project.language_server_id_for_name(buffer, RUST_ANALYZER_NAME, cx)
- })
- })?
- .await
+ let Some(rust_analyzer_server) = project.read_with(cx, |project, cx| {
+ project.language_server_id_for_name(buffer.read(cx), &RUST_ANALYZER_NAME, cx)
+ })?
else {
return Ok(());
};
@@ -5002,63 +5002,53 @@ impl Project {
}
pub fn any_language_server_supports_inlay_hints(&self, buffer: &Buffer, cx: &mut App) -> bool {
- self.lsp_store.update(cx, |this, cx| {
- this.language_servers_for_local_buffer(buffer, cx)
- .any(
- |(_, server)| match server.capabilities().inlay_hint_provider {
- Some(lsp::OneOf::Left(enabled)) => enabled,
- Some(lsp::OneOf::Right(_)) => true,
- None => false,
- },
- )
+ let Some(language) = buffer.language().cloned() else {
+ return false;
+ };
+ self.lsp_store.update(cx, |lsp_store, _| {
+ let relevant_language_servers = lsp_store
+ .languages
+ .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(
&self,
buffer: &Buffer,
- name: &str,
- cx: &mut App,
- ) -> Task<Option<LanguageServerId>> {
- if self.is_local() {
- Task::ready(self.lsp_store.update(cx, |lsp_store, cx| {
- lsp_store
- .language_servers_for_local_buffer(buffer, cx)
- .find_map(|(adapter, server)| {
- if adapter.name.0 == name {
- Some(server.server_id())
- } else {
- 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)
+ name: &LanguageServerName,
+ cx: &App,
+ ) -> Option<LanguageServerId> {
+ let language = buffer.language()?;
+ let relevant_language_servers = self
+ .languages
+ .lsp_adapters(&language.name())
+ .into_iter()
+ .map(|lsp_adapter| lsp_adapter.name())
+ .collect::<HashSet<_>>();
+ if !relevant_language_servers.contains(name) {
+ return 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 {
@@ -818,16 +818,6 @@ message LspResponse {
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 {
uint64 project_id = 1;
uint64 buffer_id = 2;
@@ -362,9 +362,6 @@ message Envelope {
GetDocumentSymbols get_document_symbols = 330;
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;
LoadCommitDiffResponse load_commit_diff_response = 335;
@@ -424,6 +421,7 @@ message Envelope {
reserved 247 to 254;
reserved 255 to 256;
reserved 280 to 281;
+ reserved 332 to 333;
}
message Hello {
@@ -121,8 +121,6 @@ messages!(
(GetImplementationResponse, Background),
(GetLlmToken, Background),
(GetLlmTokenResponse, Background),
- (LanguageServerIdForName, Background),
- (LanguageServerIdForNameResponse, Background),
(OpenUnstagedDiff, Foreground),
(OpenUnstagedDiffResponse, Foreground),
(OpenUncommittedDiff, Foreground),
@@ -431,7 +429,6 @@ request_messages!(
(UpdateWorktree, Ack),
(UpdateRepository, Ack),
(RemoveRepository, Ack),
- (LanguageServerIdForName, LanguageServerIdForNameResponse),
(LspExtExpandMacro, LspExtExpandMacroResponse),
(LspExtOpenDocs, LspExtOpenDocsResponse),
(LspExtRunnables, LspExtRunnablesResponse),
@@ -588,7 +585,6 @@ entity_messages!(
OpenServerSettings,
GetPermalinkToLine,
LanguageServerPromptRequest,
- LanguageServerIdForName,
GitGetBranches,
UpdateGitBranch,
ListToolchains,