17 files changed, 251 insertions, 109 deletions
diff --git a/Cargo.lock b/Cargo.lock
index 090454658..10bd94f7b 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -869,8 +869,8 @@ version = "0.1.0"
 name = "ra_assists"
 version = "0.1.0"
 dependencies = [
+ "either 1.5.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "format-buf 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "itertools 0.8.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "join_to_string 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "ra_db 0.1.0",
 "ra_fmt 0.1.0",
@@ -1066,6 +1066,7 @@ name = "ra_lsp_server"
 version = "0.1.0"
 dependencies = [
 "crossbeam-channel 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "either 1.5.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "env_logger 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "jod-thread 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.8 (registry+https://github.com/rust-lang/crates.io-index)",
diff --git a/crates/ra_assists/Cargo.toml b/crates/ra_assists/Cargo.toml
index 50be8d9bc..0d2109e4e 100644
--- a/crates/ra_assists/Cargo.toml
+++ b/crates/ra_assists/Cargo.toml
@@ -11,7 +11,7 @@ doctest = false
 format-buf = "1.0.0"
 join_to_string = "0.1.3"
 rustc-hash = "1.0"
-itertools = "0.8.0"
+either = "1.5"
 ra_syntax = { path = "../ra_syntax" }
 ra_text_edit = { path = "../ra_text_edit" }
diff --git a/crates/ra_assists/src/assist_ctx.rs b/crates/ra_assists/src/assist_ctx.rs
index 1a65b5dc0..9d533fa0c 100644
--- a/crates/ra_assists/src/assist_ctx.rs
+++ b/crates/ra_assists/src/assist_ctx.rs
@@ -1,4 +1,5 @@
 //! This module defines `AssistCtx` -- the API surface that is exposed to assists.
+use either::Either;
 use hir::{db::HirDatabase, InFile, SourceAnalyzer};
 use ra_db::FileRange;
 use ra_fmt::{leading_indent, reindent};
@@ -9,12 +10,12 @@ use ra_syntax::{
 };
 use ra_text_edit::TextEditBuilder;
-use crate::{AssistAction, AssistId, AssistLabel};
+use crate::{AssistAction, AssistId, AssistLabel, ResolvedAssist};
 #[derive(Clone, Debug)]
 pub(crate) enum Assist {
    Unresolved { label: AssistLabel },
-    Resolved { label: AssistLabel, action: AssistAction },
+    Resolved { assist: ResolvedAssist },
 }
 /// `AssistCtx` allows to apply an assist or check if it could be applied.
@@ -81,18 +82,45 @@ impl<'a, DB: HirDatabase> AssistCtx<'a, DB> {
        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 };
        assert!(label.label.chars().nth(0).unwrap().is_uppercase());
        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 { assist: ResolvedAssist { label, action_data: Either::Left(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_group(
+        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 {
+            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 }
        };
@@ -128,13 +156,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(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())
@@ -193,6 +228,7 @@ impl AssistBuilder {
            edit: self.edit.finish(),
            cursor_position: self.cursor_position,
            target: self.target,
+            label: self.label,
        }
    }
 }
diff --git a/crates/ra_assists/src/assists/inline_local_variable.rs b/crates/ra_assists/src/assists/inline_local_variable.rs
index 164aee90c..45e0f983f 100644
--- a/crates/ra_assists/src/assists/inline_local_variable.rs
+++ b/crates/ra_assists/src/assists/inline_local_variable.rs
@@ -4,7 +4,7 @@ use ra_syntax::{
    TextRange,
 };
-use crate::assist_ctx::AssistBuilder;
+use crate::assist_ctx::ActionBuilder;
 use crate::{Assist, AssistCtx, AssistId};
 // Assist: inline_local_variable
@@ -94,7 +94,7 @@ pub(crate) fn inline_local_varialbe(ctx: AssistCtx<impl HirDatabase>) -> Option<
    ctx.add_assist(
        AssistId("inline_local_variable"),
        "Inline variable",
-        move |edit: &mut AssistBuilder| {
+        move |edit: &mut ActionBuilder| {
            edit.delete(delete_range);
            for (desc, should_wrap) in refs.iter().zip(wrap_in_parens) {
                if should_wrap {
diff --git a/crates/ra_assists/src/ast_transform.rs b/crates/ra_assists/src/ast_transform.rs
index eac2903d1..56b7588ef 100644
--- a/crates/ra_assists/src/ast_transform.rs
+++ b/crates/ra_assists/src/ast_transform.rs
@@ -2,7 +2,7 @@
 use rustc_hash::FxHashMap;
 use hir::{db::HirDatabase, InFile, PathResolution};
-use ra_syntax::ast::{self, make, AstNode};
+use ra_syntax::ast::{self, AstNode};
 pub trait AstTransform<'a> {
    fn get_substitution(
@@ -134,11 +134,18 @@ impl<'a, DB: HirDatabase> QualifyPaths<'a, DB> {
        match resolution {
            PathResolution::Def(def) => {
                let found_path = from.find_use_path(self.db, def)?;
-                let args = p
+                let mut path = path_to_ast(found_path);
+                let type_args = p
                    .segment()
                    .and_then(|s| s.type_arg_list())
                    .map(|arg_list| apply(self, node.with_value(arg_list)));
-                Some(make::path_with_type_arg_list(path_to_ast(found_path), args).syntax().clone())
+                if let Some(type_args) = type_args {
+                    let last_segment = path.segment().unwrap();
+                    path = path.with_segment(last_segment.with_type_args(type_args))
+                }
+                Some(path.syntax().clone())
            }
            PathResolution::Local(_)
            | PathResolution::TypeParam(_)
diff --git a/crates/ra_assists/src/doc_tests.rs b/crates/ra_assists/src/doc_tests.rs
index a8f8446cb..5dc1ee233 100644
--- a/crates/ra_assists/src/doc_tests.rs
+++ b/crates/ra_assists/src/doc_tests.rs
@@ -15,21 +15,21 @@ fn check(assist_id: &str, before: &str, after: &str) {
    let (db, file_id) = TestDB::with_single_file(&before);
    let frange = FileRange { file_id, range: selection.into() };
-    let (_assist_id, action) = crate::assists(&db, frange)
+    let assist = crate::assists(&db, frange)
        .into_iter()
-        .find(|(id, _)| id.id.0 == assist_id)
+        .find(|assist| assist.label.id.0 == assist_id)
        .unwrap_or_else(|| {
            panic!(
                "\n\nAssist is not applicable: {}\nAvailable assists: {}",
                assist_id,
                crate::assists(&db, frange)
                    .into_iter()
-                    .map(|(id, _)| id.id.0)
+                    .map(|assist| assist.label.id.0)
                    .collect::<Vec<_>>()
                    .join(", ")
            )
        });
-    let actual = action.edit.apply(&before);
+    let actual = assist.get_first_action().edit.apply(&before);
    assert_eq_text!(after, &actual);
 }
diff --git a/crates/ra_assists/src/lib.rs b/crates/ra_assists/src/lib.rs
index 150b34ac7..d45b58966 100644
--- a/crates/ra_assists/src/lib.rs
+++ b/crates/ra_assists/src/lib.rs
@@ -13,6 +13,7 @@ mod doc_tests;
 mod test_db;
 pub mod ast_transform;
+use either::Either;
 use hir::db::HirDatabase;
 use ra_db::FileRange;
 use ra_syntax::{TextRange, TextUnit};
@@ -35,11 +36,27 @@ pub struct AssistLabel {
 #[derive(Debug, Clone)]
 pub struct AssistAction {
+    pub label: Option<String>,
    pub edit: TextEdit,
    pub cursor_position: Option<TextUnit>,
    pub target: Option<TextRange>,
 }
+#[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(),
+        }
+    }
+}
 /// Return all the assists applicable at the given position.
 ///
 /// Assists are returned in the "unresolved" state, that is only labels are
@@ -64,7 +81,7 @@ where
 ///
 /// Assists are returned in the "resolved" state, that is with edit fully
 /// computed.
-pub fn assists<H>(db: &H, range: FileRange) -> Vec<(AssistLabel, AssistAction)>
+pub fn assists<H>(db: &H, range: FileRange) -> Vec<ResolvedAssist>
 where
    H: HirDatabase + 'static,
 {
@@ -75,11 +92,11 @@ where
            .iter()
            .filter_map(|f| f(ctx.clone()))
            .map(|a| match a {
-                Assist::Resolved { label, action } => (label, action),
+                Assist::Resolved { assist } => assist,
                Assist::Unresolved { .. } => unreachable!(),
            })
            .collect::<Vec<_>>();
-        a.sort_by(|a, b| match (a.1.target, b.1.target) {
+        a.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,
@@ -174,7 +191,7 @@ mod helpers {
            AssistCtx::with_ctx(&db, frange, true, assist).expect("code action is not applicable");
        let action = match assist {
            Assist::Unresolved { .. } => unreachable!(),
-            Assist::Resolved { action, .. } => action,
+            Assist::Resolved { assist } => assist.get_first_action(),
        };
        let actual = action.edit.apply(&before);
@@ -201,7 +218,7 @@ mod helpers {
            AssistCtx::with_ctx(&db, frange, true, assist).expect("code action is not applicable");
        let action = match assist {
            Assist::Unresolved { .. } => unreachable!(),
-            Assist::Resolved { action, .. } => action,
+            Assist::Resolved { assist } => assist.get_first_action(),
        };
        let mut actual = action.edit.apply(&before);
@@ -224,7 +241,7 @@ mod helpers {
            AssistCtx::with_ctx(&db, frange, true, assist).expect("code action is not applicable");
        let action = match assist {
            Assist::Unresolved { .. } => unreachable!(),
-            Assist::Resolved { action, .. } => action,
+            Assist::Resolved { assist } => assist.get_first_action(),
        };
        let range = action.target.expect("expected target on action");
@@ -243,7 +260,7 @@ mod helpers {
            AssistCtx::with_ctx(&db, frange, true, assist).expect("code action is not applicable");
        let action = match assist {
            Assist::Unresolved { .. } => unreachable!(),
-            Assist::Resolved { action, .. } => action,
+            Assist::Resolved { assist } => assist.get_first_action(),
        };
        let range = action.target.expect("expected target on action");
@@ -293,10 +310,10 @@ mod tests {
        let mut assists = assists.iter();
        assert_eq!(
-            assists.next().expect("expected assist").0.label,
+            assists.next().expect("expected assist").label.label,
            "Change visibility to pub(crate)"
        );
-        assert_eq!(assists.next().expect("expected assist").0.label, "Add `#[derive]`");
+        assert_eq!(assists.next().expect("expected assist").label.label, "Add `#[derive]`");
    }
    #[test]
@@ -315,7 +332,7 @@ mod tests {
        let assists = super::assists(&db, frange);
        let mut assists = assists.iter();
-        assert_eq!(assists.next().expect("expected assist").0.label, "Extract into variable");
+        assert_eq!(assists.next().expect("expected assist").label.label, "Extract into variable");
-        assert_eq!(assists.next().expect("expected assist").0.label, "Replace with match");
+        assert_eq!(assists.next().expect("expected assist").label.label, "Replace with match");
    }
 }
diff --git a/crates/ra_hir_def/src/find_path.rs b/crates/ra_hir_def/src/find_path.rs
index f7dc8acb7..8cc2fb160 100644
--- a/crates/ra_hir_def/src/find_path.rs
+++ b/crates/ra_hir_def/src/find_path.rs
@@ -35,7 +35,7 @@ fn find_path_inner(
    let def_map = db.crate_def_map(from.krate);
    let from_scope: &crate::item_scope::ItemScope = &def_map.modules[from.local_id].scope;
    if let Some((name, _)) = from_scope.name_of(item) {
-        return Some(ModPath::from_simple_segments(PathKind::Plain, vec![name.clone()]));
+        return Some(ModPath::from_segments(PathKind::Plain, vec![name.clone()]));
    }
    // - if the item is the crate root, return `crate`
@@ -45,12 +45,12 @@ fn find_path_inner(
            local_id: def_map.root,
        }))
    {
-        return Some(ModPath::from_simple_segments(PathKind::Crate, Vec::new()));
+        return Some(ModPath::from_segments(PathKind::Crate, Vec::new()));
    }
    // - if the item is the module we're in, use `self`
    if item == ItemInNs::Types(from.into()) {
-        return Some(ModPath::from_simple_segments(PathKind::Super(0), Vec::new()));
+        return Some(ModPath::from_segments(PathKind::Super(0), Vec::new()));
    }
    // - if the item is the parent module, use `super` (this is not used recursively, since `super::super` is ugly)
@@ -61,14 +61,14 @@ fn find_path_inner(
                local_id: parent_id,
            }))
        {
-            return Some(ModPath::from_simple_segments(PathKind::Super(1), Vec::new()));
+            return Some(ModPath::from_segments(PathKind::Super(1), Vec::new()));
        }
    }
    // - if the item is the crate root of a dependency crate, return the name from the extern prelude
    for (name, def_id) in &def_map.extern_prelude {
        if item == ItemInNs::Types(*def_id) {
-            return Some(ModPath::from_simple_segments(PathKind::Plain, vec![name.clone()]));
+            return Some(ModPath::from_segments(PathKind::Plain, vec![name.clone()]));
        }
    }
@@ -79,7 +79,7 @@ fn find_path_inner(
            &prelude_def_map.modules[prelude_module.local_id].scope;
        if let Some((name, vis)) = prelude_scope.name_of(item) {
            if vis.is_visible_from(db, from) {
-                return Some(ModPath::from_simple_segments(PathKind::Plain, vec![name.clone()]));
+                return Some(ModPath::from_segments(PathKind::Plain, vec![name.clone()]));
            }
        }
    }
diff --git a/crates/ra_hir_def/src/path.rs b/crates/ra_hir_def/src/path.rs
index 9f93a5424..ab290e2c9 100644
--- a/crates/ra_hir_def/src/path.rs
+++ b/crates/ra_hir_def/src/path.rs
@@ -39,10 +39,7 @@ impl ModPath {
        lower::lower_path(path, hygiene).map(|it| it.mod_path)
    }
-    pub fn from_simple_segments(
+    pub fn from_segments(kind: PathKind, segments: impl IntoIterator<Item = Name>) -> ModPath {
-        kind: PathKind,
-        segments: impl IntoIterator<Item = Name>,
-    ) -> ModPath {
        let segments = segments.into_iter().collect::<Vec<_>>();
        ModPath { kind, segments }
    }
@@ -240,7 +237,7 @@ impl From<Name> for Path {
    fn from(name: Name) -> Path {
        Path {
            type_anchor: None,
-            mod_path: ModPath::from_simple_segments(PathKind::Plain, iter::once(name)),
+            mod_path: ModPath::from_segments(PathKind::Plain, iter::once(name)),
            generic_args: vec![None],
        }
    }
@@ -248,7 +245,7 @@ impl From<Name> for Path {
 impl From<Name> for ModPath {
    fn from(name: Name) -> ModPath {
-        ModPath::from_simple_segments(PathKind::Plain, iter::once(name))
+        ModPath::from_segments(PathKind::Plain, iter::once(name))
    }
 }
@@ -311,7 +308,7 @@ macro_rules! __known_path {
 macro_rules! __path {
    ($start:ident $(:: $seg:ident)*) => ({
        $crate::__known_path!($start $(:: $seg)*);
-        $crate::path::ModPath::from_simple_segments($crate::path::PathKind::Abs, vec![
+        $crate::path::ModPath::from_segments($crate::path::PathKind::Abs, vec![
            $crate::path::__name![$start], $($crate::path::__name![$seg],)*
        ])
    });
diff --git a/crates/ra_hir_def/src/path/lower/lower_use.rs b/crates/ra_hir_def/src/path/lower/lower_use.rs
index 3218eaf0a..531878174 100644
--- a/crates/ra_hir_def/src/path/lower/lower_use.rs
+++ b/crates/ra_hir_def/src/path/lower/lower_use.rs
@@ -84,7 +84,7 @@ fn convert_path(prefix: Option<ModPath>, path: ast::Path, hygiene: &Hygiene) ->
                    res
                }
                Either::Right(crate_id) => {
-                    return Some(ModPath::from_simple_segments(
+                    return Some(ModPath::from_segments(
                        PathKind::DollarCrate(crate_id),
                        iter::empty(),
                    ))
@@ -95,19 +95,19 @@ fn convert_path(prefix: Option<ModPath>, path: ast::Path, hygiene: &Hygiene) ->
            if prefix.is_some() {
                return None;
            }
-            ModPath::from_simple_segments(PathKind::Crate, iter::empty())
+            ModPath::from_segments(PathKind::Crate, iter::empty())
        }
        ast::PathSegmentKind::SelfKw => {
            if prefix.is_some() {
                return None;
            }
-            ModPath::from_simple_segments(PathKind::Super(0), iter::empty())
+            ModPath::from_segments(PathKind::Super(0), iter::empty())
        }
        ast::PathSegmentKind::SuperKw => {
            if prefix.is_some() {
                return None;
            }
-            ModPath::from_simple_segments(PathKind::Super(1), iter::empty())
+            ModPath::from_segments(PathKind::Super(1), iter::empty())
        }
        ast::PathSegmentKind::Type { .. } => {
            // not allowed in imports
diff --git a/crates/ra_ide/src/assists.rs b/crates/ra_ide/src/assists.rs
index e00589733..a936900da 100644
--- a/crates/ra_ide/src/assists.rs
+++ b/crates/ra_ide/src/assists.rs
@@ -2,27 +2,53 @@
 use ra_db::{FilePosition, FileRange};
-use crate::{db::RootDatabase, SourceChange, SourceFileEdit};
+use crate::{db::RootDatabase, FileId, SourceChange, SourceFileEdit};
+use either::Either;
 pub use ra_assists::AssistId;
+use ra_assists::{AssistAction, AssistLabel};
 #[derive(Debug)]
 pub struct Assist {
    pub id: AssistId,
-    pub change: SourceChange,
+    pub label: String,
+    pub change_data: Either<SourceChange, Vec<SourceChange>>,
 }
 pub(crate) fn assists(db: &RootDatabase, frange: FileRange) -> Vec<Assist> {
    ra_assists::assists(db, frange)
        .into_iter()
-        .map(|(label, action)| {
+        .map(|assist| {
            let file_id = frange.file_id;
-            let file_edit = SourceFileEdit { file_id, edit: action.edit };
+            let assist_label = &assist.label;
-            let id = label.id;
+            Assist {
-            let change = SourceChange::source_file_edit(label.label, file_edit).with_cursor_opt(
+                id: assist_label.id,
-                action.cursor_position.map(|offset| FilePosition { offset, file_id }),
+                label: assist_label.label.clone(),
-            );
+                change_data: match assist.action_data {
-            Assist { id, change }
+                    Either::Left(action) => {
+                        Either::Left(action_to_edit(action, file_id, assist_label))
+                    }
+                    Either::Right(actions) => Either::Right(
+                        actions
+                            .into_iter()
+                            .map(|action| action_to_edit(action, file_id, assist_label))
+                            .collect(),
+                    ),
+                },
+            }
        })
        .collect()
 }
+fn action_to_edit(
+    action: AssistAction,
+    file_id: FileId,
+    assist_label: &AssistLabel,
+) -> SourceChange {
+    let file_edit = SourceFileEdit { file_id, edit: action.edit };
+    SourceChange::source_file_edit(
+        action.label.unwrap_or_else(|| assist_label.label.clone()),
+        file_edit,
+    )
+    .with_cursor_opt(action.cursor_position.map(|offset| FilePosition { offset, file_id }))
+}
diff --git a/crates/ra_lsp_server/Cargo.toml b/crates/ra_lsp_server/Cargo.toml
index c08e67b8e..579158780 100644
--- a/crates/ra_lsp_server/Cargo.toml
+++ b/crates/ra_lsp_server/Cargo.toml
@@ -28,6 +28,7 @@ ra_prof = { path = "../ra_prof" }
 ra_vfs_glob = { path = "../ra_vfs_glob" }
 env_logger = { version = "0.7.1", default-features = false, features = ["humantime"] }
 ra_cargo_watch = { path = "../ra_cargo_watch" }
+either = "1.5"
 [dev-dependencies]
 tempfile = "3"
diff --git a/crates/ra_lsp_server/src/main_loop/handlers.rs b/crates/ra_lsp_server/src/main_loop/handlers.rs
index f2db575ea..9e9964880 100644
--- a/crates/ra_lsp_server/src/main_loop/handlers.rs
+++ b/crates/ra_lsp_server/src/main_loop/handlers.rs
@@ -3,6 +3,7 @@
 use std::{fmt::Write as _, io::Write as _};
+use either::Either;
 use lsp_server::ErrorCode;
 use lsp_types::{
    CallHierarchyIncomingCall, CallHierarchyIncomingCallsParams, CallHierarchyItem,
@@ -644,7 +645,6 @@ pub fn handle_code_action(
    let line_index = world.analysis().file_line_index(file_id)?;
    let range = params.range.conv_with(&line_index);
-    let assists = world.analysis().assists(FileRange { file_id, range })?.into_iter();
    let diagnostics = world.analysis().diagnostics(file_id)?;
    let mut res = CodeActionResponse::default();
@@ -697,15 +697,27 @@ pub fn handle_code_action(
        res.push(action.into());
    }
-    for assist in assists {
+    for assist in world.analysis().assists(FileRange { file_id, range })?.into_iter() {
-        let title = assist.change.label.clone();
+        let title = assist.label.clone();
-        let edit = assist.change.try_conv_with(&world)?;
-        let command = Command {
+        let command = match assist.change_data {
-            title,
+            Either::Left(change) => Command {
-            command: "rust-analyzer.applySourceChange".to_string(),
+                title,
-            arguments: Some(vec![to_value(edit).unwrap()]),
+                command: "rust-analyzer.applySourceChange".to_string(),
+                arguments: Some(vec![to_value(change.try_conv_with(&world)?)?]),
+            },
+            Either::Right(changes) => Command {
+                title,
+                command: "rust-analyzer.selectAndApplySourceChange".to_string(),
+                arguments: Some(vec![to_value(
+                    changes
+                        .into_iter()
+                        .map(|change| change.try_conv_with(&world))
+                        .collect::<Result<Vec<_>>>()?,
+                )?]),
+            },
        };
        let action = CodeAction {
            title: command.title.clone(),
            kind: match assist.id {
diff --git a/crates/ra_syntax/src/ast/edit.rs b/crates/ra_syntax/src/ast/edit.rs
index b736098ac..0e78d8b63 100644
--- a/crates/ra_syntax/src/ast/edit.rs
+++ b/crates/ra_syntax/src/ast/edit.rs
@@ -22,9 +22,8 @@ impl ast::BinExpr {
    #[must_use]
    pub fn replace_op(&self, op: SyntaxKind) -> Option<ast::BinExpr> {
        let op_node: SyntaxElement = self.op_details()?.0.into();
-        let to_insert: Option<SyntaxElement> = Some(tokens::op(op).into());
+        let to_insert: Option<SyntaxElement> = Some(make::token(op).into());
-        let replace_range = RangeInclusive::new(op_node.clone(), op_node);
+        Some(replace_children(self, single_node(op_node), to_insert))
-        Some(replace_children(self, replace_range, to_insert.into_iter()))
    }
 }
@@ -40,11 +39,10 @@ impl ast::FnDef {
        } else {
            to_insert.push(make::tokens::single_space().into());
            to_insert.push(body.syntax().clone().into());
-            return insert_children(self, InsertPosition::Last, to_insert.into_iter());
+            return insert_children(self, InsertPosition::Last, to_insert);
        };
        to_insert.push(body.syntax().clone().into());
-        let replace_range = RangeInclusive::new(old_body_or_semi.clone(), old_body_or_semi);
+        replace_children(self, single_node(old_body_or_semi), to_insert)
-        replace_children(self, replace_range, to_insert.into_iter())
    }
 }
@@ -77,7 +75,7 @@ impl ast::ItemList {
        let ws = tokens::WsBuilder::new(&format!("\n{}", indent));
        let to_insert: ArrayVec<[SyntaxElement; 2]> =
            [ws.ws().into(), item.syntax().clone().into()].into();
-        insert_children(self, position, to_insert.into_iter())
+        insert_children(self, position, to_insert)
    }
    fn l_curly(&self) -> Option<SyntaxElement> {
@@ -109,9 +107,7 @@ impl ast::ItemList {
        let to_insert = iter::once(ws.ws().into());
        match existing_ws {
            None => insert_children(self, InsertPosition::After(l_curly), to_insert),
-            Some(ws) => {
+            Some(ws) => replace_children(self, single_node(ws), to_insert),
-                replace_children(self, RangeInclusive::new(ws.clone().into(), ws.into()), to_insert)
-            }
        }
    }
 }
@@ -188,7 +184,7 @@ impl ast::RecordFieldList {
            InsertPosition::After(anchor) => after_field!(anchor),
        };
-        insert_children(self, position, to_insert.iter().cloned())
+        insert_children(self, position, to_insert)
    }
    fn l_curly(&self) -> Option<SyntaxElement> {
@@ -207,7 +203,49 @@ impl ast::TypeParam {
            Some(it) => it.syntax().clone().into(),
            None => colon.clone().into(),
        };
-        replace_children(self, RangeInclusive::new(colon.into(), end), iter::empty())
+        replace_children(self, colon.into()..=end, iter::empty())
+    }
+}
+impl ast::Path {
+    #[must_use]
+    pub fn with_segment(&self, segment: ast::PathSegment) -> ast::Path {
+        if let Some(old) = self.segment() {
+            return replace_children(
+                self,
+                single_node(old.syntax().clone()),
+                iter::once(segment.syntax().clone().into()),
+            );
+        }
+        self.clone()
+    }
+}
+impl ast::PathSegment {
+    #[must_use]
+    pub fn with_type_args(&self, type_args: ast::TypeArgList) -> ast::PathSegment {
+        self._with_type_args(type_args, false)
+    }
+    #[must_use]
+    pub fn with_turbo_fish(&self, type_args: ast::TypeArgList) -> ast::PathSegment {
+        self._with_type_args(type_args, true)
+    }
+    fn _with_type_args(&self, type_args: ast::TypeArgList, turbo: bool) -> ast::PathSegment {
+        if let Some(old) = self.type_arg_list() {
+            return replace_children(
+                self,
+                single_node(old.syntax().clone()),
+                iter::once(type_args.syntax().clone().into()),
+            );
+        }
+        let mut to_insert: ArrayVec<[SyntaxElement; 2]> = ArrayVec::new();
+        if turbo {
+            to_insert.push(make::token(T![::]).into());
+        }
+        to_insert.push(type_args.syntax().clone().into());
+        insert_children(self, InsertPosition::Last, to_insert)
    }
 }
@@ -224,7 +262,7 @@ fn strip_attrs_and_docs_inner(mut node: SyntaxNode) -> SyntaxNode {
            Some(el) if el.kind() == WHITESPACE => el.clone(),
            Some(_) | None => start.clone(),
        };
-        node = algo::replace_children(&node, RangeInclusive::new(start, end), &mut iter::empty());
+        node = algo::replace_children(&node, start..=end, &mut iter::empty());
    }
    node
 }
@@ -232,9 +270,10 @@ fn strip_attrs_and_docs_inner(mut node: SyntaxNode) -> SyntaxNode {
 #[must_use]
 pub fn replace_descendants<N: AstNode, D: AstNode>(
    parent: &N,
-    replacement_map: impl Iterator<Item = (D, D)>,
+    replacement_map: impl IntoIterator<Item = (D, D)>,
 ) -> N {
    let map = replacement_map
+        .into_iter()
        .map(|(from, to)| (from.syntax().clone().into(), to.syntax().clone().into()))
        .collect::<FxHashMap<SyntaxElement, _>>();
    let new_syntax = algo::replace_descendants(parent.syntax(), &|n| map.get(n).cloned());
@@ -348,19 +387,25 @@ fn prev_tokens(token: SyntaxToken) -> impl Iterator<Item = SyntaxToken> {
 fn insert_children<N: AstNode>(
    parent: &N,
    position: InsertPosition<SyntaxElement>,
-    mut to_insert: impl Iterator<Item = SyntaxElement>,
+    to_insert: impl IntoIterator<Item = SyntaxElement>,
 ) -> N {
-    let new_syntax = algo::insert_children(parent.syntax(), position, &mut to_insert);
+    let new_syntax = algo::insert_children(parent.syntax(), position, &mut to_insert.into_iter());
    N::cast(new_syntax).unwrap()
 }
+fn single_node(element: impl Into<SyntaxElement>) -> RangeInclusive<SyntaxElement> {
+    let element = element.into();
+    element.clone()..=element
+}
 #[must_use]
 fn replace_children<N: AstNode>(
    parent: &N,
    to_replace: RangeInclusive<SyntaxElement>,
-    mut to_insert: impl Iterator<Item = SyntaxElement>,
+    to_insert: impl IntoIterator<Item = SyntaxElement>,
 ) -> N {
-    let new_syntax = algo::replace_children(parent.syntax(), to_replace, &mut to_insert);
+    let new_syntax =
+        algo::replace_children(parent.syntax(), to_replace, &mut to_insert.into_iter());
    N::cast(new_syntax).unwrap()
 }
diff --git a/crates/ra_syntax/src/ast/make.rs b/crates/ra_syntax/src/ast/make.rs
index eef45090d..36e648180 100644
--- a/crates/ra_syntax/src/ast/make.rs
+++ b/crates/ra_syntax/src/ast/make.rs
@@ -2,7 +2,7 @@
 //! of smaller pieces.
 use itertools::Itertools;
-use crate::{algo, ast, AstNode, SourceFile};
+use crate::{ast, AstNode, SourceFile, SyntaxKind, SyntaxToken};
 pub fn name(text: &str) -> ast::Name {
    ast_from_text(&format!("mod {};", text))
@@ -21,20 +21,6 @@ pub fn path_qualified(qual: ast::Path, name_ref: ast::NameRef) -> ast::Path {
 fn path_from_text(text: &str) -> ast::Path {
    ast_from_text(text)
 }
-pub fn path_with_type_arg_list(path: ast::Path, args: Option<ast::TypeArgList>) -> ast::Path {
-    if let Some(args) = args {
-        let syntax = path.syntax();
-        // FIXME: remove existing type args
-        let new_syntax = algo::insert_children(
-            syntax,
-            crate::algo::InsertPosition::Last,
-            &mut Some(args).into_iter().map(|n| n.syntax().clone().into()),
-        );
-        ast::Path::cast(new_syntax).unwrap()
-    } else {
-        path
-    }
-}
 pub fn record_field(name: ast::NameRef, expr: Option<ast::Expr>) -> ast::RecordField {
    return match expr {
@@ -181,27 +167,27 @@ pub fn let_stmt(pattern: ast::Pat, initializer: Option<ast::Expr>) -> ast::LetSt
    ast_from_text(&format!("fn f() {{ {} }}", text))
 }
+pub fn token(kind: SyntaxKind) -> SyntaxToken {
+    tokens::SOURCE_FILE
+        .tree()
+        .syntax()
+        .descendants_with_tokens()
+        .filter_map(|it| it.into_token())
+        .find(|it| it.kind() == kind)
+        .unwrap_or_else(|| panic!("unhandled token: {:?}", kind))
+}
 fn ast_from_text<N: AstNode>(text: &str) -> N {
    let parse = SourceFile::parse(text);
    parse.tree().syntax().descendants().find_map(N::cast).unwrap()
 }
 pub mod tokens {
-    use crate::{AstNode, Parse, SourceFile, SyntaxKind, SyntaxKind::*, SyntaxToken, T};
+    use crate::{AstNode, Parse, SourceFile, SyntaxKind::*, SyntaxToken, T};
    use once_cell::sync::Lazy;
-    static SOURCE_FILE: Lazy<Parse<SourceFile>> =
+    pub(super) static SOURCE_FILE: Lazy<Parse<SourceFile>> =
-        Lazy::new(|| SourceFile::parse("const C: () = (1 != 1, 2 == 2)\n;"));
+        Lazy::new(|| SourceFile::parse("const C: <()>::Item = (1 != 1, 2 == 2)\n;"));
-    pub fn op(op: SyntaxKind) -> SyntaxToken {
-        SOURCE_FILE
-            .tree()
-            .syntax()
-            .descendants_with_tokens()
-            .filter_map(|it| it.into_token())
-            .find(|it| it.kind() == op)
-            .unwrap()
-    }
    pub fn comma() -> SyntaxToken {
        SOURCE_FILE
diff --git a/editors/code/src/commands/index.ts b/editors/code/src/commands/index.ts
index 9a1697dcb..dc075aa82 100644
--- a/editors/code/src/commands/index.ts
+++ b/editors/code/src/commands/index.ts
@@ -39,6 +39,18 @@ function applySourceChange(ctx: Ctx): Cmd {
    };
 }
+function selectAndApplySourceChange(ctx: Ctx): Cmd {
+    return async (changes: sourceChange.SourceChange[]) => {
+        if (changes.length === 1) {
+            await sourceChange.applySourceChange(ctx, changes[0]);
+        } else if (changes.length > 0) {
+            const selectedChange = await vscode.window.showQuickPick(changes);
+            if (!selectedChange) return;
+            await sourceChange.applySourceChange(ctx, selectedChange);
+        }
+    };
+}
 function reload(ctx: Ctx): Cmd {
    return async () => {
        vscode.window.showInformationMessage('Reloading rust-analyzer...');
@@ -59,5 +71,6 @@ export {
    runSingle,
    showReferences,
    applySourceChange,
+    selectAndApplySourceChange,
    reload
 };
diff --git a/editors/code/src/main.ts b/editors/code/src/main.ts
index 430ad31b4..0494ccf63 100644
--- a/editors/code/src/main.ts
+++ b/editors/code/src/main.ts
@@ -26,6 +26,7 @@ export async function activate(context: vscode.ExtensionContext) {
    ctx.registerCommand('runSingle', commands.runSingle);
    ctx.registerCommand('showReferences', commands.showReferences);
    ctx.registerCommand('applySourceChange', commands.applySourceChange);
+    ctx.registerCommand('selectAndApplySourceChange', commands.selectAndApplySourceChange);
    if (ctx.config.enableEnhancedTyping) {
        ctx.overrideCommand('type', commands.onEnter);