diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rs index 76dec3e1b6..5cfcf02174 100644 --- a/crates/editor/src/editor.rs +++ b/crates/editor/src/editor.rs @@ -12,6 +12,7 @@ mod link_go_to_definition; mod mouse_context_menu; pub mod movement; mod persistence; +mod rust_analyzer_ext; pub mod scroll; pub mod selections_collection; @@ -300,6 +301,7 @@ actions!( DeleteToEndOfLine, CutToEndOfLine, DuplicateLine, + ExpandMacroRecursively, MoveLineUp, MoveLineDown, JoinLines, @@ -425,6 +427,8 @@ pub fn init_settings(cx: &mut AppContext) { pub fn init(cx: &mut AppContext) { init_settings(cx); + + rust_analyzer_ext::apply_related_actions(cx); cx.add_action(Editor::new_file); cx.add_action(Editor::new_file_in_direction); cx.add_action(Editor::cancel); diff --git a/crates/editor/src/rust_analyzer_ext.rs b/crates/editor/src/rust_analyzer_ext.rs new file mode 100644 index 0000000000..197215ddaa --- /dev/null +++ b/crates/editor/src/rust_analyzer_ext.rs @@ -0,0 +1,98 @@ +use std::sync::Arc; + +use anyhow::Context as _; +use gpui::{AppContext, Task, ViewContext}; +use language::Language; +use multi_buffer::MultiBuffer; +use project::lsp_ext_command::ExpandMacro; +use text::ToPointUtf16; + +use crate::{Editor, ExpandMacroRecursively}; + +pub fn apply_related_actions(cx: &mut AppContext) { + cx.add_async_action(expand_macro_recursively); +} + +pub fn expand_macro_recursively( + editor: &mut Editor, + _: &ExpandMacroRecursively, + cx: &mut ViewContext<'_, '_, Editor>, +) -> Option>> { + if editor.selections.count() == 0 { + return None; + } + let project = editor.project.as_ref()?; + let workspace = editor.workspace(cx)?; + let multibuffer = editor.buffer().read(cx); + + let (trigger_anchor, rust_language, server_to_query, buffer) = editor + .selections + .disjoint_anchors() + .into_iter() + .filter(|selection| selection.start == selection.end) + .filter_map(|selection| Some((selection.start.buffer_id?, selection.start))) + .filter_map(|(buffer_id, trigger_anchor)| { + let buffer = multibuffer.buffer(buffer_id)?; + let rust_language = buffer.read(cx).language_at(trigger_anchor.text_anchor)?; + if !is_rust_language(&rust_language) { + return None; + } + Some((trigger_anchor, rust_language, buffer)) + }) + .find_map(|(trigger_anchor, rust_language, buffer)| { + project + .read(cx) + .language_servers_for_buffer(buffer.read(cx), cx) + .into_iter() + .find_map(|(adapter, server)| { + if adapter.name.0.as_ref() == "rust-analyzer" { + Some(( + trigger_anchor, + Arc::clone(&rust_language), + server.server_id(), + buffer.clone(), + )) + } else { + None + } + }) + })?; + + let project = project.clone(); + let buffer_snapshot = buffer.read(cx).snapshot(); + let position = trigger_anchor.text_anchor.to_point_utf16(&buffer_snapshot); + let expand_macro_task = project.update(cx, |project, cx| { + project.request_lsp( + buffer, + project::LanguageServerToQuery::Other(server_to_query), + ExpandMacro { position }, + cx, + ) + }); + Some(cx.spawn(|_, mut cx| async move { + let macro_expansion = expand_macro_task.await.context("expand macro")?; + if macro_expansion.is_empty() { + log::info!("Empty macro expansion for position {position:?}"); + return Ok(()); + } + + let buffer = project.update(&mut cx, |project, cx| { + project.create_buffer(¯o_expansion.expansion, Some(rust_language), cx) + })?; + workspace.update(&mut cx, |workspace, cx| { + let buffer = cx.add_model(|cx| { + MultiBuffer::singleton(buffer, cx).with_title(macro_expansion.name) + }); + workspace.add_item( + Box::new(cx.add_view(|cx| Editor::for_multibuffer(buffer, Some(project), cx))), + cx, + ); + }); + + anyhow::Ok(()) + })) +} + +fn is_rust_language(language: &Language) -> bool { + language.name().as_ref() == "Rust" +} diff --git a/crates/project/src/lsp_command.rs b/crates/project/src/lsp_command.rs index 72d79ca979..8d40f6dcb2 100644 --- a/crates/project/src/lsp_command.rs +++ b/crates/project/src/lsp_command.rs @@ -33,7 +33,7 @@ pub fn lsp_formatting_options(tab_size: u32) -> lsp::FormattingOptions { } #[async_trait(?Send)] -pub(crate) trait LspCommand: 'static + Sized { +pub trait LspCommand: 'static + Sized { type Response: 'static + Default + Send; type LspRequest: 'static + Send + lsp::request::Request; type ProtoRequest: 'static + Send + proto::RequestMessage; diff --git a/crates/project/src/lsp_ext_command.rs b/crates/project/src/lsp_ext_command.rs new file mode 100644 index 0000000000..8d6bd0f967 --- /dev/null +++ b/crates/project/src/lsp_ext_command.rs @@ -0,0 +1,137 @@ +use std::{path::Path, sync::Arc}; + +use anyhow::Context; +use async_trait::async_trait; +use gpui::{AppContext, AsyncAppContext, ModelHandle}; +use language::{point_to_lsp, proto::deserialize_anchor, Buffer}; +use lsp::{LanguageServer, LanguageServerId}; +use rpc::proto::{self, PeerId}; +use serde::{Deserialize, Serialize}; +use text::{PointUtf16, ToPointUtf16}; + +use crate::{lsp_command::LspCommand, Project}; + +pub enum LspExpandMacro {} + +impl lsp::request::Request for LspExpandMacro { + type Params = ExpandMacroParams; + type Result = Option; + const METHOD: &'static str = "rust-analyzer/expandMacro"; +} + +#[derive(Deserialize, Serialize, Debug)] +#[serde(rename_all = "camelCase")] +pub struct ExpandMacroParams { + pub text_document: lsp::TextDocumentIdentifier, + pub position: lsp::Position, +} + +#[derive(Default, Deserialize, Serialize, Debug)] +#[serde(rename_all = "camelCase")] +pub struct ExpandedMacro { + pub name: String, + pub expansion: String, +} + +impl ExpandedMacro { + pub fn is_empty(&self) -> bool { + self.name.is_empty() && self.expansion.is_empty() + } +} + +pub struct ExpandMacro { + pub position: PointUtf16, +} + +#[async_trait(?Send)] +impl LspCommand for ExpandMacro { + type Response = ExpandedMacro; + type LspRequest = LspExpandMacro; + type ProtoRequest = proto::LspExtExpandMacro; + + fn to_lsp( + &self, + path: &Path, + _: &Buffer, + _: &Arc, + _: &AppContext, + ) -> ExpandMacroParams { + ExpandMacroParams { + text_document: lsp::TextDocumentIdentifier { + uri: lsp::Url::from_file_path(path).unwrap(), + }, + position: point_to_lsp(self.position), + } + } + + async fn response_from_lsp( + self, + message: Option, + _: ModelHandle, + _: ModelHandle, + _: LanguageServerId, + _: AsyncAppContext, + ) -> anyhow::Result { + Ok(message + .map(|message| ExpandedMacro { + name: message.name, + expansion: message.expansion, + }) + .unwrap_or_default()) + } + + fn to_proto(&self, project_id: u64, buffer: &Buffer) -> proto::LspExtExpandMacro { + proto::LspExtExpandMacro { + project_id, + buffer_id: buffer.remote_id(), + position: Some(language::proto::serialize_anchor( + &buffer.anchor_before(self.position), + )), + } + } + + async fn from_proto( + message: Self::ProtoRequest, + _: ModelHandle, + buffer: ModelHandle, + mut cx: AsyncAppContext, + ) -> anyhow::Result { + let position = message + .position + .and_then(deserialize_anchor) + .context("invalid position")?; + Ok(Self { + position: buffer.update(&mut cx, |buffer, _| position.to_point_utf16(buffer)), + }) + } + + fn response_to_proto( + response: ExpandedMacro, + _: &mut Project, + _: PeerId, + _: &clock::Global, + _: &mut AppContext, + ) -> proto::LspExtExpandMacroResponse { + proto::LspExtExpandMacroResponse { + name: response.name, + expansion: response.expansion, + } + } + + async fn response_from_proto( + self, + message: proto::LspExtExpandMacroResponse, + _: ModelHandle, + _: ModelHandle, + _: AsyncAppContext, + ) -> anyhow::Result { + Ok(ExpandedMacro { + name: message.name, + expansion: message.expansion, + }) + } + + fn buffer_id_from_proto(message: &proto::LspExtExpandMacro) -> u64 { + message.buffer_id + } +} diff --git a/crates/project/src/project.rs b/crates/project/src/project.rs index 2e779b71b2..8b059948c8 100644 --- a/crates/project/src/project.rs +++ b/crates/project/src/project.rs @@ -1,5 +1,6 @@ mod ignore; -mod lsp_command; +pub mod lsp_command; +pub mod lsp_ext_command; mod prettier_support; pub mod project_settings; pub mod search; @@ -174,7 +175,7 @@ struct DelayedDebounced { cancel_channel: Option>, } -enum LanguageServerToQuery { +pub enum LanguageServerToQuery { Primary, Other(LanguageServerId), } @@ -626,6 +627,7 @@ impl Project { client.add_model_request_handler(Self::handle_open_buffer_by_path); client.add_model_request_handler(Self::handle_save_buffer); client.add_model_message_handler(Self::handle_update_diff_base); + client.add_model_request_handler(Self::handle_lsp_command::); } pub fn local( @@ -5863,7 +5865,7 @@ impl Project { .await; } - fn request_lsp( + pub fn request_lsp( &self, buffer_handle: ModelHandle, server: LanguageServerToQuery, diff --git a/crates/rpc/proto/zed.proto b/crates/rpc/proto/zed.proto index 611514aacb..5ae127e277 100644 --- a/crates/rpc/proto/zed.proto +++ b/crates/rpc/proto/zed.proto @@ -178,7 +178,9 @@ message Envelope { GetNotifications get_notifications = 150; GetNotificationsResponse get_notifications_response = 151; DeleteNotification delete_notification = 152; - MarkNotificationRead mark_notification_read = 153; // Current max + MarkNotificationRead mark_notification_read = 153; + LspExtExpandMacro lsp_ext_expand_macro = 154; + LspExtExpandMacroResponse lsp_ext_expand_macro_response = 155; // Current max } } @@ -1619,3 +1621,14 @@ message Notification { bool is_read = 6; optional bool response = 7; } + +message LspExtExpandMacro { + uint64 project_id = 1; + uint64 buffer_id = 2; + Anchor position = 3; +} + +message LspExtExpandMacroResponse { + string name = 1; + string expansion = 2; +} diff --git a/crates/rpc/src/proto.rs b/crates/rpc/src/proto.rs index 77a69122c2..336c252630 100644 --- a/crates/rpc/src/proto.rs +++ b/crates/rpc/src/proto.rs @@ -280,6 +280,8 @@ messages!( (UpdateWorktree, Foreground), (UpdateWorktreeSettings, Foreground), (UsersResponse, Foreground), + (LspExtExpandMacro, Background), + (LspExtExpandMacroResponse, Background), ); request_messages!( @@ -363,6 +365,7 @@ request_messages!( (UpdateParticipantLocation, Ack), (UpdateProject, Ack), (UpdateWorktree, Ack), + (LspExtExpandMacro, LspExtExpandMacroResponse), ); entity_messages!( @@ -415,6 +418,7 @@ entity_messages!( UpdateProjectCollaborator, UpdateWorktree, UpdateWorktreeSettings, + LspExtExpandMacro, ); entity_messages!(