Port to gpui1

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<Task<anyhow::Result<()>>> {
+    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(&macro_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"
+}