10 files changed, 246 insertions, 214 deletions

diff --git a/crates/ra_assists/src/assist_ctx.rs b/crates/ra_assists/src/assist_ctx.rs
index 81f999090..5aab5fb8b 100644
--- a/crates/ra_assists/src/assist_ctx.rs
+++ b/crates/ra_assists/src/assist_ctx.rs
@@ -1,5 +1,4 @@
 //! This module defines `AssistCtx` -- the API surface that is exposed to assists.
-use either::Either;
 use hir::{InFile, SourceAnalyzer, SourceBinder};
 use ra_db::{FileRange, SourceDatabase};
 use ra_fmt::{leading_indent, reindent};
@@ -11,12 +10,36 @@ use ra_syntax::{
 };
 use ra_text_edit::TextEditBuilder;
 
-use crate::{AssistAction, AssistId, AssistLabel, ResolvedAssist};
+use crate::{AssistAction, AssistId, AssistLabel, GroupLabel, ResolvedAssist};
 
 #[derive(Clone, Debug)]
-pub(crate) enum Assist {
-    Unresolved { label: AssistLabel },
-    Resolved { assist: ResolvedAssist },
+pub(crate) struct Assist(pub(crate) Vec<AssistInfo>);
+
+#[derive(Clone, Debug)]
+pub(crate) struct AssistInfo {
+    pub(crate) label: AssistLabel,
+    pub(crate) group_label: Option<GroupLabel>,
+    pub(crate) action: Option<AssistAction>,
+}
+
+impl AssistInfo {
+    fn new(label: AssistLabel) -> AssistInfo {
+        AssistInfo { label, group_label: None, action: None }
+    }
+
+    fn resolved(self, action: AssistAction) -> AssistInfo {
+        AssistInfo { action: Some(action), ..self }
+    }
+
+    fn with_group(self, group_label: GroupLabel) -> AssistInfo {
+        AssistInfo { group_label: Some(group_label), ..self }
+    }
+
+    pub(crate) fn into_resolved(self) -> Option<ResolvedAssist> {
+        let label = self.label;
+        let group_label = self.group_label;
+        self.action.map(|action| ResolvedAssist { label, group_label, action })
+    }
 }
 
 pub(crate) type AssistHandler = fn(AssistCtx) -> Option<Assist>;
@@ -84,44 +107,21 @@ impl<'a> AssistCtx<'a> {
     ) -> Option<Assist> {
         let label = AssistLabel::new(label.into(), id);
 
-        let assist = if self.should_compute_edit {
+        let mut info = AssistInfo::new(label);
+        if self.should_compute_edit {
             let action = {
                 let mut edit = ActionBuilder::default();
                 f(&mut edit);
                 edit.build()
             };
-            Assist::Resolved { assist: ResolvedAssist { label, action_data: Either::Left(action) } }
-        } else {
-            Assist::Unresolved { label }
+            info = info.resolved(action)
         };
 
-        Some(assist)
+        Some(Assist(vec![info]))
     }
 
-    pub(crate) fn add_assist_group(
-        self,
-        id: AssistId,
-        label: impl Into<String>,
-        f: impl FnOnce() -> Vec<ActionBuilder>,
-    ) -> Option<Assist> {
-        let label = AssistLabel::new(label.into(), id);
-        let assist = if self.should_compute_edit {
-            let actions = f();
-            assert!(!actions.is_empty(), "Assist cannot have no");
-
-            Assist::Resolved {
-                assist: ResolvedAssist {
-                    label,
-                    action_data: Either::Right(
-                        actions.into_iter().map(ActionBuilder::build).collect(),
-                    ),
-                },
-            }
-        } else {
-            Assist::Unresolved { label }
-        };
-
-        Some(assist)
+    pub(crate) fn add_assist_group(self, group_name: impl Into<String>) -> AssistGroup<'a> {
+        AssistGroup { ctx: self, group_name: group_name.into(), assists: Vec::new() }
     }
 
     pub(crate) fn token_at_offset(&self) -> TokenAtOffset<SyntaxToken> {
@@ -155,20 +155,48 @@ impl<'a> AssistCtx<'a> {
     }
 }
 
+pub(crate) struct AssistGroup<'a> {
+    ctx: AssistCtx<'a>,
+    group_name: String,
+    assists: Vec<AssistInfo>,
+}
+
+impl<'a> AssistGroup<'a> {
+    pub(crate) fn add_assist(
+        &mut self,
+        id: AssistId,
+        label: impl Into<String>,
+        f: impl FnOnce(&mut ActionBuilder),
+    ) {
+        let label = AssistLabel::new(label.into(), id);
+
+        let mut info = AssistInfo::new(label).with_group(GroupLabel(self.group_name.clone()));
+        if self.ctx.should_compute_edit {
+            let action = {
+                let mut edit = ActionBuilder::default();
+                f(&mut edit);
+                edit.build()
+            };
+            info = info.resolved(action)
+        };
+
+        self.assists.push(info)
+    }
+
+    pub(crate) fn finish(self) -> Option<Assist> {
+        assert!(!self.assists.is_empty());
+        Some(Assist(self.assists))
+    }
+}
+
 #[derive(Default)]
 pub(crate) struct ActionBuilder {
     edit: TextEditBuilder,
     cursor_position: Option<TextUnit>,
     target: Option<TextRange>,
-    label: Option<String>,
 }
 
 impl ActionBuilder {
-    /// Adds a custom label to the action, if it needs to be different from the assist label
-    pub(crate) 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())
@@ -227,7 +255,6 @@ impl ActionBuilder {
             edit: self.edit.finish(),
             cursor_position: self.cursor_position,
             target: self.target,
-            label: self.label,
         }
     }
 }
diff --git a/crates/ra_assists/src/doc_tests.rs b/crates/ra_assists/src/doc_tests.rs
index ae0e5605c..c0f9bc1fb 100644
--- a/crates/ra_assists/src/doc_tests.rs
+++ b/crates/ra_assists/src/doc_tests.rs
@@ -30,6 +30,6 @@ fn check(assist_id: &str, before: &str, after: &str) {
             )
         });
 
-    let actual = assist.get_first_action().edit.apply(&before);
+    let actual = assist.action.edit.apply(&before);
     assert_eq_text!(after, &actual);
 }
diff --git a/crates/ra_assists/src/doc_tests/generated.rs b/crates/ra_assists/src/doc_tests/generated.rs
index 0d95b957b..4ab09b167 100644
--- a/crates/ra_assists/src/doc_tests/generated.rs
+++ b/crates/ra_assists/src/doc_tests/generated.rs
@@ -1,4 +1,4 @@
-//! Generated file, do not edit by hand, see `crate/ra_tools/src/codegen`
+//! Generated file, do not edit by hand, see `xtask/src/codegen`
 
 use super::check;
 
@@ -161,21 +161,6 @@ impl Trait<u32> for () {
 }
 
 #[test]
-fn doctest_add_import() {
-    check(
-        "add_import",
-        r#####"
-fn process(map: std::collections::<|>HashMap<String, String>) {}
-"#####,
-        r#####"
-use std::collections::HashMap;
-
-fn process(map: HashMap<String, String>) {}
-"#####,
-    )
-}
-
-#[test]
 fn doctest_add_new() {
     check(
         "add_new",
@@ -592,6 +577,21 @@ fn handle(action: Action) {
 }
 
 #[test]
+fn doctest_replace_qualified_name_with_use() {
+    check(
+        "replace_qualified_name_with_use",
+        r#####"
+fn process(map: std::collections::<|>HashMap<String, String>) {}
+"#####,
+        r#####"
+use std::collections::HashMap;
+
+fn process(map: HashMap<String, String>) {}
+"#####,
+    )
+}
+
+#[test]
 fn doctest_split_import() {
     check(
         "split_import",
diff --git a/crates/ra_assists/src/handlers/add_new.rs b/crates/ra_assists/src/handlers/add_new.rs
index a08639311..2701eddb8 100644
--- a/crates/ra_assists/src/handlers/add_new.rs
+++ b/crates/ra_assists/src/handlers/add_new.rs
@@ -1,5 +1,5 @@
 use format_buf::format;
-use hir::InFile;
+use hir::{Adt, InFile};
 use join_to_string::join;
 use ra_syntax::{
     ast::{
@@ -135,16 +135,22 @@ fn find_struct_impl(ctx: &AssistCtx, strukt: &ast::StructDef) -> Option<Option<a
     })?;
     let mut sb = ctx.source_binder();
 
-    let struct_ty = {
+    let struct_def = {
         let src = InFile { file_id: ctx.frange.file_id.into(), value: strukt.clone() };
-        sb.to_def(src)?.ty(db)
+        sb.to_def(src)?
     };
 
     let block = module.descendants().filter_map(ast::ImplBlock::cast).find_map(|impl_blk| {
         let src = InFile { file_id: ctx.frange.file_id.into(), value: impl_blk.clone() };
         let blk = sb.to_def(src)?;
 
-        let same_ty = blk.target_ty(db) == struct_ty;
+        // FIXME: handle e.g. `struct S<T>; impl<U> S<U> {}`
+        // (we currently use the wrong type parameter)
+        // also we wouldn't want to use e.g. `impl S<u32>`
+        let same_ty = match blk.target_ty(db).as_adt() {
+            Some(def) => def == Adt::Struct(struct_def),
+            None => false,
+        };
         let not_trait_impl = blk.target_trait(db).is_none();
 
         if !(same_ty && not_trait_impl) {
diff --git a/crates/ra_assists/src/handlers/auto_import.rs b/crates/ra_assists/src/handlers/auto_import.rs
index 84b5474f9..1fb701da5 100644
--- a/crates/ra_assists/src/handlers/auto_import.rs
+++ b/crates/ra_assists/src/handlers/auto_import.rs
@@ -1,13 +1,9 @@
-use hir::ModPath;
 use ra_ide_db::imports_locator::ImportsLocator;
-use ra_syntax::{
-    ast::{self, AstNode},
-    SyntaxNode,
-};
+use ra_syntax::ast::{self, AstNode};
 
 use crate::{
-    assist_ctx::{ActionBuilder, Assist, AssistCtx},
-    auto_import_text_edit, AssistId,
+    assist_ctx::{Assist, AssistCtx},
+    insert_use_statement, AssistId,
 };
 use std::collections::BTreeSet;
 
@@ -31,31 +27,34 @@ use std::collections::BTreeSet;
 // # pub mod std { pub mod collections { pub struct HashMap { } } }
 // ```
 pub(crate) fn auto_import(ctx: AssistCtx) -> Option<Assist> {
-    let path_to_import: ast::Path = ctx.find_node_at_offset()?;
-    let path_to_import_syntax = path_to_import.syntax();
-    if path_to_import_syntax.ancestors().find_map(ast::UseItem::cast).is_some() {
+    let path_under_caret: ast::Path = ctx.find_node_at_offset()?;
+    if path_under_caret.syntax().ancestors().find_map(ast::UseItem::cast).is_some() {
         return None;
     }
-    let name_to_import =
-        path_to_import_syntax.descendants().find_map(ast::NameRef::cast)?.syntax().to_string();
 
-    let module = path_to_import_syntax.ancestors().find_map(ast::Module::cast);
+    let module = path_under_caret.syntax().ancestors().find_map(ast::Module::cast);
     let position = match module.and_then(|it| it.item_list()) {
         Some(item_list) => item_list.syntax().clone(),
         None => {
-            let current_file = path_to_import_syntax.ancestors().find_map(ast::SourceFile::cast)?;
+            let current_file =
+                path_under_caret.syntax().ancestors().find_map(ast::SourceFile::cast)?;
             current_file.syntax().clone()
         }
     };
     let source_analyzer = ctx.source_analyzer(&position, None);
     let module_with_name_to_import = source_analyzer.module()?;
-    if source_analyzer.resolve_path(ctx.db, &path_to_import).is_some() {
+
+    let name_ref_to_import =
+        path_under_caret.syntax().descendants().find_map(ast::NameRef::cast)?;
+    if source_analyzer
+        .resolve_path(ctx.db, &name_ref_to_import.syntax().ancestors().find_map(ast::Path::cast)?)
+        .is_some()
+    {
         return None;
     }
 
-    let mut imports_locator = ImportsLocator::new(ctx.db);
-
-    let proposed_imports = imports_locator
+    let name_to_import = name_ref_to_import.syntax().to_string();
+    let proposed_imports = ImportsLocator::new(ctx.db)
         .find_imports(&name_to_import)
         .into_iter()
         .filter_map(|module_def| module_with_name_to_import.find_use_path(ctx.db, module_def))
@@ -67,24 +66,24 @@ pub(crate) fn auto_import(ctx: AssistCtx) -> Option<Assist> {
         return None;
     }
 
-    ctx.add_assist_group(AssistId("auto_import"), format!("Import {}", name_to_import), || {
-        proposed_imports
-            .into_iter()
-            .map(|import| import_to_action(import, &position, &path_to_import_syntax))
-            .collect()
-    })
-}
-
-fn import_to_action(import: ModPath, position: &SyntaxNode, anchor: &SyntaxNode) -> ActionBuilder {
-    let mut action_builder = ActionBuilder::default();
-    action_builder.label(format!("Import `{}`", &import));
-    auto_import_text_edit(position, anchor, &import, action_builder.text_edit_builder());
-    action_builder
+    let mut group = ctx.add_assist_group(format!("Import {}", name_to_import));
+    for import in proposed_imports {
+        group.add_assist(AssistId("auto_import"), format!("Import `{}`", &import), |edit| {
+            edit.target(path_under_caret.syntax().text_range());
+            insert_use_statement(
+                &position,
+                path_under_caret.syntax(),
+                &import,
+                edit.text_edit_builder(),
+            );
+        });
+    }
+    group.finish()
 }
 
 #[cfg(test)]
 mod tests {
-    use crate::helpers::{check_assist, check_assist_not_applicable};
+    use crate::helpers::{check_assist, check_assist_not_applicable, check_assist_target};
 
     use super::*;
 
@@ -255,4 +254,40 @@ mod tests {
             ",
         );
     }
+
+    #[test]
+    fn auto_import_target() {
+        check_assist_target(
+            auto_import,
+            r"
+            struct AssistInfo {
+                group_label: Option<<|>GroupLabel>,
+            }
+
+            mod m { pub struct GroupLabel; }
+            ",
+            "GroupLabel",
+        )
+    }
+
+    #[test]
+    fn not_applicable_when_path_start_is_imported() {
+        check_assist_not_applicable(
+            auto_import,
+            r"
+            pub mod mod1 {
+                pub mod mod2 {
+                    pub mod mod3 {
+                        pub struct TestStruct;
+                    }
+                }
+            }
+
+            use mod1::mod2;
+            fn main() {
+                mod2::mod3::TestStruct<|>
+            }
+            ",
+        );
+    }
 }
diff --git a/crates/ra_assists/src/handlers/fill_match_arms.rs b/crates/ra_assists/src/handlers/fill_match_arms.rs
index 0908fc246..ae2437ed3 100644
--- a/crates/ra_assists/src/handlers/fill_match_arms.rs
+++ b/crates/ra_assists/src/handlers/fill_match_arms.rs
@@ -75,10 +75,10 @@ pub(crate) fn fill_match_arms(ctx: AssistCtx) -> Option<Assist> {
 }
 
 fn is_trivial(arm: &ast::MatchArm) -> bool {
-    arm.pats().any(|pat| match pat {
-        ast::Pat::PlaceholderPat(..) => true,
+    match arm.pat() {
+        Some(ast::Pat::PlaceholderPat(..)) => true,
         _ => false,
-    })
+    }
 }
 
 fn resolve_enum_def(
diff --git a/crates/ra_assists/src/handlers/merge_match_arms.rs b/crates/ra_assists/src/handlers/merge_match_arms.rs
index 670614dd8..b2a194cb5 100644
--- a/crates/ra_assists/src/handlers/merge_match_arms.rs
+++ b/crates/ra_assists/src/handlers/merge_match_arms.rs
@@ -75,7 +75,7 @@ pub(crate) fn merge_match_arms(ctx: AssistCtx) -> Option<Assist> {
         } else {
             arms_to_merge
                 .iter()
-                .flat_map(ast::MatchArm::pats)
+                .filter_map(ast::MatchArm::pat)
                 .map(|x| x.syntax().to_string())
                 .collect::<Vec<String>>()
                 .join(" | ")
@@ -96,10 +96,10 @@ pub(crate) fn merge_match_arms(ctx: AssistCtx) -> Option<Assist> {
 }
 
 fn contains_placeholder(a: &ast::MatchArm) -> bool {
-    a.pats().any(|x| match x {
-        ra_syntax::ast::Pat::PlaceholderPat(..) => true,
+    match a.pat() {
+        Some(ra_syntax::ast::Pat::PlaceholderPat(..)) => true,
         _ => false,
-    })
+    }
 }
 
 fn next_arm(arm: &ast::MatchArm) -> Option<ast::MatchArm> {
diff --git a/crates/ra_assists/src/handlers/move_guard.rs b/crates/ra_assists/src/handlers/move_guard.rs
index 2b91ce7c4..a61a2ba3e 100644
--- a/crates/ra_assists/src/handlers/move_guard.rs
+++ b/crates/ra_assists/src/handlers/move_guard.rs
@@ -90,7 +90,7 @@ pub(crate) fn move_guard_to_arm_body(ctx: AssistCtx) -> Option<Assist> {
 // ```
 pub(crate) fn move_arm_cond_to_match_guard(ctx: AssistCtx) -> Option<Assist> {
     let match_arm: MatchArm = ctx.find_node_at_offset::<MatchArm>()?;
-    let last_match_pat = match_arm.pats().last()?;
+    let match_pat = match_arm.pat()?;
 
     let arm_body = match_arm.expr()?;
     let if_expr: IfExpr = IfExpr::cast(arm_body.syntax().clone())?;
@@ -122,8 +122,8 @@ pub(crate) fn move_arm_cond_to_match_guard(ctx: AssistCtx) -> Option<Assist> {
                 _ => edit.replace(if_expr.syntax().text_range(), then_block.syntax().text()),
             }
 
-            edit.insert(last_match_pat.syntax().text_range().end(), buf);
-            edit.set_cursor(last_match_pat.syntax().text_range().end() + TextUnit::from(1));
+            edit.insert(match_pat.syntax().text_range().end(), buf);
+            edit.set_cursor(match_pat.syntax().text_range().end() + TextUnit::from(1));
         },
     )
 }
diff --git a/crates/ra_assists/src/handlers/add_import.rs b/crates/ra_assists/src/handlers/replace_qualified_name_with_use.rs
index f03dddac8..b70c88ec2 100644
--- a/crates/ra_assists/src/handlers/add_import.rs
+++ b/crates/ra_assists/src/handlers/replace_qualified_name_with_use.rs
@@ -12,10 +12,10 @@ use crate::{
     AssistId,
 };
 
-/// This function produces sequence of text edits into edit
-/// to import the target path in the most appropriate scope given
-/// the cursor position
-pub fn auto_import_text_edit(
+/// Creates and inserts a use statement for the given path to import.
+/// The use statement is inserted in the scope most appropriate to the
+/// the cursor position given, additionally merged with the existing use imports.
+pub fn insert_use_statement(
     // Ideally the position of the cursor, used to
     position: &SyntaxNode,
     // The statement to use as anchor (last resort)
@@ -37,9 +37,9 @@ pub fn auto_import_text_edit(
     }
 }
 
-// Assist: add_import
+// Assist: replace_qualified_name_with_use
 //
-// Adds a use statement for a given fully-qualified path.
+// Adds a use statement for a given fully-qualified name.
 //
 // ```
 // fn process(map: std::collections::<|>HashMap<String, String>) {}
@@ -50,7 +50,7 @@ pub fn auto_import_text_edit(
 //
 // fn process(map: HashMap<String, String>) {}
 // ```
-pub(crate) fn add_import(ctx: AssistCtx) -> Option<Assist> {
+pub(crate) fn replace_qualified_name_with_use(ctx: AssistCtx) -> Option<Assist> {
     let path: ast::Path = ctx.find_node_at_offset()?;
     // We don't want to mess with use statements
     if path.syntax().ancestors().find_map(ast::UseItem::cast).is_some() {
@@ -72,9 +72,13 @@ pub(crate) fn add_import(ctx: AssistCtx) -> Option<Assist> {
         }
     };
 
-    ctx.add_assist(AssistId("add_import"), format!("Import {}", fmt_segments(&segments)), |edit| {
-        apply_auto_import(&position, &path, &segments, edit.text_edit_builder());
-    })
+    ctx.add_assist(
+        AssistId("replace_qualified_name_with_use"),
+        "Replace qualified path with use",
+        |edit| {
+            replace_with_use(&position, &path, &segments, edit.text_edit_builder());
+        },
+    )
 }
 
 fn collect_path_segments_raw(
@@ -107,12 +111,6 @@ fn collect_path_segments_raw(
     Some(segments.len() - oldlen)
 }
 
-fn fmt_segments(segments: &[SmolStr]) -> String {
-    let mut buf = String::new();
-    fmt_segments_raw(segments, &mut buf);
-    buf
-}
-
 fn fmt_segments_raw(segments: &[SmolStr], buf: &mut String) {
     let mut iter = segments.iter();
     if let Some(s) = iter.next() {
@@ -558,7 +556,7 @@ fn make_assist_add_nested_import(
     }
 }
 
-fn apply_auto_import(
+fn replace_with_use(
     container: &SyntaxNode,
     path: &ast::Path,
     target: &[SmolStr],
@@ -567,7 +565,7 @@ fn apply_auto_import(
     let action = best_action_for_target(container.clone(), path.syntax().clone(), target);
     make_assist(&action, target, edit);
     if let Some(last) = path.segment() {
-        // Here we are assuming the assist will provide a  correct use statement
+        // Here we are assuming the assist will provide a correct use statement
         // so we can delete the path qualifier
         edit.delete(TextRange::from_to(
             path.syntax().text_range().start(),
@@ -603,9 +601,9 @@ mod tests {
     use super::*;
 
     #[test]
-    fn test_auto_import_add_use_no_anchor() {
+    fn test_replace_add_use_no_anchor() {
         check_assist(
-            add_import,
+            replace_qualified_name_with_use,
             "
 std::fmt::Debug<|>
     ",
@@ -617,9 +615,9 @@ Debug<|>
         );
     }
     #[test]
-    fn test_auto_import_add_use_no_anchor_with_item_below() {
+    fn test_replace_add_use_no_anchor_with_item_below() {
         check_assist(
-            add_import,
+            replace_qualified_name_with_use,
             "
 std::fmt::Debug<|>
 
@@ -638,9 +636,9 @@ fn main() {
     }
 
     #[test]
-    fn test_auto_import_add_use_no_anchor_with_item_above() {
+    fn test_replace_add_use_no_anchor_with_item_above() {
         check_assist(
-            add_import,
+            replace_qualified_name_with_use,
             "
 fn main() {
 }
@@ -659,9 +657,9 @@ Debug<|>
     }
 
     #[test]
-    fn test_auto_import_add_use_no_anchor_2seg() {
+    fn test_replace_add_use_no_anchor_2seg() {
         check_assist(
-            add_import,
+            replace_qualified_name_with_use,
             "
 std::fmt<|>::Debug
     ",
@@ -674,9 +672,9 @@ fmt<|>::Debug
     }
 
     #[test]
-    fn test_auto_import_add_use() {
+    fn test_replace_add_use() {
         check_assist(
-            add_import,
+            replace_qualified_name_with_use,
             "
 use stdx;
 
@@ -694,9 +692,9 @@ impl Debug<|> for Foo {
     }
 
     #[test]
-    fn test_auto_import_file_use_other_anchor() {
+    fn test_replace_file_use_other_anchor() {
         check_assist(
-            add_import,
+            replace_qualified_name_with_use,
             "
 impl std::fmt::Debug<|> for Foo {
 }
@@ -711,9 +709,9 @@ impl Debug<|> for Foo {
     }
 
     #[test]
-    fn test_auto_import_add_use_other_anchor_indent() {
+    fn test_replace_add_use_other_anchor_indent() {
         check_assist(
-            add_import,
+            replace_qualified_name_with_use,
             "
     impl std::fmt::Debug<|> for Foo {
     }
@@ -728,9 +726,9 @@ impl Debug<|> for Foo {
     }
 
     #[test]
-    fn test_auto_import_split_different() {
+    fn test_replace_split_different() {
         check_assist(
-            add_import,
+            replace_qualified_name_with_use,
             "
 use std::fmt;
 
@@ -747,9 +745,9 @@ impl io<|> for Foo {
     }
 
     #[test]
-    fn test_auto_import_split_self_for_use() {
+    fn test_replace_split_self_for_use() {
         check_assist(
-            add_import,
+            replace_qualified_name_with_use,
             "
 use std::fmt;
 
@@ -766,9 +764,9 @@ impl Debug<|> for Foo {
     }
 
     #[test]
-    fn test_auto_import_split_self_for_target() {
+    fn test_replace_split_self_for_target() {
         check_assist(
-            add_import,
+            replace_qualified_name_with_use,
             "
 use std::fmt::Debug;
 
@@ -785,9 +783,9 @@ impl fmt<|> for Foo {
     }
 
     #[test]
-    fn test_auto_import_add_to_nested_self_nested() {
+    fn test_replace_add_to_nested_self_nested() {
         check_assist(
-            add_import,
+            replace_qualified_name_with_use,
             "
 use std::fmt::{Debug, nested::{Display}};
 
@@ -804,9 +802,9 @@ impl nested<|> for Foo {
     }
 
     #[test]
-    fn test_auto_import_add_to_nested_self_already_included() {
+    fn test_replace_add_to_nested_self_already_included() {
         check_assist(
-            add_import,
+            replace_qualified_name_with_use,
             "
 use std::fmt::{Debug, nested::{self, Display}};
 
@@ -823,9 +821,9 @@ impl nested<|> for Foo {
     }
 
     #[test]
-    fn test_auto_import_add_to_nested_nested() {
+    fn test_replace_add_to_nested_nested() {
         check_assist(
-            add_import,
+            replace_qualified_name_with_use,
             "
 use std::fmt::{Debug, nested::{Display}};
 
@@ -842,9 +840,9 @@ impl Debug<|> for Foo {
     }
 
     #[test]
-    fn test_auto_import_split_common_target_longer() {
+    fn test_replace_split_common_target_longer() {
         check_assist(
-            add_import,
+            replace_qualified_name_with_use,
             "
 use std::fmt::Debug;
 
@@ -861,9 +859,9 @@ impl Display<|> for Foo {
     }
 
     #[test]
-    fn test_auto_import_split_common_use_longer() {
+    fn test_replace_split_common_use_longer() {
         check_assist(
-            add_import,
+            replace_qualified_name_with_use,
             "
 use std::fmt::nested::Debug;
 
@@ -880,9 +878,9 @@ impl Display<|> for Foo {
     }
 
     #[test]
-    fn test_auto_import_use_nested_import() {
+    fn test_replace_use_nested_import() {
         check_assist(
-            add_import,
+            replace_qualified_name_with_use,
             "
 use crate::{
     ty::{Substs, Ty},
@@ -903,9 +901,9 @@ fn foo() { lower<|>::trait_env() }
     }
 
     #[test]
-    fn test_auto_import_alias() {
+    fn test_replace_alias() {
         check_assist(
-            add_import,
+            replace_qualified_name_with_use,
             "
 use std::fmt as foo;
 
@@ -922,9 +920,9 @@ impl Debug<|> for Foo {
     }
 
     #[test]
-    fn test_auto_import_not_applicable_one_segment() {
+    fn test_replace_not_applicable_one_segment() {
         check_assist_not_applicable(
-            add_import,
+            replace_qualified_name_with_use,
             "
 impl foo<|> for Foo {
 }
@@ -933,9 +931,9 @@ impl foo<|> for Foo {
     }
 
     #[test]
-    fn test_auto_import_not_applicable_in_use() {
+    fn test_replace_not_applicable_in_use() {
         check_assist_not_applicable(
-            add_import,
+            replace_qualified_name_with_use,
             "
 use std::fmt<|>;
 ",
@@ -943,9 +941,9 @@ use std::fmt<|>;
     }
 
     #[test]
-    fn test_auto_import_add_use_no_anchor_in_mod_mod() {
+    fn test_replace_add_use_no_anchor_in_mod_mod() {
         check_assist(
-            add_import,
+            replace_qualified_name_with_use,
             "
 mod foo {
     mod bar {
diff --git a/crates/ra_assists/src/lib.rs b/crates/ra_assists/src/lib.rs
index eca6dec4b..828a8e9e8 100644
--- a/crates/ra_assists/src/lib.rs
+++ b/crates/ra_assists/src/lib.rs
@@ -12,16 +12,13 @@ mod doc_tests;
 mod utils;
 pub mod ast_transform;
 
-use std::cmp::Ordering;
-
-use either::Either;
 use ra_db::FileRange;
 use ra_ide_db::RootDatabase;
 use ra_syntax::{TextRange, TextUnit};
 use ra_text_edit::TextEdit;
 
 pub(crate) use crate::assist_ctx::{Assist, AssistCtx, AssistHandler};
-pub use crate::handlers::add_import::auto_import_text_edit;
+pub use crate::handlers::replace_qualified_name_with_use::insert_use_statement;
 
 /// Unique identifier of the assist, should not be shown to the user
 /// directly.
@@ -35,6 +32,9 @@ pub struct AssistLabel {
     pub id: AssistId,
 }
 
+#[derive(Clone, Debug)]
+pub struct GroupLabel(pub String);
+
 impl AssistLabel {
     pub(crate) fn new(label: String, id: AssistId) -> AssistLabel {
         // FIXME: make fields private, so that this invariant can't be broken
@@ -45,7 +45,6 @@ impl AssistLabel {
 
 #[derive(Debug, Clone)]
 pub struct AssistAction {
-    pub label: Option<String>,
     pub edit: TextEdit,
     pub cursor_position: Option<TextUnit>,
     // FIXME: This belongs to `AssistLabel`
@@ -55,16 +54,8 @@ pub struct AssistAction {
 #[derive(Debug, Clone)]
 pub struct ResolvedAssist {
     pub label: AssistLabel,
-    pub action_data: Either<AssistAction, Vec<AssistAction>>,
-}
-
-impl ResolvedAssist {
-    pub fn get_first_action(&self) -> AssistAction {
-        match &self.action_data {
-            Either::Left(action) => action.clone(),
-            Either::Right(actions) => actions[0].clone(),
-        }
-    }
+    pub group_label: Option<GroupLabel>,
+    pub action: AssistAction,
 }
 
 /// Return all the assists applicable at the given position.
@@ -76,10 +67,8 @@ pub fn unresolved_assists(db: &RootDatabase, range: FileRange) -> Vec<AssistLabe
     handlers::all()
         .iter()
         .filter_map(|f| f(ctx.clone()))
-        .map(|a| match a {
-            Assist::Unresolved { label } => label,
-            Assist::Resolved { .. } => unreachable!(),
-        })
+        .flat_map(|it| it.0)
+        .map(|a| a.label)
         .collect()
 }
 
@@ -92,24 +81,13 @@ pub fn resolved_assists(db: &RootDatabase, range: FileRange) -> Vec<ResolvedAssi
     let mut a = handlers::all()
         .iter()
         .filter_map(|f| f(ctx.clone()))
-        .map(|a| match a {
-            Assist::Resolved { assist } => assist,
-            Assist::Unresolved { .. } => unreachable!(),
-        })
+        .flat_map(|it| it.0)
+        .map(|it| it.into_resolved().unwrap())
         .collect::<Vec<_>>();
-    sort_assists(&mut a);
+    a.sort_by_key(|it| it.action.target.map_or(TextUnit::from(!0u32), |it| it.len()));
     a
 }
 
-fn sort_assists(assists: &mut [ResolvedAssist]) {
-    assists.sort_by(|a, b| match (a.get_first_action().target, b.get_first_action().target) {
-        (Some(a), Some(b)) => a.len().cmp(&b.len()),
-        (Some(_), None) => Ordering::Less,
-        (None, Some(_)) => Ordering::Greater,
-        (None, None) => Ordering::Equal,
-    });
-}
-
 mod handlers {
     use crate::AssistHandler;
 
@@ -133,7 +111,7 @@ mod handlers {
     mod replace_if_let_with_match;
     mod split_import;
     mod remove_dbg;
-    pub(crate) mod add_import;
+    pub(crate) mod replace_qualified_name_with_use;
     mod add_missing_impl_members;
     mod move_guard;
     mod move_bounds;
@@ -158,7 +136,7 @@ mod handlers {
             replace_if_let_with_match::replace_if_let_with_match,
             split_import::split_import,
             remove_dbg::remove_dbg,
-            add_import::add_import,
+            replace_qualified_name_with_use::replace_qualified_name_with_use,
             add_missing_impl_members::add_missing_impl_members,
             add_missing_impl_members::add_missing_default_members,
             inline_local_variable::inline_local_variable,
@@ -184,7 +162,7 @@ mod helpers {
     use ra_syntax::TextRange;
     use test_utils::{add_cursor, assert_eq_text, extract_offset, extract_range};
 
-    use crate::{Assist, AssistCtx, AssistHandler};
+    use crate::{AssistCtx, AssistHandler};
 
     pub(crate) fn with_single_file(text: &str) -> (RootDatabase, FileId) {
         let (mut db, file_id) = RootDatabase::with_single_file(text);
@@ -202,10 +180,7 @@ mod helpers {
             FileRange { file_id, range: TextRange::offset_len(before_cursor_pos, 0.into()) };
         let assist =
             assist(AssistCtx::new(&db, frange, true)).expect("code action is not applicable");
-        let action = match assist {
-            Assist::Unresolved { .. } => unreachable!(),
-            Assist::Resolved { assist } => assist.get_first_action(),
-        };
+        let action = assist.0[0].action.clone().unwrap();
 
         let actual = action.edit.apply(&before);
         let actual_cursor_pos = match action.cursor_position {
@@ -225,10 +200,7 @@ mod helpers {
         let frange = FileRange { file_id, range };
         let assist =
             assist(AssistCtx::new(&db, frange, true)).expect("code action is not applicable");
-        let action = match assist {
-            Assist::Unresolved { .. } => unreachable!(),
-            Assist::Resolved { assist } => assist.get_first_action(),
-        };
+        let action = assist.0[0].action.clone().unwrap();
 
         let mut actual = action.edit.apply(&before);
         if let Some(pos) = action.cursor_position {
@@ -244,10 +216,7 @@ mod helpers {
             FileRange { file_id, range: TextRange::offset_len(before_cursor_pos, 0.into()) };
         let assist =
             assist(AssistCtx::new(&db, frange, true)).expect("code action is not applicable");
-        let action = match assist {
-            Assist::Unresolved { .. } => unreachable!(),
-            Assist::Resolved { assist } => assist.get_first_action(),
-        };
+        let action = assist.0[0].action.clone().unwrap();
 
         let range = action.target.expect("expected target on action");
         assert_eq_text!(&before[range.start().to_usize()..range.end().to_usize()], target);
@@ -259,10 +228,7 @@ mod helpers {
         let frange = FileRange { file_id, range };
         let assist =
             assist(AssistCtx::new(&db, frange, true)).expect("code action is not applicable");
-        let action = match assist {
-            Assist::Unresolved { .. } => unreachable!(),
-            Assist::Resolved { assist } => assist.get_first_action(),
-        };
+        let action = assist.0[0].action.clone().unwrap();
 
         let range = action.target.expect("expected target on action");
         assert_eq_text!(&before[range.start().to_usize()..range.end().to_usize()], target);