Allow actions with multiple selectable edits

Author: SomeoneToIgnore

crates/ra_assists/src/assist_ctx.rs

@@ -14,7 +14,7 @@ use crate::{AssistAction, AssistId, AssistLabel};
 #[derive(Clone, Debug)]
 pub(crate) enum Assist {
     Unresolved { label: AssistLabel },
-    Resolved { label: AssistLabel, action: AssistAction },
+    Resolved { label: AssistLabel, available_actions: Vec<AssistAction> },
 }
 
 /// `AssistCtx` allows to apply an assist or check if it could be applied.
@@ -77,20 +77,40 @@ impl<'a, DB: HirDatabase> AssistCtx<'a, DB> {
         f(ctx)
     }
 
-    pub(crate) fn add_assist(
+    pub(crate) fn add_assist_with_single_action(
         self,
         id: AssistId,
         label: impl Into<String>,
-        f: impl FnOnce(&mut AssistBuilder),
+        f: impl FnOnce(&mut ActionBuilder),
     ) -> Option<Assist> {
         let label = AssistLabel { label: label.into(), id };
         let assist = if self.should_compute_edit {
             let action = {
-                let mut edit = AssistBuilder::default();
+                let mut edit = ActionBuilder::default();
                 f(&mut edit);
                 edit.build()
             };
-            Assist::Resolved { label, action }
+            Assist::Resolved { label, available_actions: vec![action] }
+        } else {
+            Assist::Unresolved { label }
+        };
+
+        Some(assist)
+    }
+
+    #[allow(dead_code)] // will be used for auto import assist with multiple actions
+    pub(crate) fn add_assist(
+        self,
+        id: AssistId,
+        label: impl Into<String>,
+        f: impl FnOnce() -> Vec<ActionBuilder>,
+    ) -> Option<Assist> {
+        let label = AssistLabel { label: label.into(), id };
+        let assist = if self.should_compute_edit {
+            Assist::Resolved {
+                label,
+                available_actions: f().into_iter().map(ActionBuilder::build).collect(),
+            }
         } else {
             Assist::Unresolved { label }
         };
@@ -126,13 +146,20 @@ impl<'a, DB: HirDatabase> AssistCtx<'a, DB> {
 }
 
 #[derive(Default)]
-pub(crate) struct AssistBuilder {
+pub(crate) struct ActionBuilder {
     edit: TextEditBuilder,
     cursor_position: Option<TextUnit>,
     target: Option<TextRange>,
+    label: Option<String>,
 }
 
-impl AssistBuilder {
+impl ActionBuilder {
+    #[allow(dead_code)]
+    /// Adds a custom label to the action, if it needs to be different from the assist label
+    pub fn label(&mut self, label: impl Into<String>) {
+        self.label = Some(label.into())
+    }
+
     /// Replaces specified `range` of text with a given string.
     pub(crate) fn replace(&mut self, range: TextRange, replace_with: impl Into<String>) {
         self.edit.replace(range, replace_with.into())
@@ -191,6 +218,7 @@ impl AssistBuilder {
             edit: self.edit.finish(),
             cursor_position: self.cursor_position,
             target: self.target,
+            label: self.label,
         }
     }
 }

crates/ra_assists/src/assists/add_custom_impl.rs

@@ -49,7 +49,7 @@ pub(crate) fn add_custom_impl(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist
     let annotated_name = annotated.syntax().text().to_string();
     let start_offset = annotated.syntax().parent()?.text_range().end();
 
-    ctx.add_assist(AssistId("add_custom_impl"), "add custom impl", |edit| {
+    ctx.add_assist_with_single_action(AssistId("add_custom_impl"), "add custom impl", |edit| {
         edit.target(attr.syntax().text_range());
 
         let new_attr_input = input
@@ -98,11 +98,11 @@ pub(crate) fn add_custom_impl(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::helpers::{check_assist, check_assist_not_applicable};
+    use crate::helpers::{check_assist_first_action, check_assist_not_applicable};
 
     #[test]
     fn add_custom_impl_for_unique_input() {
-        check_assist(
+        check_assist_first_action(
             add_custom_impl,
             "
 #[derive(Debu<|>g)]
@@ -124,7 +124,7 @@ impl Debug for Foo {
 
     #[test]
     fn add_custom_impl_for_with_visibility_modifier() {
-        check_assist(
+        check_assist_first_action(
             add_custom_impl,
             "
 #[derive(Debug<|>)]
@@ -146,7 +146,7 @@ impl Debug for Foo {
 
     #[test]
     fn add_custom_impl_when_multiple_inputs() {
-        check_assist(
+        check_assist_first_action(
             add_custom_impl,
             "
 #[derive(Display, Debug<|>, Serialize)]

crates/ra_assists/src/assists/add_derive.rs

@@ -28,7 +28,7 @@ use crate::{Assist, AssistCtx, AssistId};
 pub(crate) fn add_derive(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
     let nominal = ctx.find_node_at_offset::<ast::NominalDef>()?;
     let node_start = derive_insertion_offset(&nominal)?;
-    ctx.add_assist(AssistId("add_derive"), "add `#[derive]`", |edit| {
+    ctx.add_assist_with_single_action(AssistId("add_derive"), "add `#[derive]`", |edit| {
         let derive_attr = nominal
             .attrs()
             .filter_map(|x| x.as_simple_call())
@@ -43,7 +43,7 @@ pub(crate) fn add_derive(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
             Some(tt) => tt.syntax().text_range().end() - TextUnit::of_char(')'),
         };
         edit.target(nominal.syntax().text_range());
-        edit.set_cursor(offset)
+        edit.set_cursor(offset);
     })
 }
 
@@ -59,16 +59,16 @@ fn derive_insertion_offset(nominal: &ast::NominalDef) -> Option<TextUnit> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::helpers::{check_assist, check_assist_target};
+    use crate::helpers::{check_assist_first_action, check_assist_first_action_target};
 
     #[test]
     fn add_derive_new() {
-        check_assist(
+        check_assist_first_action(
             add_derive,
             "struct Foo { a: i32, <|>}",
             "#[derive(<|>)]\nstruct Foo { a: i32, }",
         );
-        check_assist(
+        check_assist_first_action(
             add_derive,
             "struct Foo { <|> a: i32, }",
             "#[derive(<|>)]\nstruct Foo {  a: i32, }",
@@ -77,7 +77,7 @@ mod tests {
 
     #[test]
     fn add_derive_existing() {
-        check_assist(
+        check_assist_first_action(
             add_derive,
             "#[derive(Clone)]\nstruct Foo { a: i32<|>, }",
             "#[derive(Clone<|>)]\nstruct Foo { a: i32, }",
@@ -86,7 +86,7 @@ mod tests {
 
     #[test]
     fn add_derive_new_with_doc_comment() {
-        check_assist(
+        check_assist_first_action(
             add_derive,
             "
 /// `Foo` is a pretty important struct.
@@ -104,7 +104,7 @@ struct Foo { a: i32, }
 
     #[test]
     fn add_derive_target() {
-        check_assist_target(
+        check_assist_first_action_target(
             add_derive,
             "
 struct SomeThingIrrelevant;

crates/ra_assists/src/assists/add_explicit_type.rs

@@ -47,7 +47,7 @@ pub(crate) fn add_explicit_type(ctx: AssistCtx<impl HirDatabase>) -> Option<Assi
         return None;
     }
 
-    ctx.add_assist(AssistId("add_explicit_type"), "add explicit type", |edit| {
+    ctx.add_assist_with_single_action(AssistId("add_explicit_type"), "add explicit type", |edit| {
         edit.target(pat_range);
         edit.insert(name_range.end(), format!(": {}", ty.display(db)));
     })
@@ -57,16 +57,18 @@ pub(crate) fn add_explicit_type(ctx: AssistCtx<impl HirDatabase>) -> Option<Assi
 mod tests {
     use super::*;
 
-    use crate::helpers::{check_assist, check_assist_not_applicable, check_assist_target};
+    use crate::helpers::{
+        check_assist_first_action, check_assist_first_action_target, check_assist_not_applicable,
+    };
 
     #[test]
     fn add_explicit_type_target() {
-        check_assist_target(add_explicit_type, "fn f() { let a<|> = 1; }", "a");
+        check_assist_first_action_target(add_explicit_type, "fn f() { let a<|> = 1; }", "a");
     }
 
     #[test]
     fn add_explicit_type_works_for_simple_expr() {
-        check_assist(
+        check_assist_first_action(
             add_explicit_type,
             "fn f() { let a<|> = 1; }",
             "fn f() { let a<|>: i32 = 1; }",
@@ -75,7 +77,7 @@ mod tests {
 
     #[test]
     fn add_explicit_type_works_for_macro_call() {
-        check_assist(
+        check_assist_first_action(
             add_explicit_type,
             "macro_rules! v { () => {0u64} } fn f() { let a<|> = v!(); }",
             "macro_rules! v { () => {0u64} } fn f() { let a<|>: u64 = v!(); }",
@@ -84,7 +86,7 @@ mod tests {
 
     #[test]
     fn add_explicit_type_works_for_macro_call_recursive() {
-        check_assist(
+        check_assist_first_action(
             add_explicit_type,
             "macro_rules! u { () => {0u64} } macro_rules! v { () => {u!()} } fn f() { let a<|> = v!(); }",
             "macro_rules! u { () => {0u64} } macro_rules! v { () => {u!()} } fn f() { let a<|>: u64 = v!(); }",

crates/ra_assists/src/assists/add_impl.rs

@@ -30,7 +30,7 @@ use crate::{Assist, AssistCtx, AssistId};
 pub(crate) fn add_impl(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
     let nominal = ctx.find_node_at_offset::<ast::NominalDef>()?;
     let name = nominal.name()?;
-    ctx.add_assist(AssistId("add_impl"), "add impl", |edit| {
+    ctx.add_assist_with_single_action(AssistId("add_impl"), "add impl", |edit| {
         edit.target(nominal.syntax().text_range());
         let type_params = nominal.type_param_list();
         let start_offset = nominal.syntax().text_range().end();
@@ -60,17 +60,21 @@ pub(crate) fn add_impl(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::helpers::{check_assist, check_assist_target};
+    use crate::helpers::{check_assist_first_action, check_assist_first_action_target};
 
     #[test]
     fn test_add_impl() {
-        check_assist(add_impl, "struct Foo {<|>}\n", "struct Foo {}\n\nimpl Foo {\n<|>\n}\n");
-        check_assist(
+        check_assist_first_action(
+            add_impl,
+            "struct Foo {<|>}\n",
+            "struct Foo {}\n\nimpl Foo {\n<|>\n}\n",
+        );
+        check_assist_first_action(
             add_impl,
             "struct Foo<T: Clone> {<|>}",
             "struct Foo<T: Clone> {}\n\nimpl<T: Clone> Foo<T> {\n<|>\n}",
         );
-        check_assist(
+        check_assist_first_action(
             add_impl,
             "struct Foo<'a, T: Foo<'a>> {<|>}",
             "struct Foo<'a, T: Foo<'a>> {}\n\nimpl<'a, T: Foo<'a>> Foo<'a, T> {\n<|>\n}",
@@ -79,7 +83,7 @@ mod tests {
 
     #[test]
     fn add_impl_target() {
-        check_assist_target(
+        check_assist_first_action_target(
             add_impl,
             "
 struct SomeThingIrrelevant;