47 files changed, 4197 insertions, 1686 deletions
diff --git a/crates/ra_assists/src/assist_config.rs b/crates/ra_assists/src/assist_config.rs
new file mode 100644
index 000000000..c0a0226fb
--- /dev/null
+++ b/crates/ra_assists/src/assist_config.rs
@@ -0,0 +1,27 @@
+//! Settings for tweaking assists.
+//!
+//! The fun thing here is `SnippetCap` -- this type can only be created in this
+//! module, and we use to statically check that we only produce snippet
+//! assists if we are allowed to.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct AssistConfig {
+    pub snippet_cap: Option<SnippetCap>,
+}
+impl AssistConfig {
+    pub fn allow_snippets(&mut self, yes: bool) {
+        self.snippet_cap = if yes { Some(SnippetCap { _private: () }) } else { None }
+    }
+}
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct SnippetCap {
+    _private: (),
+}
+impl Default for AssistConfig {
+    fn default() -> Self {
+        AssistConfig { snippet_cap: Some(SnippetCap { _private: () }) }
+    }
+}
diff --git a/crates/ra_assists/src/assist_context.rs b/crates/ra_assists/src/assist_context.rs
new file mode 100644
index 000000000..f3af70a3e
--- /dev/null
+++ b/crates/ra_assists/src/assist_context.rs
@@ -0,0 +1,257 @@
+//! See `AssistContext`
+use algo::find_covering_element;
+use hir::Semantics;
+use ra_db::{FileId, FileRange};
+use ra_fmt::{leading_indent, reindent};
+use ra_ide_db::{
+    source_change::{SingleFileChange, SourceChange},
+    RootDatabase,
+};
+use ra_syntax::{
+    algo::{self, find_node_at_offset, SyntaxRewriter},
+    AstNode, SourceFile, SyntaxElement, SyntaxKind, SyntaxNode, SyntaxToken, TextRange, TextSize,
+    TokenAtOffset,
+};
+use ra_text_edit::TextEditBuilder;
+use crate::{
+    assist_config::{AssistConfig, SnippetCap},
+    Assist, AssistId, GroupLabel, ResolvedAssist,
+};
+/// `AssistContext` allows to apply an assist or check if it could be applied.
+///
+/// Assists use a somewhat over-engineered approach, given the current needs.
+/// The assists workflow consists of two phases. In the first phase, a user asks
+/// for the list of available assists. In the second phase, the user picks a
+/// particular assist and it gets applied.
+///
+/// There are two peculiarities here:
+///
+/// * first, we ideally avoid computing more things then necessary to answer "is
+///   assist applicable" in the first phase.
+/// * second, when we are applying assist, we don't have a guarantee that there
+///   weren't any changes between the point when user asked for assists and when
+///   they applied a particular assist. So, when applying assist, we need to do
+///   all the checks from scratch.
+///
+/// To avoid repeating the same code twice for both "check" and "apply"
+/// functions, we use an approach reminiscent of that of Django's function based
+/// views dealing with forms. Each assist receives a runtime parameter,
+/// `resolve`. It first check if an edit is applicable (potentially computing
+/// info required to compute the actual edit). If it is applicable, and
+/// `resolve` is `true`, it then computes the actual edit.
+///
+/// So, to implement the original assists workflow, we can first apply each edit
+/// with `resolve = false`, and then applying the selected edit again, with
+/// `resolve = true` this time.
+///
+/// Note, however, that we don't actually use such two-phase logic at the
+/// moment, because the LSP API is pretty awkward in this place, and it's much
+/// easier to just compute the edit eagerly :-)
+pub(crate) struct AssistContext<'a> {
+    pub(crate) config: &'a AssistConfig,
+    pub(crate) sema: Semantics<'a, RootDatabase>,
+    pub(crate) db: &'a RootDatabase,
+    pub(crate) frange: FileRange,
+    source_file: SourceFile,
+}
+impl<'a> AssistContext<'a> {
+    pub(crate) fn new(
+        sema: Semantics<'a, RootDatabase>,
+        config: &'a AssistConfig,
+        frange: FileRange,
+    ) -> AssistContext<'a> {
+        let source_file = sema.parse(frange.file_id);
+        let db = sema.db;
+        AssistContext { config, sema, db, frange, source_file }
+    }
+    // NB, this ignores active selection.
+    pub(crate) fn offset(&self) -> TextSize {
+        self.frange.range.start()
+    }
+    pub(crate) fn token_at_offset(&self) -> TokenAtOffset<SyntaxToken> {
+        self.source_file.syntax().token_at_offset(self.offset())
+    }
+    pub(crate) fn find_token_at_offset(&self, kind: SyntaxKind) -> Option<SyntaxToken> {
+        self.token_at_offset().find(|it| it.kind() == kind)
+    }
+    pub(crate) fn find_node_at_offset<N: AstNode>(&self) -> Option<N> {
+        find_node_at_offset(self.source_file.syntax(), self.offset())
+    }
+    pub(crate) fn find_node_at_offset_with_descend<N: AstNode>(&self) -> Option<N> {
+        self.sema.find_node_at_offset_with_descend(self.source_file.syntax(), self.offset())
+    }
+    pub(crate) fn covering_element(&self) -> SyntaxElement {
+        find_covering_element(self.source_file.syntax(), self.frange.range)
+    }
+    // FIXME: remove
+    pub(crate) fn covering_node_for_range(&self, range: TextRange) -> SyntaxElement {
+        find_covering_element(self.source_file.syntax(), range)
+    }
+}
+pub(crate) struct Assists {
+    resolve: bool,
+    file: FileId,
+    buf: Vec<(Assist, Option<SourceChange>)>,
+}
+impl Assists {
+    pub(crate) fn new_resolved(ctx: &AssistContext) -> Assists {
+        Assists { resolve: true, file: ctx.frange.file_id, buf: Vec::new() }
+    }
+    pub(crate) fn new_unresolved(ctx: &AssistContext) -> Assists {
+        Assists { resolve: false, file: ctx.frange.file_id, buf: Vec::new() }
+    }
+    pub(crate) fn finish_unresolved(self) -> Vec<Assist> {
+        assert!(!self.resolve);
+        self.finish()
+            .into_iter()
+            .map(|(label, edit)| {
+                assert!(edit.is_none());
+                label
+            })
+            .collect()
+    }
+    pub(crate) fn finish_resolved(self) -> Vec<ResolvedAssist> {
+        assert!(self.resolve);
+        self.finish()
+            .into_iter()
+            .map(|(label, edit)| ResolvedAssist { assist: label, source_change: edit.unwrap() })
+            .collect()
+    }
+    pub(crate) fn add(
+        &mut self,
+        id: AssistId,
+        label: impl Into<String>,
+        target: TextRange,
+        f: impl FnOnce(&mut AssistBuilder),
+    ) -> Option<()> {
+        let label = Assist::new(id, label.into(), None, target);
+        self.add_impl(label, f)
+    }
+    pub(crate) fn add_group(
+        &mut self,
+        group: &GroupLabel,
+        id: AssistId,
+        label: impl Into<String>,
+        target: TextRange,
+        f: impl FnOnce(&mut AssistBuilder),
+    ) -> Option<()> {
+        let label = Assist::new(id, label.into(), Some(group.clone()), target);
+        self.add_impl(label, f)
+    }
+    fn add_impl(&mut self, label: Assist, f: impl FnOnce(&mut AssistBuilder)) -> Option<()> {
+        let change_label = label.label.clone();
+        let source_change = if self.resolve {
+            let mut builder = AssistBuilder::new(self.file);
+            f(&mut builder);
+            Some(builder.finish(change_label))
+        } else {
+            None
+        };
+        self.buf.push((label, source_change));
+        Some(())
+    }
+    fn finish(mut self) -> Vec<(Assist, Option<SourceChange>)> {
+        self.buf.sort_by_key(|(label, _edit)| label.target.len());
+        self.buf
+    }
+}
+pub(crate) struct AssistBuilder {
+    edit: TextEditBuilder,
+    file: FileId,
+    is_snippet: bool,
+}
+impl AssistBuilder {
+    pub(crate) fn new(file: FileId) -> AssistBuilder {
+        AssistBuilder { edit: TextEditBuilder::default(), file, is_snippet: false }
+    }
+    /// Remove specified `range` of text.
+    pub(crate) fn delete(&mut self, range: TextRange) {
+        self.edit.delete(range)
+    }
+    /// Append specified `text` at the given `offset`
+    pub(crate) fn insert(&mut self, offset: TextSize, text: impl Into<String>) {
+        self.edit.insert(offset, text.into())
+    }
+    /// Append specified `snippet` at the given `offset`
+    pub(crate) fn insert_snippet(
+        &mut self,
+        _cap: SnippetCap,
+        offset: TextSize,
+        snippet: impl Into<String>,
+    ) {
+        self.is_snippet = true;
+        self.insert(offset, snippet);
+    }
+    /// 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())
+    }
+    /// Replaces specified `range` of text with a given `snippet`.
+    pub(crate) fn replace_snippet(
+        &mut self,
+        _cap: SnippetCap,
+        range: TextRange,
+        snippet: impl Into<String>,
+    ) {
+        self.is_snippet = true;
+        self.replace(range, snippet);
+    }
+    pub(crate) fn replace_ast<N: AstNode>(&mut self, old: N, new: N) {
+        algo::diff(old.syntax(), new.syntax()).into_text_edit(&mut self.edit)
+    }
+    /// Replaces specified `node` of text with a given string, reindenting the
+    /// string to maintain `node`'s existing indent.
+    // FIXME: remove in favor of ra_syntax::edit::IndentLevel::increase_indent
+    pub(crate) fn replace_node_and_indent(
+        &mut self,
+        node: &SyntaxNode,
+        replace_with: impl Into<String>,
+    ) {
+        let mut replace_with = replace_with.into();
+        if let Some(indent) = leading_indent(node) {
+            replace_with = reindent(&replace_with, &indent)
+        }
+        self.replace(node.text_range(), replace_with)
+    }
+    pub(crate) fn rewrite(&mut self, rewriter: SyntaxRewriter) {
+        let node = rewriter.rewrite_root().unwrap();
+        let new = rewriter.rewrite(&node);
+        algo::diff(&node, &new).into_text_edit(&mut self.edit)
+    }
+    // FIXME: better API
+    pub(crate) fn set_file(&mut self, assist_file: FileId) {
+        self.file = assist_file;
+    }
+    // FIXME: kill this API
+    /// Get access to the raw `TextEditBuilder`.
+    pub(crate) fn text_edit_builder(&mut self) -> &mut TextEditBuilder {
+        &mut self.edit
+    }
+    fn finish(self, change_label: String) -> SourceChange {
+        let edit = self.edit.finish();
+        let mut res = SingleFileChange { label: change_label, edit }.into_source_change(self.file);
+        if self.is_snippet {
+            res.is_snippet = true;
+        }
+        res
+    }
+}
diff --git a/crates/ra_assists/src/assist_ctx.rs b/crates/ra_assists/src/assist_ctx.rs
deleted file mode 100644
index 2fe7c3de3..000000000
--- a/crates/ra_assists/src/assist_ctx.rs
+++ /dev/null
@@ -1,257 +0,0 @@
-//! This module defines `AssistCtx` -- the API surface that is exposed to assists.
-use hir::Semantics;
-use ra_db::FileRange;
-use ra_fmt::{leading_indent, reindent};
-use ra_ide_db::RootDatabase;
-use ra_syntax::{
-    algo::{self, find_covering_element, find_node_at_offset},
-    AstNode, SourceFile, SyntaxElement, SyntaxKind, SyntaxNode, SyntaxToken, TextRange, TextSize,
-    TokenAtOffset,
-};
-use ra_text_edit::TextEditBuilder;
-use crate::{AssistAction, AssistFile, AssistId, AssistLabel, GroupLabel, ResolvedAssist};
-use algo::SyntaxRewriter;
-#[derive(Clone, Debug)]
-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>;
-/// `AssistCtx` allows to apply an assist or check if it could be applied.
-///
-/// Assists use a somewhat over-engineered approach, given the current needs. The
-/// assists workflow consists of two phases. In the first phase, a user asks for
-/// the list of available assists. In the second phase, the user picks a
-/// particular assist and it gets applied.
-///
-/// There are two peculiarities here:
-///
-/// * first, we ideally avoid computing more things then necessary to answer
-///   "is assist applicable" in the first phase.
-/// * second, when we are applying assist, we don't have a guarantee that there
-///   weren't any changes between the point when user asked for assists and when
-///   they applied a particular assist. So, when applying assist, we need to do
-///   all the checks from scratch.
-///
-/// To avoid repeating the same code twice for both "check" and "apply"
-/// functions, we use an approach reminiscent of that of Django's function based
-/// views dealing with forms. Each assist receives a runtime parameter,
-/// `should_compute_edit`. It first check if an edit is applicable (potentially
-/// computing info required to compute the actual edit). If it is applicable,
-/// and `should_compute_edit` is `true`, it then computes the actual edit.
-///
-/// So, to implement the original assists workflow, we can first apply each edit
-/// with `should_compute_edit = false`, and then applying the selected edit
-/// again, with `should_compute_edit = true` this time.
-///
-/// Note, however, that we don't actually use such two-phase logic at the
-/// moment, because the LSP API is pretty awkward in this place, and it's much
-/// easier to just compute the edit eagerly :-)
-#[derive(Clone)]
-pub(crate) struct AssistCtx<'a> {
-    pub(crate) sema: &'a Semantics<'a, RootDatabase>,
-    pub(crate) db: &'a RootDatabase,
-    pub(crate) frange: FileRange,
-    source_file: SourceFile,
-    should_compute_edit: bool,
-}
-impl<'a> AssistCtx<'a> {
-    pub fn new(
-        sema: &'a Semantics<'a, RootDatabase>,
-        frange: FileRange,
-        should_compute_edit: bool,
-    ) -> AssistCtx<'a> {
-        let source_file = sema.parse(frange.file_id);
-        AssistCtx { sema, db: sema.db, frange, source_file, should_compute_edit }
-    }
-    pub(crate) fn add_assist(
-        self,
-        id: AssistId,
-        label: impl Into<String>,
-        f: impl FnOnce(&mut ActionBuilder),
-    ) -> Option<Assist> {
-        let label = AssistLabel::new(label.into(), id);
-        let mut info = AssistInfo::new(label);
-        if self.should_compute_edit {
-            let action = {
-                let mut edit = ActionBuilder::default();
-                f(&mut edit);
-                edit.build()
-            };
-            info = info.resolved(action)
-        };
-        Some(Assist(vec![info]))
-    }
-    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> {
-        self.source_file.syntax().token_at_offset(self.frange.range.start())
-    }
-    pub(crate) fn find_token_at_offset(&self, kind: SyntaxKind) -> Option<SyntaxToken> {
-        self.token_at_offset().find(|it| it.kind() == kind)
-    }
-    pub(crate) fn find_node_at_offset<N: AstNode>(&self) -> Option<N> {
-        find_node_at_offset(self.source_file.syntax(), self.frange.range.start())
-    }
-    pub(crate) fn covering_element(&self) -> SyntaxElement {
-        find_covering_element(self.source_file.syntax(), self.frange.range)
-    }
-    pub(crate) fn covering_node_for_range(&self, range: TextRange) -> SyntaxElement {
-        find_covering_element(self.source_file.syntax(), range)
-    }
-}
-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> {
-        if self.assists.is_empty() {
-            None
-        } else {
-            Some(Assist(self.assists))
-        }
-    }
-}
-#[derive(Default)]
-pub(crate) struct ActionBuilder {
-    edit: TextEditBuilder,
-    cursor_position: Option<TextSize>,
-    target: Option<TextRange>,
-    file: AssistFile,
-}
-impl ActionBuilder {
-    /// 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())
-    }
-    /// Replaces specified `node` of text with a given string, reindenting the
-    /// string to maintain `node`'s existing indent.
-    // FIXME: remove in favor of ra_syntax::edit::IndentLevel::increase_indent
-    pub(crate) fn replace_node_and_indent(
-        &mut self,
-        node: &SyntaxNode,
-        replace_with: impl Into<String>,
-    ) {
-        let mut replace_with = replace_with.into();
-        if let Some(indent) = leading_indent(node) {
-            replace_with = reindent(&replace_with, &indent)
-        }
-        self.replace(node.text_range(), replace_with)
-    }
-    /// Remove specified `range` of text.
-    #[allow(unused)]
-    pub(crate) fn delete(&mut self, range: TextRange) {
-        self.edit.delete(range)
-    }
-    /// Append specified `text` at the given `offset`
-    pub(crate) fn insert(&mut self, offset: TextSize, text: impl Into<String>) {
-        self.edit.insert(offset, text.into())
-    }
-    /// Specify desired position of the cursor after the assist is applied.
-    pub(crate) fn set_cursor(&mut self, offset: TextSize) {
-        self.cursor_position = Some(offset)
-    }
-    /// Specify that the assist should be active withing the `target` range.
-    ///
-    /// Target ranges are used to sort assists: the smaller the target range,
-    /// the more specific assist is, and so it should be sorted first.
-    pub(crate) fn target(&mut self, target: TextRange) {
-        self.target = Some(target)
-    }
-    /// Get access to the raw `TextEditBuilder`.
-    pub(crate) fn text_edit_builder(&mut self) -> &mut TextEditBuilder {
-        &mut self.edit
-    }
-    pub(crate) fn replace_ast<N: AstNode>(&mut self, old: N, new: N) {
-        algo::diff(old.syntax(), new.syntax()).into_text_edit(&mut self.edit)
-    }
-    pub(crate) fn rewrite(&mut self, rewriter: SyntaxRewriter) {
-        let node = rewriter.rewrite_root().unwrap();
-        let new = rewriter.rewrite(&node);
-        algo::diff(&node, &new).into_text_edit(&mut self.edit)
-    }
-    pub(crate) fn set_file(&mut self, assist_file: AssistFile) {
-        self.file = assist_file
-    }
-    fn build(self) -> AssistAction {
-        AssistAction {
-            edit: self.edit.finish(),
-            cursor_position: self.cursor_position,
-            target: self.target,
-            file: self.file,
-        }
-    }
-}
diff --git a/crates/ra_assists/src/ast_transform.rs b/crates/ra_assists/src/ast_transform.rs
index 9ac65ab39..3079a02a2 100644
--- a/crates/ra_assists/src/ast_transform.rs
+++ b/crates/ra_assists/src/ast_transform.rs
@@ -1,7 +1,7 @@
 //! `AstTransformer`s are functions that replace nodes in an AST and can be easily combined.
 use rustc_hash::FxHashMap;
-use hir::{PathResolution, SemanticsScope};
+use hir::{HirDisplay, PathResolution, SemanticsScope};
 use ra_ide_db::RootDatabase;
 use ra_syntax::{
    algo::SyntaxRewriter,
@@ -51,7 +51,27 @@ impl<'a> SubstituteTypeParams<'a> {
            .into_iter()
            // this is a trait impl, so we need to skip the first type parameter -- this is a bit hacky
            .skip(1)
-            .zip(substs.into_iter())
+            // The actual list of trait type parameters may be longer than the one
+            // used in the `impl` block due to trailing default type parametrs.
+            // For that case we extend the `substs` with an empty iterator so we
+            // can still hit those trailing values and check if they actually have
+            // a default type. If they do, go for that type from `hir` to `ast` so
+            // the resulting change can be applied correctly.
+            .zip(substs.into_iter().map(Some).chain(std::iter::repeat(None)))
+            .filter_map(|(k, v)| match v {
+                Some(v) => Some((k, v)),
+                None => {
+                    let default = k.default(source_scope.db)?;
+                    Some((
+                        k,
+                        ast::make::type_ref(
+                            &default
+                                .display_source_code(source_scope.db, source_scope.module()?.into())
+                                .ok()?,
+                        ),
+                    ))
+                }
+            })
            .collect();
        return SubstituteTypeParams {
            source_scope,
diff --git a/crates/ra_assists/src/doc_tests.rs b/crates/ra_assists/src/doc_tests.rs
deleted file mode 100644
index c0f9bc1fb..000000000
--- a/crates/ra_assists/src/doc_tests.rs
+++ /dev/null
@@ -1,35 +0,0 @@
-//! Each assist definition has a special comment, which specifies docs and
-//! example.
-//!
-//! We collect all the example and write the as tests in this module.
-mod generated;
-use ra_db::FileRange;
-use test_utils::{assert_eq_text, extract_range_or_offset};
-use crate::resolved_assists;
-fn check(assist_id: &str, before: &str, after: &str) {
-    let (selection, before) = extract_range_or_offset(before);
-    let (db, file_id) = crate::helpers::with_single_file(&before);
-    let frange = FileRange { file_id, range: selection.into() };
-    let assist = resolved_assists(&db, frange)
-        .into_iter()
-        .find(|assist| assist.label.id.0 == assist_id)
-        .unwrap_or_else(|| {
-            panic!(
-                "\n\nAssist is not applicable: {}\nAvailable assists: {}",
-                assist_id,
-                resolved_assists(&db, frange)
-                    .into_iter()
-                    .map(|assist| assist.label.id.0)
-                    .collect::<Vec<_>>()
-                    .join(", ")
-            )
-        });
-    let actual = assist.action.edit.apply(&before);
-    assert_eq_text!(after, &actual);
-}
diff --git a/crates/ra_assists/src/handlers/add_custom_impl.rs b/crates/ra_assists/src/handlers/add_custom_impl.rs
index 4ea26a550..fa70c8496 100644
--- a/crates/ra_assists/src/handlers/add_custom_impl.rs
+++ b/crates/ra_assists/src/handlers/add_custom_impl.rs
@@ -6,7 +6,10 @@ use ra_syntax::{
 };
 use stdx::SepBy;
-use crate::{Assist, AssistCtx, AssistId};
+use crate::{
+    assist_context::{AssistContext, Assists},
+    AssistId,
+};
 // Assist: add_custom_impl
 //
@@ -22,10 +25,10 @@ use crate::{Assist, AssistCtx, AssistId};
 // struct S;
 //
 // impl Debug for S {
-//
+//     $0
 // }
 // ```
-pub(crate) fn add_custom_impl(ctx: AssistCtx) -> Option<Assist> {
+pub(crate) fn add_custom_impl(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
    let input = ctx.find_node_at_offset::<ast::AttrInput>()?;
    let attr = input.syntax().parent().and_then(ast::Attr::cast)?;
@@ -46,11 +49,10 @@ pub(crate) fn add_custom_impl(ctx: AssistCtx) -> Option<Assist> {
    let start_offset = annotated.syntax().parent()?.text_range().end();
    let label =
-        format!("Add custom impl '{}' for '{}'", trait_token.text().as_str(), annotated_name);
+        format!("Add custom impl `{}` for `{}`", trait_token.text().as_str(), annotated_name);
-    ctx.add_assist(AssistId("add_custom_impl"), label, |edit| {
-        edit.target(attr.syntax().text_range());
+    let target = attr.syntax().text_range();
+    acc.add(AssistId("add_custom_impl"), label, target, |builder| {
        let new_attr_input = input
            .syntax()
            .descendants_with_tokens()
@@ -61,20 +63,11 @@ pub(crate) fn add_custom_impl(ctx: AssistCtx) -> Option<Assist> {
        let has_more_derives = !new_attr_input.is_empty();
        let new_attr_input = new_attr_input.iter().sep_by(", ").surround_with("(", ")").to_string();
-        let mut buf = String::new();
+        if has_more_derives {
-        buf.push_str("\n\nimpl ");
+            builder.replace(input.syntax().text_range(), new_attr_input);
-        buf.push_str(trait_token.text().as_str());
-        buf.push_str(" for ");
-        buf.push_str(annotated_name.as_str());
-        buf.push_str(" {\n");
-        let cursor_delta = if has_more_derives {
-            let delta = input.syntax().text_range().len() - TextSize::of(&new_attr_input);
-            edit.replace(input.syntax().text_range(), new_attr_input);
-            delta
        } else {
            let attr_range = attr.syntax().text_range();
-            edit.delete(attr_range);
+            builder.delete(attr_range);
            let line_break_range = attr
                .syntax()
@@ -82,20 +75,30 @@ pub(crate) fn add_custom_impl(ctx: AssistCtx) -> Option<Assist> {
                .filter(|t| t.kind() == WHITESPACE)
                .map(|t| t.text_range())
                .unwrap_or_else(|| TextRange::new(TextSize::from(0), TextSize::from(0)));
-            edit.delete(line_break_range);
+            builder.delete(line_break_range);
+        }
-            attr_range.len() + line_break_range.len()
-        };
+        match ctx.config.snippet_cap {
+            Some(cap) => {
-        edit.set_cursor(start_offset + TextSize::of(&buf) - cursor_delta);
+                builder.insert_snippet(
-        buf.push_str("\n}");
+                    cap,
-        edit.insert(start_offset, buf);
+                    start_offset,
+                    format!("\n\nimpl {} for {} {{\n    $0\n}}", trait_token, annotated_name),
+                );
+            }
+            None => {
+                builder.insert(
+                    start_offset,
+                    format!("\n\nimpl {} for {} {{\n\n}}", trait_token, annotated_name),
+                );
+            }
+        }
    })
 }
 #[cfg(test)]
 mod tests {
-    use crate::helpers::{check_assist, check_assist_not_applicable};
+    use crate::tests::{check_assist, check_assist_not_applicable};
    use super::*;
@@ -115,7 +118,7 @@ struct Foo {
 }
 impl Debug for Foo {
-<|>
+    $0
 }
            ",
        )
@@ -137,7 +140,7 @@ pub struct Foo {
 }
 impl Debug for Foo {
-<|>
+    $0
 }
            ",
        )
@@ -156,7 +159,7 @@ struct Foo {}
 struct Foo {}
 impl Debug for Foo {
-<|>
+    $0
 }
            ",
        )
diff --git a/crates/ra_assists/src/handlers/add_derive.rs b/crates/ra_assists/src/handlers/add_derive.rs
index 6254eb7c4..b123b8498 100644
--- a/crates/ra_assists/src/handlers/add_derive.rs
+++ b/crates/ra_assists/src/handlers/add_derive.rs
@@ -4,7 +4,7 @@ use ra_syntax::{
    TextSize,
 };
-use crate::{Assist, AssistCtx, AssistId};
+use crate::{AssistContext, AssistId, Assists};
 // Assist: add_derive
 //
@@ -18,31 +18,37 @@ use crate::{Assist, AssistCtx, AssistId};
 // ```
 // ->
 // ```
-// #[derive()]
+// #[derive($0)]
 // struct Point {
 //     x: u32,
 //     y: u32,
 // }
 // ```
-pub(crate) fn add_derive(ctx: AssistCtx) -> Option<Assist> {
+pub(crate) fn add_derive(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
+    let cap = ctx.config.snippet_cap?;
    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| {
+    let target = nominal.syntax().text_range();
+    acc.add(AssistId("add_derive"), "Add `#[derive]`", target, |builder| {
        let derive_attr = nominal
            .attrs()
            .filter_map(|x| x.as_simple_call())
            .filter(|(name, _arg)| name == "derive")
            .map(|(_name, arg)| arg)
            .next();
-        let offset = match derive_attr {
+        match derive_attr {
            None => {
-                edit.insert(node_start, "#[derive()]\n");
+                builder.insert_snippet(cap, node_start, "#[derive($0)]\n");
-                node_start + TextSize::of("#[derive(")
+            }
+            Some(tt) => {
+                // Just move the cursor.
+                builder.insert_snippet(
+                    cap,
+                    tt.syntax().text_range().end() - TextSize::of(')'),
+                    "$0",
+                )
            }
-            Some(tt) => tt.syntax().text_range().end() - TextSize::of(')'),
        };
-        edit.target(nominal.syntax().text_range());
-        edit.set_cursor(offset)
    })
 }
@@ -57,20 +63,21 @@ fn derive_insertion_offset(nominal: &ast::NominalDef) -> Option<TextSize> {
 #[cfg(test)]
 mod tests {
+    use crate::tests::{check_assist, check_assist_target};
    use super::*;
-    use crate::helpers::{check_assist, check_assist_target};
    #[test]
    fn add_derive_new() {
        check_assist(
            add_derive,
            "struct Foo { a: i32, <|>}",
-            "#[derive(<|>)]\nstruct Foo { a: i32, }",
+            "#[derive($0)]\nstruct Foo { a: i32, }",
        );
        check_assist(
            add_derive,
            "struct Foo { <|> a: i32, }",
-            "#[derive(<|>)]\nstruct Foo {  a: i32, }",
+            "#[derive($0)]\nstruct Foo {  a: i32, }",
        );
    }
@@ -79,7 +86,7 @@ mod tests {
        check_assist(
            add_derive,
            "#[derive(Clone)]\nstruct Foo { a: i32<|>, }",
-            "#[derive(Clone<|>)]\nstruct Foo { a: i32, }",
+            "#[derive(Clone$0)]\nstruct Foo { a: i32, }",
        );
    }
@@ -95,7 +102,7 @@ struct Foo { a: i32<|>, }
            "
 /// `Foo` is a pretty important struct.
 /// It does stuff.
-#[derive(<|>)]
+#[derive($0)]
 struct Foo { a: i32, }
            ",
        );
diff --git a/crates/ra_assists/src/handlers/add_explicit_type.rs b/crates/ra_assists/src/handlers/add_explicit_type.rs
index bc313782b..ab20c6649 100644
--- a/crates/ra_assists/src/handlers/add_explicit_type.rs
+++ b/crates/ra_assists/src/handlers/add_explicit_type.rs
@@ -4,7 +4,7 @@ use ra_syntax::{
    TextRange,
 };
-use crate::{Assist, AssistCtx, AssistId};
+use crate::{AssistContext, AssistId, Assists};
 // Assist: add_explicit_type
 //
@@ -21,12 +21,12 @@ use crate::{Assist, AssistCtx, AssistId};
 //     let x: i32 = 92;
 // }
 // ```
-pub(crate) fn add_explicit_type(ctx: AssistCtx) -> Option<Assist> {
+pub(crate) fn add_explicit_type(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
    let stmt = ctx.find_node_at_offset::<LetStmt>()?;
+    let module = ctx.sema.scope(stmt.syntax()).module()?;
    let expr = stmt.initializer()?;
-    let pat = stmt.pat()?;
    // Must be a binding
-    let pat = match pat {
+    let pat = match stmt.pat()? {
        ast::Pat::BindPat(bind_pat) => bind_pat,
        _ => return None,
    };
@@ -45,7 +45,7 @@ pub(crate) fn add_explicit_type(ctx: AssistCtx) -> Option<Assist> {
    // Assist not applicable if the type has already been specified
    // and it has no placeholders
    let ascribed_ty = stmt.ascribed_type();
-    if let Some(ref ty) = ascribed_ty {
+    if let Some(ty) = &ascribed_ty {
        if ty.syntax().descendants().find_map(ast::PlaceholderType::cast).is_none() {
            return None;
        }
@@ -57,17 +57,17 @@ pub(crate) fn add_explicit_type(ctx: AssistCtx) -> Option<Assist> {
        return None;
    }
-    let db = ctx.db;
+    let inferred_type = ty.display_source_code(ctx.db, module.into()).ok()?;
-    let new_type_string = ty.display_truncated(db, None).to_string();
+    acc.add(
-    ctx.add_assist(
        AssistId("add_explicit_type"),
-        format!("Insert explicit type '{}'", new_type_string),
+        format!("Insert explicit type `{}`", inferred_type),
-        |edit| {
+        pat_range,
-            edit.target(pat_range);
+        |builder| match ascribed_ty {
-            if let Some(ascribed_ty) = ascribed_ty {
+            Some(ascribed_ty) => {
-                edit.replace(ascribed_ty.syntax().text_range(), new_type_string);
+                builder.replace(ascribed_ty.syntax().text_range(), inferred_type);
-            } else {
+            }
-                edit.insert(name_range.end(), format!(": {}", new_type_string));
+            None => {
+                builder.insert(name_range.end(), format!(": {}", inferred_type));
            }
        },
    )
@@ -77,7 +77,7 @@ pub(crate) fn add_explicit_type(ctx: AssistCtx) -> Option<Assist> {
 mod tests {
    use super::*;
-    use crate::helpers::{check_assist, check_assist_not_applicable, check_assist_target};
+    use crate::tests::{check_assist, check_assist_not_applicable, check_assist_target};
    #[test]
    fn add_explicit_type_target() {
@@ -86,11 +86,7 @@ mod tests {
    #[test]
    fn add_explicit_type_works_for_simple_expr() {
-        check_assist(
+        check_assist(add_explicit_type, "fn f() { let a<|> = 1; }", "fn f() { let a: i32 = 1; }");
-            add_explicit_type,
-            "fn f() { let a<|> = 1; }",
-            "fn f() { let a<|>: i32 = 1; }",
-        );
    }
    #[test]
@@ -98,7 +94,7 @@ mod tests {
        check_assist(
            add_explicit_type,
            "fn f() { let a<|>: _ = 1; }",
-            "fn f() { let a<|>: i32 = 1; }",
+            "fn f() { let a: i32 = 1; }",
        );
    }
@@ -122,7 +118,7 @@ mod tests {
            }
            fn f() {
-                let a<|>: Option<i32> = Option::Some(1);
+                let a: Option<i32> = Option::Some(1);
            }"#,
        );
    }
@@ -132,7 +128,7 @@ mod tests {
        check_assist(
            add_explicit_type,
            r"macro_rules! v { () => {0u64} } fn f() { let a<|> = v!(); }",
-            r"macro_rules! v { () => {0u64} } fn f() { let a<|>: u64 = v!(); }",
+            r"macro_rules! v { () => {0u64} } fn f() { let a: u64 = v!(); }",
        );
    }
@@ -140,8 +136,8 @@ mod tests {
    fn add_explicit_type_works_for_macro_call_recursive() {
        check_assist(
            add_explicit_type,
-            "macro_rules! u { () => {0u64} } macro_rules! v { () => {u!()} } fn f() { let a<|> = v!(); }",
+            r#"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!(); }",
+            r#"macro_rules! u { () => {0u64} } macro_rules! v { () => {u!()} } fn f() { let a: u64 = v!(); }"#,
        );
    }
@@ -208,7 +204,7 @@ struct Test<K, T = u8> {
 }
 fn main() {
-    let test<|>: Test<i32> = Test { t: 23, k: 33 };
+    let test: Test<i32> = Test { t: 23, k: 33 };
 }"#,
        );
    }
diff --git a/crates/ra_assists/src/handlers/add_from_impl_for_enum.rs b/crates/ra_assists/src/handlers/add_from_impl_for_enum.rs
index 49deb6701..6a675e812 100644
--- a/crates/ra_assists/src/handlers/add_from_impl_for_enum.rs
+++ b/crates/ra_assists/src/handlers/add_from_impl_for_enum.rs
@@ -1,12 +1,8 @@
 use ra_ide_db::RootDatabase;
-use ra_syntax::{
+use ra_syntax::ast::{self, AstNode, NameOwner};
-    ast::{self, AstNode, NameOwner},
+use test_utils::mark;
-    TextSize,
-};
-use stdx::format_to;
-use crate::{utils::FamousDefs, Assist, AssistCtx, AssistId};
+use crate::{utils::FamousDefs, AssistContext, AssistId, Assists};
-use test_utils::tested_by;
 // Assist add_from_impl_for_enum
 //
@@ -25,7 +21,7 @@ use test_utils::tested_by;
 //     }
 // }
 // ```
-pub(crate) fn add_from_impl_for_enum(ctx: AssistCtx) -> Option<Assist> {
+pub(crate) fn add_from_impl_for_enum(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
    let variant = ctx.find_node_at_offset::<ast::EnumVariant>()?;
    let variant_name = variant.name()?;
    let enum_name = variant.parent_enum().name()?;
@@ -38,23 +34,23 @@ pub(crate) fn add_from_impl_for_enum(ctx: AssistCtx) -> Option<Assist> {
    }
    let field_type = field_list.fields().next()?.type_ref()?;
    let path = match field_type {
-        ast::TypeRef::PathType(p) => p,
+        ast::TypeRef::PathType(it) => it,
        _ => return None,
    };
-    if existing_from_impl(ctx.sema, &variant).is_some() {
+    if existing_from_impl(&ctx.sema, &variant).is_some() {
-        tested_by!(test_add_from_impl_already_exists);
+        mark::hit!(test_add_from_impl_already_exists);
        return None;
    }
-    ctx.add_assist(
+    let target = variant.syntax().text_range();
+    acc.add(
        AssistId("add_from_impl_for_enum"),
        "Add From impl for this enum variant",
+        target,
        |edit| {
            let start_offset = variant.parent_enum().syntax().text_range().end();
-            let mut buf = String::new();
+            let buf = format!(
-            format_to!(
-                buf,
                r#"
 impl From<{0}> for {1} {{
@@ -67,7 +63,6 @@ impl From<{0}> for {1} {{
                variant_name
            );
            edit.insert(start_offset, buf);
-            edit.set_cursor(start_offset + TextSize::of("\n\n"));
        },
    )
 }
@@ -95,10 +90,11 @@ fn existing_from_impl(
 #[cfg(test)]
 mod tests {
-    use super::*;
+    use test_utils::mark;
+    use crate::tests::{check_assist, check_assist_not_applicable};
-    use crate::helpers::{check_assist, check_assist_not_applicable};
+    use super::*;
-    use test_utils::covers;
    #[test]
    fn test_add_from_impl_for_enum() {
@@ -107,7 +103,7 @@ mod tests {
            "enum A { <|>One(u32) }",
            r#"enum A { One(u32) }
-<|>impl From<u32> for A {
+impl From<u32> for A {
    fn from(v: u32) -> Self {
        A::One(v)
    }
@@ -119,10 +115,10 @@ mod tests {
    fn test_add_from_impl_for_enum_complicated_path() {
        check_assist(
            add_from_impl_for_enum,
-            "enum A { <|>One(foo::bar::baz::Boo) }",
+            r#"enum A { <|>One(foo::bar::baz::Boo) }"#,
            r#"enum A { One(foo::bar::baz::Boo) }
-<|>impl From<foo::bar::baz::Boo> for A {
+impl From<foo::bar::baz::Boo> for A {
    fn from(v: foo::bar::baz::Boo) -> Self {
        A::One(v)
    }
@@ -153,7 +149,7 @@ mod tests {
    #[test]
    fn test_add_from_impl_already_exists() {
-        covers!(test_add_from_impl_already_exists);
+        mark::check!(test_add_from_impl_already_exists);
        check_not_applicable(
            r#"
 enum A { <|>One(u32), }
@@ -184,7 +180,7 @@ pub trait From<T> {
 }"#,
            r#"enum A { One(u32), Two(String), }
-<|>impl From<u32> for A {
+impl From<u32> for A {
    fn from(v: u32) -> Self {
        A::One(v)
    }
diff --git a/crates/ra_assists/src/handlers/add_function.rs b/crates/ra_assists/src/handlers/add_function.rs
index 6c7456579..24f931a85 100644
--- a/crates/ra_assists/src/handlers/add_function.rs
+++ b/crates/ra_assists/src/handlers/add_function.rs
@@ -1,13 +1,21 @@
+use hir::HirDisplay;
+use ra_db::FileId;
 use ra_syntax::{
-    ast::{self, AstNode},
+    ast::{
+        self,
+        edit::{AstNodeEdit, IndentLevel},
+        make, ArgListOwner, AstNode, ModuleItemOwner,
+    },
    SyntaxKind, SyntaxNode, TextSize,
 };
-use crate::{Assist, AssistCtx, AssistFile, AssistId};
-use ast::{edit::IndentLevel, ArgListOwner, ModuleItemOwner};
-use hir::HirDisplay;
 use rustc_hash::{FxHashMap, FxHashSet};
+use crate::{
+    assist_config::SnippetCap,
+    utils::{render_snippet, Cursor},
+    AssistContext, AssistId, Assists,
+};
 // Assist: add_function
 //
 // Adds a stub function with a signature matching the function under the cursor.
@@ -29,11 +37,11 @@ use rustc_hash::{FxHashMap, FxHashSet};
 // }
 //
 // fn bar(arg: &str, baz: Baz) {
-//     todo!()
+//     ${0:todo!()}
 // }
 //
 // ```
-pub(crate) fn add_function(ctx: AssistCtx) -> Option<Assist> {
+pub(crate) fn add_function(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
    let path_expr: ast::PathExpr = ctx.find_node_at_offset()?;
    let call = path_expr.syntax().parent().and_then(ast::CallExpr::cast)?;
    let path = path_expr.path()?;
@@ -43,36 +51,49 @@ pub(crate) fn add_function(ctx: AssistCtx) -> Option<Assist> {
        return None;
    }
-    let target_module = if let Some(qualifier) = path.qualifier() {
+    let target_module = match path.qualifier() {
-        if let Some(hir::PathResolution::Def(hir::ModuleDef::Module(module))) =
+        Some(qualifier) => match ctx.sema.resolve_path(&qualifier) {
-            ctx.sema.resolve_path(&qualifier)
+            Some(hir::PathResolution::Def(hir::ModuleDef::Module(module))) => Some(module),
-        {
+            _ => return None,
-            Some(module.definition_source(ctx.sema.db))
+        },
-        } else {
+        None => None,
-            return None;
-        }
-    } else {
-        None
    };
    let function_builder = FunctionBuilder::from_call(&ctx, &call, &path, target_module)?;
-    ctx.add_assist(AssistId("add_function"), "Add function", |edit| {
+    let target = call.syntax().text_range();
-        edit.target(call.syntax().text_range());
+    acc.add(AssistId("add_function"), "Add function", target, |builder| {
+        let function_template = function_builder.render();
-        if let Some(function_template) = function_builder.render() {
+        builder.set_file(function_template.file);
-            edit.set_file(function_template.file);
+        let new_fn = function_template.to_string(ctx.config.snippet_cap);
-            edit.set_cursor(function_template.cursor_offset);
+        match ctx.config.snippet_cap {
-            edit.insert(function_template.insert_offset, function_template.fn_def.to_string());
+            Some(cap) => builder.insert_snippet(cap, function_template.insert_offset, new_fn),
+            None => builder.insert(function_template.insert_offset, new_fn),
        }
    })
 }
 struct FunctionTemplate {
    insert_offset: TextSize,
-    cursor_offset: TextSize,
+    placeholder_expr: ast::MacroCall,
-    fn_def: ast::SourceFile,
+    leading_ws: String,
-    file: AssistFile,
+    fn_def: ast::FnDef,
+    trailing_ws: String,
+    file: FileId,
+}
+impl FunctionTemplate {
+    fn to_string(&self, cap: Option<SnippetCap>) -> String {
+        let f = match cap {
+            Some(cap) => render_snippet(
+                cap,
+                self.fn_def.syntax(),
+                Cursor::Replace(self.placeholder_expr.syntax()),
+            ),
+            None => self.fn_def.to_string(),
+        };
+        format!("{}{}{}", self.leading_ws, f, self.trailing_ws)
+    }
 }
 struct FunctionBuilder {
@@ -80,68 +101,73 @@ struct FunctionBuilder {
    fn_name: ast::Name,
    type_params: Option<ast::TypeParamList>,
    params: ast::ParamList,
-    file: AssistFile,
+    file: FileId,
    needs_pub: bool,
 }
 impl FunctionBuilder {
-    /// Prepares a generated function that matches `call` in `generate_in`
+    /// Prepares a generated function that matches `call`.
-    /// (or as close to `call` as possible, if `generate_in` is `None`)
+    /// The function is generated in `target_module` or next to `call`
    fn from_call(
-        ctx: &AssistCtx,
+        ctx: &AssistContext,
        call: &ast::CallExpr,
        path: &ast::Path,
-        target_module: Option<hir::InFile<hir::ModuleSource>>,
+        target_module: Option<hir::Module>,
    ) -> Option<Self> {
-        let needs_pub = target_module.is_some();
+        let mut file = ctx.frange.file_id;
-        let mut file = AssistFile::default();
+        let target = match &target_module {
-        let target = if let Some(target_module) = target_module {
+            Some(target_module) => {
-            let (in_file, target) = next_space_for_fn_in_module(ctx.sema.db, target_module)?;
+                let module_source = target_module.definition_source(ctx.db);
-            file = in_file;
+                let (in_file, target) = next_space_for_fn_in_module(ctx.sema.db, &module_source)?;
-            target
+                file = in_file;
-        } else {
+                target
-            next_space_for_fn_after_call_site(&call)?
+            }
+            None => next_space_for_fn_after_call_site(&call)?,
        };
+        let needs_pub = target_module.is_some();
+        let target_module = target_module.or_else(|| ctx.sema.scope(target.syntax()).module())?;
        let fn_name = fn_name(&path)?;
-        let (type_params, params) = fn_args(ctx, &call)?;
+        let (type_params, params) = fn_args(ctx, target_module, &call)?;
        Some(Self { target, fn_name, type_params, params, file, needs_pub })
    }
-    fn render(self) -> Option<FunctionTemplate> {
+    fn render(self) -> FunctionTemplate {
-        let placeholder_expr = ast::make::expr_todo();
+        let placeholder_expr = make::expr_todo();
-        let fn_body = ast::make::block_expr(vec![], Some(placeholder_expr));
+        let fn_body = make::block_expr(vec![], Some(placeholder_expr));
-        let mut fn_def = ast::make::fn_def(self.fn_name, self.type_params, self.params, fn_body);
+        let visibility = if self.needs_pub { Some(make::visibility_pub_crate()) } else { None };
-        if self.needs_pub {
+        let mut fn_def =
-            fn_def = ast::make::add_pub_crate_modifier(fn_def);
+            make::fn_def(visibility, self.fn_name, self.type_params, self.params, fn_body);
-        }
+        let leading_ws;
+        let trailing_ws;
-        let (fn_def, insert_offset) = match self.target {
+        let insert_offset = match self.target {
            GeneratedFunctionTarget::BehindItem(it) => {
-                let with_leading_blank_line = ast::make::add_leading_newlines(2, fn_def);
+                let indent = IndentLevel::from_node(&it);
-                let indented = IndentLevel::from_node(&it).increase_indent(with_leading_blank_line);
+                leading_ws = format!("\n\n{}", indent);
-                (indented, it.text_range().end())
+                fn_def = fn_def.indent(indent);
+                trailing_ws = String::new();
+                it.text_range().end()
            }
            GeneratedFunctionTarget::InEmptyItemList(it) => {
-                let indent_once = IndentLevel(1);
                let indent = IndentLevel::from_node(it.syntax());
+                leading_ws = format!("\n{}", indent + 1);
-                let fn_def = ast::make::add_leading_newlines(1, fn_def);
+                fn_def = fn_def.indent(indent + 1);
-                let fn_def = indent_once.increase_indent(fn_def);
+                trailing_ws = format!("\n{}", indent);
-                let fn_def = ast::make::add_trailing_newlines(1, fn_def);
+                it.syntax().text_range().start() + TextSize::of('{')
-                let fn_def = indent.increase_indent(fn_def);
-                (fn_def, it.syntax().text_range().start() + TextSize::of('{'))
            }
        };
-        let cursor_offset_from_fn_start = fn_def
+        let placeholder_expr =
-            .syntax()
+            fn_def.syntax().descendants().find_map(ast::MacroCall::cast).unwrap();
-            .descendants()
+        FunctionTemplate {
-            .find_map(ast::MacroCall::cast)?
+            insert_offset,
-            .syntax()
+            placeholder_expr,
-            .text_range()
+            leading_ws,
-            .start();
+            fn_def,
-        let cursor_offset = insert_offset + cursor_offset_from_fn_start;
+            trailing_ws,
-        Some(FunctionTemplate { insert_offset, cursor_offset, fn_def, file: self.file })
+            file: self.file,
+        }
    }
 }
@@ -150,32 +176,41 @@ enum GeneratedFunctionTarget {
    InEmptyItemList(ast::ItemList),
 }
+impl GeneratedFunctionTarget {
+    fn syntax(&self) -> &SyntaxNode {
+        match self {
+            GeneratedFunctionTarget::BehindItem(it) => it,
+            GeneratedFunctionTarget::InEmptyItemList(it) => it.syntax(),
+        }
+    }
+}
 fn fn_name(call: &ast::Path) -> Option<ast::Name> {
    let name = call.segment()?.syntax().to_string();
-    Some(ast::make::name(&name))
+    Some(make::name(&name))
 }
 /// Computes the type variables and arguments required for the generated function
 fn fn_args(
-    ctx: &AssistCtx,
+    ctx: &AssistContext,
+    target_module: hir::Module,
    call: &ast::CallExpr,
 ) -> Option<(Option<ast::TypeParamList>, ast::ParamList)> {
    let mut arg_names = Vec::new();
    let mut arg_types = Vec::new();
    for arg in call.arg_list()?.args() {
-        let arg_name = match fn_arg_name(&arg) {
+        arg_names.push(match fn_arg_name(&arg) {
            Some(name) => name,
            None => String::from("arg"),
-        };
+        });
-        arg_names.push(arg_name);
+        arg_types.push(match fn_arg_type(ctx, target_module, &arg) {
-        arg_types.push(match fn_arg_type(ctx, &arg) {
            Some(ty) => ty,
            None => String::from("()"),
        });
    }
    deduplicate_arg_names(&mut arg_names);
-    let params = arg_names.into_iter().zip(arg_types).map(|(name, ty)| ast::make::param(name, ty));
+    let params = arg_names.into_iter().zip(arg_types).map(|(name, ty)| make::param(name, ty));
-    Some((None, ast::make::param_list(params)))
+    Some((None, make::param_list(params)))
 }
 /// Makes duplicate argument names unique by appending incrementing numbers.
@@ -224,12 +259,21 @@ fn fn_arg_name(fn_arg: &ast::Expr) -> Option<String> {
    }
 }
-fn fn_arg_type(ctx: &AssistCtx, fn_arg: &ast::Expr) -> Option<String> {
+fn fn_arg_type(
+    ctx: &AssistContext,
+    target_module: hir::Module,
+    fn_arg: &ast::Expr,
+) -> Option<String> {
    let ty = ctx.sema.type_of_expr(fn_arg)?;
    if ty.is_unknown() {
        return None;
    }
-    Some(ty.display(ctx.sema.db).to_string())
+    if let Ok(rendered) = ty.display_source_code(ctx.db, target_module.into()) {
+        Some(rendered)
+    } else {
+        None
+    }
 }
 /// Returns the position inside the current mod or file
@@ -258,11 +302,10 @@ fn next_space_for_fn_after_call_site(expr: &ast::CallExpr) -> Option<GeneratedFu
 fn next_space_for_fn_in_module(
    db: &dyn hir::db::AstDatabase,
-    module: hir::InFile<hir::ModuleSource>,
+    module_source: &hir::InFile<hir::ModuleSource>,
-) -> Option<(AssistFile, GeneratedFunctionTarget)> {
+) -> Option<(FileId, GeneratedFunctionTarget)> {
-    let file = module.file_id.original_file(db);
+    let file = module_source.file_id.original_file(db);
-    let assist_file = AssistFile::TargetFile(file);
+    let assist_item = match &module_source.value {
-    let assist_item = match module.value {
        hir::ModuleSource::SourceFile(it) => {
            if let Some(last_item) = it.items().last() {
                GeneratedFunctionTarget::BehindItem(last_item.syntax().clone())
@@ -278,12 +321,12 @@ fn next_space_for_fn_in_module(
            }
        }
    };
-    Some((assist_file, assist_item))
+    Some((file, assist_item))
 }
 #[cfg(test)]
 mod tests {
-    use crate::helpers::{check_assist, check_assist_not_applicable};
+    use crate::tests::{check_assist, check_assist_not_applicable};
    use super::*;
@@ -302,7 +345,7 @@ fn foo() {
 }
 fn bar() {
-    <|>todo!()
+    ${0:todo!()}
 }
 ",
        )
@@ -329,7 +372,7 @@ impl Foo {
 }
 fn bar() {
-    <|>todo!()
+    ${0:todo!()}
 }
 ",
        )
@@ -353,7 +396,7 @@ fn foo1() {
 }
 fn bar() {
-    <|>todo!()
+    ${0:todo!()}
 }
 fn foo2() {}
@@ -379,7 +422,7 @@ mod baz {
    }
    fn bar() {
-        <|>todo!()
+        ${0:todo!()}
    }
 }
 ",
@@ -405,7 +448,7 @@ fn foo() {
 }
 fn bar(baz: Baz) {
-    <|>todo!()
+    ${0:todo!()}
 }
 ",
        );
@@ -438,7 +481,7 @@ impl Baz {
 }
 fn bar(baz: Baz) {
-    <|>todo!()
+    ${0:todo!()}
 }
 ",
        )
@@ -459,7 +502,7 @@ fn foo() {
 }
 fn bar(arg: &str) {
-    <|>todo!()
+    ${0:todo!()}
 }
 "#,
        )
@@ -480,7 +523,7 @@ fn foo() {
 }
 fn bar(arg: char) {
-    <|>todo!()
+    ${0:todo!()}
 }
 "#,
        )
@@ -501,7 +544,7 @@ fn foo() {
 }
 fn bar(arg: i32) {
-    <|>todo!()
+    ${0:todo!()}
 }
 ",
        )
@@ -522,7 +565,7 @@ fn foo() {
 }
 fn bar(arg: u8) {
-    <|>todo!()
+    ${0:todo!()}
 }
 ",
        )
@@ -547,7 +590,7 @@ fn foo() {
 }
 fn bar(x: u8) {
-    <|>todo!()
+    ${0:todo!()}
 }
 ",
        )
@@ -570,7 +613,7 @@ fn foo() {
 }
 fn bar(worble: ()) {
-    <|>todo!()
+    ${0:todo!()}
 }
 ",
        )
@@ -599,15 +642,40 @@ fn baz() {
 }
 fn bar(foo: impl Foo) {
-    <|>todo!()
+    ${0:todo!()}
+}
+",
+        )
+    }
+    #[test]
+    fn borrowed_arg() {
+        check_assist(
+            add_function,
+            r"
+struct Baz;
+fn baz() -> Baz { todo!() }
+fn foo() {
+    bar<|>(&baz())
+}
+",
+            r"
+struct Baz;
+fn baz() -> Baz { todo!() }
+fn foo() {
+    bar(&baz())
+}
+fn bar(baz: &Baz) {
+    ${0:todo!()}
 }
 ",
        )
    }
    #[test]
-    #[ignore]
-    // FIXME print paths properly to make this test pass
    fn add_function_with_qualified_path_arg() {
        check_assist(
            add_function,
@@ -616,10 +684,8 @@ mod Baz {
    pub struct Bof;
    pub fn baz() -> Bof { Bof }
 }
-mod Foo {
+fn foo() {
-    fn foo() {
+    <|>bar(Baz::baz())
-        <|>bar(super::Baz::baz())
-    }
 }
 ",
            r"
@@ -627,14 +693,12 @@ mod Baz {
    pub struct Bof;
    pub fn baz() -> Bof { Bof }
 }
-mod Foo {
+fn foo() {
-    fn foo() {
+    bar(Baz::baz())
-        bar(super::Baz::baz())
+}
-    }
-    fn bar(baz: super::Baz::Bof) {
+fn bar(baz: Baz::Bof) {
-        <|>todo!()
+    ${0:todo!()}
-    }
 }
 ",
        )
@@ -657,7 +721,7 @@ fn foo<T>(t: T) {
 }
 fn bar<T>(t: T) {
-    <|>todo!()
+    ${0:todo!()}
 }
 ",
        )
@@ -688,7 +752,7 @@ fn foo() {
 }
 fn bar(arg: fn() -> Baz) {
-    <|>todo!()
+    ${0:todo!()}
 }
 ",
        )
@@ -713,7 +777,7 @@ fn foo() {
 }
 fn bar(closure: impl Fn(i64) -> i64) {
-    <|>todo!()
+    ${0:todo!()}
 }
 ",
        )
@@ -734,7 +798,7 @@ fn foo() {
 }
 fn bar(baz: ()) {
-    <|>todo!()
+    ${0:todo!()}
 }
 ",
        )
@@ -759,7 +823,7 @@ fn foo() {
 }
 fn bar(baz_1: Baz, baz_2: Baz) {
-    <|>todo!()
+    ${0:todo!()}
 }
 ",
        )
@@ -784,7 +848,7 @@ fn foo() {
 }
 fn bar(baz_1: Baz, baz_2: Baz, arg_1: &str, arg_2: &str) {
-    <|>todo!()
+    ${0:todo!()}
 }
 "#,
        )
@@ -804,7 +868,7 @@ fn foo() {
            r"
 mod bar {
    pub(crate) fn my_fn() {
-        <|>todo!()
+        ${0:todo!()}
    }
 }
@@ -816,6 +880,40 @@ fn foo() {
    }
    #[test]
+    #[ignore]
+    // Ignored until local imports are supported.
+    // See https://github.com/rust-analyzer/rust-analyzer/issues/1165
+    fn qualified_path_uses_correct_scope() {
+        check_assist(
+            add_function,
+            "
+mod foo {
+    pub struct Foo;
+}
+fn bar() {
+    use foo::Foo;
+    let foo = Foo;
+    baz<|>(foo)
+}
+",
+            "
+mod foo {
+    pub struct Foo;
+}
+fn bar() {
+    use foo::Foo;
+    let foo = Foo;
+    baz(foo)
+}
+fn baz(foo: foo::Foo) {
+    ${0:todo!()}
+}
+",
+        )
+    }
+    #[test]
    fn add_function_in_module_containing_other_items() {
        check_assist(
            add_function,
@@ -833,7 +931,7 @@ mod bar {
    fn something_else() {}
    pub(crate) fn my_fn() {
-        <|>todo!()
+        ${0:todo!()}
    }
 }
@@ -861,7 +959,7 @@ fn foo() {
 mod bar {
    mod baz {
        pub(crate) fn my_fn() {
-            <|>todo!()
+            ${0:todo!()}
        }
    }
 }
@@ -890,7 +988,7 @@ fn main() {
 pub(crate) fn bar() {
-    <|>todo!()
+    ${0:todo!()}
 }",
        )
    }
@@ -927,21 +1025,6 @@ fn bar(baz: ()) {}
    }
    #[test]
-    fn add_function_not_applicable_if_function_path_not_singleton() {
-        // In the future this assist could be extended to generate functions
-        // if the path is in the same crate (or even the same workspace).
-        // For the beginning, I think this is fine.
-        check_assist_not_applicable(
-            add_function,
-            r"
-fn foo() {
-    other_crate::bar<|>();
-}
-        ",
-        )
-    }
-    #[test]
    #[ignore]
    fn create_method_with_no_args() {
        check_assist(
diff --git a/crates/ra_assists/src/handlers/add_impl.rs b/crates/ra_assists/src/handlers/add_impl.rs
index d26f8b93d..eceba7d0a 100644
--- a/crates/ra_assists/src/handlers/add_impl.rs
+++ b/crates/ra_assists/src/handlers/add_impl.rs
@@ -1,10 +1,7 @@
-use ra_syntax::{
+use ra_syntax::ast::{self, AstNode, NameOwner, TypeParamsOwner};
-    ast::{self, AstNode, NameOwner, TypeParamsOwner},
-    TextSize,
-};
 use stdx::{format_to, SepBy};
-use crate::{Assist, AssistCtx, AssistId};
+use crate::{AssistContext, AssistId, Assists};
 // Assist: add_impl
 //
@@ -12,24 +9,24 @@ use crate::{Assist, AssistCtx, AssistId};
 //
 // ```
 // struct Ctx<T: Clone> {
-//      data: T,<|>
+//     data: T,<|>
 // }
 // ```
 // ->
 // ```
 // struct Ctx<T: Clone> {
-//      data: T,
+//     data: T,
 // }
 //
 // impl<T: Clone> Ctx<T> {
-//
+//     $0
 // }
 // ```
-pub(crate) fn add_impl(ctx: AssistCtx) -> Option<Assist> {
+pub(crate) fn add_impl(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
    let nominal = ctx.find_node_at_offset::<ast::NominalDef>()?;
    let name = nominal.name()?;
-    ctx.add_assist(AssistId("add_impl"), format!("Implement {}", name.text().as_str()), |edit| {
+    let target = nominal.syntax().text_range();
-        edit.target(nominal.syntax().text_range());
+    acc.add(AssistId("add_impl"), format!("Implement {}", name.text().as_str()), target, |edit| {
        let type_params = nominal.type_param_list();
        let start_offset = nominal.syntax().text_range().end();
        let mut buf = String::new();
@@ -50,30 +47,37 @@ pub(crate) fn add_impl(ctx: AssistCtx) -> Option<Assist> {
            let generic_params = lifetime_params.chain(type_params).sep_by(", ");
            format_to!(buf, "<{}>", generic_params)
        }
-        buf.push_str(" {\n");
+        match ctx.config.snippet_cap {
-        edit.set_cursor(start_offset + TextSize::of(&buf));
+            Some(cap) => {
-        buf.push_str("\n}");
+                buf.push_str(" {\n    $0\n}");
-        edit.insert(start_offset, buf);
+                edit.insert_snippet(cap, start_offset, buf);
+            }
+            None => {
+                buf.push_str(" {\n}");
+                edit.insert(start_offset, buf);
+            }
+        }
    })
 }
 #[cfg(test)]
 mod tests {
+    use crate::tests::{check_assist, check_assist_target};
    use super::*;
-    use crate::helpers::{check_assist, check_assist_target};
    #[test]
    fn test_add_impl() {
-        check_assist(add_impl, "struct Foo {<|>}\n", "struct Foo {}\n\nimpl Foo {\n<|>\n}\n");
+        check_assist(add_impl, "struct Foo {<|>}\n", "struct Foo {}\n\nimpl Foo {\n    $0\n}\n");
        check_assist(
            add_impl,
            "struct Foo<T: Clone> {<|>}",
-            "struct Foo<T: Clone> {}\n\nimpl<T: Clone> Foo<T> {\n<|>\n}",
+            "struct Foo<T: Clone> {}\n\nimpl<T: Clone> Foo<T> {\n    $0\n}",
        );
        check_assist(
            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}",
+            "struct Foo<'a, T: Foo<'a>> {}\n\nimpl<'a, T: Foo<'a>> Foo<'a, T> {\n    $0\n}",
        );
    }
diff --git a/crates/ra_assists/src/handlers/add_missing_impl_members.rs b/crates/ra_assists/src/handlers/add_missing_impl_members.rs
index 2d6d44980..abacd4065 100644
--- a/crates/ra_assists/src/handlers/add_missing_impl_members.rs
+++ b/crates/ra_assists/src/handlers/add_missing_impl_members.rs
@@ -1,13 +1,18 @@
 use hir::HasSource;
 use ra_syntax::{
-    ast::{self, edit, make, AstNode, NameOwner},
+    ast::{
+        self,
+        edit::{self, AstNodeEdit, IndentLevel},
+        make, AstNode, NameOwner,
+    },
    SmolStr,
 };
 use crate::{
+    assist_context::{AssistContext, Assists},
    ast_transform::{self, AstTransform, QualifyPaths, SubstituteTypeParams},
-    utils::{get_missing_impl_items, resolve_target_trait},
+    utils::{get_missing_assoc_items, render_snippet, resolve_target_trait, Cursor},
-    Assist, AssistCtx, AssistId,
+    AssistId,
 };
 #[derive(PartialEq)]
@@ -40,12 +45,15 @@ enum AddMissingImplMembersMode {
 // }
 //
 // impl Trait<u32> for () {
-//     fn foo(&self) -> u32 { todo!() }
+//     fn foo(&self) -> u32 {
+//         ${0:todo!()}
+//     }
 //
 // }
 // ```
-pub(crate) fn add_missing_impl_members(ctx: AssistCtx) -> Option<Assist> {
+pub(crate) fn add_missing_impl_members(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
    add_missing_impl_members_inner(
+        acc,
        ctx,
        AddMissingImplMembersMode::NoDefaultMethods,
        "add_impl_missing_members",
@@ -81,12 +89,13 @@ pub(crate) fn add_missing_impl_members(ctx: AssistCtx) -> Option<Assist> {
 // impl Trait for () {
 //     Type X = ();
 //     fn foo(&self) {}
-//     fn bar(&self) {}
+//     $0fn bar(&self) {}
 //
 // }
 // ```
-pub(crate) fn add_missing_default_members(ctx: AssistCtx) -> Option<Assist> {
+pub(crate) fn add_missing_default_members(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
    add_missing_impl_members_inner(
+        acc,
        ctx,
        AddMissingImplMembersMode::DefaultMethodsOnly,
        "add_impl_default_members",
@@ -95,36 +104,37 @@ pub(crate) fn add_missing_default_members(ctx: AssistCtx) -> Option<Assist> {
 }
 fn add_missing_impl_members_inner(
-    ctx: AssistCtx,
+    acc: &mut Assists,
+    ctx: &AssistContext,
    mode: AddMissingImplMembersMode,
    assist_id: &'static str,
    label: &'static str,
-) -> Option<Assist> {
+) -> Option<()> {
    let _p = ra_prof::profile("add_missing_impl_members_inner");
-    let impl_node = ctx.find_node_at_offset::<ast::ImplDef>()?;
+    let impl_def = ctx.find_node_at_offset::<ast::ImplDef>()?;
-    let impl_item_list = impl_node.item_list()?;
+    let impl_item_list = impl_def.item_list()?;
-    let trait_ = resolve_target_trait(&ctx.sema, &impl_node)?;
+    let trait_ = resolve_target_trait(&ctx.sema, &impl_def)?;
-    let def_name = |item: &ast::ImplItem| -> Option<SmolStr> {
+    let def_name = |item: &ast::AssocItem| -> Option<SmolStr> {
        match item {
-            ast::ImplItem::FnDef(def) => def.name(),
+            ast::AssocItem::FnDef(def) => def.name(),
-            ast::ImplItem::TypeAliasDef(def) => def.name(),
+            ast::AssocItem::TypeAliasDef(def) => def.name(),
-            ast::ImplItem::ConstDef(def) => def.name(),
+            ast::AssocItem::ConstDef(def) => def.name(),
        }
        .map(|it| it.text().clone())
    };
-    let missing_items = get_missing_impl_items(&ctx.sema, &impl_node)
+    let missing_items = get_missing_assoc_items(&ctx.sema, &impl_def)
        .iter()
        .map(|i| match i {
-            hir::AssocItem::Function(i) => ast::ImplItem::FnDef(i.source(ctx.db).value),
+            hir::AssocItem::Function(i) => ast::AssocItem::FnDef(i.source(ctx.db).value),
-            hir::AssocItem::TypeAlias(i) => ast::ImplItem::TypeAliasDef(i.source(ctx.db).value),
+            hir::AssocItem::TypeAlias(i) => ast::AssocItem::TypeAliasDef(i.source(ctx.db).value),
-            hir::AssocItem::Const(i) => ast::ImplItem::ConstDef(i.source(ctx.db).value),
+            hir::AssocItem::Const(i) => ast::AssocItem::ConstDef(i.source(ctx.db).value),
        })
        .filter(|t| def_name(&t).is_some())
        .filter(|t| match t {
-            ast::ImplItem::FnDef(def) => match mode {
+            ast::AssocItem::FnDef(def) => match mode {
                AddMissingImplMembersMode::DefaultMethodsOnly => def.body().is_some(),
                AddMissingImplMembersMode::NoDefaultMethods => def.body().is_none(),
            },
@@ -136,44 +146,59 @@ fn add_missing_impl_members_inner(
        return None;
    }
-    let sema = ctx.sema;
+    let target = impl_def.syntax().text_range();
+    acc.add(AssistId(assist_id), label, target, |builder| {
-    ctx.add_assist(AssistId(assist_id), label, |edit| {
+        let n_existing_items = impl_item_list.assoc_items().count();
-        let n_existing_items = impl_item_list.impl_items().count();
+        let source_scope = ctx.sema.scope_for_def(trait_);
-        let source_scope = sema.scope_for_def(trait_);
+        let target_scope = ctx.sema.scope(impl_item_list.syntax());
-        let target_scope = sema.scope(impl_item_list.syntax());
        let ast_transform = QualifyPaths::new(&target_scope, &source_scope)
-            .or(SubstituteTypeParams::for_trait_impl(&source_scope, trait_, impl_node));
+            .or(SubstituteTypeParams::for_trait_impl(&source_scope, trait_, impl_def));
        let items = missing_items
            .into_iter()
            .map(|it| ast_transform::apply(&*ast_transform, it))
            .map(|it| match it {
-                ast::ImplItem::FnDef(def) => ast::ImplItem::FnDef(add_body(def)),
+                ast::AssocItem::FnDef(def) => ast::AssocItem::FnDef(add_body(def)),
                _ => it,
            })
            .map(|it| edit::remove_attrs_and_docs(&it));
        let new_impl_item_list = impl_item_list.append_items(items);
-        let cursor_position = {
+        let first_new_item = new_impl_item_list.assoc_items().nth(n_existing_items).unwrap();
-            let first_new_item = new_impl_item_list.impl_items().nth(n_existing_items).unwrap();
-            first_new_item.syntax().text_range().start()
+        let original_range = impl_item_list.syntax().text_range();
+        match ctx.config.snippet_cap {
+            None => builder.replace(original_range, new_impl_item_list.to_string()),
+            Some(cap) => {
+                let mut cursor = Cursor::Before(first_new_item.syntax());
+                let placeholder;
+                if let ast::AssocItem::FnDef(func) = &first_new_item {
+                    if let Some(m) = func.syntax().descendants().find_map(ast::MacroCall::cast) {
+                        if m.syntax().text() == "todo!()" {
+                            placeholder = m;
+                            cursor = Cursor::Replace(placeholder.syntax());
+                        }
+                    }
+                }
+                builder.replace_snippet(
+                    cap,
+                    original_range,
+                    render_snippet(cap, new_impl_item_list.syntax(), cursor),
+                )
+            }
        };
-        edit.replace_ast(impl_item_list, new_impl_item_list);
-        edit.set_cursor(cursor_position);
    })
 }
 fn add_body(fn_def: ast::FnDef) -> ast::FnDef {
-    if fn_def.body().is_none() {
+    if fn_def.body().is_some() {
-        fn_def.with_body(make::block_from_expr(make::expr_todo()))
+        return fn_def;
-    } else {
-        fn_def
    }
+    let body = make::block_expr(None, Some(make::expr_todo())).indent(IndentLevel(1));
+    fn_def.with_body(body)
 }
 #[cfg(test)]
 mod tests {
-    use crate::helpers::{check_assist, check_assist_not_applicable};
+    use crate::tests::{check_assist, check_assist_not_applicable};
    use super::*;
@@ -181,7 +206,7 @@ mod tests {
    fn test_add_missing_impl_members() {
        check_assist(
            add_missing_impl_members,
-            "
+            r#"
 trait Foo {
    type Output;
@@ -197,8 +222,8 @@ struct S;
 impl Foo for S {
    fn bar(&self) {}
 <|>
-}",
+}"#,
-            "
+            r#"
 trait Foo {
    type Output;
@@ -213,12 +238,16 @@ struct S;
 impl Foo for S {
    fn bar(&self) {}
-    <|>type Output;
+    $0type Output;
    const CONST: usize = 42;
-    fn foo(&self) { todo!() }
+    fn foo(&self) {
-    fn baz(&self) { todo!() }
+        todo!()
+    }
+    fn baz(&self) {
+        todo!()
+    }
-}",
+}"#,
        );
    }
@@ -226,7 +255,7 @@ impl Foo for S {
    fn test_copied_overriden_members() {
        check_assist(
            add_missing_impl_members,
-            "
+            r#"
 trait Foo {
    fn foo(&self);
    fn bar(&self) -> bool { true }
@@ -238,8 +267,8 @@ struct S;
 impl Foo for S {
    fn bar(&self) {}
 <|>
-}",
+}"#,
-            "
+            r#"
 trait Foo {
    fn foo(&self);
    fn bar(&self) -> bool { true }
@@ -250,9 +279,11 @@ struct S;
 impl Foo for S {
    fn bar(&self) {}
-    <|>fn foo(&self) { todo!() }
+    fn foo(&self) {
+        ${0:todo!()}
+    }
-}",
+}"#,
        );
    }
@@ -260,16 +291,18 @@ impl Foo for S {
    fn test_empty_impl_def() {
        check_assist(
            add_missing_impl_members,
-            "
+            r#"
 trait Foo { fn foo(&self); }
 struct S;
-impl Foo for S { <|> }",
+impl Foo for S { <|> }"#,
-            "
+            r#"
 trait Foo { fn foo(&self); }
 struct S;
 impl Foo for S {
-    <|>fn foo(&self) { todo!() }
+    fn foo(&self) {
-}",
+        ${0:todo!()}
+    }
+}"#,
        );
    }
@@ -277,16 +310,18 @@ impl Foo for S {
    fn fill_in_type_params_1() {
        check_assist(
            add_missing_impl_members,
-            "
+            r#"
 trait Foo<T> { fn foo(&self, t: T) -> &T; }
 struct S;
-impl Foo<u32> for S { <|> }",
+impl Foo<u32> for S { <|> }"#,
-            "
+            r#"
 trait Foo<T> { fn foo(&self, t: T) -> &T; }
 struct S;
 impl Foo<u32> for S {
-    <|>fn foo(&self, t: u32) -> &u32 { todo!() }
+    fn foo(&self, t: u32) -> &u32 {
-}",
+        ${0:todo!()}
+    }
+}"#,
        );
    }
@@ -294,16 +329,18 @@ impl Foo<u32> for S {
    fn fill_in_type_params_2() {
        check_assist(
            add_missing_impl_members,
-            "
+            r#"
 trait Foo<T> { fn foo(&self, t: T) -> &T; }
 struct S;
-impl<U> Foo<U> for S { <|> }",
+impl<U> Foo<U> for S { <|> }"#,
-            "
+            r#"
 trait Foo<T> { fn foo(&self, t: T) -> &T; }
 struct S;
 impl<U> Foo<U> for S {
-    <|>fn foo(&self, t: U) -> &U { todo!() }
+    fn foo(&self, t: U) -> &U {
-}",
+        ${0:todo!()}
+    }
+}"#,
        );
    }
@@ -311,16 +348,18 @@ impl<U> Foo<U> for S {
    fn test_cursor_after_empty_impl_def() {
        check_assist(
            add_missing_impl_members,
-            "
+            r#"
 trait Foo { fn foo(&self); }
 struct S;
-impl Foo for S {}<|>",
+impl Foo for S {}<|>"#,
-            "
+            r#"
 trait Foo { fn foo(&self); }
 struct S;
 impl Foo for S {
-    <|>fn foo(&self) { todo!() }
+    fn foo(&self) {
-}",
+        ${0:todo!()}
+    }
+}"#,
        )
    }
@@ -328,22 +367,24 @@ impl Foo for S {
    fn test_qualify_path_1() {
        check_assist(
            add_missing_impl_members,
-            "
+            r#"
 mod foo {
    pub struct Bar;
    trait Foo { fn foo(&self, bar: Bar); }
 }
 struct S;
-impl foo::Foo for S { <|> }",
+impl foo::Foo for S { <|> }"#,
-            "
+            r#"
 mod foo {
    pub struct Bar;
    trait Foo { fn foo(&self, bar: Bar); }
 }
 struct S;
 impl foo::Foo for S {
-    <|>fn foo(&self, bar: foo::Bar) { todo!() }
+    fn foo(&self, bar: foo::Bar) {
-}",
+        ${0:todo!()}
+    }
+}"#,
        );
    }
@@ -351,22 +392,24 @@ impl foo::Foo for S {
    fn test_qualify_path_generic() {
        check_assist(
            add_missing_impl_members,
-            "
+            r#"
 mod foo {
    pub struct Bar<T>;
    trait Foo { fn foo(&self, bar: Bar<u32>); }
 }
 struct S;
-impl foo::Foo for S { <|> }",
+impl foo::Foo for S { <|> }"#,
-            "
+            r#"
 mod foo {
    pub struct Bar<T>;
    trait Foo { fn foo(&self, bar: Bar<u32>); }
 }
 struct S;
 impl foo::Foo for S {
-    <|>fn foo(&self, bar: foo::Bar<u32>) { todo!() }
+    fn foo(&self, bar: foo::Bar<u32>) {
-}",
+        ${0:todo!()}
+    }
+}"#,
        );
    }
@@ -374,22 +417,24 @@ impl foo::Foo for S {
    fn test_qualify_path_and_substitute_param() {
        check_assist(
            add_missing_impl_members,
-            "
+            r#"
 mod foo {
    pub struct Bar<T>;
    trait Foo<T> { fn foo(&self, bar: Bar<T>); }
 }
 struct S;
-impl foo::Foo<u32> for S { <|> }",
+impl foo::Foo<u32> for S { <|> }"#,
-            "
+            r#"
 mod foo {
    pub struct Bar<T>;
    trait Foo<T> { fn foo(&self, bar: Bar<T>); }
 }
 struct S;
 impl foo::Foo<u32> for S {
-    <|>fn foo(&self, bar: foo::Bar<u32>) { todo!() }
+    fn foo(&self, bar: foo::Bar<u32>) {
-}",
+        ${0:todo!()}
+    }
+}"#,
        );
    }
@@ -398,15 +443,15 @@ impl foo::Foo<u32> for S {
        // when substituting params, the substituted param should not be qualified!
        check_assist(
            add_missing_impl_members,
-            "
+            r#"
 mod foo {
    trait Foo<T> { fn foo(&self, bar: T); }
    pub struct Param;
 }
 struct Param;
 struct S;
-impl foo::Foo<Param> for S { <|> }",
+impl foo::Foo<Param> for S { <|> }"#,
-            "
+            r#"
 mod foo {
    trait Foo<T> { fn foo(&self, bar: T); }
    pub struct Param;
@@ -414,8 +459,10 @@ mod foo {
 struct Param;
 struct S;
 impl foo::Foo<Param> for S {
-    <|>fn foo(&self, bar: Param) { todo!() }
+    fn foo(&self, bar: Param) {
-}",
+        ${0:todo!()}
+    }
+}"#,
        );
    }
@@ -423,15 +470,15 @@ impl foo::Foo<Param> for S {
    fn test_qualify_path_associated_item() {
        check_assist(
            add_missing_impl_members,
-            "
+            r#"
 mod foo {
    pub struct Bar<T>;
    impl Bar<T> { type Assoc = u32; }
    trait Foo { fn foo(&self, bar: Bar<u32>::Assoc); }
 }
 struct S;
-impl foo::Foo for S { <|> }",
+impl foo::Foo for S { <|> }"#,
-            "
+            r#"
 mod foo {
    pub struct Bar<T>;
    impl Bar<T> { type Assoc = u32; }
@@ -439,8 +486,10 @@ mod foo {
 }
 struct S;
 impl foo::Foo for S {
-    <|>fn foo(&self, bar: foo::Bar<u32>::Assoc) { todo!() }
+    fn foo(&self, bar: foo::Bar<u32>::Assoc) {
-}",
+        ${0:todo!()}
+    }
+}"#,
        );
    }
@@ -448,15 +497,15 @@ impl foo::Foo for S {
    fn test_qualify_path_nested() {
        check_assist(
            add_missing_impl_members,
-            "
+            r#"
 mod foo {
    pub struct Bar<T>;
    pub struct Baz;
    trait Foo { fn foo(&self, bar: Bar<Baz>); }
 }
 struct S;
-impl foo::Foo for S { <|> }",
+impl foo::Foo for S { <|> }"#,
-            "
+            r#"
 mod foo {
    pub struct Bar<T>;
    pub struct Baz;
@@ -464,8 +513,10 @@ mod foo {
 }
 struct S;
 impl foo::Foo for S {
-    <|>fn foo(&self, bar: foo::Bar<foo::Baz>) { todo!() }
+    fn foo(&self, bar: foo::Bar<foo::Baz>) {
-}",
+        ${0:todo!()}
+    }
+}"#,
        );
    }
@@ -473,22 +524,24 @@ impl foo::Foo for S {
    fn test_qualify_path_fn_trait_notation() {
        check_assist(
            add_missing_impl_members,
-            "
+            r#"
 mod foo {
    pub trait Fn<Args> { type Output; }
    trait Foo { fn foo(&self, bar: dyn Fn(u32) -> i32); }
 }
 struct S;
-impl foo::Foo for S { <|> }",
+impl foo::Foo for S { <|> }"#,
-            "
+            r#"
 mod foo {
    pub trait Fn<Args> { type Output; }
    trait Foo { fn foo(&self, bar: dyn Fn(u32) -> i32); }
 }
 struct S;
 impl foo::Foo for S {
-    <|>fn foo(&self, bar: dyn Fn(u32) -> i32) { todo!() }
+    fn foo(&self, bar: dyn Fn(u32) -> i32) {
-}",
+        ${0:todo!()}
+    }
+}"#,
        );
    }
@@ -496,10 +549,10 @@ impl foo::Foo for S {
    fn test_empty_trait() {
        check_assist_not_applicable(
            add_missing_impl_members,
-            "
+            r#"
 trait Foo;
 struct S;
-impl Foo for S { <|> }",
+impl Foo for S { <|> }"#,
        )
    }
@@ -507,13 +560,13 @@ impl Foo for S { <|> }",
    fn test_ignore_unnamed_trait_members_and_default_methods() {
        check_assist_not_applicable(
            add_missing_impl_members,
-            "
+            r#"
 trait Foo {
    fn (arg: u32);
    fn valid(some: u32) -> bool { false }
 }
 struct S;
-impl Foo for S { <|> }",
+impl Foo for S { <|> }"#,
        )
    }
@@ -543,8 +596,10 @@ trait Foo {
 }
 struct S;
 impl Foo for S {
-    <|>type Output;
+    $0type Output;
-    fn foo(&self) { todo!() }
+    fn foo(&self) {
+        todo!()
+    }
 }"#,
        )
    }
@@ -553,7 +608,7 @@ impl Foo for S {
    fn test_default_methods() {
        check_assist(
            add_missing_default_members,
-            "
+            r#"
 trait Foo {
    type Output;
@@ -563,8 +618,8 @@ trait Foo {
    fn foo(some: u32) -> bool;
 }
 struct S;
-impl Foo for S { <|> }",
+impl Foo for S { <|> }"#,
-            "
+            r#"
 trait Foo {
    type Output;
@@ -575,8 +630,58 @@ trait Foo {
 }
 struct S;
 impl Foo for S {
-    <|>fn valid(some: u32) -> bool { false }
+    $0fn valid(some: u32) -> bool { false }
-}",
+}"#,
+        )
+    }
+    #[test]
+    fn test_generic_single_default_parameter() {
+        check_assist(
+            add_missing_impl_members,
+            r#"
+trait Foo<T = Self> {
+    fn bar(&self, other: &T);
+}
+struct S;
+impl Foo for S { <|> }"#,
+            r#"
+trait Foo<T = Self> {
+    fn bar(&self, other: &T);
+}
+struct S;
+impl Foo for S {
+    fn bar(&self, other: &Self) {
+        ${0:todo!()}
+    }
+}"#,
+        )
+    }
+    #[test]
+    fn test_generic_default_parameter_is_second() {
+        check_assist(
+            add_missing_impl_members,
+            r#"
+trait Foo<T1, T2 = Self> {
+    fn bar(&self, this: &T1, that: &T2);
+}
+struct S<T>;
+impl Foo<T> for S<T> { <|> }"#,
+            r#"
+trait Foo<T1, T2 = Self> {
+    fn bar(&self, this: &T1, that: &T2);
+}
+struct S<T>;
+impl Foo<T> for S<T> {
+    fn bar(&self, this: &T, that: &Self) {
+        ${0:todo!()}
+    }
+}"#,
        )
    }
 }
diff --git a/crates/ra_assists/src/handlers/add_new.rs b/crates/ra_assists/src/handlers/add_new.rs
index 0f9174a29..837aa8377 100644
--- a/crates/ra_assists/src/handlers/add_new.rs
+++ b/crates/ra_assists/src/handlers/add_new.rs
@@ -3,11 +3,11 @@ use ra_syntax::{
    ast::{
        self, AstNode, NameOwner, StructKind, TypeAscriptionOwner, TypeParamsOwner, VisibilityOwner,
    },
-    TextSize, T,
+    T,
 };
 use stdx::{format_to, SepBy};
-use crate::{Assist, AssistCtx, AssistId};
+use crate::{AssistContext, AssistId, Assists};
 // Assist: add_new
 //
@@ -25,11 +25,11 @@ use crate::{Assist, AssistCtx, AssistId};
 // }
 //
 // impl<T: Clone> Ctx<T> {
-//     fn new(data: T) -> Self { Self { data } }
+//     fn $0new(data: T) -> Self { Self { data } }
 // }
 //
 // ```
-pub(crate) fn add_new(ctx: AssistCtx) -> Option<Assist> {
+pub(crate) fn add_new(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
    let strukt = ctx.find_node_at_offset::<ast::StructDef>()?;
    // We want to only apply this to non-union structs with named fields
@@ -41,33 +41,27 @@ pub(crate) fn add_new(ctx: AssistCtx) -> Option<Assist> {
    // Return early if we've found an existing new fn
    let impl_def = find_struct_impl(&ctx, &strukt)?;
-    ctx.add_assist(AssistId("add_new"), "Add default constructor", |edit| {
+    let target = strukt.syntax().text_range();
-        edit.target(strukt.syntax().text_range());
+    acc.add(AssistId("add_new"), "Add default constructor", target, |builder| {
        let mut buf = String::with_capacity(512);
        if impl_def.is_some() {
            buf.push('\n');
        }
-        let vis = strukt.visibility().map(|v| format!("{} ", v));
+        let vis = strukt.visibility().map_or(String::new(), |v| format!("{} ", v));
-        let vis = vis.as_deref().unwrap_or("");
        let params = field_list
            .fields()
            .filter_map(|f| {
-                Some(format!(
+                Some(format!("{}: {}", f.name()?.syntax(), f.ascribed_type()?.syntax()))
-                    "{}: {}",
-                    f.name()?.syntax().text(),
-                    f.ascribed_type()?.syntax().text()
-                ))
            })
            .sep_by(", ");
        let fields = field_list.fields().filter_map(|f| f.name()).sep_by(", ");
        format_to!(buf, "    {}fn new({}) -> Self {{ Self {{ {} }} }}", vis, params, fields);
-        let (start_offset, end_offset) = impl_def
+        let start_offset = impl_def
            .and_then(|impl_def| {
                buf.push('\n');
                let start = impl_def
@@ -77,17 +71,20 @@ pub(crate) fn add_new(ctx: AssistCtx) -> Option<Assist> {
                    .text_range()
                    .end();
-                Some((start, TextSize::of("\n")))
+                Some(start)
            })
            .unwrap_or_else(|| {
                buf = generate_impl_text(&strukt, &buf);
-                let start = strukt.syntax().text_range().end();
+                strukt.syntax().text_range().end()
-                (start, TextSize::of("\n}\n"))
            });
-        edit.set_cursor(start_offset + TextSize::of(&buf) - end_offset);
+        match ctx.config.snippet_cap {
-        edit.insert(start_offset, buf);
+            None => builder.insert(start_offset, buf),
+            Some(cap) => {
+                buf = buf.replace("fn new", "fn $0new");
+                builder.insert_snippet(cap, start_offset, buf);
+            }
+        }
    })
 }
@@ -124,7 +121,7 @@ fn generate_impl_text(strukt: &ast::StructDef, code: &str) -> String {
 //
 // FIXME: change the new fn checking to a more semantic approach when that's more
 // viable (e.g. we process proc macros, etc)
-fn find_struct_impl(ctx: &AssistCtx, strukt: &ast::StructDef) -> Option<Option<ast::ImplDef>> {
+fn find_struct_impl(ctx: &AssistContext, strukt: &ast::StructDef) -> Option<Option<ast::ImplDef>> {
    let db = ctx.db;
    let module = strukt.syntax().ancestors().find(|node| {
        ast::Module::can_cast(node.kind()) || ast::SourceFile::can_cast(node.kind())
@@ -162,8 +159,8 @@ fn find_struct_impl(ctx: &AssistCtx, strukt: &ast::StructDef) -> Option<Option<a
 fn has_new_fn(imp: &ast::ImplDef) -> bool {
    if let Some(il) = imp.item_list() {
-        for item in il.impl_items() {
+        for item in il.assoc_items() {
-            if let ast::ImplItem::FnDef(f) = item {
+            if let ast::AssocItem::FnDef(f) = item {
                if let Some(name) = f.name() {
                    if name.text().eq_ignore_ascii_case("new") {
                        return true;
@@ -178,7 +175,7 @@ fn has_new_fn(imp: &ast::ImplDef) -> bool {
 #[cfg(test)]
 mod tests {
-    use crate::helpers::{check_assist, check_assist_not_applicable, check_assist_target};
+    use crate::tests::{check_assist, check_assist_not_applicable, check_assist_target};
    use super::*;
@@ -192,7 +189,7 @@ mod tests {
 "struct Foo {}
 impl Foo {
-    fn new() -> Self { Self {  } }<|>
+    fn $0new() -> Self { Self {  } }
 }
 ",
        );
@@ -202,7 +199,7 @@ impl Foo {
 "struct Foo<T: Clone> {}
 impl<T: Clone> Foo<T> {
-    fn new() -> Self { Self {  } }<|>
+    fn $0new() -> Self { Self {  } }
 }
 ",
        );
@@ -212,7 +209,7 @@ impl<T: Clone> Foo<T> {
 "struct Foo<'a, T: Foo<'a>> {}
 impl<'a, T: Foo<'a>> Foo<'a, T> {
-    fn new() -> Self { Self {  } }<|>
+    fn $0new() -> Self { Self {  } }
 }
 ",
        );
@@ -222,7 +219,7 @@ impl<'a, T: Foo<'a>> Foo<'a, T> {
 "struct Foo { baz: String }
 impl Foo {
-    fn new(baz: String) -> Self { Self { baz } }<|>
+    fn $0new(baz: String) -> Self { Self { baz } }
 }
 ",
        );
@@ -232,7 +229,7 @@ impl Foo {
 "struct Foo { baz: String, qux: Vec<i32> }
 impl Foo {
-    fn new(baz: String, qux: Vec<i32>) -> Self { Self { baz, qux } }<|>
+    fn $0new(baz: String, qux: Vec<i32>) -> Self { Self { baz, qux } }
 }
 ",
        );
@@ -244,7 +241,7 @@ impl Foo {
 "struct Foo { pub baz: String, pub qux: Vec<i32> }
 impl Foo {
-    fn new(baz: String, qux: Vec<i32>) -> Self { Self { baz, qux } }<|>
+    fn $0new(baz: String, qux: Vec<i32>) -> Self { Self { baz, qux } }
 }
 ",
        );
@@ -259,7 +256,7 @@ impl Foo {}
 "struct Foo {}
 impl Foo {
-    fn new() -> Self { Self {  } }<|>
+    fn $0new() -> Self { Self {  } }
 }
 ",
        );
@@ -274,7 +271,7 @@ impl Foo {
 "struct Foo {}
 impl Foo {
-    fn new() -> Self { Self {  } }<|>
+    fn $0new() -> Self { Self {  } }
    fn qux(&self) {}
 }
@@ -295,7 +292,7 @@ impl Foo {
 "struct Foo {}
 impl Foo {
-    fn new() -> Self { Self {  } }<|>
+    fn $0new() -> Self { Self {  } }
    fn qux(&self) {}
    fn baz() -> i32 {
@@ -312,7 +309,7 @@ impl Foo {
 "pub struct Foo {}
 impl Foo {
-    pub fn new() -> Self { Self {  } }<|>
+    pub fn $0new() -> Self { Self {  } }
 }
 ",
        );
@@ -322,7 +319,7 @@ impl Foo {
 "pub(crate) struct Foo {}
 impl Foo {
-    pub(crate) fn new() -> Self { Self {  } }<|>
+    pub(crate) fn $0new() -> Self { Self {  } }
 }
 ",
        );
@@ -415,7 +412,7 @@ pub struct Source<T> {
 }
 impl<T> Source<T> {
-    pub fn new(file_id: HirFileId, ast: T) -> Self { Self { file_id, ast } }<|>
+    pub fn $0new(file_id: HirFileId, ast: T) -> Self { Self { file_id, ast } }
    pub fn map<F: FnOnce(T) -> U, U>(self, f: F) -> Source<U> {
        Source { file_id: self.file_id, ast: f(self.ast) }
diff --git a/crates/ra_assists/src/handlers/add_turbo_fish.rs b/crates/ra_assists/src/handlers/add_turbo_fish.rs
new file mode 100644
index 000000000..26acf81f2
--- /dev/null
+++ b/crates/ra_assists/src/handlers/add_turbo_fish.rs
@@ -0,0 +1,134 @@
+use ra_ide_db::defs::{classify_name_ref, Definition, NameRefClass};
+use ra_syntax::{ast, AstNode, SyntaxKind, T};
+use test_utils::mark;
+use crate::{
+    assist_context::{AssistContext, Assists},
+    AssistId,
+};
+// Assist: add_turbo_fish
+//
+// Adds `::<_>` to a call of a generic method or function.
+//
+// ```
+// fn make<T>() -> T { todo!() }
+// fn main() {
+//     let x = make<|>();
+// }
+// ```
+// ->
+// ```
+// fn make<T>() -> T { todo!() }
+// fn main() {
+//     let x = make::<${0:_}>();
+// }
+// ```
+pub(crate) fn add_turbo_fish(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
+    let ident = ctx.find_token_at_offset(SyntaxKind::IDENT)?;
+    let next_token = ident.next_token()?;
+    if next_token.kind() == T![::] {
+        mark::hit!(add_turbo_fish_one_fish_is_enough);
+        return None;
+    }
+    let name_ref = ast::NameRef::cast(ident.parent())?;
+    let def = match classify_name_ref(&ctx.sema, &name_ref)? {
+        NameRefClass::Definition(def) => def,
+        NameRefClass::FieldShorthand { .. } => return None,
+    };
+    let fun = match def {
+        Definition::ModuleDef(hir::ModuleDef::Function(it)) => it,
+        _ => return None,
+    };
+    let generics = hir::GenericDef::Function(fun).params(ctx.sema.db);
+    if generics.is_empty() {
+        mark::hit!(add_turbo_fish_non_generic);
+        return None;
+    }
+    acc.add(AssistId("add_turbo_fish"), "Add `::<>`", ident.text_range(), |builder| {
+        match ctx.config.snippet_cap {
+            Some(cap) => builder.insert_snippet(cap, ident.text_range().end(), "::<${0:_}>"),
+            None => builder.insert(ident.text_range().end(), "::<_>"),
+        }
+    })
+}
+#[cfg(test)]
+mod tests {
+    use crate::tests::{check_assist, check_assist_not_applicable};
+    use super::*;
+    use test_utils::mark;
+    #[test]
+    fn add_turbo_fish_function() {
+        check_assist(
+            add_turbo_fish,
+            r#"
+fn make<T>() -> T {}
+fn main() {
+    make<|>();
+}
+"#,
+            r#"
+fn make<T>() -> T {}
+fn main() {
+    make::<${0:_}>();
+}
+"#,
+        );
+    }
+    #[test]
+    fn add_turbo_fish_method() {
+        check_assist(
+            add_turbo_fish,
+            r#"
+struct S;
+impl S {
+    fn make<T>(&self) -> T {}
+}
+fn main() {
+    S.make<|>();
+}
+"#,
+            r#"
+struct S;
+impl S {
+    fn make<T>(&self) -> T {}
+}
+fn main() {
+    S.make::<${0:_}>();
+}
+"#,
+        );
+    }
+    #[test]
+    fn add_turbo_fish_one_fish_is_enough() {
+        mark::check!(add_turbo_fish_one_fish_is_enough);
+        check_assist_not_applicable(
+            add_turbo_fish,
+            r#"
+fn make<T>() -> T {}
+fn main() {
+    make<|>::<()>();
+}
+"#,
+        );
+    }
+    #[test]
+    fn add_turbo_fish_non_generic() {
+        mark::check!(add_turbo_fish_non_generic);
+        check_assist_not_applicable(
+            add_turbo_fish,
+            r#"
+fn make() -> () {}
+fn main() {
+    make<|>();
+}
+"#,
+        );
+    }
+}
diff --git a/crates/ra_assists/src/handlers/apply_demorgan.rs b/crates/ra_assists/src/handlers/apply_demorgan.rs
index 260b9e073..233e8fb8e 100644
--- a/crates/ra_assists/src/handlers/apply_demorgan.rs
+++ b/crates/ra_assists/src/handlers/apply_demorgan.rs
@@ -1,6 +1,6 @@
 use ra_syntax::ast::{self, AstNode};
-use crate::{utils::invert_boolean_expression, Assist, AssistCtx, AssistId};
+use crate::{utils::invert_boolean_expression, AssistContext, AssistId, Assists};
 // Assist: apply_demorgan
 //
@@ -21,7 +21,7 @@ use crate::{utils::invert_boolean_expression, Assist, AssistCtx, AssistId};
 //     if !(x == 4 && y) {}
 // }
 // ```
-pub(crate) fn apply_demorgan(ctx: AssistCtx) -> Option<Assist> {
+pub(crate) fn apply_demorgan(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
    let expr = ctx.find_node_at_offset::<ast::BinExpr>()?;
    let op = expr.op_kind()?;
    let op_range = expr.op_token()?.text_range();
@@ -39,8 +39,7 @@ pub(crate) fn apply_demorgan(ctx: AssistCtx) -> Option<Assist> {
    let rhs_range = rhs.syntax().text_range();
    let not_rhs = invert_boolean_expression(rhs);
-    ctx.add_assist(AssistId("apply_demorgan"), "Apply De Morgan's law", |edit| {
+    acc.add(AssistId("apply_demorgan"), "Apply De Morgan's law", op_range, |edit| {
-        edit.target(op_range);
        edit.replace(op_range, opposite_op);
        edit.replace(lhs_range, format!("!({}", not_lhs.syntax().text()));
        edit.replace(rhs_range, format!("{})", not_rhs.syntax().text()));
@@ -60,26 +59,26 @@ fn opposite_logic_op(kind: ast::BinOp) -> Option<&'static str> {
 mod tests {
    use super::*;
-    use crate::helpers::{check_assist, check_assist_not_applicable};
+    use crate::tests::{check_assist, check_assist_not_applicable};
    #[test]
    fn demorgan_turns_and_into_or() {
-        check_assist(apply_demorgan, "fn f() { !x &&<|> !x }", "fn f() { !(x ||<|> x) }")
+        check_assist(apply_demorgan, "fn f() { !x &&<|> !x }", "fn f() { !(x || x) }")
    }
    #[test]
    fn demorgan_turns_or_into_and() {
-        check_assist(apply_demorgan, "fn f() { !x ||<|> !x }", "fn f() { !(x &&<|> x) }")
+        check_assist(apply_demorgan, "fn f() { !x ||<|> !x }", "fn f() { !(x && x) }")
    }
    #[test]
    fn demorgan_removes_inequality() {
-        check_assist(apply_demorgan, "fn f() { x != x ||<|> !x }", "fn f() { !(x == x &&<|> x) }")
+        check_assist(apply_demorgan, "fn f() { x != x ||<|> !x }", "fn f() { !(x == x && x) }")
    }
    #[test]
    fn demorgan_general_case() {
-        check_assist(apply_demorgan, "fn f() { x ||<|> x }", "fn f() { !(!x &&<|> !x) }")
+        check_assist(apply_demorgan, "fn f() { x ||<|> x }", "fn f() { !(!x && !x) }")
    }
    #[test]
diff --git a/crates/ra_assists/src/handlers/auto_import.rs b/crates/ra_assists/src/handlers/auto_import.rs
index 99682e023..edf96d50e 100644
--- a/crates/ra_assists/src/handlers/auto_import.rs
+++ b/crates/ra_assists/src/handlers/auto_import.rs
@@ -1,5 +1,6 @@
 use std::collections::BTreeSet;
+use either::Either;
 use hir::{
    AsAssocItem, AssocItemContainer, ModPath, Module, ModuleDef, PathResolution, Semantics, Trait,
    Type,
@@ -12,12 +13,7 @@ use ra_syntax::{
 };
 use rustc_hash::FxHashSet;
-use crate::{
+use crate::{utils::insert_use_statement, AssistContext, AssistId, Assists, GroupLabel};
-    assist_ctx::{Assist, AssistCtx},
-    utils::insert_use_statement,
-    AssistId,
-};
-use either::Either;
 // Assist: auto_import
 //
@@ -38,25 +34,32 @@ use either::Either;
 // }
 // # pub mod std { pub mod collections { pub struct HashMap { } } }
 // ```
-pub(crate) fn auto_import(ctx: AssistCtx) -> Option<Assist> {
+pub(crate) fn auto_import(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
    let auto_import_assets = AutoImportAssets::new(&ctx)?;
    let proposed_imports = auto_import_assets.search_for_imports(ctx.db);
    if proposed_imports.is_empty() {
        return None;
    }
-    let mut group = ctx.add_assist_group(auto_import_assets.get_import_group_message());
+    let range = ctx.sema.original_range(&auto_import_assets.syntax_under_caret).range;
+    let group = auto_import_assets.get_import_group_message();
    for import in proposed_imports {
-        group.add_assist(AssistId("auto_import"), format!("Import `{}`", &import), |edit| {
+        acc.add_group(
-            edit.target(auto_import_assets.syntax_under_caret.text_range());
+            &group,
-            insert_use_statement(
+            AssistId("auto_import"),
-                &auto_import_assets.syntax_under_caret,
+            format!("Import `{}`", &import),
-                &import,
+            range,
-                edit.text_edit_builder(),
+            |builder| {
-            );
+                insert_use_statement(
-        });
+                    &auto_import_assets.syntax_under_caret,
-    }
+                    &import,
-    group.finish()
+                    ctx,
+                    builder.text_edit_builder(),
+                );
+            },
+        );
+    }
+    Some(())
 }
 #[derive(Debug)]
@@ -67,15 +70,15 @@ struct AutoImportAssets {
 }
 impl AutoImportAssets {
-    fn new(ctx: &AssistCtx) -> Option<Self> {
+    fn new(ctx: &AssistContext) -> Option<Self> {
-        if let Some(path_under_caret) = ctx.find_node_at_offset::<ast::Path>() {
+        if let Some(path_under_caret) = ctx.find_node_at_offset_with_descend::<ast::Path>() {
            Self::for_regular_path(path_under_caret, &ctx)
        } else {
-            Self::for_method_call(ctx.find_node_at_offset()?, &ctx)
+            Self::for_method_call(ctx.find_node_at_offset_with_descend()?, &ctx)
        }
    }
-    fn for_method_call(method_call: ast::MethodCallExpr, ctx: &AssistCtx) -> Option<Self> {
+    fn for_method_call(method_call: ast::MethodCallExpr, ctx: &AssistContext) -> Option<Self> {
        let syntax_under_caret = method_call.syntax().to_owned();
        let module_with_name_to_import = ctx.sema.scope(&syntax_under_caret).module()?;
        Some(Self {
@@ -85,7 +88,7 @@ impl AutoImportAssets {
        })
    }
-    fn for_regular_path(path_under_caret: ast::Path, ctx: &AssistCtx) -> Option<Self> {
+    fn for_regular_path(path_under_caret: ast::Path, ctx: &AssistContext) -> Option<Self> {
        let syntax_under_caret = path_under_caret.syntax().to_owned();
        if syntax_under_caret.ancestors().find_map(ast::UseItem::cast).is_some() {
            return None;
@@ -108,8 +111,8 @@ impl AutoImportAssets {
        }
    }
-    fn get_import_group_message(&self) -> String {
+    fn get_import_group_message(&self) -> GroupLabel {
-        match &self.import_candidate {
+        let name = match &self.import_candidate {
            ImportCandidate::UnqualifiedName(name) => format!("Import {}", name),
            ImportCandidate::QualifierStart(qualifier_start) => {
                format!("Import {}", qualifier_start)
@@ -120,7 +123,8 @@ impl AutoImportAssets {
            ImportCandidate::TraitMethod(_, trait_method_name) => {
                format!("Import a trait for method {}", trait_method_name)
            }
-        }
+        };
+        GroupLabel(name)
    }
    fn search_for_imports(&self, db: &RootDatabase) -> BTreeSet<ModPath> {
@@ -280,7 +284,7 @@ impl ImportCandidate {
 #[cfg(test)]
 mod tests {
    use super::*;
-    use crate::helpers::{check_assist, check_assist_not_applicable, check_assist_target};
+    use crate::tests::{check_assist, check_assist_not_applicable, check_assist_target};
    #[test]
    fn applicable_when_found_an_import() {
@@ -294,7 +298,7 @@ mod tests {
            }
            ",
            r"
-            <|>use PubMod::PubStruct;
+            use PubMod::PubStruct;
            PubStruct
@@ -306,6 +310,35 @@ mod tests {
    }
    #[test]
+    fn applicable_when_found_an_import_in_macros() {
+        check_assist(
+            auto_import,
+            r"
+            macro_rules! foo {
+                ($i:ident) => { fn foo(a: $i) {} }
+            }
+            foo!(Pub<|>Struct);
+            pub mod PubMod {
+                pub struct PubStruct;
+            }
+            ",
+            r"
+            use PubMod::PubStruct;
+            macro_rules! foo {
+                ($i:ident) => { fn foo(a: $i) {} }
+            }
+            foo!(PubStruct);
+            pub mod PubMod {
+                pub struct PubStruct;
+            }
+            ",
+        );
+    }
+    #[test]
    fn auto_imports_are_merged() {
        check_assist(
            auto_import,
@@ -327,7 +360,7 @@ mod tests {
            use PubMod::{PubStruct2, PubStruct1};
            struct Test {
-                test: Pub<|>Struct2<u8>,
+                test: PubStruct2<u8>,
            }
            pub mod PubMod {
@@ -358,9 +391,9 @@ mod tests {
            }
            ",
            r"
-            use PubMod1::PubStruct;
+            use PubMod3::PubStruct;
-            PubSt<|>ruct
+            PubStruct
            pub mod PubMod1 {
                pub struct PubStruct;
@@ -441,7 +474,7 @@ mod tests {
            r"
            use PubMod::test_function;
-            test_function<|>
+            test_function
            pub mod PubMod {
                pub fn test_function() {};
@@ -468,7 +501,7 @@ mod tests {
            r"use crate_with_macro::foo;
 fn main() {
-    foo<|>
+    foo
 }
 ",
        );
@@ -554,7 +587,7 @@ fn main() {
            }
            fn main() {
-                TestStruct::test_function<|>
+                TestStruct::test_function
            }
            ",
        );
@@ -587,7 +620,7 @@ fn main() {
            }
            fn main() {
-                TestStruct::TEST_CONST<|>
+                TestStruct::TEST_CONST
            }
            ",
        );
@@ -626,7 +659,7 @@ fn main() {
            }
            fn main() {
-                test_mod::TestStruct::test_function<|>
+                test_mod::TestStruct::test_function
            }
            ",
        );
@@ -697,7 +730,7 @@ fn main() {
            }
            fn main() {
-                test_mod::TestStruct::TEST_CONST<|>
+                test_mod::TestStruct::TEST_CONST
            }
            ",
        );
@@ -770,7 +803,7 @@ fn main() {
            fn main() {
                let test_struct = test_mod::TestStruct {};
-                test_struct.test_meth<|>od()
+                test_struct.test_method()
            }
            ",
        );
diff --git a/crates/ra_assists/src/handlers/change_return_type_to_result.rs b/crates/ra_assists/src/handlers/change_return_type_to_result.rs
new file mode 100644
index 000000000..c6baa0a57
--- /dev/null
+++ b/crates/ra_assists/src/handlers/change_return_type_to_result.rs
@@ -0,0 +1,961 @@
+use ra_syntax::{
+    ast::{self, BlockExpr, Expr, LoopBodyOwner},
+    AstNode, SyntaxNode,
+};
+use crate::{AssistContext, AssistId, Assists};
+// Assist: change_return_type_to_result
+//
+// Change the function's return type to Result.
+//
+// ```
+// fn foo() -> i32<|> { 42i32 }
+// ```
+// ->
+// ```
+// fn foo() -> Result<i32, ${0:_}> { Ok(42i32) }
+// ```
+pub(crate) fn change_return_type_to_result(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
+    let ret_type = ctx.find_node_at_offset::<ast::RetType>()?;
+    // FIXME: extend to lambdas as well
+    let fn_def = ret_type.syntax().parent().and_then(ast::FnDef::cast)?;
+    let type_ref = &ret_type.type_ref()?;
+    if type_ref.syntax().text().to_string().starts_with("Result<") {
+        return None;
+    }
+    let block_expr = &fn_def.body()?;
+    acc.add(
+        AssistId("change_return_type_to_result"),
+        "Change return type to Result",
+        type_ref.syntax().text_range(),
+        |builder| {
+            let mut tail_return_expr_collector = TailReturnCollector::new();
+            tail_return_expr_collector.collect_jump_exprs(block_expr, false);
+            tail_return_expr_collector.collect_tail_exprs(block_expr);
+            for ret_expr_arg in tail_return_expr_collector.exprs_to_wrap {
+                builder.replace_node_and_indent(&ret_expr_arg, format!("Ok({})", ret_expr_arg));
+            }
+            match ctx.config.snippet_cap {
+                Some(cap) => {
+                    let snippet = format!("Result<{}, ${{0:_}}>", type_ref);
+                    builder.replace_snippet(cap, type_ref.syntax().text_range(), snippet)
+                }
+                None => builder
+                    .replace(type_ref.syntax().text_range(), format!("Result<{}, _>", type_ref)),
+            }
+        },
+    )
+}
+struct TailReturnCollector {
+    exprs_to_wrap: Vec<SyntaxNode>,
+}
+impl TailReturnCollector {
+    fn new() -> Self {
+        Self { exprs_to_wrap: vec![] }
+    }
+    /// Collect all`return` expression
+    fn collect_jump_exprs(&mut self, block_expr: &BlockExpr, collect_break: bool) {
+        let statements = block_expr.statements();
+        for stmt in statements {
+            let expr = match &stmt {
+                ast::Stmt::ExprStmt(stmt) => stmt.expr(),
+                ast::Stmt::LetStmt(stmt) => stmt.initializer(),
+            };
+            if let Some(expr) = &expr {
+                self.handle_exprs(expr, collect_break);
+            }
+        }
+        // Browse tail expressions for each block
+        if let Some(expr) = block_expr.expr() {
+            if let Some(last_exprs) = get_tail_expr_from_block(&expr) {
+                for last_expr in last_exprs {
+                    let last_expr = match last_expr {
+                        NodeType::Node(expr) | NodeType::Leaf(expr) => expr,
+                    };
+                    if let Some(last_expr) = Expr::cast(last_expr.clone()) {
+                        self.handle_exprs(&last_expr, collect_break);
+                    } else if let Some(expr_stmt) = ast::Stmt::cast(last_expr) {
+                        let expr_stmt = match &expr_stmt {
+                            ast::Stmt::ExprStmt(stmt) => stmt.expr(),
+                            ast::Stmt::LetStmt(stmt) => stmt.initializer(),
+                        };
+                        if let Some(expr) = &expr_stmt {
+                            self.handle_exprs(expr, collect_break);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    fn handle_exprs(&mut self, expr: &Expr, collect_break: bool) {
+        match expr {
+            Expr::BlockExpr(block_expr) => {
+                self.collect_jump_exprs(&block_expr, collect_break);
+            }
+            Expr::ReturnExpr(ret_expr) => {
+                if let Some(ret_expr_arg) = &ret_expr.expr() {
+                    self.exprs_to_wrap.push(ret_expr_arg.syntax().clone());
+                }
+            }
+            Expr::BreakExpr(break_expr) if collect_break => {
+                if let Some(break_expr_arg) = &break_expr.expr() {
+                    self.exprs_to_wrap.push(break_expr_arg.syntax().clone());
+                }
+            }
+            Expr::IfExpr(if_expr) => {
+                for block in if_expr.blocks() {
+                    self.collect_jump_exprs(&block, collect_break);
+                }
+            }
+            Expr::LoopExpr(loop_expr) => {
+                if let Some(block_expr) = loop_expr.loop_body() {
+                    self.collect_jump_exprs(&block_expr, collect_break);
+                }
+            }
+            Expr::ForExpr(for_expr) => {
+                if let Some(block_expr) = for_expr.loop_body() {
+                    self.collect_jump_exprs(&block_expr, collect_break);
+                }
+            }
+            Expr::WhileExpr(while_expr) => {
+                if let Some(block_expr) = while_expr.loop_body() {
+                    self.collect_jump_exprs(&block_expr, collect_break);
+                }
+            }
+            Expr::MatchExpr(match_expr) => {
+                if let Some(arm_list) = match_expr.match_arm_list() {
+                    arm_list.arms().filter_map(|match_arm| match_arm.expr()).for_each(|expr| {
+                        self.handle_exprs(&expr, collect_break);
+                    });
+                }
+            }
+            _ => {}
+        }
+    }
+    fn collect_tail_exprs(&mut self, block: &BlockExpr) {
+        if let Some(expr) = block.expr() {
+            self.handle_exprs(&expr, true);
+            self.fetch_tail_exprs(&expr);
+        }
+    }
+    fn fetch_tail_exprs(&mut self, expr: &Expr) {
+        if let Some(exprs) = get_tail_expr_from_block(expr) {
+            for node_type in &exprs {
+                match node_type {
+                    NodeType::Leaf(expr) => {
+                        self.exprs_to_wrap.push(expr.clone());
+                    }
+                    NodeType::Node(expr) => match &Expr::cast(expr.clone()) {
+                        Some(last_expr) => {
+                            self.fetch_tail_exprs(last_expr);
+                        }
+                        None => {
+                            self.exprs_to_wrap.push(expr.clone());
+                        }
+                    },
+                }
+            }
+        }
+    }
+}
+#[derive(Debug)]
+enum NodeType {
+    Leaf(SyntaxNode),
+    Node(SyntaxNode),
+}
+/// Get a tail expression inside a block
+fn get_tail_expr_from_block(expr: &Expr) -> Option<Vec<NodeType>> {
+    match expr {
+        Expr::IfExpr(if_expr) => {
+            let mut nodes = vec![];
+            for block in if_expr.blocks() {
+                if let Some(block_expr) = block.expr() {
+                    if let Some(tail_exprs) = get_tail_expr_from_block(&block_expr) {
+                        nodes.extend(tail_exprs);
+                    }
+                } else if let Some(last_expr) = block.syntax().last_child() {
+                    nodes.push(NodeType::Node(last_expr));
+                } else {
+                    nodes.push(NodeType::Node(block.syntax().clone()));
+                }
+            }
+            Some(nodes)
+        }
+        Expr::LoopExpr(loop_expr) => {
+            loop_expr.syntax().last_child().map(|lc| vec![NodeType::Node(lc)])
+        }
+        Expr::ForExpr(for_expr) => {
+            for_expr.syntax().last_child().map(|lc| vec![NodeType::Node(lc)])
+        }
+        Expr::WhileExpr(while_expr) => {
+            while_expr.syntax().last_child().map(|lc| vec![NodeType::Node(lc)])
+        }
+        Expr::BlockExpr(block_expr) => {
+            block_expr.expr().map(|lc| vec![NodeType::Node(lc.syntax().clone())])
+        }
+        Expr::MatchExpr(match_expr) => {
+            let arm_list = match_expr.match_arm_list()?;
+            let arms: Vec<NodeType> = arm_list
+                .arms()
+                .filter_map(|match_arm| match_arm.expr())
+                .map(|expr| match expr {
+                    Expr::ReturnExpr(ret_expr) => NodeType::Node(ret_expr.syntax().clone()),
+                    Expr::BreakExpr(break_expr) => NodeType::Node(break_expr.syntax().clone()),
+                    _ => match expr.syntax().last_child() {
+                        Some(last_expr) => NodeType::Node(last_expr),
+                        None => NodeType::Node(expr.syntax().clone()),
+                    },
+                })
+                .collect();
+            Some(arms)
+        }
+        Expr::BreakExpr(expr) => expr.expr().map(|e| vec![NodeType::Leaf(e.syntax().clone())]),
+        Expr::ReturnExpr(ret_expr) => Some(vec![NodeType::Node(ret_expr.syntax().clone())]),
+        Expr::CallExpr(call_expr) => Some(vec![NodeType::Leaf(call_expr.syntax().clone())]),
+        Expr::Literal(lit_expr) => Some(vec![NodeType::Leaf(lit_expr.syntax().clone())]),
+        Expr::TupleExpr(expr) => Some(vec![NodeType::Leaf(expr.syntax().clone())]),
+        Expr::ArrayExpr(expr) => Some(vec![NodeType::Leaf(expr.syntax().clone())]),
+        Expr::ParenExpr(expr) => Some(vec![NodeType::Leaf(expr.syntax().clone())]),
+        Expr::PathExpr(expr) => Some(vec![NodeType::Leaf(expr.syntax().clone())]),
+        Expr::Label(expr) => Some(vec![NodeType::Leaf(expr.syntax().clone())]),
+        Expr::RecordLit(expr) => Some(vec![NodeType::Leaf(expr.syntax().clone())]),
+        Expr::IndexExpr(expr) => Some(vec![NodeType::Leaf(expr.syntax().clone())]),
+        Expr::MethodCallExpr(expr) => Some(vec![NodeType::Leaf(expr.syntax().clone())]),
+        Expr::AwaitExpr(expr) => Some(vec![NodeType::Leaf(expr.syntax().clone())]),
+        Expr::CastExpr(expr) => Some(vec![NodeType::Leaf(expr.syntax().clone())]),
+        Expr::RefExpr(expr) => Some(vec![NodeType::Leaf(expr.syntax().clone())]),
+        Expr::PrefixExpr(expr) => Some(vec![NodeType::Leaf(expr.syntax().clone())]),
+        Expr::RangeExpr(expr) => Some(vec![NodeType::Leaf(expr.syntax().clone())]),
+        Expr::BinExpr(expr) => Some(vec![NodeType::Leaf(expr.syntax().clone())]),
+        Expr::MacroCall(expr) => Some(vec![NodeType::Leaf(expr.syntax().clone())]),
+        Expr::BoxExpr(expr) => Some(vec![NodeType::Leaf(expr.syntax().clone())]),
+        _ => None,
+    }
+}
+#[cfg(test)]
+mod tests {
+    use crate::tests::{check_assist, check_assist_not_applicable};
+    use super::*;
+    #[test]
+    fn change_return_type_to_result_simple() {
+        check_assist(
+            change_return_type_to_result,
+            r#"fn foo() -> i3<|>2 {
+                let test = "test";
+                return 42i32;
+            }"#,
+            r#"fn foo() -> Result<i32, ${0:_}> {
+                let test = "test";
+                return Ok(42i32);
+            }"#,
+        );
+    }
+    #[test]
+    fn change_return_type_to_result_simple_return_type() {
+        check_assist(
+            change_return_type_to_result,
+            r#"fn foo() -> i32<|> {
+                let test = "test";
+                return 42i32;
+            }"#,
+            r#"fn foo() -> Result<i32, ${0:_}> {
+                let test = "test";
+                return Ok(42i32);
+            }"#,
+        );
+    }
+    #[test]
+    fn change_return_type_to_result_simple_return_type_bad_cursor() {
+        check_assist_not_applicable(
+            change_return_type_to_result,
+            r#"fn foo() -> i32 {
+                let test = "test";<|>
+                return 42i32;
+            }"#,
+        );
+    }
+    #[test]
+    fn change_return_type_to_result_simple_with_cursor() {
+        check_assist(
+            change_return_type_to_result,
+            r#"fn foo() -> <|>i32 {
+                let test = "test";
+                return 42i32;
+            }"#,
+            r#"fn foo() -> Result<i32, ${0:_}> {
+                let test = "test";
+                return Ok(42i32);
+            }"#,
+        );
+    }
+    #[test]
+    fn change_return_type_to_result_simple_with_tail() {
+        check_assist(
+            change_return_type_to_result,
+            r#"fn foo() -><|> i32 {
+                let test = "test";
+                42i32
+            }"#,
+            r#"fn foo() -> Result<i32, ${0:_}> {
+                let test = "test";
+                Ok(42i32)
+            }"#,
+        );
+    }
+    #[test]
+    fn change_return_type_to_result_simple_with_tail_only() {
+        check_assist(
+            change_return_type_to_result,
+            r#"fn foo() -> i32<|> {
+                42i32
+            }"#,
+            r#"fn foo() -> Result<i32, ${0:_}> {
+                Ok(42i32)
+            }"#,
+        );
+    }
+    #[test]
+    fn change_return_type_to_result_simple_with_tail_block_like() {
+        check_assist(
+            change_return_type_to_result,
+            r#"fn foo() -> i32<|> {
+                if true {
+                    42i32
+                } else {
+                    24i32
+                }
+            }"#,
+            r#"fn foo() -> Result<i32, ${0:_}> {
+                if true {
+                    Ok(42i32)
+                } else {
+                    Ok(24i32)
+                }
+            }"#,
+        );
+    }
+    #[test]
+    fn change_return_type_to_result_simple_with_nested_if() {
+        check_assist(
+            change_return_type_to_result,
+            r#"fn foo() -> i32<|> {
+                if true {
+                    if false {
+                        1
+                    } else {
+                        2
+                    }
+                } else {
+                    24i32
+                }
+            }"#,
+            r#"fn foo() -> Result<i32, ${0:_}> {
+                if true {
+                    if false {
+                        Ok(1)
+                    } else {
+                        Ok(2)
+                    }
+                } else {
+                    Ok(24i32)
+                }
+            }"#,
+        );
+    }
+    #[test]
+    fn change_return_type_to_result_simple_with_await() {
+        check_assist(
+            change_return_type_to_result,
+            r#"async fn foo() -> i<|>32 {
+                if true {
+                    if false {
+                        1.await
+                    } else {
+                        2.await
+                    }
+                } else {
+                    24i32.await
+                }
+            }"#,
+            r#"async fn foo() -> Result<i32, ${0:_}> {
+                if true {
+                    if false {
+                        Ok(1.await)
+                    } else {
+                        Ok(2.await)
+                    }
+                } else {
+                    Ok(24i32.await)
+                }
+            }"#,
+        );
+    }
+    #[test]
+    fn change_return_type_to_result_simple_with_array() {
+        check_assist(
+            change_return_type_to_result,
+            r#"fn foo() -> [i32;<|> 3] {
+                [1, 2, 3]
+            }"#,
+            r#"fn foo() -> Result<[i32; 3], ${0:_}> {
+                Ok([1, 2, 3])
+            }"#,
+        );
+    }
+    #[test]
+    fn change_return_type_to_result_simple_with_cast() {
+        check_assist(
+            change_return_type_to_result,
+            r#"fn foo() -<|>> i32 {
+                if true {
+                    if false {
+                        1 as i32
+                    } else {
+                        2 as i32
+                    }
+                } else {
+                    24 as i32
+                }
+            }"#,
+            r#"fn foo() -> Result<i32, ${0:_}> {
+                if true {
+                    if false {
+                        Ok(1 as i32)
+                    } else {
+                        Ok(2 as i32)
+                    }
+                } else {
+                    Ok(24 as i32)
+                }
+            }"#,
+        );
+    }
+    #[test]
+    fn change_return_type_to_result_simple_with_tail_block_like_match() {
+        check_assist(
+            change_return_type_to_result,
+            r#"fn foo() -> i32<|> {
+                let my_var = 5;
+                match my_var {
+                    5 => 42i32,
+                    _ => 24i32,
+                }
+            }"#,
+            r#"fn foo() -> Result<i32, ${0:_}> {
+                let my_var = 5;
+                match my_var {
+                    5 => Ok(42i32),
+                    _ => Ok(24i32),
+                }
+            }"#,
+        );
+    }
+    #[test]
+    fn change_return_type_to_result_simple_with_loop_with_tail() {
+        check_assist(
+            change_return_type_to_result,
+            r#"fn foo() -> i32<|> {
+                let my_var = 5;
+                loop {
+                    println!("test");
+                    5
+                }
+                my_var
+            }"#,
+            r#"fn foo() -> Result<i32, ${0:_}> {
+                let my_var = 5;
+                loop {
+                    println!("test");
+                    5
+                }
+                Ok(my_var)
+            }"#,
+        );
+    }
+    #[test]
+    fn change_return_type_to_result_simple_with_loop_in_let_stmt() {
+        check_assist(
+            change_return_type_to_result,
+            r#"fn foo() -> i32<|> {
+                let my_var = let x = loop {
+                    break 1;
+                };
+                my_var
+            }"#,
+            r#"fn foo() -> Result<i32, ${0:_}> {
+                let my_var = let x = loop {
+                    break 1;
+                };
+                Ok(my_var)
+            }"#,
+        );
+    }
+    #[test]
+    fn change_return_type_to_result_simple_with_tail_block_like_match_return_expr() {
+        check_assist(
+            change_return_type_to_result,
+            r#"fn foo() -> i32<|> {
+                let my_var = 5;
+                let res = match my_var {
+                    5 => 42i32,
+                    _ => return 24i32,
+                };
+                res
+            }"#,
+            r#"fn foo() -> Result<i32, ${0:_}> {
+                let my_var = 5;
+                let res = match my_var {
+                    5 => 42i32,
+                    _ => return Ok(24i32),
+                };
+                Ok(res)
+            }"#,
+        );
+        check_assist(
+            change_return_type_to_result,
+            r#"fn foo() -> i32<|> {
+                let my_var = 5;
+                let res = if my_var == 5 {
+                    42i32
+                } else {
+                    return 24i32;
+                };
+                res
+            }"#,
+            r#"fn foo() -> Result<i32, ${0:_}> {
+                let my_var = 5;
+                let res = if my_var == 5 {
+                    42i32
+                } else {
+                    return Ok(24i32);
+                };
+                Ok(res)
+            }"#,
+        );
+    }
+    #[test]
+    fn change_return_type_to_result_simple_with_tail_block_like_match_deeper() {
+        check_assist(
+            change_return_type_to_result,
+            r#"fn foo() -> i32<|> {
+                let my_var = 5;
+                match my_var {
+                    5 => {
+                        if true {
+                            42i32
+                        } else {
+                            25i32
+                        }
+                    },
+                    _ => {
+                        let test = "test";
+                        if test == "test" {
+                            return bar();
+                        }
+                        53i32
+                    },
+                }
+            }"#,
+            r#"fn foo() -> Result<i32, ${0:_}> {
+                let my_var = 5;
+                match my_var {
+                    5 => {
+                        if true {
+                            Ok(42i32)
+                        } else {
+                            Ok(25i32)
+                        }
+                    },
+                    _ => {
+                        let test = "test";
+                        if test == "test" {
+                            return Ok(bar());
+                        }
+                        Ok(53i32)
+                    },
+                }
+            }"#,
+        );
+    }
+    #[test]
+    fn change_return_type_to_result_simple_with_tail_block_like_early_return() {
+        check_assist(
+            change_return_type_to_result,
+            r#"fn foo() -> i<|>32 {
+                let test = "test";
+                if test == "test" {
+                    return 24i32;
+                }
+                53i32
+            }"#,
+            r#"fn foo() -> Result<i32, ${0:_}> {
+                let test = "test";
+                if test == "test" {
+                    return Ok(24i32);
+                }
+                Ok(53i32)
+            }"#,
+        );
+    }
+    #[test]
+    fn change_return_type_to_result_simple_with_closure() {
+        check_assist(
+            change_return_type_to_result,
+            r#"fn foo(the_field: u32) -><|> u32 {
+                let true_closure = || {
+                    return true;
+                };
+                if the_field < 5 {
+                    let mut i = 0;
+                    if true_closure() {
+                        return 99;
+                    } else {
+                        return 0;
+                    }
+                }
+                the_field
+            }"#,
+            r#"fn foo(the_field: u32) -> Result<u32, ${0:_}> {
+                let true_closure = || {
+                    return true;
+                };
+                if the_field < 5 {
+                    let mut i = 0;
+                    if true_closure() {
+                        return Ok(99);
+                    } else {
+                        return Ok(0);
+                    }
+                }
+                Ok(the_field)
+            }"#,
+        );
+        check_assist(
+            change_return_type_to_result,
+            r#"fn foo(the_field: u32) -> u32<|> {
+                let true_closure = || {
+                    return true;
+                };
+                if the_field < 5 {
+                    let mut i = 0;
+                    if true_closure() {
+                        return 99;
+                    } else {
+                        return 0;
+                    }
+                }
+                let t = None;
+                t.unwrap_or_else(|| the_field)
+            }"#,
+            r#"fn foo(the_field: u32) -> Result<u32, ${0:_}> {
+                let true_closure = || {
+                    return true;
+                };
+                if the_field < 5 {
+                    let mut i = 0;
+                    if true_closure() {
+                        return Ok(99);
+                    } else {
+                        return Ok(0);
+                    }
+                }
+                let t = None;
+                Ok(t.unwrap_or_else(|| the_field))
+            }"#,
+        );
+    }
+    #[test]
+    fn change_return_type_to_result_simple_with_weird_forms() {
+        check_assist(
+            change_return_type_to_result,
+            r#"fn foo() -> i32<|> {
+                let test = "test";
+                if test == "test" {
+                    return 24i32;
+                }
+                let mut i = 0;
+                loop {
+                    if i == 1 {
+                        break 55;
+                    }
+                    i += 1;
+                }
+            }"#,
+            r#"fn foo() -> Result<i32, ${0:_}> {
+                let test = "test";
+                if test == "test" {
+                    return Ok(24i32);
+                }
+                let mut i = 0;
+                loop {
+                    if i == 1 {
+                        break Ok(55);
+                    }
+                    i += 1;
+                }
+            }"#,
+        );
+        check_assist(
+            change_return_type_to_result,
+            r#"fn foo() -> i32<|> {
+                let test = "test";
+                if test == "test" {
+                    return 24i32;
+                }
+                let mut i = 0;
+                loop {
+                    loop {
+                        if i == 1 {
+                            break 55;
+                        }
+                        i += 1;
+                    }
+                }
+            }"#,
+            r#"fn foo() -> Result<i32, ${0:_}> {
+                let test = "test";
+                if test == "test" {
+                    return Ok(24i32);
+                }
+                let mut i = 0;
+                loop {
+                    loop {
+                        if i == 1 {
+                            break Ok(55);
+                        }
+                        i += 1;
+                    }
+                }
+            }"#,
+        );
+        check_assist(
+            change_return_type_to_result,
+            r#"fn foo() -> i3<|>2 {
+                let test = "test";
+                let other = 5;
+                if test == "test" {
+                    let res = match other {
+                        5 => 43,
+                        _ => return 56,
+                    };
+                }
+                let mut i = 0;
+                loop {
+                    loop {
+                        if i == 1 {
+                            break 55;
+                        }
+                        i += 1;
+                    }
+                }
+            }"#,
+            r#"fn foo() -> Result<i32, ${0:_}> {
+                let test = "test";
+                let other = 5;
+                if test == "test" {
+                    let res = match other {
+                        5 => 43,
+                        _ => return Ok(56),
+                    };
+                }
+                let mut i = 0;
+                loop {
+                    loop {
+                        if i == 1 {
+                            break Ok(55);
+                        }
+                        i += 1;
+                    }
+                }
+            }"#,
+        );
+        check_assist(
+            change_return_type_to_result,
+            r#"fn foo(the_field: u32) -> u32<|> {
+                if the_field < 5 {
+                    let mut i = 0;
+                    loop {
+                        if i > 5 {
+                            return 55u32;
+                        }
+                        i += 3;
+                    }
+                    match i {
+                        5 => return 99,
+                        _ => return 0,
+                    };
+                }
+                the_field
+            }"#,
+            r#"fn foo(the_field: u32) -> Result<u32, ${0:_}> {
+                if the_field < 5 {
+                    let mut i = 0;
+                    loop {
+                        if i > 5 {
+                            return Ok(55u32);
+                        }
+                        i += 3;
+                    }
+                    match i {
+                        5 => return Ok(99),
+                        _ => return Ok(0),
+                    };
+                }
+                Ok(the_field)
+            }"#,
+        );
+        check_assist(
+            change_return_type_to_result,
+            r#"fn foo(the_field: u32) -> u3<|>2 {
+                if the_field < 5 {
+                    let mut i = 0;
+                    match i {
+                        5 => return 99,
+                        _ => return 0,
+                    }
+                }
+                the_field
+            }"#,
+            r#"fn foo(the_field: u32) -> Result<u32, ${0:_}> {
+                if the_field < 5 {
+                    let mut i = 0;
+                    match i {
+                        5 => return Ok(99),
+                        _ => return Ok(0),
+                    }
+                }
+                Ok(the_field)
+            }"#,
+        );
+        check_assist(
+            change_return_type_to_result,
+            r#"fn foo(the_field: u32) -> u32<|> {
+                if the_field < 5 {
+                    let mut i = 0;
+                    if i == 5 {
+                        return 99
+                    } else {
+                        return 0
+                    }
+                }
+                the_field
+            }"#,
+            r#"fn foo(the_field: u32) -> Result<u32, ${0:_}> {
+                if the_field < 5 {
+                    let mut i = 0;
+                    if i == 5 {
+                        return Ok(99)
+                    } else {
+                        return Ok(0)
+                    }
+                }
+                Ok(the_field)
+            }"#,
+        );
+        check_assist(
+            change_return_type_to_result,
+            r#"fn foo(the_field: u32) -> <|>u32 {
+                if the_field < 5 {
+                    let mut i = 0;
+                    if i == 5 {
+                        return 99;
+                    } else {
+                        return 0;
+                    }
+                }
+                the_field
+            }"#,
+            r#"fn foo(the_field: u32) -> Result<u32, ${0:_}> {
+                if the_field < 5 {
+                    let mut i = 0;
+                    if i == 5 {
+                        return Ok(99);
+                    } else {
+                        return Ok(0);
+                    }
+                }
+                Ok(the_field)
+            }"#,
+        );
+    }
+}
diff --git a/crates/ra_assists/src/handlers/change_visibility.rs b/crates/ra_assists/src/handlers/change_visibility.rs
index 44f6a1dae..c21d75be0 100644
--- a/crates/ra_assists/src/handlers/change_visibility.rs
+++ b/crates/ra_assists/src/handlers/change_visibility.rs
@@ -7,9 +7,9 @@ use ra_syntax::{
    },
    SyntaxNode, TextSize, T,
 };
+use test_utils::mark;
-use crate::{Assist, AssistCtx, AssistId};
+use crate::{AssistContext, AssistId, Assists};
-use test_utils::tested_by;
 // Assist: change_visibility
 //
@@ -22,14 +22,14 @@ use test_utils::tested_by;
 // ```
 // pub(crate) fn frobnicate() {}
 // ```
-pub(crate) fn change_visibility(ctx: AssistCtx) -> Option<Assist> {
+pub(crate) fn change_visibility(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
    if let Some(vis) = ctx.find_node_at_offset::<ast::Visibility>() {
-        return change_vis(ctx, vis);
+        return change_vis(acc, vis);
    }
-    add_vis(ctx)
+    add_vis(acc, ctx)
 }
-fn add_vis(ctx: AssistCtx) -> Option<Assist> {
+fn add_vis(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
    let item_keyword = ctx.token_at_offset().find(|leaf| match leaf.kind() {
        T![const] | T![fn] | T![mod] | T![struct] | T![enum] | T![trait] => true,
        _ => false,
@@ -47,23 +47,27 @@ fn add_vis(ctx: AssistCtx) -> Option<Assist> {
            return None;
        }
        (vis_offset(&parent), keyword.text_range())
-    } else {
+    } else if let Some(field_name) = ctx.find_node_at_offset::<ast::Name>() {
-        let field_name: ast::Name = ctx.find_node_at_offset()?;
        let field = field_name.syntax().ancestors().find_map(ast::RecordFieldDef::cast)?;
        if field.name()? != field_name {
-            tested_by!(change_visibility_field_false_positive);
+            mark::hit!(change_visibility_field_false_positive);
            return None;
        }
        if field.visibility().is_some() {
            return None;
        }
        (vis_offset(field.syntax()), field_name.syntax().text_range())
+    } else if let Some(field) = ctx.find_node_at_offset::<ast::TupleFieldDef>() {
+        if field.visibility().is_some() {
+            return None;
+        }
+        (vis_offset(field.syntax()), field.syntax().text_range())
+    } else {
+        return None;
    };
-    ctx.add_assist(AssistId("change_visibility"), "Change visibility to pub(crate)", |edit| {
+    acc.add(AssistId("change_visibility"), "Change visibility to pub(crate)", target, |edit| {
-        edit.target(target);
        edit.insert(offset, "pub(crate) ");
-        edit.set_cursor(offset);
    })
 }
@@ -78,49 +82,49 @@ fn vis_offset(node: &SyntaxNode) -> TextSize {
        .unwrap_or_else(|| node.text_range().start())
 }
-fn change_vis(ctx: AssistCtx, vis: ast::Visibility) -> Option<Assist> {
+fn change_vis(acc: &mut Assists, vis: ast::Visibility) -> Option<()> {
    if vis.syntax().text() == "pub" {
-        return ctx.add_assist(
+        let target = vis.syntax().text_range();
+        return acc.add(
            AssistId("change_visibility"),
            "Change Visibility to pub(crate)",
+            target,
            |edit| {
-                edit.target(vis.syntax().text_range());
                edit.replace(vis.syntax().text_range(), "pub(crate)");
-                edit.set_cursor(vis.syntax().text_range().start())
            },
        );
    }
    if vis.syntax().text() == "pub(crate)" {
-        return ctx.add_assist(AssistId("change_visibility"), "Change visibility to pub", |edit| {
+        let target = vis.syntax().text_range();
-            edit.target(vis.syntax().text_range());
+        return acc.add(
-            edit.replace(vis.syntax().text_range(), "pub");
+            AssistId("change_visibility"),
-            edit.set_cursor(vis.syntax().text_range().start());
+            "Change visibility to pub",
-        });
+            target,
+            |edit| {
+                edit.replace(vis.syntax().text_range(), "pub");
+            },
+        );
    }
    None
 }
 #[cfg(test)]
 mod tests {
-    use test_utils::covers;
+    use test_utils::mark;
-    use crate::helpers::{check_assist, check_assist_not_applicable, check_assist_target};
+    use crate::tests::{check_assist, check_assist_not_applicable, check_assist_target};
    use super::*;
    #[test]
    fn change_visibility_adds_pub_crate_to_items() {
-        check_assist(change_visibility, "<|>fn foo() {}", "<|>pub(crate) fn foo() {}");
+        check_assist(change_visibility, "<|>fn foo() {}", "pub(crate) fn foo() {}");
-        check_assist(change_visibility, "f<|>n foo() {}", "<|>pub(crate) fn foo() {}");
+        check_assist(change_visibility, "f<|>n foo() {}", "pub(crate) fn foo() {}");
-        check_assist(change_visibility, "<|>struct Foo {}", "<|>pub(crate) struct Foo {}");
+        check_assist(change_visibility, "<|>struct Foo {}", "pub(crate) struct Foo {}");
-        check_assist(change_visibility, "<|>mod foo {}", "<|>pub(crate) mod foo {}");
+        check_assist(change_visibility, "<|>mod foo {}", "pub(crate) mod foo {}");
-        check_assist(change_visibility, "<|>trait Foo {}", "<|>pub(crate) trait Foo {}");
+        check_assist(change_visibility, "<|>trait Foo {}", "pub(crate) trait Foo {}");
-        check_assist(change_visibility, "m<|>od {}", "<|>pub(crate) mod {}");
+        check_assist(change_visibility, "m<|>od {}", "pub(crate) mod {}");
-        check_assist(
+        check_assist(change_visibility, "unsafe f<|>n foo() {}", "pub(crate) unsafe fn foo() {}");
-            change_visibility,
-            "unsafe f<|>n foo() {}",
-            "<|>pub(crate) unsafe fn foo() {}",
-        );
    }
    #[test]
@@ -128,13 +132,14 @@ mod tests {
        check_assist(
            change_visibility,
            r"struct S { <|>field: u32 }",
-            r"struct S { <|>pub(crate) field: u32 }",
+            r"struct S { pub(crate) field: u32 }",
-        )
+        );
+        check_assist(change_visibility, r"struct S ( <|>u32 )", r"struct S ( pub(crate) u32 )");
    }
    #[test]
    fn change_visibility_field_false_positive() {
-        covers!(change_visibility_field_false_positive);
+        mark::check!(change_visibility_field_false_positive);
        check_assist_not_applicable(
            change_visibility,
            r"struct S { field: [(); { let <|>x = ();}] }",
@@ -143,17 +148,17 @@ mod tests {
    #[test]
    fn change_visibility_pub_to_pub_crate() {
-        check_assist(change_visibility, "<|>pub fn foo() {}", "<|>pub(crate) fn foo() {}")
+        check_assist(change_visibility, "<|>pub fn foo() {}", "pub(crate) fn foo() {}")
    }
    #[test]
    fn change_visibility_pub_crate_to_pub() {
-        check_assist(change_visibility, "<|>pub(crate) fn foo() {}", "<|>pub fn foo() {}")
+        check_assist(change_visibility, "<|>pub(crate) fn foo() {}", "pub fn foo() {}")
    }
    #[test]
    fn change_visibility_const() {
-        check_assist(change_visibility, "<|>const FOO = 3u8;", "<|>pub(crate) const FOO = 3u8;");
+        check_assist(change_visibility, "<|>const FOO = 3u8;", "pub(crate) const FOO = 3u8;");
    }
    #[test]
@@ -174,12 +179,21 @@ mod tests {
            // comments
            #[derive(Debug)]
-            <|>pub(crate) struct Foo;
+            pub(crate) struct Foo;
            ",
        )
    }
    #[test]
+    fn not_applicable_for_enum_variants() {
+        check_assist_not_applicable(
+            change_visibility,
+            r"mod foo { pub enum Foo {Foo1} }
+              fn main() { foo::Foo::Foo1<|> } ",
+        );
+    }
+    #[test]
    fn change_visibility_target() {
        check_assist_target(change_visibility, "<|>fn foo() {}", "fn");
        check_assist_target(change_visibility, "pub(crate)<|> fn foo() {}", "pub(crate)");
diff --git a/crates/ra_assists/src/handlers/early_return.rs b/crates/ra_assists/src/handlers/early_return.rs
index ea6c56f8c..4cc75a7ce 100644
--- a/crates/ra_assists/src/handlers/early_return.rs
+++ b/crates/ra_assists/src/handlers/early_return.rs
@@ -2,14 +2,18 @@ use std::{iter::once, ops::RangeInclusive};
 use ra_syntax::{
    algo::replace_children,
-    ast::{self, edit::IndentLevel, make, Block, Pat::TupleStructPat},
+    ast::{
+        self,
+        edit::{AstNodeEdit, IndentLevel},
+        make,
+    },
    AstNode,
    SyntaxKind::{FN_DEF, LOOP_EXPR, L_CURLY, R_CURLY, WHILE_EXPR, WHITESPACE},
    SyntaxNode,
 };
 use crate::{
-    assist_ctx::{Assist, AssistCtx},
+    assist_context::{AssistContext, Assists},
    utils::invert_boolean_expression,
    AssistId,
 };
@@ -36,7 +40,7 @@ use crate::{
 //     bar();
 // }
 // ```
-pub(crate) fn convert_to_guarded_return(ctx: AssistCtx) -> Option<Assist> {
+pub(crate) fn convert_to_guarded_return(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
    let if_expr: ast::IfExpr = ctx.find_node_at_offset()?;
    if if_expr.else_branch().is_some() {
        return None;
@@ -47,7 +51,7 @@ pub(crate) fn convert_to_guarded_return(ctx: AssistCtx) -> Option<Assist> {
    // Check if there is an IfLet that we can handle.
    let if_let_pat = match cond.pat() {
        None => None, // No IfLet, supported.
-        Some(TupleStructPat(pat)) if pat.args().count() == 1 => {
+        Some(ast::Pat::TupleStructPat(pat)) if pat.args().count() == 1 => {
            let path = pat.path()?;
            match path.qualifier() {
                None => {
@@ -61,9 +65,9 @@ pub(crate) fn convert_to_guarded_return(ctx: AssistCtx) -> Option<Assist> {
    };
    let cond_expr = cond.expr()?;
-    let then_block = if_expr.then_branch()?.block()?;
+    let then_block = if_expr.then_branch()?;
-    let parent_block = if_expr.syntax().parent()?.ancestors().find_map(ast::Block::cast)?;
+    let parent_block = if_expr.syntax().parent()?.ancestors().find_map(ast::BlockExpr::cast)?;
    if parent_block.expr()? != if_expr.clone().into() {
        return None;
@@ -80,7 +84,7 @@ pub(crate) fn convert_to_guarded_return(ctx: AssistCtx) -> Option<Assist> {
        return None;
    }
-    let parent_container = parent_block.syntax().parent()?.parent()?;
+    let parent_container = parent_block.syntax().parent()?;
    let early_expression: ast::Expr = match parent_container.kind() {
        WHILE_EXPR | LOOP_EXPR => make::expr_continue(),
@@ -93,9 +97,9 @@ pub(crate) fn convert_to_guarded_return(ctx: AssistCtx) -> Option<Assist> {
    }
    then_block.syntax().last_child_or_token().filter(|t| t.kind() == R_CURLY)?;
-    let cursor_position = ctx.frange.range.start();
-    ctx.add_assist(AssistId("convert_to_guarded_return"), "Convert to guarded return", |edit| {
+    let target = if_expr.syntax().text_range();
+    acc.add(AssistId("convert_to_guarded_return"), "Convert to guarded return", target, |edit| {
        let if_indent_level = IndentLevel::from_node(&if_expr.syntax());
        let new_block = match if_let_pat {
            None => {
@@ -104,8 +108,7 @@ pub(crate) fn convert_to_guarded_return(ctx: AssistCtx) -> Option<Assist> {
                    let then_branch =
                        make::block_expr(once(make::expr_stmt(early_expression).into()), None);
                    let cond = invert_boolean_expression(cond_expr);
-                    let e = make::expr_if(make::condition(cond, None), then_branch);
+                    make::expr_if(make::condition(cond, None), then_branch).indent(if_indent_level)
-                    if_indent_level.increase_indent(e)
                };
                replace(new_expr.syntax(), &then_block, &parent_block, &if_expr)
            }
@@ -139,21 +142,19 @@ pub(crate) fn convert_to_guarded_return(ctx: AssistCtx) -> Option<Assist> {
                    make::bind_pat(make::name(&bound_ident.syntax().to_string())).into(),
                    Some(match_expr),
                );
-                let let_stmt = if_indent_level.increase_indent(let_stmt);
+                let let_stmt = let_stmt.indent(if_indent_level);
                replace(let_stmt.syntax(), &then_block, &parent_block, &if_expr)
            }
        };
-        edit.target(if_expr.syntax().text_range());
+        edit.replace_ast(parent_block, ast::BlockExpr::cast(new_block).unwrap());
-        edit.replace_ast(parent_block, ast::Block::cast(new_block).unwrap());
-        edit.set_cursor(cursor_position);
        fn replace(
            new_expr: &SyntaxNode,
-            then_block: &Block,
+            then_block: &ast::BlockExpr,
-            parent_block: &Block,
+            parent_block: &ast::BlockExpr,
            if_expr: &ast::IfExpr,
        ) -> SyntaxNode {
-            let then_block_items = IndentLevel::from(1).decrease_indent(then_block.clone());
+            let then_block_items = then_block.dedent(IndentLevel::from(1));
            let end_of_then = then_block_items.syntax().last_child_or_token().unwrap();
            let end_of_then =
                if end_of_then.prev_sibling_or_token().map(|n| n.kind()) == Some(WHITESPACE) {
@@ -182,7 +183,7 @@ pub(crate) fn convert_to_guarded_return(ctx: AssistCtx) -> Option<Assist> {
 #[cfg(test)]
 mod tests {
-    use crate::helpers::{check_assist, check_assist_not_applicable};
+    use crate::tests::{check_assist, check_assist_not_applicable};
    use super::*;
@@ -204,7 +205,7 @@ mod tests {
            r#"
            fn main() {
                bar();
-                if<|> !true {
+                if !true {
                    return;
                }
                foo();
@@ -234,7 +235,7 @@ mod tests {
            r#"
            fn main(n: Option<String>) {
                bar();
-                le<|>t n = match n {
+                let n = match n {
                    Some(it) => it,
                    _ => return,
                };
@@ -260,7 +261,7 @@ mod tests {
            "#,
            r#"
            fn main() {
-                le<|>t x = match Err(92) {
+                let x = match Err(92) {
                    Ok(it) => it,
                    _ => return,
                };
@@ -288,7 +289,7 @@ mod tests {
            r#"
            fn main(n: Option<String>) {
                bar();
-                le<|>t n = match n {
+                let n = match n {
                    Ok(it) => it,
                    _ => return,
                };
@@ -318,7 +319,7 @@ mod tests {
            r#"
            fn main() {
                while true {
-                    if<|> !true {
+                    if !true {
                        continue;
                    }
                    foo();
@@ -346,7 +347,7 @@ mod tests {
            r#"
            fn main() {
                while true {
-                    le<|>t n = match n {
+                    let n = match n {
                        Some(it) => it,
                        _ => continue,
                    };
@@ -375,7 +376,7 @@ mod tests {
            r#"
            fn main() {
                loop {
-                    if<|> !true {
+                    if !true {
                        continue;
                    }
                    foo();
@@ -403,7 +404,7 @@ mod tests {
            r#"
            fn main() {
                loop {
-                    le<|>t n = match n {
+                    let n = match n {
                        Some(it) => it,
                        _ => continue,
                    };
diff --git a/crates/ra_assists/src/handlers/fill_match_arms.rs b/crates/ra_assists/src/handlers/fill_match_arms.rs
index 8d1af9933..cc303285b 100644
--- a/crates/ra_assists/src/handlers/fill_match_arms.rs
+++ b/crates/ra_assists/src/handlers/fill_match_arms.rs
@@ -4,8 +4,12 @@ use hir::{Adt, HasSource, ModuleDef, Semantics};
 use itertools::Itertools;
 use ra_ide_db::RootDatabase;
 use ra_syntax::ast::{self, make, AstNode, MatchArm, NameOwner, Pat};
+use test_utils::mark;
-use crate::{Assist, AssistCtx, AssistId};
+use crate::{
+    utils::{render_snippet, Cursor, FamousDefs},
+    AssistContext, AssistId, Assists,
+};
 // Assist: fill_match_arms
 //
@@ -26,12 +30,12 @@ use crate::{Assist, AssistCtx, AssistId};
 //
 // fn handle(action: Action) {
 //     match action {
-//         Action::Move { distance } => {}
+//         $0Action::Move { distance } => {}
 //         Action::Stop => {}
 //     }
 // }
 // ```
-pub(crate) fn fill_match_arms(ctx: AssistCtx) -> Option<Assist> {
+pub(crate) fn fill_match_arms(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
    let match_expr = ctx.find_node_at_offset::<ast::MatchExpr>()?;
    let match_arm_list = match_expr.match_arm_list()?;
@@ -49,12 +53,18 @@ pub(crate) fn fill_match_arms(ctx: AssistCtx) -> Option<Assist> {
    let missing_arms: Vec<MatchArm> = if let Some(enum_def) = resolve_enum_def(&ctx.sema, &expr) {
        let variants = enum_def.variants(ctx.db);
-        variants
+        let mut variants = variants
            .into_iter()
            .filter_map(|variant| build_pat(ctx.db, module, variant))
            .filter(|variant_pat| is_variant_missing(&mut arms, variant_pat))
            .map(|pat| make::match_arm(iter::once(pat), make::expr_empty_block()))
-            .collect()
+            .collect::<Vec<_>>();
+        if Some(enum_def) == FamousDefs(&ctx.sema, module.krate()).core_option_Option() {
+            // Match `Some` variant first.
+            mark::hit!(option_order);
+            variants.reverse()
+        }
+        variants
    } else if let Some(enum_defs) = resolve_tuple_of_enum_def(&ctx.sema, &expr) {
        // Partial fill not currently supported for tuple of enums.
        if !arms.is_empty() {
@@ -92,12 +102,24 @@ pub(crate) fn fill_match_arms(ctx: AssistCtx) -> Option<Assist> {
        return None;
    }
-    ctx.add_assist(AssistId("fill_match_arms"), "Fill match arms", |edit| {
+    let target = match_expr.syntax().text_range();
-        let new_arm_list = match_arm_list.remove_placeholder().append_arms(missing_arms);
+    acc.add(AssistId("fill_match_arms"), "Fill match arms", target, |builder| {
+        let new_arm_list = match_arm_list.remove_placeholder();
-        edit.target(match_expr.syntax().text_range());
+        let n_old_arms = new_arm_list.arms().count();
-        edit.set_cursor(expr.syntax().text_range().start());
+        let new_arm_list = new_arm_list.append_arms(missing_arms);
-        edit.replace_ast(match_arm_list, new_arm_list);
+        let first_new_arm = new_arm_list.arms().nth(n_old_arms);
+        let old_range = match_arm_list.syntax().text_range();
+        match (first_new_arm, ctx.config.snippet_cap) {
+            (Some(first_new_arm), Some(cap)) => {
+                let snippet = render_snippet(
+                    cap,
+                    new_arm_list.syntax(),
+                    Cursor::Before(first_new_arm.syntax()),
+                );
+                builder.replace_snippet(cap, old_range, snippet);
+            }
+            _ => builder.replace(old_range, new_arm_list.to_string()),
+        }
    })
 }
@@ -168,7 +190,12 @@ fn build_pat(db: &RootDatabase, module: hir::Module, var: hir::EnumVariant) -> O
 #[cfg(test)]
 mod tests {
-    use crate::helpers::{check_assist, check_assist_not_applicable, check_assist_target};
+    use test_utils::mark;
+    use crate::{
+        tests::{check_assist, check_assist_not_applicable, check_assist_target},
+        utils::FamousDefs,
+    };
    use super::fill_match_arms;
@@ -215,12 +242,12 @@ mod tests {
            r#"
            enum A {
                As,
-                Bs{x:i32, y:Option<i32>},
+                Bs { x: i32, y: Option<i32> },
                Cs(i32, Option<i32>),
            }
            fn main() {
                match A::As<|> {
-                    A::Bs{x,y:Some(_)} => {}
+                    A::Bs { x, y: Some(_) } => {}
                    A::Cs(_, Some(_)) => {}
                }
            }
@@ -228,14 +255,14 @@ mod tests {
            r#"
            enum A {
                As,
-                Bs{x:i32, y:Option<i32>},
+                Bs { x: i32, y: Option<i32> },
                Cs(i32, Option<i32>),
            }
            fn main() {
-                match <|>A::As {
+                match A::As {
-                    A::Bs{x,y:Some(_)} => {}
+                    A::Bs { x, y: Some(_) } => {}
                    A::Cs(_, Some(_)) => {}
-                    A::As => {}
+                    $0A::As => {}
                }
            }
            "#,
@@ -265,9 +292,9 @@ mod tests {
                Cs(Option<i32>),
            }
            fn main() {
-                match <|>A::As {
+                match A::As {
                    A::Cs(_) | A::Bs => {}
-                    A::As => {}
+                    $0A::As => {}
                }
            }
            "#,
@@ -311,11 +338,11 @@ mod tests {
                Ys,
            }
            fn main() {
-                match <|>A::As {
+                match A::As {
                    A::Bs if 0 < 1 => {}
                    A::Ds(_value) => { let x = 1; }
                    A::Es(B::Xs) => (),
-                    A::As => {}
+                    $0A::As => {}
                    A::Cs => {}
                }
            }
@@ -333,7 +360,7 @@ mod tests {
                Bs,
                Cs(String),
                Ds(String, String),
-                Es{ x: usize, y: usize }
+                Es { x: usize, y: usize }
            }
            fn main() {
@@ -347,13 +374,13 @@ mod tests {
                Bs,
                Cs(String),
                Ds(String, String),
-                Es{ x: usize, y: usize }
+                Es { x: usize, y: usize }
            }
            fn main() {
                let a = A::As;
-                match <|>a {
+                match a {
-                    A::As => {}
+                    $0A::As => {}
                    A::Bs => {}
                    A::Cs(_) => {}
                    A::Ds(_, _) => {}
@@ -369,14 +396,8 @@ mod tests {
        check_assist(
            fill_match_arms,
            r#"
-            enum A {
+            enum A { One, Two }
-                One,
+            enum B { One, Two }
-                Two,
-            }
-            enum B {
-                One,
-                Two,
-            }
            fn main() {
                let a = A::One;
@@ -385,20 +406,14 @@ mod tests {
            }
            "#,
            r#"
-            enum A {
+            enum A { One, Two }
-                One,
+            enum B { One, Two }
-                Two,
-            }
-            enum B {
-                One,
-                Two,
-            }
            fn main() {
                let a = A::One;
                let b = B::One;
-                match <|>(a, b) {
+                match (a, b) {
-                    (A::One, B::One) => {}
+                    $0(A::One, B::One) => {}
                    (A::One, B::Two) => {}
                    (A::Two, B::One) => {}
                    (A::Two, B::Two) => {}
@@ -413,14 +428,8 @@ mod tests {
        check_assist(
            fill_match_arms,
            r#"
-            enum A {
+            enum A { One, Two }
-                One,
+            enum B { One, Two }
-                Two,
-            }
-            enum B {
-                One,
-                Two,
-            }
            fn main() {
                let a = A::One;
@@ -429,20 +438,14 @@ mod tests {
            }
            "#,
            r#"
-            enum A {
+            enum A { One, Two }
-                One,
+            enum B { One, Two }
-                Two,
-            }
-            enum B {
-                One,
-                Two,
-            }
            fn main() {
                let a = A::One;
                let b = B::One;
-                match <|>(&a, &b) {
+                match (&a, &b) {
-                    (A::One, B::One) => {}
+                    $0(A::One, B::One) => {}
                    (A::One, B::Two) => {}
                    (A::Two, B::One) => {}
                    (A::Two, B::Two) => {}
@@ -457,14 +460,8 @@ mod tests {
        check_assist_not_applicable(
            fill_match_arms,
            r#"
-            enum A {
+            enum A { One, Two }
-                One,
+            enum B { One, Two }
-                Two,
-            }
-            enum B {
-                One,
-                Two,
-            }
            fn main() {
                let a = A::One;
@@ -482,14 +479,8 @@ mod tests {
        check_assist_not_applicable(
            fill_match_arms,
            r#"
-            enum A {
+            enum A { One, Two }
-                One,
+            enum B { One, Two }
-                Two,
-            }
-            enum B {
-                One,
-                Two,
-            }
            fn main() {
                let a = A::One;
@@ -513,10 +504,7 @@ mod tests {
        check_assist_not_applicable(
            fill_match_arms,
            r#"
-            enum A {
+            enum A { One, Two }
-                One,
-                Two,
-            }
            fn main() {
                let a = A::One;
@@ -532,9 +520,7 @@ mod tests {
        check_assist(
            fill_match_arms,
            r#"
-            enum A {
+            enum A { As }
-                As,
-            }
            fn foo(a: &A) {
                match a<|> {
@@ -542,13 +528,11 @@ mod tests {
            }
            "#,
            r#"
-            enum A {
+            enum A { As }
-                As,
-            }
            fn foo(a: &A) {
-                match <|>a {
+                match a {
-                    A::As => {}
+                    $0A::As => {}
                }
            }
            "#,
@@ -558,7 +542,7 @@ mod tests {
            fill_match_arms,
            r#"
            enum A {
-                Es{ x: usize, y: usize }
+                Es { x: usize, y: usize }
            }
            fn foo(a: &mut A) {
@@ -568,12 +552,12 @@ mod tests {
            "#,
            r#"
            enum A {
-                Es{ x: usize, y: usize }
+                Es { x: usize, y: usize }
            }
            fn foo(a: &mut A) {
-                match <|>a {
+                match a {
-                    A::Es { x, y } => {}
+                    $0A::Es { x, y } => {}
                }
            }
            "#,
@@ -612,8 +596,8 @@ mod tests {
            enum E { X, Y }
            fn main() {
-                match <|>E::X {
+                match E::X {
-                    E::X => {}
+                    $0E::X => {}
                    E::Y => {}
                }
            }
@@ -640,8 +624,8 @@ mod tests {
            use foo::E::X;
            fn main() {
-                match <|>X {
+                match X {
-                    X => {}
+                    $0X => {}
                    foo::E::Y => {}
                }
            }
@@ -654,10 +638,7 @@ mod tests {
        check_assist(
            fill_match_arms,
            r#"
-            enum A {
+            enum A { One, Two }
-                One,
-                Two,
-            }
            fn foo(a: A) {
                match a {
                    // foo bar baz<|>
@@ -667,16 +648,13 @@ mod tests {
            }
            "#,
            r#"
-            enum A {
+            enum A { One, Two }
-                One,
-                Two,
-            }
            fn foo(a: A) {
-                match <|>a {
+                match a {
                    // foo bar baz
                    A::One => {}
                    // This is where the rest should be
-                    A::Two => {}
+                    $0A::Two => {}
                }
            }
            "#,
@@ -688,10 +666,7 @@ mod tests {
        check_assist(
            fill_match_arms,
            r#"
-            enum A {
+            enum A { One, Two }
-                One,
-                Two,
-            }
            fn foo(a: A) {
                match a {
                    // foo bar baz<|>
@@ -699,14 +674,11 @@ mod tests {
            }
            "#,
            r#"
-            enum A {
+            enum A { One, Two }
-                One,
-                Two,
-            }
            fn foo(a: A) {
-                match <|>a {
+                match a {
                    // foo bar baz
-                    A::One => {}
+                    $0A::One => {}
                    A::Two => {}
                }
            }
@@ -729,12 +701,37 @@ mod tests {
            r#"
            enum A { One, Two, }
            fn foo(a: A) {
-                match <|>a {
+                match a {
-                    A::One => {}
+                    $0A::One => {}
                    A::Two => {}
                }
            }
            "#,
        );
    }
+    #[test]
+    fn option_order() {
+        mark::check!(option_order);
+        let before = r#"
+fn foo(opt: Option<i32>) {
+    match opt<|> {
+    }
+}"#;
+        let before =
+            &format!("//- main.rs crate:main deps:core\n{}{}", before, FamousDefs::FIXTURE);
+        check_assist(
+            fill_match_arms,
+            before,
+            r#"
+fn foo(opt: Option<i32>) {
+    match opt {
+        $0Some(_) => {}
+        None => {}
+    }
+}
+"#,
+        );
+    }
 }
diff --git a/crates/ra_assists/src/handlers/fix_visibility.rs b/crates/ra_assists/src/handlers/fix_visibility.rs
new file mode 100644
index 000000000..9ec42f568
--- /dev/null
+++ b/crates/ra_assists/src/handlers/fix_visibility.rs
@@ -0,0 +1,559 @@
+use hir::{db::HirDatabase, HasSource, HasVisibility, PathResolution};
+use ra_db::FileId;
+use ra_syntax::{
+    ast, AstNode,
+    SyntaxKind::{ATTR, COMMENT, WHITESPACE},
+    SyntaxNode, TextRange, TextSize,
+};
+use crate::{AssistContext, AssistId, Assists};
+// FIXME: this really should be a fix for diagnostic, rather than an assist.
+// Assist: fix_visibility
+//
+// Makes inaccessible item public.
+//
+// ```
+// mod m {
+//     fn frobnicate() {}
+// }
+// fn main() {
+//     m::frobnicate<|>() {}
+// }
+// ```
+// ->
+// ```
+// mod m {
+//     $0pub(crate) fn frobnicate() {}
+// }
+// fn main() {
+//     m::frobnicate() {}
+// }
+// ```
+pub(crate) fn fix_visibility(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
+    add_vis_to_referenced_module_def(acc, ctx)
+        .or_else(|| add_vis_to_referenced_record_field(acc, ctx))
+}
+fn add_vis_to_referenced_module_def(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
+    let path: ast::Path = ctx.find_node_at_offset()?;
+    let path_res = ctx.sema.resolve_path(&path)?;
+    let def = match path_res {
+        PathResolution::Def(def) => def,
+        _ => return None,
+    };
+    let current_module = ctx.sema.scope(&path.syntax()).module()?;
+    let target_module = def.module(ctx.db)?;
+    let vis = target_module.visibility_of(ctx.db, &def)?;
+    if vis.is_visible_from(ctx.db, current_module.into()) {
+        return None;
+    };
+    let (offset, target, target_file, target_name) = target_data_for_def(ctx.db, def)?;
+    let missing_visibility =
+        if current_module.krate() == target_module.krate() { "pub(crate)" } else { "pub" };
+    let assist_label = match target_name {
+        None => format!("Change visibility to {}", missing_visibility),
+        Some(name) => format!("Change visibility of {} to {}", name, missing_visibility),
+    };
+    acc.add(AssistId("fix_visibility"), assist_label, target, |builder| {
+        builder.set_file(target_file);
+        match ctx.config.snippet_cap {
+            Some(cap) => builder.insert_snippet(cap, offset, format!("$0{} ", missing_visibility)),
+            None => builder.insert(offset, format!("{} ", missing_visibility)),
+        }
+    })
+}
+fn add_vis_to_referenced_record_field(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
+    let record_field: ast::RecordField = ctx.find_node_at_offset()?;
+    let (record_field_def, _) = ctx.sema.resolve_record_field(&record_field)?;
+    let current_module = ctx.sema.scope(record_field.syntax()).module()?;
+    let visibility = record_field_def.visibility(ctx.db);
+    if visibility.is_visible_from(ctx.db, current_module.into()) {
+        return None;
+    }
+    let parent = record_field_def.parent_def(ctx.db);
+    let parent_name = parent.name(ctx.db);
+    let target_module = parent.module(ctx.db);
+    let in_file_source = record_field_def.source(ctx.db);
+    let (offset, target) = match in_file_source.value {
+        hir::FieldSource::Named(it) => {
+            let s = it.syntax();
+            (vis_offset(s), s.text_range())
+        }
+        hir::FieldSource::Pos(it) => {
+            let s = it.syntax();
+            (vis_offset(s), s.text_range())
+        }
+    };
+    let missing_visibility =
+        if current_module.krate() == target_module.krate() { "pub(crate)" } else { "pub" };
+    let target_file = in_file_source.file_id.original_file(ctx.db);
+    let target_name = record_field_def.name(ctx.db);
+    let assist_label =
+        format!("Change visibility of {}.{} to {}", parent_name, target_name, missing_visibility);
+    acc.add(AssistId("fix_visibility"), assist_label, target, |builder| {
+        builder.set_file(target_file);
+        match ctx.config.snippet_cap {
+            Some(cap) => builder.insert_snippet(cap, offset, format!("$0{} ", missing_visibility)),
+            None => builder.insert(offset, format!("{} ", missing_visibility)),
+        }
+    })
+}
+fn target_data_for_def(
+    db: &dyn HirDatabase,
+    def: hir::ModuleDef,
+) -> Option<(TextSize, TextRange, FileId, Option<hir::Name>)> {
+    fn offset_target_and_file_id<S, Ast>(
+        db: &dyn HirDatabase,
+        x: S,
+    ) -> (TextSize, TextRange, FileId)
+    where
+        S: HasSource<Ast = Ast>,
+        Ast: AstNode,
+    {
+        let source = x.source(db);
+        let in_file_syntax = source.syntax();
+        let file_id = in_file_syntax.file_id;
+        let syntax = in_file_syntax.value;
+        (vis_offset(syntax), syntax.text_range(), file_id.original_file(db.upcast()))
+    }
+    let target_name;
+    let (offset, target, target_file) = match def {
+        hir::ModuleDef::Function(f) => {
+            target_name = Some(f.name(db));
+            offset_target_and_file_id(db, f)
+        }
+        hir::ModuleDef::Adt(adt) => {
+            target_name = Some(adt.name(db));
+            match adt {
+                hir::Adt::Struct(s) => offset_target_and_file_id(db, s),
+                hir::Adt::Union(u) => offset_target_and_file_id(db, u),
+                hir::Adt::Enum(e) => offset_target_and_file_id(db, e),
+            }
+        }
+        hir::ModuleDef::Const(c) => {
+            target_name = c.name(db);
+            offset_target_and_file_id(db, c)
+        }
+        hir::ModuleDef::Static(s) => {
+            target_name = s.name(db);
+            offset_target_and_file_id(db, s)
+        }
+        hir::ModuleDef::Trait(t) => {
+            target_name = Some(t.name(db));
+            offset_target_and_file_id(db, t)
+        }
+        hir::ModuleDef::TypeAlias(t) => {
+            target_name = Some(t.name(db));
+            offset_target_and_file_id(db, t)
+        }
+        hir::ModuleDef::Module(m) => {
+            target_name = m.name(db);
+            let in_file_source = m.declaration_source(db)?;
+            let file_id = in_file_source.file_id.original_file(db.upcast());
+            let syntax = in_file_source.value.syntax();
+            (vis_offset(syntax), syntax.text_range(), file_id)
+        }
+        // Enum variants can't be private, we can't modify builtin types
+        hir::ModuleDef::EnumVariant(_) | hir::ModuleDef::BuiltinType(_) => return None,
+    };
+    Some((offset, target, target_file, target_name))
+}
+fn vis_offset(node: &SyntaxNode) -> TextSize {
+    node.children_with_tokens()
+        .skip_while(|it| match it.kind() {
+            WHITESPACE | COMMENT | ATTR => true,
+            _ => false,
+        })
+        .next()
+        .map(|it| it.text_range().start())
+        .unwrap_or_else(|| node.text_range().start())
+}
+#[cfg(test)]
+mod tests {
+    use crate::tests::{check_assist, check_assist_not_applicable};
+    use super::*;
+    #[test]
+    fn fix_visibility_of_fn() {
+        check_assist(
+            fix_visibility,
+            r"mod foo { fn foo() {} }
+              fn main() { foo::foo<|>() } ",
+            r"mod foo { $0pub(crate) fn foo() {} }
+              fn main() { foo::foo() } ",
+        );
+        check_assist_not_applicable(
+            fix_visibility,
+            r"mod foo { pub fn foo() {} }
+              fn main() { foo::foo<|>() } ",
+        )
+    }
+    #[test]
+    fn fix_visibility_of_adt_in_submodule() {
+        check_assist(
+            fix_visibility,
+            r"mod foo { struct Foo; }
+              fn main() { foo::Foo<|> } ",
+            r"mod foo { $0pub(crate) struct Foo; }
+              fn main() { foo::Foo } ",
+        );
+        check_assist_not_applicable(
+            fix_visibility,
+            r"mod foo { pub struct Foo; }
+              fn main() { foo::Foo<|> } ",
+        );
+        check_assist(
+            fix_visibility,
+            r"mod foo { enum Foo; }
+              fn main() { foo::Foo<|> } ",
+            r"mod foo { $0pub(crate) enum Foo; }
+              fn main() { foo::Foo } ",
+        );
+        check_assist_not_applicable(
+            fix_visibility,
+            r"mod foo { pub enum Foo; }
+              fn main() { foo::Foo<|> } ",
+        );
+        check_assist(
+            fix_visibility,
+            r"mod foo { union Foo; }
+              fn main() { foo::Foo<|> } ",
+            r"mod foo { $0pub(crate) union Foo; }
+              fn main() { foo::Foo } ",
+        );
+        check_assist_not_applicable(
+            fix_visibility,
+            r"mod foo { pub union Foo; }
+              fn main() { foo::Foo<|> } ",
+        );
+    }
+    #[test]
+    fn fix_visibility_of_adt_in_other_file() {
+        check_assist(
+            fix_visibility,
+            r"
+              //- /main.rs
+              mod foo;
+              fn main() { foo::Foo<|> }
+              //- /foo.rs
+              struct Foo;
+              ",
+            r"$0pub(crate) struct Foo;
+",
+        );
+    }
+    #[test]
+    fn fix_visibility_of_struct_field() {
+        check_assist(
+            fix_visibility,
+            r"mod foo { pub struct Foo { bar: (), } }
+              fn main() { foo::Foo { <|>bar: () }; } ",
+            r"mod foo { pub struct Foo { $0pub(crate) bar: (), } }
+              fn main() { foo::Foo { bar: () }; } ",
+        );
+        check_assist(
+            fix_visibility,
+            r"//- /lib.rs
+              mod foo;
+              fn main() { foo::Foo { <|>bar: () }; }
+              //- /foo.rs
+              pub struct Foo { bar: () }
+              ",
+            r"pub struct Foo { $0pub(crate) bar: () }
+",
+        );
+        check_assist_not_applicable(
+            fix_visibility,
+            r"mod foo { pub struct Foo { pub bar: (), } }
+              fn main() { foo::Foo { <|>bar: () }; } ",
+        );
+        check_assist_not_applicable(
+            fix_visibility,
+            r"//- /lib.rs
+              mod foo;
+              fn main() { foo::Foo { <|>bar: () }; }
+              //- /foo.rs
+              pub struct Foo { pub bar: () }
+              ",
+        );
+    }
+    #[test]
+    fn fix_visibility_of_enum_variant_field() {
+        check_assist(
+            fix_visibility,
+            r"mod foo { pub enum Foo { Bar { bar: () } } }
+              fn main() { foo::Foo::Bar { <|>bar: () }; } ",
+            r"mod foo { pub enum Foo { Bar { $0pub(crate) bar: () } } }
+              fn main() { foo::Foo::Bar { bar: () }; } ",
+        );
+        check_assist(
+            fix_visibility,
+            r"//- /lib.rs
+              mod foo;
+              fn main() { foo::Foo::Bar { <|>bar: () }; }
+              //- /foo.rs
+              pub enum Foo { Bar { bar: () } }
+              ",
+            r"pub enum Foo { Bar { $0pub(crate) bar: () } }
+",
+        );
+        check_assist_not_applicable(
+            fix_visibility,
+            r"mod foo { pub struct Foo { pub bar: (), } }
+              fn main() { foo::Foo { <|>bar: () }; } ",
+        );
+        check_assist_not_applicable(
+            fix_visibility,
+            r"//- /lib.rs
+              mod foo;
+              fn main() { foo::Foo { <|>bar: () }; }
+              //- /foo.rs
+              pub struct Foo { pub bar: () }
+              ",
+        );
+    }
+    #[test]
+    #[ignore]
+    // FIXME reenable this test when `Semantics::resolve_record_field` works with union fields
+    fn fix_visibility_of_union_field() {
+        check_assist(
+            fix_visibility,
+            r"mod foo { pub union Foo { bar: (), } }
+              fn main() { foo::Foo { <|>bar: () }; } ",
+            r"mod foo { pub union Foo { $0pub(crate) bar: (), } }
+              fn main() { foo::Foo { bar: () }; } ",
+        );
+        check_assist(
+            fix_visibility,
+            r"//- /lib.rs
+              mod foo;
+              fn main() { foo::Foo { <|>bar: () }; }
+              //- /foo.rs
+              pub union Foo { bar: () }
+              ",
+            r"pub union Foo { $0pub(crate) bar: () }
+",
+        );
+        check_assist_not_applicable(
+            fix_visibility,
+            r"mod foo { pub union Foo { pub bar: (), } }
+              fn main() { foo::Foo { <|>bar: () }; } ",
+        );
+        check_assist_not_applicable(
+            fix_visibility,
+            r"//- /lib.rs
+              mod foo;
+              fn main() { foo::Foo { <|>bar: () }; }
+              //- /foo.rs
+              pub union Foo { pub bar: () }
+              ",
+        );
+    }
+    #[test]
+    fn fix_visibility_of_const() {
+        check_assist(
+            fix_visibility,
+            r"mod foo { const FOO: () = (); }
+              fn main() { foo::FOO<|> } ",
+            r"mod foo { $0pub(crate) const FOO: () = (); }
+              fn main() { foo::FOO } ",
+        );
+        check_assist_not_applicable(
+            fix_visibility,
+            r"mod foo { pub const FOO: () = (); }
+              fn main() { foo::FOO<|> } ",
+        );
+    }
+    #[test]
+    fn fix_visibility_of_static() {
+        check_assist(
+            fix_visibility,
+            r"mod foo { static FOO: () = (); }
+              fn main() { foo::FOO<|> } ",
+            r"mod foo { $0pub(crate) static FOO: () = (); }
+              fn main() { foo::FOO } ",
+        );
+        check_assist_not_applicable(
+            fix_visibility,
+            r"mod foo { pub static FOO: () = (); }
+              fn main() { foo::FOO<|> } ",
+        );
+    }
+    #[test]
+    fn fix_visibility_of_trait() {
+        check_assist(
+            fix_visibility,
+            r"mod foo { trait Foo { fn foo(&self) {} } }
+              fn main() { let x: &dyn foo::<|>Foo; } ",
+            r"mod foo { $0pub(crate) trait Foo { fn foo(&self) {} } }
+              fn main() { let x: &dyn foo::Foo; } ",
+        );
+        check_assist_not_applicable(
+            fix_visibility,
+            r"mod foo { pub trait Foo { fn foo(&self) {} } }
+              fn main() { let x: &dyn foo::Foo<|>; } ",
+        );
+    }
+    #[test]
+    fn fix_visibility_of_type_alias() {
+        check_assist(
+            fix_visibility,
+            r"mod foo { type Foo = (); }
+              fn main() { let x: foo::Foo<|>; } ",
+            r"mod foo { $0pub(crate) type Foo = (); }
+              fn main() { let x: foo::Foo; } ",
+        );
+        check_assist_not_applicable(
+            fix_visibility,
+            r"mod foo { pub type Foo = (); }
+              fn main() { let x: foo::Foo<|>; } ",
+        );
+    }
+    #[test]
+    fn fix_visibility_of_module() {
+        check_assist(
+            fix_visibility,
+            r"mod foo { mod bar { fn bar() {} } }
+              fn main() { foo::bar<|>::bar(); } ",
+            r"mod foo { $0pub(crate) mod bar { fn bar() {} } }
+              fn main() { foo::bar::bar(); } ",
+        );
+        check_assist(
+            fix_visibility,
+            r"
+            //- /main.rs
+            mod foo;
+            fn main() { foo::bar<|>::baz(); }
+            //- /foo.rs
+            mod bar {
+                pub fn baz() {}
+            }
+            ",
+            r"$0pub(crate) mod bar {
+    pub fn baz() {}
+}
+",
+        );
+        check_assist_not_applicable(
+            fix_visibility,
+            r"mod foo { pub mod bar { pub fn bar() {} } }
+              fn main() { foo::bar<|>::bar(); } ",
+        );
+    }
+    #[test]
+    fn fix_visibility_of_inline_module_in_other_file() {
+        check_assist(
+            fix_visibility,
+            r"
+            //- /main.rs
+            mod foo;
+            fn main() { foo::bar<|>::baz(); }
+            //- /foo.rs
+            mod bar;
+            //- /foo/bar.rs
+            pub fn baz() {}
+            }
+            ",
+            r"$0pub(crate) mod bar;
+",
+        );
+    }
+    #[test]
+    fn fix_visibility_of_module_declaration_in_other_file() {
+        check_assist(
+            fix_visibility,
+            r"//- /main.rs
+              mod foo;
+              fn main() { foo::bar<|>>::baz(); }
+              //- /foo.rs
+              mod bar {
+                  pub fn baz() {}
+              }",
+            r"$0pub(crate) mod bar {
+    pub fn baz() {}
+}
+",
+        );
+    }
+    #[test]
+    fn adds_pub_when_target_is_in_another_crate() {
+        check_assist(
+            fix_visibility,
+            r"//- /main.rs crate:a deps:foo
+              foo::Bar<|>
+              //- /lib.rs crate:foo
+              struct Bar;",
+            r"$0pub struct Bar;
+",
+        )
+    }
+    #[test]
+    #[ignore]
+    // FIXME handle reexports properly
+    fn fix_visibility_of_reexport() {
+        check_assist(
+            fix_visibility,
+            r"
+            mod foo {
+                use bar::Baz;
+                mod bar { pub(super) struct Baz; }
+            }
+            foo::Baz<|>
+            ",
+            r"
+            mod foo {
+                $0pub(crate) use bar::Baz;
+                mod bar { pub(super) struct Baz; }
+            }
+            foo::Baz
+            ",
+        )
+    }
+}
diff --git a/crates/ra_assists/src/handlers/flip_binexpr.rs b/crates/ra_assists/src/handlers/flip_binexpr.rs
index 8030efb35..573196576 100644
--- a/crates/ra_assists/src/handlers/flip_binexpr.rs
+++ b/crates/ra_assists/src/handlers/flip_binexpr.rs
@@ -1,6 +1,6 @@
 use ra_syntax::ast::{AstNode, BinExpr, BinOp};
-use crate::{Assist, AssistCtx, AssistId};
+use crate::{AssistContext, AssistId, Assists};
 // Assist: flip_binexpr
 //
@@ -17,7 +17,7 @@ use crate::{Assist, AssistCtx, AssistId};
 //     let _ = 2 + 90;
 // }
 // ```
-pub(crate) fn flip_binexpr(ctx: AssistCtx) -> Option<Assist> {
+pub(crate) fn flip_binexpr(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
    let expr = ctx.find_node_at_offset::<BinExpr>()?;
    let lhs = expr.lhs()?.syntax().clone();
    let rhs = expr.rhs()?.syntax().clone();
@@ -33,8 +33,7 @@ pub(crate) fn flip_binexpr(ctx: AssistCtx) -> Option<Assist> {
        return None;
    }
-    ctx.add_assist(AssistId("flip_binexpr"), "Flip binary expression", |edit| {
+    acc.add(AssistId("flip_binexpr"), "Flip binary expression", op_range, |edit| {
-        edit.target(op_range);
        if let FlipAction::FlipAndReplaceOp(new_op) = action {
            edit.replace(op_range, new_op);
        }
@@ -69,7 +68,7 @@ impl From<BinOp> for FlipAction {
 mod tests {
    use super::*;
-    use crate::helpers::{check_assist, check_assist_not_applicable, check_assist_target};
+    use crate::tests::{check_assist, check_assist_not_applicable, check_assist_target};
    #[test]
    fn flip_binexpr_target_is_the_op() {
@@ -86,17 +85,13 @@ mod tests {
        check_assist(
            flip_binexpr,
            "fn f() { let res = 1 ==<|> 2; }",
-            "fn f() { let res = 2 ==<|> 1; }",
+            "fn f() { let res = 2 == 1; }",
        )
    }
    #[test]
    fn flip_binexpr_works_for_gt() {
-        check_assist(
+        check_assist(flip_binexpr, "fn f() { let res = 1 ><|> 2; }", "fn f() { let res = 2 < 1; }")
-            flip_binexpr,
-            "fn f() { let res = 1 ><|> 2; }",
-            "fn f() { let res = 2 <<|> 1; }",
-        )
    }
    #[test]
@@ -104,7 +99,7 @@ mod tests {
        check_assist(
            flip_binexpr,
            "fn f() { let res = 1 <=<|> 2; }",
-            "fn f() { let res = 2 >=<|> 1; }",
+            "fn f() { let res = 2 >= 1; }",
        )
    }
@@ -113,7 +108,7 @@ mod tests {
        check_assist(
            flip_binexpr,
            "fn f() { let res = (1 + 1) ==<|> (2 + 2); }",
-            "fn f() { let res = (2 + 2) ==<|> (1 + 1); }",
+            "fn f() { let res = (2 + 2) == (1 + 1); }",
        )
    }
@@ -133,7 +128,7 @@ mod tests {
            fn dyn_eq(&self, other: &dyn Diagnostic) -> bool {
                match other.downcast_ref::<Self>() {
                    None => false,
-                    Some(it) => self ==<|> it,
+                    Some(it) => self == it,
                }
            }
            "#,
diff --git a/crates/ra_assists/src/handlers/flip_comma.rs b/crates/ra_assists/src/handlers/flip_comma.rs
index 1dacf29f8..a57a1c463 100644
--- a/crates/ra_assists/src/handlers/flip_comma.rs
+++ b/crates/ra_assists/src/handlers/flip_comma.rs
@@ -1,6 +1,6 @@
 use ra_syntax::{algo::non_trivia_sibling, Direction, T};
-use crate::{Assist, AssistCtx, AssistId};
+use crate::{AssistContext, AssistId, Assists};
 // Assist: flip_comma
 //
@@ -17,7 +17,7 @@ use crate::{Assist, AssistCtx, AssistId};
 //     ((3, 4), (1, 2));
 // }
 // ```
-pub(crate) fn flip_comma(ctx: AssistCtx) -> Option<Assist> {
+pub(crate) fn flip_comma(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
    let comma = ctx.find_token_at_offset(T![,])?;
    let prev = non_trivia_sibling(comma.clone().into(), Direction::Prev)?;
    let next = non_trivia_sibling(comma.clone().into(), Direction::Next)?;
@@ -28,8 +28,7 @@ pub(crate) fn flip_comma(ctx: AssistCtx) -> Option<Assist> {
        return None;
    }
-    ctx.add_assist(AssistId("flip_comma"), "Flip comma", |edit| {
+    acc.add(AssistId("flip_comma"), "Flip comma", comma.text_range(), |edit| {
-        edit.target(comma.text_range());
        edit.replace(prev.text_range(), next.to_string());
        edit.replace(next.text_range(), prev.to_string());
    })
@@ -39,14 +38,14 @@ pub(crate) fn flip_comma(ctx: AssistCtx) -> Option<Assist> {
 mod tests {
    use super::*;
-    use crate::helpers::{check_assist, check_assist_target};
+    use crate::tests::{check_assist, check_assist_target};
    #[test]
    fn flip_comma_works_for_function_parameters() {
        check_assist(
            flip_comma,
            "fn foo(x: i32,<|> y: Result<(), ()>) {}",
-            "fn foo(y: Result<(), ()>,<|> x: i32) {}",
+            "fn foo(y: Result<(), ()>, x: i32) {}",
        )
    }
diff --git a/crates/ra_assists/src/handlers/flip_trait_bound.rs b/crates/ra_assists/src/handlers/flip_trait_bound.rs
index f56769624..0115adc8b 100644
--- a/crates/ra_assists/src/handlers/flip_trait_bound.rs
+++ b/crates/ra_assists/src/handlers/flip_trait_bound.rs
@@ -4,7 +4,7 @@ use ra_syntax::{
    Direction, T,
 };
-use crate::{Assist, AssistCtx, AssistId};
+use crate::{AssistContext, AssistId, Assists};
 // Assist: flip_trait_bound
 //
@@ -17,7 +17,7 @@ use crate::{Assist, AssistCtx, AssistId};
 // ```
 // fn foo<T: Copy + Clone>() { }
 // ```
-pub(crate) fn flip_trait_bound(ctx: AssistCtx) -> Option<Assist> {
+pub(crate) fn flip_trait_bound(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
    // We want to replicate the behavior of `flip_binexpr` by only suggesting
    // the assist when the cursor is on a `+`
    let plus = ctx.find_token_at_offset(T![+])?;
@@ -32,8 +32,8 @@ pub(crate) fn flip_trait_bound(ctx: AssistCtx) -> Option<Assist> {
        non_trivia_sibling(plus.clone().into(), Direction::Next)?,
    );
-    ctx.add_assist(AssistId("flip_trait_bound"), "Flip trait bounds", |edit| {
+    let target = plus.text_range();
-        edit.target(plus.text_range());
+    acc.add(AssistId("flip_trait_bound"), "Flip trait bounds", target, |edit| {
        edit.replace(before.text_range(), after.to_string());
        edit.replace(after.text_range(), before.to_string());
    })
@@ -43,7 +43,7 @@ pub(crate) fn flip_trait_bound(ctx: AssistCtx) -> Option<Assist> {
 mod tests {
    use super::*;
-    use crate::helpers::{check_assist, check_assist_not_applicable, check_assist_target};
+    use crate::tests::{check_assist, check_assist_not_applicable, check_assist_target};
    #[test]
    fn flip_trait_bound_assist_available() {
@@ -60,7 +60,7 @@ mod tests {
        check_assist(
            flip_trait_bound,
            "struct S<T> where T: A <|>+ B { }",
-            "struct S<T> where T: B <|>+ A { }",
+            "struct S<T> where T: B + A { }",
        )
    }
@@ -69,13 +69,13 @@ mod tests {
        check_assist(
            flip_trait_bound,
            "impl X for S<T> where T: A +<|> B { }",
-            "impl X for S<T> where T: B +<|> A { }",
+            "impl X for S<T> where T: B + A { }",
        )
    }
    #[test]
    fn flip_trait_bound_works_for_fn() {
-        check_assist(flip_trait_bound, "fn f<T: A <|>+ B>(t: T) { }", "fn f<T: B <|>+ A>(t: T) { }")
+        check_assist(flip_trait_bound, "fn f<T: A <|>+ B>(t: T) { }", "fn f<T: B + A>(t: T) { }")
    }
    #[test]
@@ -83,7 +83,7 @@ mod tests {
        check_assist(
            flip_trait_bound,
            "fn f<T>(t: T) where T: A +<|> B { }",
-            "fn f<T>(t: T) where T: B +<|> A { }",
+            "fn f<T>(t: T) where T: B + A { }",
        )
    }
@@ -92,7 +92,7 @@ mod tests {
        check_assist(
            flip_trait_bound,
            "fn f<T>(t: T) where T: A <|>+ 'static { }",
-            "fn f<T>(t: T) where T: 'static <|>+ A { }",
+            "fn f<T>(t: T) where T: 'static + A { }",
        )
    }
@@ -101,7 +101,7 @@ mod tests {
        check_assist(
            flip_trait_bound,
            "struct S<T> where T: A<T> <|>+ b_mod::B<T> + C<T> { }",
-            "struct S<T> where T: b_mod::B<T> <|>+ A<T> + C<T> { }",
+            "struct S<T> where T: b_mod::B<T> + A<T> + C<T> { }",
        )
    }
@@ -110,7 +110,7 @@ mod tests {
        check_assist(
            flip_trait_bound,
            "struct S<T> where T: A + B + C + D + E + F +<|> G + H + I + J { }",
-            "struct S<T> where T: A + B + C + D + E + G +<|> F + H + I + J { }",
+            "struct S<T> where T: A + B + C + D + E + G + F + H + I + J { }",
        )
    }
 }
diff --git a/crates/ra_assists/src/handlers/inline_local_variable.rs b/crates/ra_assists/src/handlers/inline_local_variable.rs
index f5702f6e0..d26e68847 100644
--- a/crates/ra_assists/src/handlers/inline_local_variable.rs
+++ b/crates/ra_assists/src/handlers/inline_local_variable.rs
@@ -3,9 +3,12 @@ use ra_syntax::{
    ast::{self, AstNode, AstToken},
    TextRange,
 };
-use test_utils::tested_by;
+use test_utils::mark;
-use crate::{assist_ctx::ActionBuilder, Assist, AssistCtx, AssistId};
+use crate::{
+    assist_context::{AssistContext, Assists},
+    AssistId,
+};
 // Assist: inline_local_variable
 //
@@ -23,18 +26,18 @@ use crate::{assist_ctx::ActionBuilder, Assist, AssistCtx, AssistId};
 //     (1 + 2) * 4;
 // }
 // ```
-pub(crate) fn inline_local_variable(ctx: AssistCtx) -> Option<Assist> {
+pub(crate) fn inline_local_variable(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
    let let_stmt = ctx.find_node_at_offset::<ast::LetStmt>()?;
    let bind_pat = match let_stmt.pat()? {
        ast::Pat::BindPat(pat) => pat,
        _ => return None,
    };
    if bind_pat.mut_token().is_some() {
-        tested_by!(test_not_inline_mut_variable);
+        mark::hit!(test_not_inline_mut_variable);
        return None;
    }
-    if !bind_pat.syntax().text_range().contains_inclusive(ctx.frange.range.start()) {
+    if !bind_pat.syntax().text_range().contains_inclusive(ctx.offset()) {
-        tested_by!(not_applicable_outside_of_bind_pat);
+        mark::hit!(not_applicable_outside_of_bind_pat);
        return None;
    }
    let initializer_expr = let_stmt.initializer()?;
@@ -43,7 +46,7 @@ pub(crate) fn inline_local_variable(ctx: AssistCtx) -> Option<Assist> {
    let def = Definition::Local(def);
    let refs = def.find_usages(ctx.db, None);
    if refs.is_empty() {
-        tested_by!(test_not_applicable_if_variable_unused);
+        mark::hit!(test_not_applicable_if_variable_unused);
        return None;
    };
@@ -89,6 +92,7 @@ pub(crate) fn inline_local_variable(ctx: AssistCtx) -> Option<Assist> {
            | (ast::Expr::ParenExpr(_), _)
            | (ast::Expr::PathExpr(_), _)
            | (ast::Expr::BlockExpr(_), _)
+            | (ast::Expr::EffectExpr(_), _)
            | (_, ast::Expr::CallExpr(_))
            | (_, ast::Expr::TupleExpr(_))
            | (_, ast::Expr::ArrayExpr(_))
@@ -105,26 +109,21 @@ pub(crate) fn inline_local_variable(ctx: AssistCtx) -> Option<Assist> {
    let init_str = initializer_expr.syntax().text().to_string();
    let init_in_paren = format!("({})", &init_str);
-    ctx.add_assist(
+    let target = bind_pat.syntax().text_range();
-        AssistId("inline_local_variable"),
+    acc.add(AssistId("inline_local_variable"), "Inline variable", target, move |builder| {
-        "Inline variable",
+        builder.delete(delete_range);
-        move |edit: &mut ActionBuilder| {
+        for (desc, should_wrap) in refs.iter().zip(wrap_in_parens) {
-            edit.delete(delete_range);
+            let replacement = if should_wrap { init_in_paren.clone() } else { init_str.clone() };
-            for (desc, should_wrap) in refs.iter().zip(wrap_in_parens) {
+            builder.replace(desc.file_range.range, replacement)
-                let replacement =
+        }
-                    if should_wrap { init_in_paren.clone() } else { init_str.clone() };
+    })
-                edit.replace(desc.file_range.range, replacement)
-            }
-            edit.set_cursor(delete_range.start())
-        },
-    )
 }
 #[cfg(test)]
 mod tests {
-    use test_utils::covers;
+    use test_utils::mark;
-    use crate::helpers::{check_assist, check_assist_not_applicable};
+    use crate::tests::{check_assist, check_assist_not_applicable};
    use super::*;
@@ -149,7 +148,7 @@ fn foo() {
            r"
 fn bar(a: usize) {}
 fn foo() {
-    <|>1 + 1;
+    1 + 1;
    if 1 > 10 {
    }
@@ -183,7 +182,7 @@ fn foo() {
            r"
 fn bar(a: usize) {}
 fn foo() {
-    <|>(1 + 1) + 1;
+    (1 + 1) + 1;
    if (1 + 1) > 10 {
    }
@@ -217,7 +216,7 @@ fn foo() {
            r"
 fn bar(a: usize) {}
 fn foo() {
-    <|>bar(1) + 1;
+    bar(1) + 1;
    if bar(1) > 10 {
    }
@@ -251,7 +250,7 @@ fn foo() {
            r"
 fn bar(a: usize): usize { a }
 fn foo() {
-    <|>(bar(1) as u64) + 1;
+    (bar(1) as u64) + 1;
    if (bar(1) as u64) > 10 {
    }
@@ -283,7 +282,7 @@ fn foo() {
 }",
            r"
 fn foo() {
-    <|>{ 10 + 1 } + 1;
+    { 10 + 1 } + 1;
    if { 10 + 1 } > 10 {
    }
@@ -315,7 +314,7 @@ fn foo() {
 }",
            r"
 fn foo() {
-    <|>( 10 + 1 ) + 1;
+    ( 10 + 1 ) + 1;
    if ( 10 + 1 ) > 10 {
    }
@@ -330,7 +329,7 @@ fn foo() {
    #[test]
    fn test_not_inline_mut_variable() {
-        covers!(test_not_inline_mut_variable);
+        mark::check!(test_not_inline_mut_variable);
        check_assist_not_applicable(
            inline_local_variable,
            r"
@@ -353,7 +352,7 @@ fn foo() {
 }",
            r"
 fn foo() {
-    <|>let b = bar(10 + 1) * 10;
+    let b = bar(10 + 1) * 10;
    let c = bar(10 + 1) as usize;
 }",
        );
@@ -373,7 +372,7 @@ fn foo() {
            r"
 fn foo() {
    let x = vec![1, 2, 3];
-    <|>let b = x[0] * 10;
+    let b = x[0] * 10;
    let c = x[0] as usize;
 }",
        );
@@ -393,7 +392,7 @@ fn foo() {
            r"
 fn foo() {
    let bar = vec![1];
-    <|>let b = bar.len() * 10;
+    let b = bar.len() * 10;
    let c = bar.len() as usize;
 }",
        );
@@ -421,7 +420,7 @@ struct Bar {
 fn foo() {
    let bar = Bar { foo: 1 };
-    <|>let b = bar.foo * 10;
+    let b = bar.foo * 10;
    let c = bar.foo as usize;
 }",
        );
@@ -442,7 +441,7 @@ fn foo() -> Option<usize> {
            r"
 fn foo() -> Option<usize> {
    let bar = Some(1);
-    <|>let b = bar? * 10;
+    let b = bar? * 10;
    let c = bar? as usize;
    None
 }",
@@ -462,7 +461,7 @@ fn foo() {
            r"
 fn foo() {
    let bar = 10;
-    <|>let b = &bar * 10;
+    let b = &bar * 10;
 }",
        );
    }
@@ -478,7 +477,7 @@ fn foo() {
 }",
            r"
 fn foo() {
-    <|>let b = (10, 20)[0];
+    let b = (10, 20)[0];
 }",
        );
    }
@@ -494,7 +493,7 @@ fn foo() {
 }",
            r"
 fn foo() {
-    <|>let b = [1, 2, 3].len();
+    let b = [1, 2, 3].len();
 }",
        );
    }
@@ -511,7 +510,7 @@ fn foo() {
 }",
            r"
 fn foo() {
-    <|>let b = (10 + 20) * 10;
+    let b = (10 + 20) * 10;
    let c = (10 + 20) as usize;
 }",
        );
@@ -531,7 +530,7 @@ fn foo() {
            r"
 fn foo() {
    let d = 10;
-    <|>let b = d * 10;
+    let b = d * 10;
    let c = d as usize;
 }",
        );
@@ -549,7 +548,7 @@ fn foo() {
 }",
            r"
 fn foo() {
-    <|>let b = { 10 } * 10;
+    let b = { 10 } * 10;
    let c = { 10 } as usize;
 }",
        );
@@ -569,7 +568,7 @@ fn foo() {
 }",
            r"
 fn foo() {
-    <|>let b = (10 + 20) * 10;
+    let b = (10 + 20) * 10;
    let c = (10 + 20, 20);
    let d = [10 + 20, 10];
    let e = (10 + 20);
@@ -588,7 +587,7 @@ fn foo() {
 }",
            r"
 fn foo() {
-    <|>for i in vec![10, 20] {}
+    for i in vec![10, 20] {}
 }",
        );
    }
@@ -604,7 +603,7 @@ fn foo() {
 }",
            r"
 fn foo() {
-    <|>while 1 > 0 {}
+    while 1 > 0 {}
 }",
        );
    }
@@ -622,7 +621,7 @@ fn foo() {
 }",
            r"
 fn foo() {
-    <|>loop {
+    loop {
        break 1 + 1;
    }
 }",
@@ -640,7 +639,7 @@ fn foo() {
 }",
            r"
 fn foo() {
-    <|>return 1 > 0;
+    return 1 > 0;
 }",
        );
    }
@@ -656,14 +655,14 @@ fn foo() {
 }",
            r"
 fn foo() {
-    <|>match 1 > 0 {}
+    match 1 > 0 {}
 }",
        );
    }
    #[test]
    fn test_not_applicable_if_variable_unused() {
-        covers!(test_not_applicable_if_variable_unused);
+        mark::check!(test_not_applicable_if_variable_unused);
        check_assist_not_applicable(
            inline_local_variable,
            r"
@@ -676,7 +675,7 @@ fn foo() {
    #[test]
    fn not_applicable_outside_of_bind_pat() {
-        covers!(not_applicable_outside_of_bind_pat);
+        mark::check!(not_applicable_outside_of_bind_pat);
        check_assist_not_applicable(
            inline_local_variable,
            r"
diff --git a/crates/ra_assists/src/handlers/introduce_variable.rs b/crates/ra_assists/src/handlers/introduce_variable.rs
index eda9ac296..31d6539f7 100644
--- a/crates/ra_assists/src/handlers/introduce_variable.rs
+++ b/crates/ra_assists/src/handlers/introduce_variable.rs
@@ -4,12 +4,12 @@ use ra_syntax::{
        BLOCK_EXPR, BREAK_EXPR, COMMENT, LAMBDA_EXPR, LOOP_EXPR, MATCH_ARM, PATH_EXPR, RETURN_EXPR,
        WHITESPACE,
    },
-    SyntaxNode, TextSize,
+    SyntaxNode,
 };
 use stdx::format_to;
-use test_utils::tested_by;
+use test_utils::mark;
-use crate::{Assist, AssistCtx, AssistId};
+use crate::{AssistContext, AssistId, Assists};
 // Assist: introduce_variable
 //
@@ -23,17 +23,17 @@ use crate::{Assist, AssistCtx, AssistId};
 // ->
 // ```
 // fn main() {
-//     let var_name = (1 + 2);
+//     let $0var_name = (1 + 2);
 //     var_name * 4;
 // }
 // ```
-pub(crate) fn introduce_variable(ctx: AssistCtx) -> Option<Assist> {
+pub(crate) fn introduce_variable(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
    if ctx.frange.range.is_empty() {
        return None;
    }
    let node = ctx.covering_element();
    if node.kind() == COMMENT {
-        tested_by!(introduce_var_in_comment_is_not_applicable);
+        mark::hit!(introduce_var_in_comment_is_not_applicable);
        return None;
    }
    let expr = node.ancestors().find_map(valid_target_expr)?;
@@ -42,17 +42,17 @@ pub(crate) fn introduce_variable(ctx: AssistCtx) -> Option<Assist> {
    if indent.kind() != WHITESPACE {
        return None;
    }
-    ctx.add_assist(AssistId("introduce_variable"), "Extract into variable", move |edit| {
+    let target = expr.syntax().text_range();
+    acc.add(AssistId("introduce_variable"), "Extract into variable", target, move |edit| {
        let mut buf = String::new();
-        let cursor_offset = if wrap_in_block {
+        if wrap_in_block {
            buf.push_str("{ let var_name = ");
-            TextSize::of("{ let ")
        } else {
            buf.push_str("let var_name = ");
-            TextSize::of("let ")
        };
        format_to!(buf, "{}", expr.syntax());
        let full_stmt = ast::ExprStmt::cast(anchor_stmt.clone());
        let is_full_stmt = if let Some(expr_stmt) = &full_stmt {
            Some(expr.syntax().clone()) == expr_stmt.expr().map(|e| e.syntax().clone())
@@ -60,33 +60,47 @@ pub(crate) fn introduce_variable(ctx: AssistCtx) -> Option<Assist> {
            false
        };
        if is_full_stmt {
-            tested_by!(test_introduce_var_expr_stmt);
+            mark::hit!(test_introduce_var_expr_stmt);
            if full_stmt.unwrap().semicolon_token().is_none() {
                buf.push_str(";");
            }
-            edit.replace(expr.syntax().text_range(), buf);
+            let offset = expr.syntax().text_range();
-        } else {
+            match ctx.config.snippet_cap {
-            buf.push_str(";");
+                Some(cap) => {
+                    let snip = buf.replace("let var_name", "let $0var_name");
-            // We want to maintain the indent level,
+                    edit.replace_snippet(cap, offset, snip)
-            // but we do not want to duplicate possible
+                }
-            // extra newlines in the indent block
+                None => edit.replace(offset, buf),
-            let text = indent.text();
-            if text.starts_with('\n') {
-                buf.push_str("\n");
-                buf.push_str(text.trim_start_matches('\n'));
-            } else {
-                buf.push_str(text);
            }
+            return;
+        }
-            edit.target(expr.syntax().text_range());
+        buf.push_str(";");
-            edit.replace(expr.syntax().text_range(), "var_name".to_string());
-            edit.insert(anchor_stmt.text_range().start(), buf);
+        // We want to maintain the indent level,
-            if wrap_in_block {
+        // but we do not want to duplicate possible
-                edit.insert(anchor_stmt.text_range().end(), " }");
+        // extra newlines in the indent block
+        let text = indent.text();
+        if text.starts_with('\n') {
+            buf.push_str("\n");
+            buf.push_str(text.trim_start_matches('\n'));
+        } else {
+            buf.push_str(text);
+        }
+        edit.replace(expr.syntax().text_range(), "var_name".to_string());
+        let offset = anchor_stmt.text_range().start();
+        match ctx.config.snippet_cap {
+            Some(cap) => {
+                let snip = buf.replace("let var_name", "let $0var_name");
+                edit.insert_snippet(cap, offset, snip)
            }
+            None => edit.insert(offset, buf),
+        }
+        if wrap_in_block {
+            edit.insert(anchor_stmt.text_range().end(), " }");
        }
-        edit.set_cursor(anchor_stmt.text_range().start() + cursor_offset);
    })
 }
@@ -111,9 +125,9 @@ fn valid_target_expr(node: SyntaxNode) -> Option<ast::Expr> {
 /// expression like a lambda or match arm.
 fn anchor_stmt(expr: ast::Expr) -> Option<(SyntaxNode, bool)> {
    expr.syntax().ancestors().find_map(|node| {
-        if let Some(expr) = node.parent().and_then(ast::Block::cast).and_then(|it| it.expr()) {
+        if let Some(expr) = node.parent().and_then(ast::BlockExpr::cast).and_then(|it| it.expr()) {
            if expr.syntax() == &node {
-                tested_by!(test_introduce_var_last_expr);
+                mark::hit!(test_introduce_var_last_expr);
                return Some((node, false));
            }
        }
@@ -134,9 +148,9 @@ fn anchor_stmt(expr: ast::Expr) -> Option<(SyntaxNode, bool)> {
 #[cfg(test)]
 mod tests {
-    use test_utils::covers;
+    use test_utils::mark;
-    use crate::helpers::{check_assist, check_assist_not_applicable, check_assist_target};
+    use crate::tests::{check_assist, check_assist_not_applicable, check_assist_target};
    use super::*;
@@ -144,37 +158,37 @@ mod tests {
    fn test_introduce_var_simple() {
        check_assist(
            introduce_variable,
-            "
+            r#"
 fn foo() {
    foo(<|>1 + 1<|>);
-}",
+}"#,
-            "
+            r#"
 fn foo() {
-    let <|>var_name = 1 + 1;
+    let $0var_name = 1 + 1;
    foo(var_name);
-}",
+}"#,
        );
    }
    #[test]
    fn introduce_var_in_comment_is_not_applicable() {
-        covers!(introduce_var_in_comment_is_not_applicable);
+        mark::check!(introduce_var_in_comment_is_not_applicable);
        check_assist_not_applicable(introduce_variable, "fn main() { 1 + /* <|>comment<|> */ 1; }");
    }
    #[test]
    fn test_introduce_var_expr_stmt() {
-        covers!(test_introduce_var_expr_stmt);
+        mark::check!(test_introduce_var_expr_stmt);
        check_assist(
            introduce_variable,
-            "
+            r#"
 fn foo() {
    <|>1 + 1<|>;
-}",
+}"#,
-            "
+            r#"
 fn foo() {
-    let <|>var_name = 1 + 1;
+    let $0var_name = 1 + 1;
-}",
+}"#,
        );
        check_assist(
            introduce_variable,
@@ -185,7 +199,7 @@ fn foo() {
 }",
            "
 fn foo() {
-    let <|>var_name = { let x = 0; x };
+    let $0var_name = { let x = 0; x };
    something_else();
 }",
        );
@@ -201,7 +215,7 @@ fn foo() {
 }",
            "
 fn foo() {
-    let <|>var_name = 1;
+    let $0var_name = 1;
    var_name + 1;
 }",
        );
@@ -209,7 +223,7 @@ fn foo() {
    #[test]
    fn test_introduce_var_last_expr() {
-        covers!(test_introduce_var_last_expr);
+        mark::check!(test_introduce_var_last_expr);
        check_assist(
            introduce_variable,
            "
@@ -218,7 +232,7 @@ fn foo() {
 }",
            "
 fn foo() {
-    let <|>var_name = 1 + 1;
+    let $0var_name = 1 + 1;
    bar(var_name)
 }",
        );
@@ -230,7 +244,7 @@ fn foo() {
 }",
            "
 fn foo() {
-    let <|>var_name = bar(1 + 1);
+    let $0var_name = bar(1 + 1);
    var_name
 }",
        )
@@ -253,7 +267,7 @@ fn main() {
 fn main() {
    let x = true;
    let tuple = match x {
-        true => { let <|>var_name = 2 + 2; (var_name, true) }
+        true => { let $0var_name = 2 + 2; (var_name, true) }
        _ => (0, false)
    };
 }
@@ -283,7 +297,7 @@ fn main() {
    let tuple = match x {
        true => {
            let y = 1;
-            let <|>var_name = 2 + y;
+            let $0var_name = 2 + y;
            (var_name, true)
        }
        _ => (0, false)
@@ -304,7 +318,7 @@ fn main() {
 ",
            "
 fn main() {
-    let lambda = |x: u32| { let <|>var_name = x * 2; var_name };
+    let lambda = |x: u32| { let $0var_name = x * 2; var_name };
 }
 ",
        );
@@ -321,7 +335,7 @@ fn main() {
 ",
            "
 fn main() {
-    let lambda = |x: u32| { let <|>var_name = x * 2; var_name };
+    let lambda = |x: u32| { let $0var_name = x * 2; var_name };
 }
 ",
        );
@@ -338,7 +352,7 @@ fn main() {
 ",
            "
 fn main() {
-    let <|>var_name = Some(true);
+    let $0var_name = Some(true);
    let o = var_name;
 }
 ",
@@ -356,7 +370,7 @@ fn main() {
 ",
            "
 fn main() {
-    let <|>var_name = bar.foo();
+    let $0var_name = bar.foo();
    let v = var_name;
 }
 ",
@@ -374,7 +388,7 @@ fn foo() -> u32 {
 ",
            "
 fn foo() -> u32 {
-    let <|>var_name = 2 + 2;
+    let $0var_name = 2 + 2;
    return var_name;
 }
 ",
@@ -396,7 +410,7 @@ fn foo() -> u32 {
 fn foo() -> u32 {
-    let <|>var_name = 2 + 2;
+    let $0var_name = 2 + 2;
    return var_name;
 }
 ",
@@ -413,7 +427,7 @@ fn foo() -> u32 {
            "
 fn foo() -> u32 {
-        let <|>var_name = 2 + 2;
+        let $0var_name = 2 + 2;
        return var_name;
 }
 ",
@@ -438,7 +452,7 @@ fn foo() -> u32 {
    // bar
-    let <|>var_name = 2 + 2;
+    let $0var_name = 2 + 2;
    return var_name;
 }
 ",
@@ -459,7 +473,7 @@ fn main() {
            "
 fn main() {
    let result = loop {
-        let <|>var_name = 2 + 2;
+        let $0var_name = 2 + 2;
        break var_name;
    };
 }
@@ -478,7 +492,7 @@ fn main() {
 ",
            "
 fn main() {
-    let <|>var_name = 0f32 as u32;
+    let $0var_name = 0f32 as u32;
    let v = var_name;
 }
 ",
diff --git a/crates/ra_assists/src/handlers/invert_if.rs b/crates/ra_assists/src/handlers/invert_if.rs
index 682e08512..59d278eb9 100644
--- a/crates/ra_assists/src/handlers/invert_if.rs
+++ b/crates/ra_assists/src/handlers/invert_if.rs
@@ -3,7 +3,11 @@ use ra_syntax::{
    T,
 };
-use crate::{utils::invert_boolean_expression, Assist, AssistCtx, AssistId};
+use crate::{
+    assist_context::{AssistContext, Assists},
+    utils::invert_boolean_expression,
+    AssistId,
+};
 // Assist: invert_if
 //
@@ -24,7 +28,7 @@ use crate::{utils::invert_boolean_expression, Assist, AssistCtx, AssistId};
 // }
 // ```
-pub(crate) fn invert_if(ctx: AssistCtx) -> Option<Assist> {
+pub(crate) fn invert_if(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
    let if_keyword = ctx.find_token_at_offset(T![if])?;
    let expr = ast::IfExpr::cast(if_keyword.parent())?;
    let if_range = if_keyword.text_range();
@@ -40,36 +44,35 @@ pub(crate) fn invert_if(ctx: AssistCtx) -> Option<Assist> {
    let cond = expr.condition()?.expr()?;
    let then_node = expr.then_branch()?.syntax().clone();
+    let else_block = match expr.else_branch()? {
+        ast::ElseBranch::Block(it) => it,
+        ast::ElseBranch::IfExpr(_) => return None,
+    };
-    if let ast::ElseBranch::Block(else_block) = expr.else_branch()? {
+    let cond_range = cond.syntax().text_range();
-        let cond_range = cond.syntax().text_range();
+    let flip_cond = invert_boolean_expression(cond);
-        let flip_cond = invert_boolean_expression(cond);
+    let else_node = else_block.syntax();
-        let else_node = else_block.syntax();
+    let else_range = else_node.text_range();
-        let else_range = else_node.text_range();
+    let then_range = then_node.text_range();
-        let then_range = then_node.text_range();
+    acc.add(AssistId("invert_if"), "Invert if", if_range, |edit| {
-        return ctx.add_assist(AssistId("invert_if"), "Invert if", |edit| {
+        edit.replace(cond_range, flip_cond.syntax().text());
-            edit.target(if_range);
+        edit.replace(else_range, then_node.text());
-            edit.replace(cond_range, flip_cond.syntax().text());
+        edit.replace(then_range, else_node.text());
-            edit.replace(else_range, then_node.text());
+    })
-            edit.replace(then_range, else_node.text());
-        });
-    }
-    None
 }
 #[cfg(test)]
 mod tests {
    use super::*;
-    use crate::helpers::{check_assist, check_assist_not_applicable};
+    use crate::tests::{check_assist, check_assist_not_applicable};
    #[test]
    fn invert_if_remove_inequality() {
        check_assist(
            invert_if,
            "fn f() { i<|>f x != 3 { 1 } else { 3 + 2 } }",
-            "fn f() { i<|>f x == 3 { 3 + 2 } else { 1 } }",
+            "fn f() { if x == 3 { 3 + 2 } else { 1 } }",
        )
    }
@@ -78,7 +81,7 @@ mod tests {
        check_assist(
            invert_if,
            "fn f() { <|>if !cond { 3 * 2 } else { 1 } }",
-            "fn f() { <|>if cond { 1 } else { 3 * 2 } }",
+            "fn f() { if cond { 1 } else { 3 * 2 } }",
        )
    }
@@ -87,7 +90,7 @@ mod tests {
        check_assist(
            invert_if,
            "fn f() { i<|>f cond { 3 * 2 } else { 1 } }",
-            "fn f() { i<|>f !cond { 1 } else { 3 * 2 } }",
+            "fn f() { if !cond { 1 } else { 3 * 2 } }",
        )
    }
diff --git a/crates/ra_assists/src/handlers/merge_imports.rs b/crates/ra_assists/src/handlers/merge_imports.rs
index 4be1238f1..972d16241 100644
--- a/crates/ra_assists/src/handlers/merge_imports.rs
+++ b/crates/ra_assists/src/handlers/merge_imports.rs
@@ -6,7 +6,10 @@ use ra_syntax::{
    AstNode, Direction, InsertPosition, SyntaxElement, T,
 };
-use crate::{Assist, AssistCtx, AssistId};
+use crate::{
+    assist_context::{AssistContext, Assists},
+    AssistId,
+};
 // Assist: merge_imports
 //
@@ -20,10 +23,10 @@ use crate::{Assist, AssistCtx, AssistId};
 // ```
 // use std::{fmt::Formatter, io};
 // ```
-pub(crate) fn merge_imports(ctx: AssistCtx) -> Option<Assist> {
+pub(crate) fn merge_imports(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
    let tree: ast::UseTree = ctx.find_node_at_offset()?;
    let mut rewriter = SyntaxRewriter::default();
-    let mut offset = ctx.frange.range.start();
+    let mut offset = ctx.offset();
    if let Some(use_item) = tree.syntax().parent().and_then(ast::UseItem::cast) {
        let (merged, to_delete) = next_prev()
@@ -52,10 +55,9 @@ pub(crate) fn merge_imports(ctx: AssistCtx) -> Option<Assist> {
        }
    };
-    ctx.add_assist(AssistId("merge_imports"), "Merge imports", |edit| {
+    let target = tree.syntax().text_range();
-        edit.rewrite(rewriter);
+    acc.add(AssistId("merge_imports"), "Merge imports", target, |builder| {
-        // FIXME: we only need because our diff is imprecise
+        builder.rewrite(rewriter);
-        edit.set_cursor(offset);
    })
 }
@@ -125,7 +127,7 @@ fn first_path(path: &ast::Path) -> ast::Path {
 #[cfg(test)]
 mod tests {
-    use crate::helpers::check_assist;
+    use crate::tests::check_assist;
    use super::*;
@@ -138,7 +140,7 @@ use std::fmt<|>::Debug;
 use std::fmt::Display;
 ",
            r"
-use std::fmt<|>::{Debug, Display};
+use std::fmt::{Debug, Display};
 ",
        )
    }
@@ -152,7 +154,7 @@ use std::fmt::Debug;
 use std::fmt<|>::Display;
 ",
            r"
-use std::fmt:<|>:{Display, Debug};
+use std::fmt::{Display, Debug};
 ",
        );
    }
@@ -165,7 +167,7 @@ use std::fmt:<|>:{Display, Debug};
 use std::{fmt<|>::Debug, fmt::Display};
 ",
            r"
-use std::{fmt<|>::{Debug, Display}};
+use std::{fmt::{Debug, Display}};
 ",
        );
        check_assist(
@@ -174,7 +176,7 @@ use std::{fmt<|>::{Debug, Display}};
 use std::{fmt::Debug, fmt<|>::Display};
 ",
            r"
-use std::{fmt::<|>{Display, Debug}};
+use std::{fmt::{Display, Debug}};
 ",
        );
    }
@@ -188,7 +190,7 @@ use std<|>::cell::*;
 use std::str;
 ",
            r"
-use std<|>::{cell::*, str};
+use std::{cell::*, str};
 ",
        )
    }
@@ -202,7 +204,7 @@ use std<|>::cell::*;
 use std::str::*;
 ",
            r"
-use std<|>::{cell::*, str::*};
+use std::{cell::*, str::*};
 ",
        )
    }
@@ -218,7 +220,7 @@ use foo::baz;
 /// Doc comment
 ",
            r"
-use foo<|>::{bar, baz};
+use foo::{bar, baz};
 /// Doc comment
 ",
@@ -237,7 +239,7 @@ use {
 ",
            r"
 use {
-    foo<|>::{bar, baz},
+    foo::{bar, baz},
 };
 ",
        );
@@ -251,7 +253,7 @@ use {
 ",
            r"
 use {
-    foo::{bar<|>, baz},
+    foo::{bar, baz},
 };
 ",
        );
@@ -268,7 +270,7 @@ use foo::<|>{
 };
 ",
            r"
-use foo::{<|>
+use foo::{
    FooBar,
 bar::baz};
 ",
diff --git a/crates/ra_assists/src/handlers/merge_match_arms.rs b/crates/ra_assists/src/handlers/merge_match_arms.rs
index 5a77d3dbc..ca04ec671 100644
--- a/crates/ra_assists/src/handlers/merge_match_arms.rs
+++ b/crates/ra_assists/src/handlers/merge_match_arms.rs
@@ -3,10 +3,10 @@ use std::iter::successors;
 use ra_syntax::{
    algo::neighbor,
    ast::{self, AstNode},
-    Direction, TextSize,
+    Direction,
 };
-use crate::{Assist, AssistCtx, AssistId, TextRange};
+use crate::{AssistContext, AssistId, Assists, TextRange};
 // Assist: merge_match_arms
 //
@@ -32,7 +32,7 @@ use crate::{Assist, AssistCtx, AssistId, TextRange};
 //     }
 // }
 // ```
-pub(crate) fn merge_match_arms(ctx: AssistCtx) -> Option<Assist> {
+pub(crate) fn merge_match_arms(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
    let current_arm = ctx.find_node_at_offset::<ast::MatchArm>()?;
    // Don't try to handle arms with guards for now - can add support for this later
    if current_arm.guard().is_some() {
@@ -41,17 +41,6 @@ pub(crate) fn merge_match_arms(ctx: AssistCtx) -> Option<Assist> {
    let current_expr = current_arm.expr()?;
    let current_text_range = current_arm.syntax().text_range();
-    enum CursorPos {
-        InExpr(TextSize),
-        InPat(TextSize),
-    }
-    let cursor_pos = ctx.frange.range.start();
-    let cursor_pos = if current_expr.syntax().text_range().contains(cursor_pos) {
-        CursorPos::InExpr(current_text_range.end() - cursor_pos)
-    } else {
-        CursorPos::InPat(cursor_pos)
-    };
    // We check if the following match arms match this one. We could, but don't,
    // compare to the previous match arm as well.
    let arms_to_merge = successors(Some(current_arm), |it| neighbor(it, Direction::Next))
@@ -70,7 +59,7 @@ pub(crate) fn merge_match_arms(ctx: AssistCtx) -> Option<Assist> {
        return None;
    }
-    ctx.add_assist(AssistId("merge_match_arms"), "Merge match arms", |edit| {
+    acc.add(AssistId("merge_match_arms"), "Merge match arms", current_text_range, |edit| {
        let pats = if arms_to_merge.iter().any(contains_placeholder) {
            "_".into()
        } else {
@@ -87,11 +76,6 @@ pub(crate) fn merge_match_arms(ctx: AssistCtx) -> Option<Assist> {
        let start = arms_to_merge.first().unwrap().syntax().text_range().start();
        let end = arms_to_merge.last().unwrap().syntax().text_range().end();
-        edit.target(current_text_range);
-        edit.set_cursor(match cursor_pos {
-            CursorPos::InExpr(back_offset) => start + TextSize::of(&arm) - back_offset,
-            CursorPos::InPat(offset) => offset,
-        });
        edit.replace(TextRange::new(start, end), arm);
    })
 }
@@ -105,7 +89,7 @@ fn contains_placeholder(a: &ast::MatchArm) -> bool {
 #[cfg(test)]
 mod tests {
-    use crate::helpers::{check_assist, check_assist_not_applicable};
+    use crate::tests::{check_assist, check_assist_not_applicable};
    use super::*;
@@ -133,7 +117,7 @@ mod tests {
            fn main() {
                let x = X::A;
                let y = match x {
-                    X::A | X::B => { 1i32<|> }
+                    X::A | X::B => { 1i32 }
                    X::C => { 2i32 }
                }
            }
@@ -165,7 +149,7 @@ mod tests {
            fn main() {
                let x = X::A;
                let y = match x {
-                    X::A | X::B | X::C | X::D => {<|> 1i32 },
+                    X::A | X::B | X::C | X::D => { 1i32 },
                    X::E => { 2i32 },
                }
            }
@@ -198,7 +182,7 @@ mod tests {
                let x = X::A;
                let y = match x {
                    X::A => { 1i32 },
-                    _ => { 2i<|>32 }
+                    _ => { 2i32 }
                }
            }
            "#,
@@ -227,7 +211,7 @@ mod tests {
            fn main() {
                match X::A {
-                    X::A<|> | X::B | X::C => 92,
+                    X::A | X::B | X::C => 92,
                    X::D => 62,
                    _ => panic!(),
                }
diff --git a/crates/ra_assists/src/handlers/move_bounds.rs b/crates/ra_assists/src/handlers/move_bounds.rs
index 0f26884dc..be2a7eddc 100644
--- a/crates/ra_assists/src/handlers/move_bounds.rs
+++ b/crates/ra_assists/src/handlers/move_bounds.rs
@@ -5,7 +5,7 @@ use ra_syntax::{
    T,
 };
-use crate::{Assist, AssistCtx, AssistId};
+use crate::{AssistContext, AssistId, Assists};
 // Assist: move_bounds_to_where_clause
 //
@@ -22,7 +22,7 @@ use crate::{Assist, AssistCtx, AssistId};
 //     f(x)
 // }
 // ```
-pub(crate) fn move_bounds_to_where_clause(ctx: AssistCtx) -> Option<Assist> {
+pub(crate) fn move_bounds_to_where_clause(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
    let type_param_list = ctx.find_node_at_offset::<ast::TypeParamList>()?;
    let mut type_params = type_param_list.type_params();
@@ -49,7 +49,8 @@ pub(crate) fn move_bounds_to_where_clause(ctx: AssistCtx) -> Option<Assist> {
        }
    };
-    ctx.add_assist(AssistId("move_bounds_to_where_clause"), "Move to where clause", |edit| {
+    let target = type_param_list.syntax().text_range();
+    acc.add(AssistId("move_bounds_to_where_clause"), "Move to where clause", target, |edit| {
        let new_params = type_param_list
            .type_params()
            .filter(|it| it.type_bound_list().is_some())
@@ -71,7 +72,6 @@ pub(crate) fn move_bounds_to_where_clause(ctx: AssistCtx) -> Option<Assist> {
            _ => format!(" {}", where_clause.syntax()),
        };
        edit.insert(anchor.text_range().start(), to_insert);
-        edit.target(type_param_list.syntax().text_range());
    })
 }
@@ -89,7 +89,7 @@ fn build_predicate(param: ast::TypeParam) -> Option<ast::WherePred> {
 mod tests {
    use super::*;
-    use crate::helpers::check_assist;
+    use crate::tests::check_assist;
    #[test]
    fn move_bounds_to_where_clause_fn() {
@@ -99,7 +99,7 @@ mod tests {
            fn foo<T: u32, <|>F: FnOnce(T) -> T>() {}
            "#,
            r#"
-            fn foo<T, <|>F>() where T: u32, F: FnOnce(T) -> T {}
+            fn foo<T, F>() where T: u32, F: FnOnce(T) -> T {}
            "#,
        );
    }
@@ -112,7 +112,7 @@ mod tests {
            impl<U: u32, <|>T> A<U, T> {}
            "#,
            r#"
-            impl<U, <|>T> A<U, T> where U: u32 {}
+            impl<U, T> A<U, T> where U: u32 {}
            "#,
        );
    }
@@ -125,7 +125,7 @@ mod tests {
            struct A<<|>T: Iterator<Item = u32>> {}
            "#,
            r#"
-            struct A<<|>T> where T: Iterator<Item = u32> {}
+            struct A<T> where T: Iterator<Item = u32> {}
            "#,
        );
    }
@@ -138,7 +138,7 @@ mod tests {
            struct Pair<<|>T: u32>(T, T);
            "#,
            r#"
-            struct Pair<<|>T>(T, T) where T: u32;
+            struct Pair<T>(T, T) where T: u32;
            "#,
        );
    }
diff --git a/crates/ra_assists/src/handlers/move_guard.rs b/crates/ra_assists/src/handlers/move_guard.rs
index d5ccdd91c..7edcf0748 100644
--- a/crates/ra_assists/src/handlers/move_guard.rs
+++ b/crates/ra_assists/src/handlers/move_guard.rs
@@ -1,10 +1,9 @@
 use ra_syntax::{
-    ast,
+    ast::{AstNode, IfExpr, MatchArm},
-    ast::{AstNode, AstToken, IfExpr, MatchArm},
+    SyntaxKind::WHITESPACE,
-    TextSize,
 };
-use crate::{Assist, AssistCtx, AssistId};
+use crate::{AssistContext, AssistId, Assists};
 // Assist: move_guard_to_arm_body
 //
@@ -31,7 +30,7 @@ use crate::{Assist, AssistCtx, AssistId};
 //     }
 // }
 // ```
-pub(crate) fn move_guard_to_arm_body(ctx: AssistCtx) -> Option<Assist> {
+pub(crate) fn move_guard_to_arm_body(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
    let match_arm = ctx.find_node_at_offset::<MatchArm>()?;
    let guard = match_arm.guard()?;
    let space_before_guard = guard.syntax().prev_sibling_or_token();
@@ -40,26 +39,17 @@ pub(crate) fn move_guard_to_arm_body(ctx: AssistCtx) -> Option<Assist> {
    let arm_expr = match_arm.expr()?;
    let buf = format!("if {} {{ {} }}", guard_conditions.syntax().text(), arm_expr.syntax().text());
-    ctx.add_assist(AssistId("move_guard_to_arm_body"), "Move guard to arm body", |edit| {
+    let target = guard.syntax().text_range();
-        edit.target(guard.syntax().text_range());
+    acc.add(AssistId("move_guard_to_arm_body"), "Move guard to arm body", target, |edit| {
-        let offseting_amount = match space_before_guard.and_then(|it| it.into_token()) {
+        match space_before_guard {
-            Some(tok) => {
+            Some(element) if element.kind() == WHITESPACE => {
-                if ast::Whitespace::cast(tok.clone()).is_some() {
+                edit.delete(element.text_range());
-                    let ele = tok.text_range();
-                    edit.delete(ele);
-                    ele.len()
-                } else {
-                    TextSize::from(0)
-                }
            }
-            _ => TextSize::from(0),
+            _ => (),
        };
        edit.delete(guard.syntax().text_range());
        edit.replace_node_and_indent(arm_expr.syntax(), buf);
-        edit.set_cursor(
-            arm_expr.syntax().text_range().start() + TextSize::from(3) - offseting_amount,
-        );
    })
 }
@@ -88,7 +78,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> {
+pub(crate) fn move_arm_cond_to_match_guard(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
    let match_arm: MatchArm = ctx.find_node_at_offset::<MatchArm>()?;
    let match_pat = match_arm.pat()?;
@@ -108,14 +98,15 @@ pub(crate) fn move_arm_cond_to_match_guard(ctx: AssistCtx) -> Option<Assist> {
    let buf = format!(" if {}", cond.syntax().text());
-    ctx.add_assist(
+    let target = if_expr.syntax().text_range();
+    acc.add(
        AssistId("move_arm_cond_to_match_guard"),
        "Move condition to match guard",
+        target,
        |edit| {
-            edit.target(if_expr.syntax().text_range());
+            let then_only_expr = then_block.statements().next().is_none();
-            let then_only_expr = then_block.block().and_then(|it| it.statements().next()).is_none();
-            match &then_block.block().and_then(|it| it.expr()) {
+            match &then_block.expr() {
                Some(then_expr) if then_only_expr => {
                    edit.replace(if_expr.syntax().text_range(), then_expr.syntax().text())
                }
@@ -123,7 +114,6 @@ pub(crate) fn move_arm_cond_to_match_guard(ctx: AssistCtx) -> Option<Assist> {
            }
            edit.insert(match_pat.syntax().text_range().end(), buf);
-            edit.set_cursor(match_pat.syntax().text_range().end() + TextSize::from(1));
        },
    )
 }
@@ -132,7 +122,7 @@ pub(crate) fn move_arm_cond_to_match_guard(ctx: AssistCtx) -> Option<Assist> {
 mod tests {
    use super::*;
-    use crate::helpers::{check_assist, check_assist_not_applicable, check_assist_target};
+    use crate::tests::{check_assist, check_assist_not_applicable, check_assist_target};
    #[test]
    fn move_guard_to_arm_body_target() {
@@ -171,7 +161,7 @@ mod tests {
                let t = 'a';
                let chars = "abcd";
                match t {
-                    '\r' => if chars.clone().next() == Some('\n') { <|>false },
+                    '\r' => if chars.clone().next() == Some('\n') { false },
                    _ => true
                }
            }
@@ -194,7 +184,7 @@ mod tests {
            r#"
            fn f() {
                match x {
-                    y @ 4 | y @ 5 => if y > 5 { <|>true },
+                    y @ 4 | y @ 5 => if y > 5 { true },
                    _ => false
                }
            }
@@ -221,7 +211,7 @@ mod tests {
                let t = 'a';
                let chars = "abcd";
                match t {
-                    '\r' <|>if chars.clone().next() == Some('\n') => false,
+                    '\r' if chars.clone().next() == Some('\n') => false,
                    _ => true
                }
            }
@@ -265,7 +255,7 @@ mod tests {
                let t = 'a';
                let chars = "abcd";
                match t {
-                    '\r' <|>if chars.clone().next().is_some() => {  },
+                    '\r' if chars.clone().next().is_some() => {  },
                    _ => true
                }
            }
@@ -295,7 +285,7 @@ mod tests {
                let mut t = 'a';
                let chars = "abcd";
                match t {
-                    '\r' <|>if chars.clone().next().is_some() => {
+                    '\r' if chars.clone().next().is_some() => {
                        t = 'e';
                        false
                    },
diff --git a/crates/ra_assists/src/handlers/raw_string.rs b/crates/ra_assists/src/handlers/raw_string.rs
index 567400b9c..16002d2ac 100644
--- a/crates/ra_assists/src/handlers/raw_string.rs
+++ b/crates/ra_assists/src/handlers/raw_string.rs
@@ -5,7 +5,7 @@ use ra_syntax::{
    TextSize,
 };
-use crate::{Assist, AssistCtx, AssistId};
+use crate::{AssistContext, AssistId, Assists};
 // Assist: make_raw_string
 //
@@ -22,11 +22,11 @@ use crate::{Assist, AssistCtx, AssistId};
 //     r#"Hello, World!"#;
 // }
 // ```
-pub(crate) fn make_raw_string(ctx: AssistCtx) -> Option<Assist> {
+pub(crate) fn make_raw_string(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
    let token = ctx.find_token_at_offset(STRING).and_then(ast::String::cast)?;
    let value = token.value()?;
-    ctx.add_assist(AssistId("make_raw_string"), "Rewrite as raw string", |edit| {
+    let target = token.syntax().text_range();
-        edit.target(token.syntax().text_range());
+    acc.add(AssistId("make_raw_string"), "Rewrite as raw string", target, |edit| {
        let max_hash_streak = count_hashes(&value);
        let mut hashes = String::with_capacity(max_hash_streak + 1);
        for _ in 0..hashes.capacity() {
@@ -51,11 +51,11 @@ pub(crate) fn make_raw_string(ctx: AssistCtx) -> Option<Assist> {
 //     "Hello, \"World!\"";
 // }
 // ```
-pub(crate) fn make_usual_string(ctx: AssistCtx) -> Option<Assist> {
+pub(crate) fn make_usual_string(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
    let token = ctx.find_token_at_offset(RAW_STRING).and_then(ast::RawString::cast)?;
    let value = token.value()?;
-    ctx.add_assist(AssistId("make_usual_string"), "Rewrite as regular string", |edit| {
+    let target = token.syntax().text_range();
-        edit.target(token.syntax().text_range());
+    acc.add(AssistId("make_usual_string"), "Rewrite as regular string", target, |edit| {
        // parse inside string to escape `"`
        let escaped = value.escape_default().to_string();
        edit.replace(token.syntax().text_range(), format!("\"{}\"", escaped));
@@ -77,10 +77,10 @@ pub(crate) fn make_usual_string(ctx: AssistCtx) -> Option<Assist> {
 //     r##"Hello, World!"##;
 // }
 // ```
-pub(crate) fn add_hash(ctx: AssistCtx) -> Option<Assist> {
+pub(crate) fn add_hash(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
    let token = ctx.find_token_at_offset(RAW_STRING)?;
-    ctx.add_assist(AssistId("add_hash"), "Add # to raw string", |edit| {
+    let target = token.text_range();
-        edit.target(token.text_range());
+    acc.add(AssistId("add_hash"), "Add # to raw string", target, |edit| {
        edit.insert(token.text_range().start() + TextSize::of('r'), "#");
        edit.insert(token.text_range().end(), "#");
    })
@@ -101,15 +101,15 @@ pub(crate) fn add_hash(ctx: AssistCtx) -> Option<Assist> {
 //     r"Hello, World!";
 // }
 // ```
-pub(crate) fn remove_hash(ctx: AssistCtx) -> Option<Assist> {
+pub(crate) fn remove_hash(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
    let token = ctx.find_token_at_offset(RAW_STRING)?;
    let text = token.text().as_str();
    if text.starts_with("r\"") {
        // no hash to remove
        return None;
    }
-    ctx.add_assist(AssistId("remove_hash"), "Remove hash from raw string", |edit| {
+    let target = token.text_range();
-        edit.target(token.text_range());
+    acc.add(AssistId("remove_hash"), "Remove hash from raw string", target, |edit| {
        let result = &text[2..text.len() - 1];
        let result = if result.starts_with('\"') {
            // FIXME: this logic is wrong, not only the last has has to handled specially
@@ -138,7 +138,7 @@ fn count_hashes(s: &str) -> usize {
 #[cfg(test)]
 mod test {
    use super::*;
-    use crate::helpers::{check_assist, check_assist_not_applicable, check_assist_target};
+    use crate::tests::{check_assist, check_assist_not_applicable, check_assist_target};
    #[test]
    fn make_raw_string_target() {
@@ -164,7 +164,7 @@ mod test {
            "#,
            r##"
            fn f() {
-                let s = <|>r#"random
+                let s = r#"random
 string"#;
            }
            "##,
@@ -182,7 +182,7 @@ string"#;
            "#,
            r##"
            fn f() {
-                format!(<|>r#"x = {}"#, 92)
+                format!(r#"x = {}"#, 92)
            }
            "##,
        )
@@ -199,7 +199,7 @@ string"#;
            "###,
            r####"
            fn f() {
-                let s = <|>r#"#random##
+                let s = r#"#random##
 string"#;
            }
            "####,
@@ -217,7 +217,7 @@ string"#;
            "###,
            r####"
            fn f() {
-                let s = <|>r###"#random"##
+                let s = r###"#random"##
 string"###;
            }
            "####,
@@ -235,7 +235,7 @@ string"###;
            "#,
            r##"
            fn f() {
-                let s = <|>r#"random string"#;
+                let s = r#"random string"#;
            }
            "##,
        )
@@ -289,7 +289,7 @@ string"###;
            "#,
            r##"
            fn f() {
-                let s = <|>r#"random string"#;
+                let s = r#"random string"#;
            }
            "##,
        )
@@ -306,7 +306,7 @@ string"###;
            "##,
            r###"
            fn f() {
-                let s = <|>r##"random"string"##;
+                let s = r##"random"string"##;
            }
            "###,
        )
@@ -348,7 +348,7 @@ string"###;
            "##,
            r#"
            fn f() {
-                let s = <|>r"random string";
+                let s = r"random string";
            }
            "#,
        )
@@ -365,7 +365,7 @@ string"###;
            "##,
            r#"
            fn f() {
-                let s = <|>r"random\"str\"ing";
+                let s = r"random\"str\"ing";
            }
            "#,
        )
@@ -382,7 +382,7 @@ string"###;
            "###,
            r##"
            fn f() {
-                let s = <|>r#"random string"#;
+                let s = r#"random string"#;
            }
            "##,
        )
@@ -436,7 +436,7 @@ string"###;
            "##,
            r#"
            fn f() {
-                let s = <|>"random string";
+                let s = "random string";
            }
            "#,
        )
@@ -453,7 +453,7 @@ string"###;
            "##,
            r#"
            fn f() {
-                let s = <|>"random\"str\"ing";
+                let s = "random\"str\"ing";
            }
            "#,
        )
@@ -470,7 +470,7 @@ string"###;
            "###,
            r##"
            fn f() {
-                let s = <|>"random string";
+                let s = "random string";
            }
            "##,
        )
diff --git a/crates/ra_assists/src/handlers/remove_dbg.rs b/crates/ra_assists/src/handlers/remove_dbg.rs
index 4e5eb4350..961ee1731 100644
--- a/crates/ra_assists/src/handlers/remove_dbg.rs
+++ b/crates/ra_assists/src/handlers/remove_dbg.rs
@@ -3,7 +3,7 @@ use ra_syntax::{
    TextSize, T,
 };
-use crate::{Assist, AssistCtx, AssistId};
+use crate::{AssistContext, AssistId, Assists};
 // Assist: remove_dbg
 //
@@ -20,7 +20,7 @@ use crate::{Assist, AssistCtx, AssistId};
 //     92;
 // }
 // ```
-pub(crate) fn remove_dbg(ctx: AssistCtx) -> Option<Assist> {
+pub(crate) fn remove_dbg(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
    let macro_call = ctx.find_node_at_offset::<ast::MacroCall>()?;
    if !is_valid_macrocall(&macro_call, "dbg")? {
@@ -29,26 +29,6 @@ pub(crate) fn remove_dbg(ctx: AssistCtx) -> Option<Assist> {
    let macro_range = macro_call.syntax().text_range();
-    // If the cursor is inside the macro call, we'll try to maintain the cursor
-    // position by subtracting the length of dbg!( from the start of the file
-    // range, otherwise we'll default to using the start of the macro call
-    let cursor_pos = {
-        let file_range = ctx.frange.range;
-        let offset_start = file_range
-            .start()
-            .checked_sub(macro_range.start())
-            .unwrap_or_else(|| TextSize::from(0));
-        let dbg_size = TextSize::of("dbg!(");
-        if offset_start > dbg_size {
-            file_range.start() - dbg_size
-        } else {
-            macro_range.start()
-        }
-    };
    let macro_content = {
        let macro_args = macro_call.token_tree()?.syntax().clone();
@@ -57,10 +37,9 @@ pub(crate) fn remove_dbg(ctx: AssistCtx) -> Option<Assist> {
        text.slice(without_parens).to_string()
    };
-    ctx.add_assist(AssistId("remove_dbg"), "Remove dbg!()", |edit| {
+    let target = macro_call.syntax().text_range();
-        edit.target(macro_call.syntax().text_range());
+    acc.add(AssistId("remove_dbg"), "Remove dbg!()", target, |builder| {
-        edit.replace(macro_range, macro_content);
+        builder.replace(macro_range, macro_content);
-        edit.set_cursor(cursor_pos);
    })
 }
@@ -90,17 +69,17 @@ fn is_valid_macrocall(macro_call: &ast::MacroCall, macro_name: &str) -> Option<b
 #[cfg(test)]
 mod tests {
    use super::*;
-    use crate::helpers::{check_assist, check_assist_not_applicable, check_assist_target};
+    use crate::tests::{check_assist, check_assist_not_applicable, check_assist_target};
    #[test]
    fn test_remove_dbg() {
-        check_assist(remove_dbg, "<|>dbg!(1 + 1)", "<|>1 + 1");
+        check_assist(remove_dbg, "<|>dbg!(1 + 1)", "1 + 1");
-        check_assist(remove_dbg, "dbg!<|>((1 + 1))", "<|>(1 + 1)");
+        check_assist(remove_dbg, "dbg!<|>((1 + 1))", "(1 + 1)");
-        check_assist(remove_dbg, "dbg!(1 <|>+ 1)", "1 <|>+ 1");
+        check_assist(remove_dbg, "dbg!(1 <|>+ 1)", "1 + 1");
-        check_assist(remove_dbg, "let _ = <|>dbg!(1 + 1)", "let _ = <|>1 + 1");
+        check_assist(remove_dbg, "let _ = <|>dbg!(1 + 1)", "let _ = 1 + 1");
        check_assist(
            remove_dbg,
@@ -113,7 +92,7 @@ fn foo(n: usize) {
 ",
            "
 fn foo(n: usize) {
-    if let Some(_) = n.<|>checked_sub(4) {
+    if let Some(_) = n.checked_sub(4) {
        // ...
    }
 }
@@ -122,8 +101,8 @@ fn foo(n: usize) {
    }
    #[test]
    fn test_remove_dbg_with_brackets_and_braces() {
-        check_assist(remove_dbg, "dbg![<|>1 + 1]", "<|>1 + 1");
+        check_assist(remove_dbg, "dbg![<|>1 + 1]", "1 + 1");
-        check_assist(remove_dbg, "dbg!{<|>1 + 1}", "<|>1 + 1");
+        check_assist(remove_dbg, "dbg!{<|>1 + 1}", "1 + 1");
    }
    #[test]
diff --git a/crates/ra_assists/src/handlers/remove_mut.rs b/crates/ra_assists/src/handlers/remove_mut.rs
index e598023b2..fe4eada03 100644
--- a/crates/ra_assists/src/handlers/remove_mut.rs
+++ b/crates/ra_assists/src/handlers/remove_mut.rs
@@ -1,6 +1,6 @@
 use ra_syntax::{SyntaxKind, TextRange, T};
-use crate::{Assist, AssistCtx, AssistId};
+use crate::{AssistContext, AssistId, Assists};
 // Assist: remove_mut
 //
@@ -17,7 +17,7 @@ use crate::{Assist, AssistCtx, AssistId};
 //     fn feed(&self, amount: u32) {}
 // }
 // ```
-pub(crate) fn remove_mut(ctx: AssistCtx) -> Option<Assist> {
+pub(crate) fn remove_mut(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
    let mut_token = ctx.find_token_at_offset(T![mut])?;
    let delete_from = mut_token.text_range().start();
    let delete_to = match mut_token.next_token() {
@@ -25,8 +25,8 @@ pub(crate) fn remove_mut(ctx: AssistCtx) -> Option<Assist> {
        _ => mut_token.text_range().end(),
    };
-    ctx.add_assist(AssistId("remove_mut"), "Remove `mut` keyword", |edit| {
+    let target = mut_token.text_range();
-        edit.set_cursor(delete_from);
+    acc.add(AssistId("remove_mut"), "Remove `mut` keyword", target, |builder| {
-        edit.delete(TextRange::new(delete_from, delete_to));
+        builder.delete(TextRange::new(delete_from, delete_to));
    })
 }
diff --git a/crates/ra_assists/src/handlers/reorder_fields.rs b/crates/ra_assists/src/handlers/reorder_fields.rs
index 5cbb98d73..30229edc2 100644
--- a/crates/ra_assists/src/handlers/reorder_fields.rs
+++ b/crates/ra_assists/src/handlers/reorder_fields.rs
@@ -3,18 +3,9 @@ use std::collections::HashMap;
 use hir::{Adt, ModuleDef, PathResolution, Semantics, Struct};
 use itertools::Itertools;
 use ra_ide_db::RootDatabase;
-use ra_syntax::{
+use ra_syntax::{algo, ast, match_ast, AstNode, SyntaxKind, SyntaxKind::*, SyntaxNode};
-    algo,
-    ast::{self, Path, RecordLit, RecordPat},
+use crate::{AssistContext, AssistId, Assists};
-    match_ast, AstNode, SyntaxKind,
-    SyntaxKind::*,
-    SyntaxNode,
-};
-use crate::{
-    assist_ctx::{Assist, AssistCtx},
-    AssistId,
-};
 // Assist: reorder_fields
 //
@@ -31,13 +22,13 @@ use crate::{
 // const test: Foo = Foo {foo: 1, bar: 0}
 // ```
 //
-pub(crate) fn reorder_fields(ctx: AssistCtx) -> Option<Assist> {
+pub(crate) fn reorder_fields(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
-    reorder::<RecordLit>(ctx.clone()).or_else(|| reorder::<RecordPat>(ctx))
+    reorder::<ast::RecordLit>(acc, ctx.clone()).or_else(|| reorder::<ast::RecordPat>(acc, ctx))
 }
-fn reorder<R: AstNode>(ctx: AssistCtx) -> Option<Assist> {
+fn reorder<R: AstNode>(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
    let record = ctx.find_node_at_offset::<R>()?;
-    let path = record.syntax().children().find_map(Path::cast)?;
+    let path = record.syntax().children().find_map(ast::Path::cast)?;
    let ranks = compute_fields_ranks(&path, &ctx)?;
@@ -50,11 +41,11 @@ fn reorder<R: AstNode>(ctx: AssistCtx) -> Option<Assist> {
        return None;
    }
-    ctx.add_assist(AssistId("reorder_fields"), "Reorder record fields", |edit| {
+    let target = record.syntax().text_range();
+    acc.add(AssistId("reorder_fields"), "Reorder record fields", target, |edit| {
        for (old, new) in fields.iter().zip(&sorted_fields) {
            algo::diff(old, new).into_text_edit(edit.text_edit_builder());
        }
-        edit.target(record.syntax().text_range())
    })
 }
@@ -96,9 +87,9 @@ fn struct_definition(path: &ast::Path, sema: &Semantics<RootDatabase>) -> Option
    }
 }
-fn compute_fields_ranks(path: &Path, ctx: &AssistCtx) -> Option<HashMap<String, usize>> {
+fn compute_fields_ranks(path: &ast::Path, ctx: &AssistContext) -> Option<HashMap<String, usize>> {
    Some(
-        struct_definition(path, ctx.sema)?
+        struct_definition(path, &ctx.sema)?
            .fields(ctx.db)
            .iter()
            .enumerate()
@@ -109,7 +100,7 @@ fn compute_fields_ranks(path: &Path, ctx: &AssistCtx) -> Option<HashMap<String,
 #[cfg(test)]
 mod tests {
-    use crate::helpers::{check_assist, check_assist_not_applicable};
+    use crate::tests::{check_assist, check_assist_not_applicable};
    use super::*;
@@ -149,7 +140,7 @@ mod tests {
        "#,
            r#"
        struct Foo {foo: i32, bar: i32};
-        const test: Foo = <|>Foo {foo: 1, bar: 0}
+        const test: Foo = Foo {foo: 1, bar: 0}
        "#,
        )
    }
@@ -173,7 +164,7 @@ mod tests {
        fn f(f: Foo) -> {
            match f {
-                <|>Foo { ref mut bar, baz: 0, .. } => (),
+                Foo { ref mut bar, baz: 0, .. } => (),
                _ => ()
            }
        }
@@ -211,7 +202,7 @@ mod tests {
            impl Foo {
                fn new() -> Foo {
                    let foo = String::new();
-                    <|>Foo {
+                    Foo {
                        foo,
                        bar: foo.clone(),
                        extra: "Extra field",
diff --git a/crates/ra_assists/src/handlers/replace_if_let_with_match.rs b/crates/ra_assists/src/handlers/replace_if_let_with_match.rs
index 9841f6980..e016f51c3 100644
--- a/crates/ra_assists/src/handlers/replace_if_let_with_match.rs
+++ b/crates/ra_assists/src/handlers/replace_if_let_with_match.rs
@@ -1,10 +1,14 @@
 use ra_fmt::unwrap_trivial_block;
 use ra_syntax::{
-    ast::{self, edit::IndentLevel, make},
+    ast::{
+        self,
+        edit::{AstNodeEdit, IndentLevel},
+        make,
+    },
    AstNode,
 };
-use crate::{utils::TryEnum, Assist, AssistCtx, AssistId};
+use crate::{utils::TryEnum, AssistContext, AssistId, Assists};
 // Assist: replace_if_let_with_match
 //
@@ -32,7 +36,7 @@ use crate::{utils::TryEnum, Assist, AssistCtx, AssistId};
 //     }
 // }
 // ```
-pub(crate) fn replace_if_let_with_match(ctx: AssistCtx) -> Option<Assist> {
+pub(crate) fn replace_if_let_with_match(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
    let if_expr: ast::IfExpr = ctx.find_node_at_offset()?;
    let cond = if_expr.condition()?;
    let pat = cond.pat()?;
@@ -43,29 +47,27 @@ pub(crate) fn replace_if_let_with_match(ctx: AssistCtx) -> Option<Assist> {
        ast::ElseBranch::IfExpr(_) => return None,
    };
-    let sema = ctx.sema;
+    let target = if_expr.syntax().text_range();
-    ctx.add_assist(AssistId("replace_if_let_with_match"), "Replace with match", move |edit| {
+    acc.add(AssistId("replace_if_let_with_match"), "Replace with match", target, move |edit| {
        let match_expr = {
            let then_arm = {
                let then_expr = unwrap_trivial_block(then_block);
                make::match_arm(vec![pat.clone()], then_expr)
            };
            let else_arm = {
-                let pattern = sema
+                let pattern = ctx
+                    .sema
                    .type_of_pat(&pat)
-                    .and_then(|ty| TryEnum::from_ty(sema, &ty))
+                    .and_then(|ty| TryEnum::from_ty(&ctx.sema, &ty))
                    .map(|it| it.sad_pattern())
                    .unwrap_or_else(|| make::placeholder_pat().into());
                let else_expr = unwrap_trivial_block(else_block);
                make::match_arm(vec![pattern], else_expr)
            };
            make::expr_match(expr, make::match_arm_list(vec![then_arm, else_arm]))
+                .indent(IndentLevel::from_node(if_expr.syntax()))
        };
-        let match_expr = IndentLevel::from_node(if_expr.syntax()).increase_indent(match_expr);
-        edit.target(if_expr.syntax().text_range());
-        edit.set_cursor(if_expr.syntax().text_range().start());
        edit.replace_ast::<ast::Expr>(if_expr.into(), match_expr);
    })
 }
@@ -74,13 +76,13 @@ pub(crate) fn replace_if_let_with_match(ctx: AssistCtx) -> Option<Assist> {
 mod tests {
    use super::*;
-    use crate::helpers::{check_assist, check_assist_target};
+    use crate::tests::{check_assist, check_assist_target};
    #[test]
    fn test_replace_if_let_with_match_unwraps_simple_expressions() {
        check_assist(
            replace_if_let_with_match,
-            "
+            r#"
 impl VariantData {
    pub fn is_struct(&self) -> bool {
        if <|>let VariantData::Struct(..) = *self {
@@ -89,16 +91,16 @@ impl VariantData {
            false
        }
    }
-}           ",
+}           "#,
-            "
+            r#"
 impl VariantData {
    pub fn is_struct(&self) -> bool {
-        <|>match *self {
+        match *self {
            VariantData::Struct(..) => true,
            _ => false,
        }
    }
-}           ",
+}           "#,
        )
    }
@@ -106,7 +108,7 @@ impl VariantData {
    fn test_replace_if_let_with_match_doesnt_unwrap_multiline_expressions() {
        check_assist(
            replace_if_let_with_match,
-            "
+            r#"
 fn foo() {
    if <|>let VariantData::Struct(..) = a {
        bar(
@@ -115,10 +117,10 @@ fn foo() {
    } else {
        false
    }
-}           ",
+}           "#,
-            "
+            r#"
 fn foo() {
-    <|>match a {
+    match a {
        VariantData::Struct(..) => {
            bar(
                123
@@ -126,7 +128,7 @@ fn foo() {
        }
        _ => false,
    }
-}           ",
+}           "#,
        )
    }
@@ -134,7 +136,7 @@ fn foo() {
    fn replace_if_let_with_match_target() {
        check_assist_target(
            replace_if_let_with_match,
-            "
+            r#"
 impl VariantData {
    pub fn is_struct(&self) -> bool {
        if <|>let VariantData::Struct(..) = *self {
@@ -143,7 +145,7 @@ impl VariantData {
            false
        }
    }
-}           ",
+}           "#,
            "if let VariantData::Struct(..) = *self {
            true
        } else {
@@ -173,7 +175,7 @@ enum Option<T> { Some(T), None }
 use Option::*;
 fn foo(x: Option<i32>) {
-    <|>match x {
+    match x {
        Some(x) => println!("{}", x),
        None => println!("none"),
    }
@@ -203,7 +205,7 @@ enum Result<T, E> { Ok(T), Err(E) }
 use Result::*;
 fn foo(x: Result<i32, ()>) {
-    <|>match x {
+    match x {
        Ok(x) => println!("{}", x),
        Err(_) => println!("none"),
    }
diff --git a/crates/ra_assists/src/handlers/replace_let_with_if_let.rs b/crates/ra_assists/src/handlers/replace_let_with_if_let.rs
index 0cf23b754..761557ac0 100644
--- a/crates/ra_assists/src/handlers/replace_let_with_if_let.rs
+++ b/crates/ra_assists/src/handlers/replace_let_with_if_let.rs
@@ -9,11 +9,7 @@ use ra_syntax::{
    AstNode, T,
 };
-use crate::{
+use crate::{utils::TryEnum, AssistContext, AssistId, Assists};
-    assist_ctx::{Assist, AssistCtx},
-    utils::TryEnum,
-    AssistId,
-};
 // Assist: replace_let_with_if_let
 //
@@ -39,15 +35,16 @@ use crate::{
 //
 // fn compute() -> Option<i32> { None }
 // ```
-pub(crate) fn replace_let_with_if_let(ctx: AssistCtx) -> Option<Assist> {
+pub(crate) fn replace_let_with_if_let(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
    let let_kw = ctx.find_token_at_offset(T![let])?;
    let let_stmt = let_kw.ancestors().find_map(ast::LetStmt::cast)?;
    let init = let_stmt.initializer()?;
    let original_pat = let_stmt.pat()?;
    let ty = ctx.sema.type_of_expr(&init)?;
-    let happy_variant = TryEnum::from_ty(ctx.sema, &ty).map(|it| it.happy_case());
+    let happy_variant = TryEnum::from_ty(&ctx.sema, &ty).map(|it| it.happy_case());
-    ctx.add_assist(AssistId("replace_let_with_if_let"), "Replace with if-let", |edit| {
+    let target = let_kw.text_range();
+    acc.add(AssistId("replace_let_with_if_let"), "Replace with if-let", target, |edit| {
        let with_placeholder: ast::Pat = match happy_variant {
            None => make::placeholder_pat().into(),
            Some(var_name) => make::tuple_struct_pat(
@@ -56,25 +53,20 @@ pub(crate) fn replace_let_with_if_let(ctx: AssistCtx) -> Option<Assist> {
            )
            .into(),
        };
-        let block =
+        let block = make::block_expr(None, None).indent(IndentLevel::from_node(let_stmt.syntax()));
-            IndentLevel::from_node(let_stmt.syntax()).increase_indent(make::block_expr(None, None));
        let if_ = make::expr_if(make::condition(init, Some(with_placeholder)), block);
        let stmt = make::expr_stmt(if_);
        let placeholder = stmt.syntax().descendants().find_map(ast::PlaceholderPat::cast).unwrap();
-        let target_offset =
-            let_stmt.syntax().text_range().start() + placeholder.syntax().text_range().start();
        let stmt = stmt.replace_descendant(placeholder.into(), original_pat);
        edit.replace_ast(ast::Stmt::from(let_stmt), ast::Stmt::from(stmt));
-        edit.target(let_kw.text_range());
-        edit.set_cursor(target_offset);
    })
 }
 #[cfg(test)]
 mod tests {
-    use crate::helpers::check_assist;
+    use crate::tests::check_assist;
    use super::*;
@@ -93,7 +85,7 @@ fn main() {
 enum E<T> { X(T), Y(T) }
 fn main() {
-    if let <|>x = E::X(92) {
+    if let x = E::X(92) {
    }
 }
            ",
diff --git a/crates/ra_assists/src/handlers/replace_qualified_name_with_use.rs b/crates/ra_assists/src/handlers/replace_qualified_name_with_use.rs
index 918e8dd8d..0197a8cf0 100644
--- a/crates/ra_assists/src/handlers/replace_qualified_name_with_use.rs
+++ b/crates/ra_assists/src/handlers/replace_qualified_name_with_use.rs
@@ -1,11 +1,7 @@
 use hir;
 use ra_syntax::{ast, AstNode, SmolStr, TextRange};
-use crate::{
+use crate::{utils::insert_use_statement, AssistContext, AssistId, Assists};
-    assist_ctx::{Assist, AssistCtx},
-    utils::insert_use_statement,
-    AssistId,
-};
 // Assist: replace_qualified_name_with_use
 //
@@ -20,7 +16,10 @@ use crate::{
 //
 // fn process(map: HashMap<String, String>) {}
 // ```
-pub(crate) fn replace_qualified_name_with_use(ctx: AssistCtx) -> Option<Assist> {
+pub(crate) fn replace_qualified_name_with_use(
+    acc: &mut Assists,
+    ctx: &AssistContext,
+) -> Option<()> {
    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() {
@@ -33,17 +32,19 @@ pub(crate) fn replace_qualified_name_with_use(ctx: AssistCtx) -> Option<Assist>
        return None;
    }
-    ctx.add_assist(
+    let target = path.syntax().text_range();
+    acc.add(
        AssistId("replace_qualified_name_with_use"),
        "Replace qualified path with use",
-        |edit| {
+        target,
+        |builder| {
            let path_to_import = hir_path.mod_path().clone();
-            insert_use_statement(path.syntax(), &path_to_import, edit.text_edit_builder());
+            insert_use_statement(path.syntax(), &path_to_import, ctx, builder.text_edit_builder());
            if let Some(last) = path.segment() {
                // Here we are assuming the assist will provide a correct use statement
                // so we can delete the path qualifier
-                edit.delete(TextRange::new(
+                builder.delete(TextRange::new(
                    path.syntax().text_range().start(),
                    last.syntax().text_range().start(),
                ));
@@ -74,7 +75,7 @@ fn collect_hir_path_segments(path: &hir::Path) -> Option<Vec<SmolStr>> {
 #[cfg(test)]
 mod tests {
-    use crate::helpers::{check_assist, check_assist_not_applicable};
+    use crate::tests::{check_assist, check_assist_not_applicable};
    use super::*;
@@ -88,7 +89,7 @@ std::fmt::Debug<|>
            "
 use std::fmt::Debug;
-Debug<|>
+Debug
    ",
        );
    }
@@ -105,7 +106,7 @@ fn main() {
            "
 use std::fmt::Debug;
-Debug<|>
+Debug
 fn main() {
 }
@@ -129,7 +130,7 @@ use std::fmt::Debug;
 fn main() {
 }
-Debug<|>
+Debug
    ",
        );
    }
@@ -144,7 +145,7 @@ std::fmt<|>::Debug
            "
 use std::fmt;
-fmt<|>::Debug
+fmt::Debug
    ",
        );
    }
@@ -163,7 +164,7 @@ impl std::fmt::Debug<|> for Foo {
 use stdx;
 use std::fmt::Debug;
-impl Debug<|> for Foo {
+impl Debug for Foo {
 }
    ",
        );
@@ -180,7 +181,7 @@ impl std::fmt::Debug<|> for Foo {
            "
 use std::fmt::Debug;
-impl Debug<|> for Foo {
+impl Debug for Foo {
 }
    ",
        );
@@ -197,7 +198,7 @@ impl Debug<|> for Foo {
            "
    use std::fmt::Debug;
-    impl Debug<|> for Foo {
+    impl Debug for Foo {
    }
    ",
        );
@@ -216,7 +217,7 @@ impl std::io<|> for Foo {
            "
 use std::{io, fmt};
-impl io<|> for Foo {
+impl io for Foo {
 }
    ",
        );
@@ -235,7 +236,7 @@ impl std::fmt::Debug<|> for Foo {
            "
 use std::fmt::{self, Debug, };
-impl Debug<|> for Foo {
+impl Debug for Foo {
 }
    ",
        );
@@ -254,7 +255,7 @@ impl std::fmt<|> for Foo {
            "
 use std::fmt::{self, Debug};
-impl fmt<|> for Foo {
+impl fmt for Foo {
 }
    ",
        );
@@ -273,7 +274,7 @@ impl std::fmt::nested<|> for Foo {
            "
 use std::fmt::{Debug, nested::{Display, self}};
-impl nested<|> for Foo {
+impl nested for Foo {
 }
 ",
        );
@@ -292,7 +293,7 @@ impl std::fmt::nested<|> for Foo {
            "
 use std::fmt::{Debug, nested::{self, Display}};
-impl nested<|> for Foo {
+impl nested for Foo {
 }
 ",
        );
@@ -311,7 +312,7 @@ impl std::fmt::nested::Debug<|> for Foo {
            "
 use std::fmt::{Debug, nested::{Display, Debug}};
-impl Debug<|> for Foo {
+impl Debug for Foo {
 }
 ",
        );
@@ -330,7 +331,7 @@ impl std::fmt::nested::Display<|> for Foo {
            "
 use std::fmt::{nested::Display, Debug};
-impl Display<|> for Foo {
+impl Display for Foo {
 }
 ",
        );
@@ -349,7 +350,7 @@ impl std::fmt::Display<|> for Foo {
            "
 use std::fmt::{Display, nested::Debug};
-impl Display<|> for Foo {
+impl Display for Foo {
 }
 ",
        );
@@ -373,7 +374,7 @@ use crate::{
    AssocItem,
 };
-fn foo() { lower<|>::trait_env() }
+fn foo() { lower::trait_env() }
 ",
        );
    }
@@ -391,7 +392,7 @@ impl foo::Debug<|> for Foo {
            "
 use std::fmt as foo;
-impl Debug<|> for Foo {
+impl Debug for Foo {
 }
 ",
        );
@@ -434,7 +435,7 @@ mod foo {
    mod bar {
        use std::fmt::Debug;
-        Debug<|>
+        Debug
    }
 }
    ",
@@ -457,7 +458,7 @@ fn main() {
 use std::fmt::Debug;
 fn main() {
-    Debug<|>
+    Debug
 }
    ",
        );
diff --git a/crates/ra_assists/src/handlers/replace_unwrap_with_match.rs b/crates/ra_assists/src/handlers/replace_unwrap_with_match.rs
index 62d4ea522..cff7dfb81 100644
--- a/crates/ra_assists/src/handlers/replace_unwrap_with_match.rs
+++ b/crates/ra_assists/src/handlers/replace_unwrap_with_match.rs
@@ -1,11 +1,18 @@
 use std::iter;
 use ra_syntax::{
-    ast::{self, edit::IndentLevel, make},
+    ast::{
+        self,
+        edit::{AstNodeEdit, IndentLevel},
+        make,
+    },
    AstNode,
 };
-use crate::{utils::TryEnum, Assist, AssistCtx, AssistId};
+use crate::{
+    utils::{render_snippet, Cursor, TryEnum},
+    AssistContext, AssistId, Assists,
+};
 // Assist: replace_unwrap_with_match
 //
@@ -25,11 +32,11 @@ use crate::{utils::TryEnum, Assist, AssistCtx, AssistId};
 //     let x: Result<i32, i32> = Result::Ok(92);
 //     let y = match x {
 //         Ok(a) => a,
-//         _ => unreachable!(),
+//         $0_ => unreachable!(),
 //     };
 // }
 // ```
-pub(crate) fn replace_unwrap_with_match(ctx: AssistCtx) -> Option<Assist> {
+pub(crate) fn replace_unwrap_with_match(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
    let method_call: ast::MethodCallExpr = ctx.find_node_at_offset()?;
    let name = method_call.name_ref()?;
    if name.text() != "unwrap" {
@@ -37,9 +44,9 @@ pub(crate) fn replace_unwrap_with_match(ctx: AssistCtx) -> Option<Assist> {
    }
    let caller = method_call.expr()?;
    let ty = ctx.sema.type_of_expr(&caller)?;
-    let happy_variant = TryEnum::from_ty(ctx.sema, &ty)?.happy_case();
+    let happy_variant = TryEnum::from_ty(&ctx.sema, &ty)?.happy_case();
+    let target = method_call.syntax().text_range();
-    ctx.add_assist(AssistId("replace_unwrap_with_match"), "Replace unwrap with match", |edit| {
+    acc.add(AssistId("replace_unwrap_with_match"), "Replace unwrap with match", target, |builder| {
        let ok_path = make::path_unqualified(make::path_segment(make::name_ref(happy_variant)));
        let it = make::bind_pat(make::name("a")).into();
        let ok_tuple = make::tuple_struct_pat(ok_path, iter::once(it)).into();
@@ -47,23 +54,36 @@ pub(crate) fn replace_unwrap_with_match(ctx: AssistCtx) -> Option<Assist> {
        let bind_path = make::path_unqualified(make::path_segment(make::name_ref("a")));
        let ok_arm = make::match_arm(iter::once(ok_tuple), make::expr_path(bind_path));
-        let unreachable_call = make::unreachable_macro_call().into();
+        let unreachable_call = make::expr_unreachable();
        let err_arm = make::match_arm(iter::once(make::placeholder_pat().into()), unreachable_call);
        let match_arm_list = make::match_arm_list(vec![ok_arm, err_arm]);
-        let match_expr = make::expr_match(caller.clone(), match_arm_list);
+        let match_expr = make::expr_match(caller.clone(), match_arm_list)
-        let match_expr = IndentLevel::from_node(method_call.syntax()).increase_indent(match_expr);
+            .indent(IndentLevel::from_node(method_call.syntax()));
-        edit.target(method_call.syntax().text_range());
+        let range = method_call.syntax().text_range();
-        edit.set_cursor(caller.syntax().text_range().start());
+        match ctx.config.snippet_cap {
-        edit.replace_ast::<ast::Expr>(method_call.into(), match_expr);
+            Some(cap) => {
+                let err_arm = match_expr
+                    .syntax()
+                    .descendants()
+                    .filter_map(ast::MatchArm::cast)
+                    .last()
+                    .unwrap();
+                let snippet =
+                    render_snippet(cap, match_expr.syntax(), Cursor::Before(err_arm.syntax()));
+                builder.replace_snippet(cap, range, snippet)
+            }
+            None => builder.replace(range, match_expr.to_string()),
+        }
    })
 }
 #[cfg(test)]
 mod tests {
+    use crate::tests::{check_assist, check_assist_target};
    use super::*;
-    use crate::helpers::{check_assist, check_assist_target};
    #[test]
    fn test_replace_result_unwrap_with_match() {
@@ -82,9 +102,9 @@ enum Result<T, E> { Ok(T), Err(E) }
 fn i<T>(a: T) -> T { a }
 fn main() {
    let x: Result<i32, i32> = Result::Ok(92);
-    let y = <|>match i(x) {
+    let y = match i(x) {
        Ok(a) => a,
-        _ => unreachable!(),
+        $0_ => unreachable!(),
    };
 }
            ",
@@ -108,9 +128,9 @@ enum Option<T> { Some(T), None }
 fn i<T>(a: T) -> T { a }
 fn main() {
    let x = Option::Some(92);
-    let y = <|>match i(x) {
+    let y = match i(x) {
        Some(a) => a,
-        _ => unreachable!(),
+        $0_ => unreachable!(),
    };
 }
            ",
@@ -134,9 +154,9 @@ enum Result<T, E> { Ok(T), Err(E) }
 fn i<T>(a: T) -> T { a }
 fn main() {
    let x: Result<i32, i32> = Result::Ok(92);
-    let y = <|>match i(x) {
+    let y = match i(x) {
        Ok(a) => a,
-        _ => unreachable!(),
+        $0_ => unreachable!(),
    }.count_zeroes();
 }
            ",
diff --git a/crates/ra_assists/src/handlers/split_import.rs b/crates/ra_assists/src/handlers/split_import.rs
index f25826796..c7a874480 100644
--- a/crates/ra_assists/src/handlers/split_import.rs
+++ b/crates/ra_assists/src/handlers/split_import.rs
@@ -2,7 +2,7 @@ use std::iter::successors;
 use ra_syntax::{ast, AstNode, T};
-use crate::{Assist, AssistCtx, AssistId};
+use crate::{AssistContext, AssistId, Assists};
 // Assist: split_import
 //
@@ -15,7 +15,7 @@ use crate::{Assist, AssistCtx, AssistId};
 // ```
 // use std::{collections::HashMap};
 // ```
-pub(crate) fn split_import(ctx: AssistCtx) -> Option<Assist> {
+pub(crate) fn split_import(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
    let colon_colon = ctx.find_token_at_offset(T![::])?;
    let path = ast::Path::cast(colon_colon.parent())?.qualifier()?;
    let top_path = successors(Some(path.clone()), |it| it.parent_path()).last()?;
@@ -26,18 +26,16 @@ pub(crate) fn split_import(ctx: AssistCtx) -> Option<Assist> {
    if new_tree == use_tree {
        return None;
    }
-    let cursor = ctx.frange.range.start();
-    ctx.add_assist(AssistId("split_import"), "Split import", |edit| {
+    let target = colon_colon.text_range();
-        edit.target(colon_colon.text_range());
+    acc.add(AssistId("split_import"), "Split import", target, |edit| {
        edit.replace_ast(use_tree, new_tree);
-        edit.set_cursor(cursor);
    })
 }
 #[cfg(test)]
 mod tests {
-    use crate::helpers::{check_assist, check_assist_not_applicable, check_assist_target};
+    use crate::tests::{check_assist, check_assist_not_applicable, check_assist_target};
    use super::*;
@@ -46,7 +44,7 @@ mod tests {
        check_assist(
            split_import,
            "use crate::<|>db::RootDatabase;",
-            "use crate::<|>{db::RootDatabase};",
+            "use crate::{db::RootDatabase};",
        )
    }
@@ -55,7 +53,7 @@ mod tests {
        check_assist(
            split_import,
            "use crate:<|>:db::{RootDatabase, FileSymbol}",
-            "use crate:<|>:{db::{RootDatabase, FileSymbol}}",
+            "use crate::{db::{RootDatabase, FileSymbol}}",
        )
    }
diff --git a/crates/ra_assists/src/handlers/unwrap_block.rs b/crates/ra_assists/src/handlers/unwrap_block.rs
new file mode 100644
index 000000000..8440c7d0f
--- /dev/null
+++ b/crates/ra_assists/src/handlers/unwrap_block.rs
@@ -0,0 +1,512 @@
+use ra_fmt::unwrap_trivial_block;
+use ra_syntax::{
+    ast::{self, ElseBranch, Expr, LoopBodyOwner},
+    match_ast, AstNode, TextRange, T,
+};
+use crate::{AssistContext, AssistId, Assists};
+// Assist: unwrap_block
+//
+// This assist removes if...else, for, while and loop control statements to just keep the body.
+//
+// ```
+// fn foo() {
+//     if true {<|>
+//         println!("foo");
+//     }
+// }
+// ```
+// ->
+// ```
+// fn foo() {
+//     println!("foo");
+// }
+// ```
+pub(crate) fn unwrap_block(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
+    let l_curly_token = ctx.find_token_at_offset(T!['{'])?;
+    let block = ast::BlockExpr::cast(l_curly_token.parent())?;
+    let parent = block.syntax().parent()?;
+    let assist_id = AssistId("unwrap_block");
+    let assist_label = "Unwrap block";
+    let (expr, expr_to_unwrap) = match_ast! {
+        match parent {
+            ast::ForExpr(for_expr) => {
+                let block_expr = for_expr.loop_body()?;
+                let expr_to_unwrap = extract_expr(ctx.frange.range, block_expr)?;
+                (ast::Expr::ForExpr(for_expr), expr_to_unwrap)
+            },
+            ast::WhileExpr(while_expr) => {
+                let block_expr = while_expr.loop_body()?;
+                let expr_to_unwrap = extract_expr(ctx.frange.range, block_expr)?;
+                (ast::Expr::WhileExpr(while_expr), expr_to_unwrap)
+            },
+            ast::LoopExpr(loop_expr) => {
+                let block_expr = loop_expr.loop_body()?;
+                let expr_to_unwrap = extract_expr(ctx.frange.range, block_expr)?;
+                (ast::Expr::LoopExpr(loop_expr), expr_to_unwrap)
+            },
+            ast::IfExpr(if_expr) => {
+                let mut resp = None;
+                let then_branch = if_expr.then_branch()?;
+                if then_branch.l_curly_token()?.text_range().contains_range(ctx.frange.range) {
+                    if let Some(ancestor) = if_expr.syntax().parent().and_then(ast::IfExpr::cast) {
+                        // For `else if` blocks
+                        let ancestor_then_branch = ancestor.then_branch()?;
+                        let l_curly_token = then_branch.l_curly_token()?;
+                        let target = then_branch.syntax().text_range();
+                        return acc.add(assist_id, assist_label, target, |edit| {
+                            let range_to_del_else_if = TextRange::new(ancestor_then_branch.syntax().text_range().end(), l_curly_token.text_range().start());
+                            let range_to_del_rest = TextRange::new(then_branch.syntax().text_range().end(), if_expr.syntax().text_range().end());
+                            edit.delete(range_to_del_rest);
+                            edit.delete(range_to_del_else_if);
+                            edit.replace(target, update_expr_string(then_branch.to_string(), &[' ', '{']));
+                        });
+                    } else {
+                        resp = Some((ast::Expr::IfExpr(if_expr.clone()), Expr::BlockExpr(then_branch)));
+                    }
+                } else if let Some(else_branch) = if_expr.else_branch() {
+                    match else_branch {
+                        ElseBranch::Block(else_block) => {
+                            let l_curly_token = else_block.l_curly_token()?;
+                            if l_curly_token.text_range().contains_range(ctx.frange.range) {
+                                let target = else_block.syntax().text_range();
+                                return acc.add(assist_id, assist_label, target, |edit| {
+                                    let range_to_del = TextRange::new(then_branch.syntax().text_range().end(), l_curly_token.text_range().start());
+                                    edit.delete(range_to_del);
+                                    edit.replace(target, update_expr_string(else_block.to_string(), &[' ', '{']));
+                                });
+                            }
+                        },
+                        ElseBranch::IfExpr(_) => {},
+                    }
+                }
+                resp?
+            },
+            _ => return None,
+        }
+    };
+    let target = expr_to_unwrap.syntax().text_range();
+    acc.add(assist_id, assist_label, target, |edit| {
+        edit.replace(
+            expr.syntax().text_range(),
+            update_expr_string(expr_to_unwrap.to_string(), &[' ', '{', '\n']),
+        );
+    })
+}
+fn extract_expr(cursor_range: TextRange, block: ast::BlockExpr) -> Option<ast::Expr> {
+    let cursor_in_range = block.l_curly_token()?.text_range().contains_range(cursor_range);
+    if cursor_in_range {
+        Some(unwrap_trivial_block(block))
+    } else {
+        None
+    }
+}
+fn update_expr_string(expr_str: String, trim_start_pat: &[char]) -> String {
+    let expr_string = expr_str.trim_start_matches(trim_start_pat);
+    let mut expr_string_lines: Vec<&str> = expr_string.lines().collect();
+    expr_string_lines.pop(); // Delete last line
+    expr_string_lines
+        .into_iter()
+        .map(|line| line.replacen("    ", "", 1)) // Delete indentation
+        .collect::<Vec<String>>()
+        .join("\n")
+}
+#[cfg(test)]
+mod tests {
+    use crate::tests::{check_assist, check_assist_not_applicable};
+    use super::*;
+    #[test]
+    fn simple_if() {
+        check_assist(
+            unwrap_block,
+            r#"
+            fn main() {
+                bar();
+                if true {<|>
+                    foo();
+                    //comment
+                    bar();
+                } else {
+                    println!("bar");
+                }
+            }
+            "#,
+            r#"
+            fn main() {
+                bar();
+                foo();
+                //comment
+                bar();
+            }
+            "#,
+        );
+    }
+    #[test]
+    fn simple_if_else() {
+        check_assist(
+            unwrap_block,
+            r#"
+            fn main() {
+                bar();
+                if true {
+                    foo();
+                    //comment
+                    bar();
+                } else {<|>
+                    println!("bar");
+                }
+            }
+            "#,
+            r#"
+            fn main() {
+                bar();
+                if true {
+                    foo();
+                    //comment
+                    bar();
+                }
+                println!("bar");
+            }
+            "#,
+        );
+    }
+    #[test]
+    fn simple_if_else_if() {
+        check_assist(
+            unwrap_block,
+            r#"
+            fn main() {
+                //bar();
+                if true {
+                    println!("true");
+                    //comment
+                    //bar();
+                } else if false {<|>
+                    println!("bar");
+                } else {
+                    println!("foo");
+                }
+            }
+            "#,
+            r#"
+            fn main() {
+                //bar();
+                if true {
+                    println!("true");
+                    //comment
+                    //bar();
+                }
+                println!("bar");
+            }
+            "#,
+        );
+    }
+    #[test]
+    fn simple_if_else_if_nested() {
+        check_assist(
+            unwrap_block,
+            r#"
+            fn main() {
+                //bar();
+                if true {
+                    println!("true");
+                    //comment
+                    //bar();
+                } else if false {
+                    println!("bar");
+                } else if true {<|>
+                    println!("foo");
+                }
+            }
+            "#,
+            r#"
+            fn main() {
+                //bar();
+                if true {
+                    println!("true");
+                    //comment
+                    //bar();
+                } else if false {
+                    println!("bar");
+                }
+                println!("foo");
+            }
+            "#,
+        );
+    }
+    #[test]
+    fn simple_if_else_if_nested_else() {
+        check_assist(
+            unwrap_block,
+            r#"
+            fn main() {
+                //bar();
+                if true {
+                    println!("true");
+                    //comment
+                    //bar();
+                } else if false {
+                    println!("bar");
+                } else if true {
+                    println!("foo");
+                } else {<|>
+                    println!("else");
+                }
+            }
+            "#,
+            r#"
+            fn main() {
+                //bar();
+                if true {
+                    println!("true");
+                    //comment
+                    //bar();
+                } else if false {
+                    println!("bar");
+                } else if true {
+                    println!("foo");
+                }
+                println!("else");
+            }
+            "#,
+        );
+    }
+    #[test]
+    fn simple_if_else_if_nested_middle() {
+        check_assist(
+            unwrap_block,
+            r#"
+            fn main() {
+                //bar();
+                if true {
+                    println!("true");
+                    //comment
+                    //bar();
+                } else if false {
+                    println!("bar");
+                } else if true {<|>
+                    println!("foo");
+                } else {
+                    println!("else");
+                }
+            }
+            "#,
+            r#"
+            fn main() {
+                //bar();
+                if true {
+                    println!("true");
+                    //comment
+                    //bar();
+                } else if false {
+                    println!("bar");
+                }
+                println!("foo");
+            }
+            "#,
+        );
+    }
+    #[test]
+    fn simple_if_bad_cursor_position() {
+        check_assist_not_applicable(
+            unwrap_block,
+            r#"
+            fn main() {
+                bar();<|>
+                if true {
+                    foo();
+                    //comment
+                    bar();
+                } else {
+                    println!("bar");
+                }
+            }
+            "#,
+        );
+    }
+    #[test]
+    fn simple_for() {
+        check_assist(
+            unwrap_block,
+            r#"
+            fn main() {
+                for i in 0..5 {<|>
+                    if true {
+                        foo();
+                        //comment
+                        bar();
+                    } else {
+                        println!("bar");
+                    }
+                }
+            }
+            "#,
+            r#"
+            fn main() {
+                if true {
+                    foo();
+                    //comment
+                    bar();
+                } else {
+                    println!("bar");
+                }
+            }
+            "#,
+        );
+    }
+    #[test]
+    fn simple_if_in_for() {
+        check_assist(
+            unwrap_block,
+            r#"
+            fn main() {
+                for i in 0..5 {
+                    if true {<|>
+                        foo();
+                        //comment
+                        bar();
+                    } else {
+                        println!("bar");
+                    }
+                }
+            }
+            "#,
+            r#"
+            fn main() {
+                for i in 0..5 {
+                    foo();
+                    //comment
+                    bar();
+                }
+            }
+            "#,
+        );
+    }
+    #[test]
+    fn simple_loop() {
+        check_assist(
+            unwrap_block,
+            r#"
+            fn main() {
+                loop {<|>
+                    if true {
+                        foo();
+                        //comment
+                        bar();
+                    } else {
+                        println!("bar");
+                    }
+                }
+            }
+            "#,
+            r#"
+            fn main() {
+                if true {
+                    foo();
+                    //comment
+                    bar();
+                } else {
+                    println!("bar");
+                }
+            }
+            "#,
+        );
+    }
+    #[test]
+    fn simple_while() {
+        check_assist(
+            unwrap_block,
+            r#"
+            fn main() {
+                while true {<|>
+                    if true {
+                        foo();
+                        //comment
+                        bar();
+                    } else {
+                        println!("bar");
+                    }
+                }
+            }
+            "#,
+            r#"
+            fn main() {
+                if true {
+                    foo();
+                    //comment
+                    bar();
+                } else {
+                    println!("bar");
+                }
+            }
+            "#,
+        );
+    }
+    #[test]
+    fn simple_if_in_while_bad_cursor_position() {
+        check_assist_not_applicable(
+            unwrap_block,
+            r#"
+            fn main() {
+                while true {
+                    if true {
+                        foo();<|>
+                        //comment
+                        bar();
+                    } else {
+                        println!("bar");
+                    }
+                }
+            }
+            "#,
+        );
+    }
+}
diff --git a/crates/ra_assists/src/lib.rs b/crates/ra_assists/src/lib.rs
index 64bd87afb..464bc03dd 100644
--- a/crates/ra_assists/src/lib.rs
+++ b/crates/ra_assists/src/lib.rs
@@ -10,119 +10,113 @@ macro_rules! eprintln {
    ($($tt:tt)*) => { stdx::eprintln!($($tt)*) };
 }
-mod assist_ctx;
+mod assist_config;
-mod marks;
+mod assist_context;
 #[cfg(test)]
-mod doc_tests;
+mod tests;
 pub mod utils;
 pub mod ast_transform;
-use ra_db::{FileId, FileRange};
-use ra_ide_db::RootDatabase;
-use ra_syntax::{TextRange, TextSize};
-use ra_text_edit::TextEdit;
-pub(crate) use crate::assist_ctx::{Assist, AssistCtx, AssistHandler};
 use hir::Semantics;
+use ra_db::FileRange;
+use ra_ide_db::{source_change::SourceChange, RootDatabase};
+use ra_syntax::TextRange;
+pub(crate) use crate::assist_context::{AssistContext, Assists};
+pub use assist_config::AssistConfig;
 /// Unique identifier of the assist, should not be shown to the user
 /// directly.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub struct AssistId(pub &'static str);
-#[derive(Debug, Clone)]
-pub struct AssistLabel {
-    /// Short description of the assist, as shown in the UI.
-    pub label: String,
-    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
-        assert!(label.starts_with(|c: char| c.is_uppercase()));
-        AssistLabel { label, id }
-    }
-}
 #[derive(Debug, Clone)]
-pub struct AssistAction {
+pub struct Assist {
-    pub edit: TextEdit,
+    pub id: AssistId,
-    pub cursor_position: Option<TextSize>,
+    /// Short description of the assist, as shown in the UI.
-    // FIXME: This belongs to `AssistLabel`
+    pub label: String,
-    pub target: Option<TextRange>,
+    pub group: Option<GroupLabel>,
-    pub file: AssistFile,
+    /// Target ranges are used to sort assists: the smaller the target range,
+    /// the more specific assist is, and so it should be sorted first.
+    pub target: TextRange,
 }
 #[derive(Debug, Clone)]
 pub struct ResolvedAssist {
-    pub label: AssistLabel,
+    pub assist: Assist,
-    pub group_label: Option<GroupLabel>,
+    pub source_change: SourceChange,
-    pub action: AssistAction,
 }
-#[derive(Debug, Clone, Copy)]
+impl Assist {
-pub enum AssistFile {
+    /// Return all the assists applicable at the given position.
-    CurrentFile,
+    ///
-    TargetFile(FileId),
+    /// Assists are returned in the "unresolved" state, that is only labels are
-}
+    /// returned, without actual edits.
+    pub fn unresolved(db: &RootDatabase, config: &AssistConfig, range: FileRange) -> Vec<Assist> {
-impl Default for AssistFile {
+        let sema = Semantics::new(db);
-    fn default() -> Self {
+        let ctx = AssistContext::new(sema, config, range);
-        Self::CurrentFile
+        let mut acc = Assists::new_unresolved(&ctx);
+        handlers::all().iter().for_each(|handler| {
+            handler(&mut acc, &ctx);
+        });
+        acc.finish_unresolved()
    }
-}
-/// Return all the assists applicable at the given position.
+    /// Return all the assists applicable at the given position.
-///
+    ///
-/// Assists are returned in the "unresolved" state, that is only labels are
+    /// Assists are returned in the "resolved" state, that is with edit fully
-/// returned, without actual edits.
+    /// computed.
-pub fn unresolved_assists(db: &RootDatabase, range: FileRange) -> Vec<AssistLabel> {
+    pub fn resolved(
-    let sema = Semantics::new(db);
+        db: &RootDatabase,
-    let ctx = AssistCtx::new(&sema, range, false);
+        config: &AssistConfig,
-    handlers::all()
+        range: FileRange,
-        .iter()
+    ) -> Vec<ResolvedAssist> {
-        .filter_map(|f| f(ctx.clone()))
+        let sema = Semantics::new(db);
-        .flat_map(|it| it.0)
+        let ctx = AssistContext::new(sema, config, range);
-        .map(|a| a.label)
+        let mut acc = Assists::new_resolved(&ctx);
-        .collect()
+        handlers::all().iter().for_each(|handler| {
-}
+            handler(&mut acc, &ctx);
+        });
+        acc.finish_resolved()
+    }
-/// Return all the assists applicable at the given position.
+    pub(crate) fn new(
-///
+        id: AssistId,
-/// Assists are returned in the "resolved" state, that is with edit fully
+        label: String,
-/// computed.
+        group: Option<GroupLabel>,
-pub fn resolved_assists(db: &RootDatabase, range: FileRange) -> Vec<ResolvedAssist> {
+        target: TextRange,
-    let sema = Semantics::new(db);
+    ) -> Assist {
-    let ctx = AssistCtx::new(&sema, range, true);
+        // FIXME: make fields private, so that this invariant can't be broken
-    let mut a = handlers::all()
+        assert!(label.starts_with(|c: char| c.is_uppercase()));
-        .iter()
+        Assist { id, label, group, target }
-        .filter_map(|f| f(ctx.clone()))
+    }
-        .flat_map(|it| it.0)
-        .map(|it| it.into_resolved().unwrap())
-        .collect::<Vec<_>>();
-    a.sort_by_key(|it| it.action.target.map_or(TextSize::from(!0u32), |it| it.len()));
-    a
 }
 mod handlers {
-    use crate::AssistHandler;
+    use crate::{AssistContext, Assists};
+    pub(crate) type Handler = fn(&mut Assists, &AssistContext) -> Option<()>;
    mod add_custom_impl;
    mod add_derive;
    mod add_explicit_type;
+    mod add_from_impl_for_enum;
    mod add_function;
    mod add_impl;
    mod add_missing_impl_members;
    mod add_new;
+    mod add_turbo_fish;
    mod apply_demorgan;
    mod auto_import;
+    mod change_return_type_to_result;
    mod change_visibility;
    mod early_return;
    mod fill_match_arms;
+    mod fix_visibility;
    mod flip_binexpr;
    mod flip_comma;
    mod flip_trait_bound;
@@ -136,28 +130,32 @@ mod handlers {
    mod raw_string;
    mod remove_dbg;
    mod remove_mut;
+    mod reorder_fields;
    mod replace_if_let_with_match;
    mod replace_let_with_if_let;
    mod replace_qualified_name_with_use;
    mod replace_unwrap_with_match;
    mod split_import;
-    mod add_from_impl_for_enum;
+    mod unwrap_block;
-    mod reorder_fields;
-    pub(crate) fn all() -> &'static [AssistHandler] {
+    pub(crate) fn all() -> &'static [Handler] {
        &[
            // These are alphabetic for the foolish consistency
            add_custom_impl::add_custom_impl,
            add_derive::add_derive,
            add_explicit_type::add_explicit_type,
+            add_from_impl_for_enum::add_from_impl_for_enum,
            add_function::add_function,
            add_impl::add_impl,
            add_new::add_new,
+            add_turbo_fish::add_turbo_fish,
            apply_demorgan::apply_demorgan,
            auto_import::auto_import,
+            change_return_type_to_result::change_return_type_to_result,
            change_visibility::change_visibility,
            early_return::convert_to_guarded_return,
            fill_match_arms::fill_match_arms,
+            fix_visibility::fix_visibility,
            flip_binexpr::flip_binexpr,
            flip_comma::flip_comma,
            flip_trait_bound::flip_trait_bound,
@@ -175,167 +173,18 @@ mod handlers {
            raw_string::remove_hash,
            remove_dbg::remove_dbg,
            remove_mut::remove_mut,
+            reorder_fields::reorder_fields,
            replace_if_let_with_match::replace_if_let_with_match,
            replace_let_with_if_let::replace_let_with_if_let,
            replace_qualified_name_with_use::replace_qualified_name_with_use,
            replace_unwrap_with_match::replace_unwrap_with_match,
            split_import::split_import,
-            add_from_impl_for_enum::add_from_impl_for_enum,
+            unwrap_block::unwrap_block,
            // These are manually sorted for better priorities
            add_missing_impl_members::add_missing_impl_members,
            add_missing_impl_members::add_missing_default_members,
-            reorder_fields::reorder_fields,
+            // Are you sure you want to add new assist here, and not to the
+            // sorted list above?
        ]
    }
 }
-#[cfg(test)]
-mod helpers {
-    use std::sync::Arc;
-    use ra_db::{fixture::WithFixture, FileId, FileRange, SourceDatabaseExt};
-    use ra_ide_db::{symbol_index::SymbolsDatabase, RootDatabase};
-    use test_utils::{add_cursor, assert_eq_text, extract_range_or_offset, RangeOrOffset};
-    use crate::{AssistCtx, AssistFile, AssistHandler};
-    use hir::Semantics;
-    pub(crate) fn with_single_file(text: &str) -> (RootDatabase, FileId) {
-        let (mut db, file_id) = RootDatabase::with_single_file(text);
-        // FIXME: ideally, this should be done by the above `RootDatabase::with_single_file`,
-        // but it looks like this might need specialization? :(
-        db.set_local_roots(Arc::new(vec![db.file_source_root(file_id)]));
-        (db, file_id)
-    }
-    pub(crate) fn check_assist(
-        assist: AssistHandler,
-        ra_fixture_before: &str,
-        ra_fixture_after: &str,
-    ) {
-        check(assist, ra_fixture_before, ExpectedResult::After(ra_fixture_after));
-    }
-    // FIXME: instead of having a separate function here, maybe use
-    // `extract_ranges` and mark the target as `<target> </target>` in the
-    // fixuture?
-    pub(crate) fn check_assist_target(assist: AssistHandler, ra_fixture: &str, target: &str) {
-        check(assist, ra_fixture, ExpectedResult::Target(target));
-    }
-    pub(crate) fn check_assist_not_applicable(assist: AssistHandler, ra_fixture: &str) {
-        check(assist, ra_fixture, ExpectedResult::NotApplicable);
-    }
-    enum ExpectedResult<'a> {
-        NotApplicable,
-        After(&'a str),
-        Target(&'a str),
-    }
-    fn check(assist: AssistHandler, before: &str, expected: ExpectedResult) {
-        let (text_without_caret, file_with_caret_id, range_or_offset, db) =
-            if before.contains("//-") {
-                let (mut db, position) = RootDatabase::with_position(before);
-                db.set_local_roots(Arc::new(vec![db.file_source_root(position.file_id)]));
-                (
-                    db.file_text(position.file_id).as_ref().to_owned(),
-                    position.file_id,
-                    RangeOrOffset::Offset(position.offset),
-                    db,
-                )
-            } else {
-                let (range_or_offset, text_without_caret) = extract_range_or_offset(before);
-                let (db, file_id) = with_single_file(&text_without_caret);
-                (text_without_caret, file_id, range_or_offset, db)
-            };
-        let frange = FileRange { file_id: file_with_caret_id, range: range_or_offset.into() };
-        let sema = Semantics::new(&db);
-        let assist_ctx = AssistCtx::new(&sema, frange, true);
-        match (assist(assist_ctx), expected) {
-            (Some(assist), ExpectedResult::After(after)) => {
-                let action = assist.0[0].action.clone().unwrap();
-                let assisted_file_text = if let AssistFile::TargetFile(file_id) = action.file {
-                    db.file_text(file_id).as_ref().to_owned()
-                } else {
-                    text_without_caret
-                };
-                let mut actual = action.edit.apply(&assisted_file_text);
-                match action.cursor_position {
-                    None => {
-                        if let RangeOrOffset::Offset(before_cursor_pos) = range_or_offset {
-                            let off = action
-                                .edit
-                                .apply_to_offset(before_cursor_pos)
-                                .expect("cursor position is affected by the edit");
-                            actual = add_cursor(&actual, off)
-                        }
-                    }
-                    Some(off) => actual = add_cursor(&actual, off),
-                };
-                assert_eq_text!(after, &actual);
-            }
-            (Some(assist), ExpectedResult::Target(target)) => {
-                let action = assist.0[0].action.clone().unwrap();
-                let range = action.target.expect("expected target on action");
-                assert_eq_text!(&text_without_caret[range], target);
-            }
-            (Some(_), ExpectedResult::NotApplicable) => panic!("assist should not be applicable!"),
-            (None, ExpectedResult::After(_)) | (None, ExpectedResult::Target(_)) => {
-                panic!("code action is not applicable")
-            }
-            (None, ExpectedResult::NotApplicable) => (),
-        };
-    }
-}
-#[cfg(test)]
-mod tests {
-    use ra_db::FileRange;
-    use ra_syntax::TextRange;
-    use test_utils::{extract_offset, extract_range};
-    use crate::{helpers, resolved_assists};
-    #[test]
-    fn assist_order_field_struct() {
-        let before = "struct Foo { <|>bar: u32 }";
-        let (before_cursor_pos, before) = extract_offset(before);
-        let (db, file_id) = helpers::with_single_file(&before);
-        let frange = FileRange { file_id, range: TextRange::empty(before_cursor_pos) };
-        let assists = resolved_assists(&db, frange);
-        let mut assists = assists.iter();
-        assert_eq!(
-            assists.next().expect("expected assist").label.label,
-            "Change visibility to pub(crate)"
-        );
-        assert_eq!(assists.next().expect("expected assist").label.label, "Add `#[derive]`");
-    }
-    #[test]
-    fn assist_order_if_expr() {
-        let before = "
-        pub fn test_some_range(a: int) -> bool {
-            if let 2..6 = <|>5<|> {
-                true
-            } else {
-                false
-            }
-        }";
-        let (range, before) = extract_range(before);
-        let (db, file_id) = helpers::with_single_file(&before);
-        let frange = FileRange { file_id, range };
-        let assists = resolved_assists(&db, frange);
-        let mut assists = assists.iter();
-        assert_eq!(assists.next().expect("expected assist").label.label, "Extract into variable");
-        assert_eq!(assists.next().expect("expected assist").label.label, "Replace with match");
-    }
-}
diff --git a/crates/ra_assists/src/marks.rs b/crates/ra_assists/src/marks.rs
deleted file mode 100644
index 8d910205f..000000000
--- a/crates/ra_assists/src/marks.rs
+++ /dev/null
@@ -1,12 +0,0 @@
-//! See test_utils/src/marks.rs
-test_utils::marks![
-    introduce_var_in_comment_is_not_applicable
-    test_introduce_var_expr_stmt
-    test_introduce_var_last_expr
-    not_applicable_outside_of_bind_pat
-    test_not_inline_mut_variable
-    test_not_applicable_if_variable_unused
-    change_visibility_field_false_positive
-    test_add_from_impl_already_exists
-];
diff --git a/crates/ra_assists/src/tests.rs b/crates/ra_assists/src/tests.rs
new file mode 100644
index 000000000..62dd3547f
--- /dev/null
+++ b/crates/ra_assists/src/tests.rs
@@ -0,0 +1,153 @@
+mod generated;
+use std::sync::Arc;
+use hir::Semantics;
+use ra_db::{fixture::WithFixture, FileId, FileRange, SourceDatabaseExt};
+use ra_ide_db::{symbol_index::SymbolsDatabase, RootDatabase};
+use ra_syntax::TextRange;
+use test_utils::{
+    assert_eq_text, extract_offset, extract_range, extract_range_or_offset, RangeOrOffset,
+};
+use crate::{handlers::Handler, Assist, AssistConfig, AssistContext, Assists};
+pub(crate) fn with_single_file(text: &str) -> (RootDatabase, FileId) {
+    let (mut db, file_id) = RootDatabase::with_single_file(text);
+    // FIXME: ideally, this should be done by the above `RootDatabase::with_single_file`,
+    // but it looks like this might need specialization? :(
+    db.set_local_roots(Arc::new(vec![db.file_source_root(file_id)]));
+    (db, file_id)
+}
+pub(crate) fn check_assist(assist: Handler, ra_fixture_before: &str, ra_fixture_after: &str) {
+    check(assist, ra_fixture_before, ExpectedResult::After(ra_fixture_after));
+}
+// FIXME: instead of having a separate function here, maybe use
+// `extract_ranges` and mark the target as `<target> </target>` in the
+// fixuture?
+pub(crate) fn check_assist_target(assist: Handler, ra_fixture: &str, target: &str) {
+    check(assist, ra_fixture, ExpectedResult::Target(target));
+}
+pub(crate) fn check_assist_not_applicable(assist: Handler, ra_fixture: &str) {
+    check(assist, ra_fixture, ExpectedResult::NotApplicable);
+}
+fn check_doc_test(assist_id: &str, before: &str, after: &str) {
+    let (selection, before) = extract_range_or_offset(before);
+    let (db, file_id) = crate::tests::with_single_file(&before);
+    let frange = FileRange { file_id, range: selection.into() };
+    let mut assist = Assist::resolved(&db, &AssistConfig::default(), frange)
+        .into_iter()
+        .find(|assist| assist.assist.id.0 == assist_id)
+        .unwrap_or_else(|| {
+            panic!(
+                "\n\nAssist is not applicable: {}\nAvailable assists: {}",
+                assist_id,
+                Assist::resolved(&db, &AssistConfig::default(), frange)
+                    .into_iter()
+                    .map(|assist| assist.assist.id.0)
+                    .collect::<Vec<_>>()
+                    .join(", ")
+            )
+        });
+    let actual = {
+        let change = assist.source_change.source_file_edits.pop().unwrap();
+        let mut actual = before.clone();
+        change.edit.apply(&mut actual);
+        actual
+    };
+    assert_eq_text!(after, &actual);
+}
+enum ExpectedResult<'a> {
+    NotApplicable,
+    After(&'a str),
+    Target(&'a str),
+}
+fn check(handler: Handler, before: &str, expected: ExpectedResult) {
+    let (text_without_caret, file_with_caret_id, range_or_offset, db) = if before.contains("//-") {
+        let (mut db, position) = RootDatabase::with_position(before);
+        db.set_local_roots(Arc::new(vec![db.file_source_root(position.file_id)]));
+        (
+            db.file_text(position.file_id).as_ref().to_owned(),
+            position.file_id,
+            RangeOrOffset::Offset(position.offset),
+            db,
+        )
+    } else {
+        let (range_or_offset, text_without_caret) = extract_range_or_offset(before);
+        let (db, file_id) = with_single_file(&text_without_caret);
+        (text_without_caret, file_id, range_or_offset, db)
+    };
+    let frange = FileRange { file_id: file_with_caret_id, range: range_or_offset.into() };
+    let sema = Semantics::new(&db);
+    let config = AssistConfig::default();
+    let ctx = AssistContext::new(sema, &config, frange);
+    let mut acc = Assists::new_resolved(&ctx);
+    handler(&mut acc, &ctx);
+    let mut res = acc.finish_resolved();
+    let assist = res.pop();
+    match (assist, expected) {
+        (Some(assist), ExpectedResult::After(after)) => {
+            let mut source_change = assist.source_change;
+            let change = source_change.source_file_edits.pop().unwrap();
+            let mut actual = db.file_text(change.file_id).as_ref().to_owned();
+            change.edit.apply(&mut actual);
+            assert_eq_text!(after, &actual);
+        }
+        (Some(assist), ExpectedResult::Target(target)) => {
+            let range = assist.assist.target;
+            assert_eq_text!(&text_without_caret[range], target);
+        }
+        (Some(_), ExpectedResult::NotApplicable) => panic!("assist should not be applicable!"),
+        (None, ExpectedResult::After(_)) | (None, ExpectedResult::Target(_)) => {
+            panic!("code action is not applicable")
+        }
+        (None, ExpectedResult::NotApplicable) => (),
+    };
+}
+#[test]
+fn assist_order_field_struct() {
+    let before = "struct Foo { <|>bar: u32 }";
+    let (before_cursor_pos, before) = extract_offset(before);
+    let (db, file_id) = with_single_file(&before);
+    let frange = FileRange { file_id, range: TextRange::empty(before_cursor_pos) };
+    let assists = Assist::resolved(&db, &AssistConfig::default(), frange);
+    let mut assists = assists.iter();
+    assert_eq!(
+        assists.next().expect("expected assist").assist.label,
+        "Change visibility to pub(crate)"
+    );
+    assert_eq!(assists.next().expect("expected assist").assist.label, "Add `#[derive]`");
+}
+#[test]
+fn assist_order_if_expr() {
+    let before = "
+    pub fn test_some_range(a: int) -> bool {
+        if let 2..6 = <|>5<|> {
+            true
+        } else {
+            false
+        }
+    }";
+    let (range, before) = extract_range(before);
+    let (db, file_id) = with_single_file(&before);
+    let frange = FileRange { file_id, range };
+    let assists = Assist::resolved(&db, &AssistConfig::default(), frange);
+    let mut assists = assists.iter();
+    assert_eq!(assists.next().expect("expected assist").assist.label, "Extract into variable");
+    assert_eq!(assists.next().expect("expected assist").assist.label, "Replace with match");
+}
diff --git a/crates/ra_assists/src/doc_tests/generated.rs b/crates/ra_assists/src/tests/generated.rs
index e4fa9ee36..250e56a69 100644
--- a/crates/ra_assists/src/doc_tests/generated.rs
+++ b/crates/ra_assists/src/tests/generated.rs
@@ -1,10 +1,10 @@
 //! Generated file, do not edit by hand, see `xtask/src/codegen`
-use super::check;
+use super::check_doc_test;
 #[test]
 fn doctest_add_custom_impl() {
-    check(
+    check_doc_test(
        "add_custom_impl",
        r#####"
 #[derive(Deb<|>ug, Display)]
@@ -15,7 +15,7 @@ struct S;
 struct S;
 impl Debug for S {
+    $0
 }
 "#####,
    )
@@ -23,7 +23,7 @@ impl Debug for S {
 #[test]
 fn doctest_add_derive() {
-    check(
+    check_doc_test(
        "add_derive",
        r#####"
 struct Point {
@@ -32,7 +32,7 @@ struct Point {
 }
 "#####,
        r#####"
-#[derive()]
+#[derive($0)]
 struct Point {
    x: u32,
    y: u32,
@@ -43,7 +43,7 @@ struct Point {
 #[test]
 fn doctest_add_explicit_type() {
-    check(
+    check_doc_test(
        "add_explicit_type",
        r#####"
 fn main() {
@@ -60,7 +60,7 @@ fn main() {
 #[test]
 fn doctest_add_function() {
-    check(
+    check_doc_test(
        "add_function",
        r#####"
 struct Baz;
@@ -78,7 +78,7 @@ fn foo() {
 }
 fn bar(arg: &str, baz: Baz) {
-    todo!()
+    ${0:todo!()}
 }
 "#####,
@@ -87,7 +87,7 @@ fn bar(arg: &str, baz: Baz) {
 #[test]
 fn doctest_add_hash() {
-    check(
+    check_doc_test(
        "add_hash",
        r#####"
 fn main() {
@@ -104,20 +104,20 @@ fn main() {
 #[test]
 fn doctest_add_impl() {
-    check(
+    check_doc_test(
        "add_impl",
        r#####"
 struct Ctx<T: Clone> {
-     data: T,<|>
+    data: T,<|>
 }
 "#####,
        r#####"
 struct Ctx<T: Clone> {
-     data: T,
+    data: T,
 }
 impl<T: Clone> Ctx<T> {
+    $0
 }
 "#####,
    )
@@ -125,7 +125,7 @@ impl<T: Clone> Ctx<T> {
 #[test]
 fn doctest_add_impl_default_members() {
-    check(
+    check_doc_test(
        "add_impl_default_members",
        r#####"
 trait Trait {
@@ -150,7 +150,7 @@ trait Trait {
 impl Trait for () {
    Type X = ();
    fn foo(&self) {}
-    fn bar(&self) {}
+    $0fn bar(&self) {}
 }
 "#####,
@@ -159,7 +159,7 @@ impl Trait for () {
 #[test]
 fn doctest_add_impl_missing_members() {
-    check(
+    check_doc_test(
        "add_impl_missing_members",
        r#####"
 trait Trait<T> {
@@ -180,7 +180,9 @@ trait Trait<T> {
 }
 impl Trait<u32> for () {
-    fn foo(&self) -> u32 { todo!() }
+    fn foo(&self) -> u32 {
+        ${0:todo!()}
+    }
 }
 "#####,
@@ -189,7 +191,7 @@ impl Trait<u32> for () {
 #[test]
 fn doctest_add_new() {
-    check(
+    check_doc_test(
        "add_new",
        r#####"
 struct Ctx<T: Clone> {
@@ -202,7 +204,7 @@ struct Ctx<T: Clone> {
 }
 impl<T: Clone> Ctx<T> {
-    fn new(data: T) -> Self { Self { data } }
+    fn $0new(data: T) -> Self { Self { data } }
 }
 "#####,
@@ -210,8 +212,27 @@ impl<T: Clone> Ctx<T> {
 }
 #[test]
+fn doctest_add_turbo_fish() {
+    check_doc_test(
+        "add_turbo_fish",
+        r#####"
+fn make<T>() -> T { todo!() }
+fn main() {
+    let x = make<|>();
+}
+"#####,
+        r#####"
+fn make<T>() -> T { todo!() }
+fn main() {
+    let x = make::<${0:_}>();
+}
+"#####,
+    )
+}
+#[test]
 fn doctest_apply_demorgan() {
-    check(
+    check_doc_test(
        "apply_demorgan",
        r#####"
 fn main() {
@@ -228,7 +249,7 @@ fn main() {
 #[test]
 fn doctest_auto_import() {
-    check(
+    check_doc_test(
        "auto_import",
        r#####"
 fn main() {
@@ -248,8 +269,21 @@ pub mod std { pub mod collections { pub struct HashMap { } } }
 }
 #[test]
+fn doctest_change_return_type_to_result() {
+    check_doc_test(
+        "change_return_type_to_result",
+        r#####"
+fn foo() -> i32<|> { 42i32 }
+"#####,
+        r#####"
+fn foo() -> Result<i32, ${0:_}> { Ok(42i32) }
+"#####,
+    )
+}
+#[test]
 fn doctest_change_visibility() {
-    check(
+    check_doc_test(
        "change_visibility",
        r#####"
 <|>fn frobnicate() {}
@@ -262,7 +296,7 @@ pub(crate) fn frobnicate() {}
 #[test]
 fn doctest_convert_to_guarded_return() {
-    check(
+    check_doc_test(
        "convert_to_guarded_return",
        r#####"
 fn main() {
@@ -286,7 +320,7 @@ fn main() {
 #[test]
 fn doctest_fill_match_arms() {
-    check(
+    check_doc_test(
        "fill_match_arms",
        r#####"
 enum Action { Move { distance: u32 }, Stop }
@@ -302,7 +336,7 @@ enum Action { Move { distance: u32 }, Stop }
 fn handle(action: Action) {
    match action {
-        Action::Move { distance } => {}
+        $0Action::Move { distance } => {}
        Action::Stop => {}
    }
 }
@@ -311,8 +345,31 @@ fn handle(action: Action) {
 }
 #[test]
+fn doctest_fix_visibility() {
+    check_doc_test(
+        "fix_visibility",
+        r#####"
+mod m {
+    fn frobnicate() {}
+}
+fn main() {
+    m::frobnicate<|>() {}
+}
+"#####,
+        r#####"
+mod m {
+    $0pub(crate) fn frobnicate() {}
+}
+fn main() {
+    m::frobnicate() {}
+}
+"#####,
+    )
+}
+#[test]
 fn doctest_flip_binexpr() {
-    check(
+    check_doc_test(
        "flip_binexpr",
        r#####"
 fn main() {
@@ -329,7 +386,7 @@ fn main() {
 #[test]
 fn doctest_flip_comma() {
-    check(
+    check_doc_test(
        "flip_comma",
        r#####"
 fn main() {
@@ -346,7 +403,7 @@ fn main() {
 #[test]
 fn doctest_flip_trait_bound() {
-    check(
+    check_doc_test(
        "flip_trait_bound",
        r#####"
 fn foo<T: Clone +<|> Copy>() { }
@@ -359,7 +416,7 @@ fn foo<T: Copy + Clone>() { }
 #[test]
 fn doctest_inline_local_variable() {
-    check(
+    check_doc_test(
        "inline_local_variable",
        r#####"
 fn main() {
@@ -377,7 +434,7 @@ fn main() {
 #[test]
 fn doctest_introduce_variable() {
-    check(
+    check_doc_test(
        "introduce_variable",
        r#####"
 fn main() {
@@ -386,7 +443,7 @@ fn main() {
 "#####,
        r#####"
 fn main() {
-    let var_name = (1 + 2);
+    let $0var_name = (1 + 2);
    var_name * 4;
 }
 "#####,
@@ -395,7 +452,7 @@ fn main() {
 #[test]
 fn doctest_invert_if() {
-    check(
+    check_doc_test(
        "invert_if",
        r#####"
 fn main() {
@@ -412,7 +469,7 @@ fn main() {
 #[test]
 fn doctest_make_raw_string() {
-    check(
+    check_doc_test(
        "make_raw_string",
        r#####"
 fn main() {
@@ -429,7 +486,7 @@ fn main() {
 #[test]
 fn doctest_make_usual_string() {
-    check(
+    check_doc_test(
        "make_usual_string",
        r#####"
 fn main() {
@@ -446,7 +503,7 @@ fn main() {
 #[test]
 fn doctest_merge_imports() {
-    check(
+    check_doc_test(
        "merge_imports",
        r#####"
 use std::<|>fmt::Formatter;
@@ -460,7 +517,7 @@ use std::{fmt::Formatter, io};
 #[test]
 fn doctest_merge_match_arms() {
-    check(
+    check_doc_test(
        "merge_match_arms",
        r#####"
 enum Action { Move { distance: u32 }, Stop }
@@ -486,7 +543,7 @@ fn handle(action: Action) {
 #[test]
 fn doctest_move_arm_cond_to_match_guard() {
-    check(
+    check_doc_test(
        "move_arm_cond_to_match_guard",
        r#####"
 enum Action { Move { distance: u32 }, Stop }
@@ -513,7 +570,7 @@ fn handle(action: Action) {
 #[test]
 fn doctest_move_bounds_to_where_clause() {
-    check(
+    check_doc_test(
        "move_bounds_to_where_clause",
        r#####"
 fn apply<T, U, <|>F: FnOnce(T) -> U>(f: F, x: T) -> U {
@@ -530,7 +587,7 @@ fn apply<T, U, F>(f: F, x: T) -> U where F: FnOnce(T) -> U {
 #[test]
 fn doctest_move_guard_to_arm_body() {
-    check(
+    check_doc_test(
        "move_guard_to_arm_body",
        r#####"
 enum Action { Move { distance: u32 }, Stop }
@@ -557,7 +614,7 @@ fn handle(action: Action) {
 #[test]
 fn doctest_remove_dbg() {
-    check(
+    check_doc_test(
        "remove_dbg",
        r#####"
 fn main() {
@@ -574,7 +631,7 @@ fn main() {
 #[test]
 fn doctest_remove_hash() {
-    check(
+    check_doc_test(
        "remove_hash",
        r#####"
 fn main() {
@@ -591,7 +648,7 @@ fn main() {
 #[test]
 fn doctest_remove_mut() {
-    check(
+    check_doc_test(
        "remove_mut",
        r#####"
 impl Walrus {
@@ -608,7 +665,7 @@ impl Walrus {
 #[test]
 fn doctest_reorder_fields() {
-    check(
+    check_doc_test(
        "reorder_fields",
        r#####"
 struct Foo {foo: i32, bar: i32};
@@ -623,7 +680,7 @@ const test: Foo = Foo {foo: 1, bar: 0}
 #[test]
 fn doctest_replace_if_let_with_match() {
-    check(
+    check_doc_test(
        "replace_if_let_with_match",
        r#####"
 enum Action { Move { distance: u32 }, Stop }
@@ -651,7 +708,7 @@ fn handle(action: Action) {
 #[test]
 fn doctest_replace_let_with_if_let() {
-    check(
+    check_doc_test(
        "replace_let_with_if_let",
        r#####"
 enum Option<T> { Some(T), None }
@@ -677,7 +734,7 @@ fn compute() -> Option<i32> { None }
 #[test]
 fn doctest_replace_qualified_name_with_use() {
-    check(
+    check_doc_test(
        "replace_qualified_name_with_use",
        r#####"
 fn process(map: std::collections::<|>HashMap<String, String>) {}
@@ -692,7 +749,7 @@ fn process(map: HashMap<String, String>) {}
 #[test]
 fn doctest_replace_unwrap_with_match() {
-    check(
+    check_doc_test(
        "replace_unwrap_with_match",
        r#####"
 enum Result<T, E> { Ok(T), Err(E) }
@@ -707,7 +764,7 @@ fn main() {
    let x: Result<i32, i32> = Result::Ok(92);
    let y = match x {
        Ok(a) => a,
-        _ => unreachable!(),
+        $0_ => unreachable!(),
    };
 }
 "#####,
@@ -716,7 +773,7 @@ fn main() {
 #[test]
 fn doctest_split_import() {
-    check(
+    check_doc_test(
        "split_import",
        r#####"
 use std::<|>collections::HashMap;
@@ -726,3 +783,22 @@ use std::{collections::HashMap};
 "#####,
    )
 }
+#[test]
+fn doctest_unwrap_block() {
+    check_doc_test(
+        "unwrap_block",
+        r#####"
+fn foo() {
+    if true {<|>
+        println!("foo");
+    }
+}
+"#####,
+        r#####"
+fn foo() {
+    println!("foo");
+}
+"#####,
+    )
+}
diff --git a/crates/ra_assists/src/utils.rs b/crates/ra_assists/src/utils.rs
index efd988697..0038a9764 100644
--- a/crates/ra_assists/src/utils.rs
+++ b/crates/ra_assists/src/utils.rs
@@ -1,19 +1,58 @@
 //! Assorted functions shared by several assists.
 pub(crate) mod insert_use;
-use std::iter;
+use std::{iter, ops};
-use hir::{Adt, Crate, Semantics, Trait, Type};
+use hir::{Adt, Crate, Enum, ScopeDef, Semantics, Trait, Type};
 use ra_ide_db::RootDatabase;
 use ra_syntax::{
    ast::{self, make, NameOwner},
-    AstNode, T,
+    AstNode, SyntaxNode, T,
 };
 use rustc_hash::FxHashSet;
-pub use insert_use::insert_use_statement;
+use crate::assist_config::SnippetCap;
-pub fn get_missing_impl_items(
+pub(crate) use insert_use::insert_use_statement;
+#[derive(Clone, Copy, Debug)]
+pub(crate) enum Cursor<'a> {
+    Replace(&'a SyntaxNode),
+    Before(&'a SyntaxNode),
+}
+impl<'a> Cursor<'a> {
+    fn node(self) -> &'a SyntaxNode {
+        match self {
+            Cursor::Replace(node) | Cursor::Before(node) => node,
+        }
+    }
+}
+pub(crate) fn render_snippet(_cap: SnippetCap, node: &SyntaxNode, cursor: Cursor) -> String {
+    assert!(cursor.node().ancestors().any(|it| it == *node));
+    let range = cursor.node().text_range() - node.text_range().start();
+    let range: ops::Range<usize> = range.into();
+    let mut placeholder = cursor.node().to_string();
+    escape(&mut placeholder);
+    let tab_stop = match cursor {
+        Cursor::Replace(placeholder) => format!("${{0:{}}}", placeholder),
+        Cursor::Before(placeholder) => format!("$0{}", placeholder),
+    };
+    let mut buf = node.to_string();
+    buf.replace_range(range, &tab_stop);
+    return buf;
+    fn escape(buf: &mut String) {
+        stdx::replace(buf, '{', r"\{");
+        stdx::replace(buf, '}', r"\}");
+        stdx::replace(buf, '$', r"\$");
+    }
+}
+pub fn get_missing_assoc_items(
    sema: &Semantics<RootDatabase>,
    impl_def: &ast::ImplDef,
 ) -> Vec<hir::AssocItem> {
@@ -23,21 +62,21 @@ pub fn get_missing_impl_items(
    let mut impl_type = FxHashSet::default();
    if let Some(item_list) = impl_def.item_list() {
-        for item in item_list.impl_items() {
+        for item in item_list.assoc_items() {
            match item {
-                ast::ImplItem::FnDef(f) => {
+                ast::AssocItem::FnDef(f) => {
                    if let Some(n) = f.name() {
                        impl_fns_consts.insert(n.syntax().to_string());
                    }
                }
-                ast::ImplItem::TypeAliasDef(t) => {
+                ast::AssocItem::TypeAliasDef(t) => {
                    if let Some(n) = t.name() {
                        impl_type.insert(n.syntax().to_string());
                    }
                }
-                ast::ImplItem::ConstDef(c) => {
+                ast::AssocItem::ConstDef(c) => {
                    if let Some(n) = c.name() {
                        impl_fns_consts.insert(n.syntax().to_string());
                    }
@@ -103,7 +142,7 @@ fn invert_special_case(expr: &ast::Expr) -> Option<ast::Expr> {
 }
 #[derive(Clone, Copy)]
-pub(crate) enum TryEnum {
+pub enum TryEnum {
    Result,
    Option,
 }
@@ -111,7 +150,7 @@ pub(crate) enum TryEnum {
 impl TryEnum {
    const ALL: [TryEnum; 2] = [TryEnum::Option, TryEnum::Result];
-    pub(crate) fn from_ty(sema: &Semantics<RootDatabase>, ty: &Type) -> Option<TryEnum> {
+    pub fn from_ty(sema: &Semantics<RootDatabase>, ty: &Type) -> Option<TryEnum> {
        let enum_ = match ty.as_adt() {
            Some(Adt::Enum(it)) => it,
            _ => return None,
@@ -161,13 +200,19 @@ impl FamousDefs<'_, '_> {
    #[cfg(test)]
    pub(crate) const FIXTURE: &'static str = r#"
 //- /libcore.rs crate:core
-pub mod convert{
+pub mod convert {
    pub trait From<T> {
        fn from(T) -> Self;
    }
 }
-pub mod prelude { pub use crate::convert::From }
+pub mod option {
+    pub enum Option<T> { None, Some(T)}
+}
+pub mod prelude {
+    pub use crate::{convert::From, option::Option::{self, *}};
+}
 #[prelude_import]
 pub use prelude::*;
 "#;
@@ -176,7 +221,25 @@ pub use prelude::*;
        self.find_trait("core:convert:From")
    }
+    pub(crate) fn core_option_Option(&self) -> Option<Enum> {
+        self.find_enum("core:option:Option")
+    }
    fn find_trait(&self, path: &str) -> Option<Trait> {
+        match self.find_def(path)? {
+            hir::ScopeDef::ModuleDef(hir::ModuleDef::Trait(it)) => Some(it),
+            _ => None,
+        }
+    }
+    fn find_enum(&self, path: &str) -> Option<Enum> {
+        match self.find_def(path)? {
+            hir::ScopeDef::ModuleDef(hir::ModuleDef::Adt(hir::Adt::Enum(it))) => Some(it),
+            _ => None,
+        }
+    }
+    fn find_def(&self, path: &str) -> Option<ScopeDef> {
        let db = self.0.db;
        let mut path = path.split(':');
        let trait_ = path.next_back()?;
@@ -201,9 +264,6 @@ pub use prelude::*;
        }
        let def =
            module.scope(db, None).into_iter().find(|(name, _def)| &name.to_string() == trait_)?.1;
-        match def {
+        Some(def)
-            hir::ScopeDef::ModuleDef(hir::ModuleDef::Trait(it)) => Some(it),
-            _ => None,
-        }
    }
 }
diff --git a/crates/ra_assists/src/utils/insert_use.rs b/crates/ra_assists/src/utils/insert_use.rs
index c507e71e0..0ee43482f 100644
--- a/crates/ra_assists/src/utils/insert_use.rs
+++ b/crates/ra_assists/src/utils/insert_use.rs
@@ -11,17 +11,20 @@ use ra_syntax::{
 };
 use ra_text_edit::TextEditBuilder;
+use crate::assist_context::AssistContext;
 /// 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(
+pub(crate) fn insert_use_statement(
    // Ideally the position of the cursor, used to
    position: &SyntaxNode,
    path_to_import: &ModPath,
-    edit: &mut TextEditBuilder,
+    ctx: &AssistContext,
+    builder: &mut TextEditBuilder,
 ) {
    let target = path_to_import.to_string().split("::").map(SmolStr::new).collect::<Vec<_>>();
-    let container = position.ancestors().find_map(|n| {
+    let container = ctx.sema.ancestors_with_macros(position.clone()).find_map(|n| {
        if let Some(module) = ast::Module::cast(n.clone()) {
            return module.item_list().map(|it| it.syntax().clone());
        }
@@ -30,7 +33,7 @@ pub fn insert_use_statement(
    if let Some(container) = container {
        let action = best_action_for_target(container, position.clone(), &target);
-        make_assist(&action, &target, edit);
+        make_assist(&action, &target, builder);
    }
 }