61 files changed, 2297 insertions, 1008 deletions
diff --git a/crates/ra_assists/src/assist_context.rs b/crates/ra_assists/src/assist_context.rs
new file mode 100644
index 000000000..3085c4330
--- /dev/null
+++ b/crates/ra_assists/src/assist_context.rs
@@ -0,0 +1,233 @@
+//! 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, 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) sema: Semantics<'a, RootDatabase>,
+    pub(super) db: &'a RootDatabase,
+    pub(crate) frange: FileRange,
+    source_file: SourceFile,
+}
+impl<'a> AssistContext<'a> {
+    pub fn new(sema: Semantics<'a, RootDatabase>, frange: FileRange) -> AssistContext<'a> {
+        let source_file = sema.parse(frange.file_id);
+        let db = sema.db;
+        AssistContext { 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,
+    cursor_position: Option<TextSize>,
+    file: FileId,
+}
+impl AssistBuilder {
+    pub(crate) fn new(file: FileId) -> AssistBuilder {
+        AssistBuilder { edit: TextEditBuilder::default(), cursor_position: None, file }
+    }
+    /// 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())
+    }
+    /// 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())
+    }
+    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)
+    }
+    /// 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)
+    }
+    // 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();
+        if edit.is_empty() && self.cursor_position.is_none() {
+            panic!("Only call `add_assist` if the assist can be applied")
+        }
+        SingleFileChange { label: change_label, edit, cursor_position: self.cursor_position }
+            .into_source_change(self.file)
+    }
+}
diff --git a/crates/ra_assists/src/assist_ctx.rs b/crates/ra_assists/src/assist_ctx.rs
deleted file mode 100644
index 83dd270c6..000000000
--- a/crates/ra_assists/src/assist_ctx.rs
+++ /dev/null
@@ -1,274 +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, SyntaxRewriter},
-    AstNode, SourceFile, SyntaxElement, SyntaxKind, SyntaxNode, SyntaxToken, TextRange, TextSize,
-    TokenAtOffset,
-};
-use ra_text_edit::TextEditBuilder;
-use crate::{AssistAction, AssistFile, AssistId, AssistLabel, GroupLabel, ResolvedAssist};
-#[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;
-        self.action.map(|action| ResolvedAssist { label, action })
-    }
-}
-/// `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(id, label.into(), None);
-        let mut info = AssistInfo::new(label);
-        if self.should_compute_edit {
-            let action = {
-                let mut edit = ActionBuilder::new(&self);
-                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> {
-        let group = GroupLabel(group_name.into());
-        AssistGroup { ctx: self, group, 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 find_node_at_offset_with_descend<N: AstNode>(&self) -> Option<N> {
-        self.sema
-            .find_node_at_offset_with_descend(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: GroupLabel,
-    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(id, label.into(), Some(self.group.clone()));
-        let mut info = AssistInfo::new(label).with_group(self.group.clone());
-        if self.ctx.should_compute_edit {
-            let action = {
-                let mut edit = ActionBuilder::new(&self.ctx);
-                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))
-        }
-    }
-}
-pub(crate) struct ActionBuilder<'a, 'b> {
-    edit: TextEditBuilder,
-    cursor_position: Option<TextSize>,
-    target: Option<TextRange>,
-    file: AssistFile,
-    ctx: &'a AssistCtx<'b>,
-}
-impl<'a, 'b> ActionBuilder<'a, 'b> {
-    fn new(ctx: &'a AssistCtx<'b>) -> Self {
-        Self {
-            edit: TextEditBuilder::default(),
-            cursor_position: None,
-            target: None,
-            file: AssistFile::default(),
-            ctx,
-        }
-    }
-    pub(crate) fn ctx(&self) -> &AssistCtx<'b> {
-        &self.ctx
-    }
-    /// 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/doc_tests.rs b/crates/ra_assists/src/doc_tests.rs
deleted file mode 100644
index f627f31dc..000000000
--- a/crates/ra_assists/src/doc_tests.rs
+++ /dev/null
@@ -1,39 +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 = {
-        let mut actual = before.clone();
-        assist.action.edit.apply(&mut actual);
-        actual
-    };
-    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..795a225a4 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
 //
@@ -25,7 +28,7 @@ use crate::{Assist, AssistCtx, AssistId};
 //
 // }
 // ```
-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)?;
@@ -48,9 +51,8 @@ pub(crate) fn add_custom_impl(ctx: AssistCtx) -> Option<Assist> {
    let label =
        format!("Add custom impl '{}' for '{}'", trait_token.text().as_str(), annotated_name);
-    ctx.add_assist(AssistId("add_custom_impl"), label, |edit| {
+    let target = attr.syntax().text_range();
-        edit.target(attr.syntax().text_range());
+    acc.add(AssistId("add_custom_impl"), label, target, |edit| {
        let new_attr_input = input
            .syntax()
            .descendants_with_tokens()
@@ -95,7 +97,7 @@ pub(crate) fn add_custom_impl(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::*;
diff --git a/crates/ra_assists/src/handlers/add_derive.rs b/crates/ra_assists/src/handlers/add_derive.rs
index 6254eb7c4..fb08c19e9 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
 //
@@ -24,10 +24,11 @@ use crate::{Assist, AssistCtx, AssistId};
 //     y: u32,
 // }
 // ```
-pub(crate) fn add_derive(ctx: AssistCtx) -> Option<Assist> {
+pub(crate) fn add_derive(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
    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, |edit| {
        let derive_attr = nominal
            .attrs()
            .filter_map(|x| x.as_simple_call())
@@ -41,7 +42,6 @@ pub(crate) fn add_derive(ctx: AssistCtx) -> Option<Assist> {
            }
            Some(tt) => tt.syntax().text_range().end() - TextSize::of(')'),
        };
-        edit.target(nominal.syntax().text_range());
        edit.set_cursor(offset)
    })
 }
@@ -57,8 +57,9 @@ 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() {
diff --git a/crates/ra_assists/src/handlers/add_explicit_type.rs b/crates/ra_assists/src/handlers/add_explicit_type.rs
index bc313782b..55409e501 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,7 +21,7 @@ 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 expr = stmt.initializer()?;
    let pat = stmt.pat()?;
@@ -59,11 +59,11 @@ pub(crate) fn add_explicit_type(ctx: AssistCtx) -> Option<Assist> {
    let db = ctx.db;
    let new_type_string = ty.display_truncated(db, None).to_string();
-    ctx.add_assist(
+    acc.add(
        AssistId("add_explicit_type"),
        format!("Insert explicit type '{}'", new_type_string),
+        pat_range,
        |edit| {
-            edit.target(pat_range);
            if let Some(ascribed_ty) = ascribed_ty {
                edit.replace(ascribed_ty.syntax().text_range(), new_type_string);
            } else {
@@ -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() {
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..275184e24 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
@@ -4,10 +4,10 @@ use ra_syntax::{
    TextSize,
 };
 use stdx::format_to;
-use crate::{utils::FamousDefs, Assist, AssistCtx, AssistId};
 use test_utils::tested_by;
+use crate::{utils::FamousDefs, AssistContext, AssistId, Assists};
 // Assist add_from_impl_for_enum
 //
 // Adds a From impl for an enum variant with one tuple field
@@ -25,7 +25,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()?;
@@ -42,14 +42,16 @@ pub(crate) fn add_from_impl_for_enum(ctx: AssistCtx) -> Option<Assist> {
        _ => 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);
        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();
@@ -97,7 +99,7 @@ fn existing_from_impl(
 mod tests {
    use super::*;
-    use crate::helpers::{check_assist, check_assist_not_applicable};
+    use crate::tests::{check_assist, check_assist_not_applicable};
    use test_utils::covers;
    #[test]
diff --git a/crates/ra_assists/src/handlers/add_function.rs b/crates/ra_assists/src/handlers/add_function.rs
index 6c7456579..6b5616aa9 100644
--- a/crates/ra_assists/src/handlers/add_function.rs
+++ b/crates/ra_assists/src/handlers/add_function.rs
@@ -1,13 +1,13 @@
+use hir::HirDisplay;
+use ra_db::FileId;
 use ra_syntax::{
-    ast::{self, AstNode},
+    ast::{self, edit::IndentLevel, 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::{AssistContext, AssistId, Assists};
 // Assist: add_function
 //
 // Adds a stub function with a signature matching the function under the cursor.
@@ -33,7 +33,7 @@ use rustc_hash::{FxHashMap, FxHashSet};
 // }
 //
 // ```
-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()?;
@@ -57,14 +57,12 @@ pub(crate) fn add_function(ctx: AssistCtx) -> Option<Assist> {
    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, |edit| {
+        let function_template = function_builder.render();
-        if let Some(function_template) = function_builder.render() {
+        edit.set_file(function_template.file);
-            edit.set_file(function_template.file);
+        edit.set_cursor(function_template.cursor_offset);
-            edit.set_cursor(function_template.cursor_offset);
+        edit.insert(function_template.insert_offset, function_template.fn_def.to_string());
-            edit.insert(function_template.insert_offset, function_template.fn_def.to_string());
-        }
    })
 }
@@ -72,7 +70,7 @@ struct FunctionTemplate {
    insert_offset: TextSize,
    cursor_offset: TextSize,
    fn_def: ast::SourceFile,
-    file: AssistFile,
+    file: FileId,
 }
 struct FunctionBuilder {
@@ -80,7 +78,7 @@ struct FunctionBuilder {
    fn_name: ast::Name,
    type_params: Option<ast::TypeParamList>,
    params: ast::ParamList,
-    file: AssistFile,
+    file: FileId,
    needs_pub: bool,
 }
@@ -88,13 +86,13 @@ impl FunctionBuilder {
    /// Prepares a generated function that matches `call` in `generate_in`
    /// (or as close to `call` as possible, if `generate_in` is `None`)
    fn from_call(
-        ctx: &AssistCtx,
+        ctx: &AssistContext,
        call: &ast::CallExpr,
        path: &ast::Path,
        target_module: Option<hir::InFile<hir::ModuleSource>>,
    ) -> Option<Self> {
        let needs_pub = target_module.is_some();
-        let mut file = AssistFile::default();
+        let mut file = ctx.frange.file_id;
        let target = if let Some(target_module) = target_module {
            let (in_file, target) = next_space_for_fn_in_module(ctx.sema.db, target_module)?;
            file = in_file;
@@ -107,7 +105,7 @@ impl FunctionBuilder {
        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 fn_body = ast::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);
@@ -133,15 +131,11 @@ impl FunctionBuilder {
            }
        };
-        let cursor_offset_from_fn_start = fn_def
+        let placeholder_expr =
-            .syntax()
+            fn_def.syntax().descendants().find_map(ast::MacroCall::cast).unwrap();
-            .descendants()
+        let cursor_offset_from_fn_start = placeholder_expr.syntax().text_range().start();
-            .find_map(ast::MacroCall::cast)?
-            .syntax()
-            .text_range()
-            .start();
        let cursor_offset = insert_offset + cursor_offset_from_fn_start;
-        Some(FunctionTemplate { insert_offset, cursor_offset, fn_def, file: self.file })
+        FunctionTemplate { insert_offset, cursor_offset, fn_def, file: self.file }
    }
 }
@@ -157,7 +151,7 @@ fn fn_name(call: &ast::Path) -> Option<ast::Name> {
 /// Computes the type variables and arguments required for the generated function
 fn fn_args(
-    ctx: &AssistCtx,
+    ctx: &AssistContext,
    call: &ast::CallExpr,
 ) -> Option<(Option<ast::TypeParamList>, ast::ParamList)> {
    let mut arg_names = Vec::new();
@@ -224,7 +218,7 @@ 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, fn_arg: &ast::Expr) -> Option<String> {
    let ty = ctx.sema.type_of_expr(fn_arg)?;
    if ty.is_unknown() {
        return None;
@@ -259,9 +253,8 @@ 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>,
-) -> Option<(AssistFile, GeneratedFunctionTarget)> {
+) -> Option<(FileId, GeneratedFunctionTarget)> {
    let file = module.file_id.original_file(db);
-    let assist_file = AssistFile::TargetFile(file);
    let assist_item = match module.value {
        hir::ModuleSource::SourceFile(it) => {
            if let Some(last_item) = it.items().last() {
@@ -278,12 +271,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::*;
diff --git a/crates/ra_assists/src/handlers/add_impl.rs b/crates/ra_assists/src/handlers/add_impl.rs
index d26f8b93d..df114a0d8 100644
--- a/crates/ra_assists/src/handlers/add_impl.rs
+++ b/crates/ra_assists/src/handlers/add_impl.rs
@@ -4,7 +4,7 @@ use ra_syntax::{
 };
 use stdx::{format_to, SepBy};
-use crate::{Assist, AssistCtx, AssistId};
+use crate::{AssistContext, AssistId, Assists};
 // Assist: add_impl
 //
@@ -25,11 +25,11 @@ use crate::{Assist, AssistCtx, AssistId};
 //
 // }
 // ```
-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();
@@ -60,7 +60,7 @@ pub(crate) fn add_impl(ctx: AssistCtx) -> Option<Assist> {
 #[cfg(test)]
 mod tests {
    use super::*;
-    use crate::helpers::{check_assist, check_assist_target};
+    use crate::tests::{check_assist, check_assist_target};
    #[test]
    fn test_add_impl() {
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 e47feda71..3482a75bf 100644
--- a/crates/ra_assists/src/handlers/add_missing_impl_members.rs
+++ b/crates/ra_assists/src/handlers/add_missing_impl_members.rs
@@ -9,9 +9,10 @@ use ra_syntax::{
 };
 use crate::{
+    assist_context::{AssistContext, Assists},
    ast_transform::{self, AstTransform, QualifyPaths, SubstituteTypeParams},
    utils::{get_missing_assoc_items, resolve_target_trait},
-    Assist, AssistCtx, AssistId,
+    AssistId,
 };
 #[derive(PartialEq)]
@@ -50,8 +51,9 @@ enum AddMissingImplMembersMode {
 //
 // }
 // ```
-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",
@@ -91,8 +93,9 @@ pub(crate) fn add_missing_impl_members(ctx: AssistCtx) -> Option<Assist> {
 //
 // }
 // ```
-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",
@@ -101,16 +104,17 @@ 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::AssocItem| -> Option<SmolStr> {
        match item {
@@ -121,7 +125,7 @@ fn add_missing_impl_members_inner(
        .map(|it| it.text().clone())
    };
-    let missing_items = get_missing_assoc_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::AssocItem::FnDef(i.source(ctx.db).value),
@@ -142,14 +146,13 @@ 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, |edit| {
-    ctx.add_assist(AssistId(assist_id), label, |edit| {
        let n_existing_items = impl_item_list.assoc_items().count();
-        let source_scope = sema.scope_for_def(trait_);
+        let source_scope = ctx.sema.scope_for_def(trait_);
-        let target_scope = sema.scope(impl_item_list.syntax());
+        let target_scope = ctx.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))
@@ -170,18 +173,17 @@ fn add_missing_impl_members_inner(
 }
 fn add_body(fn_def: ast::FnDef) -> ast::FnDef {
-    if fn_def.body().is_none() {
+    if fn_def.body().is_some() {
-        let body = make::block_expr(None, Some(make::expr_todo()));
+        return fn_def;
-        let body = IndentLevel(1).increase_indent(body);
-        fn_def.with_body(body)
-    } else {
-        fn_def
    }
+    let body = make::block_expr(None, Some(make::expr_todo()));
+    let body = IndentLevel(1).increase_indent(body);
+    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::*;
diff --git a/crates/ra_assists/src/handlers/add_new.rs b/crates/ra_assists/src/handlers/add_new.rs
index e8a36c7de..fe7451dcf 100644
--- a/crates/ra_assists/src/handlers/add_new.rs
+++ b/crates/ra_assists/src/handlers/add_new.rs
@@ -7,7 +7,7 @@ use ra_syntax::{
 };
 use stdx::{format_to, SepBy};
-use crate::{Assist, AssistCtx, AssistId};
+use crate::{AssistContext, AssistId, Assists};
 // Assist: add_new
 //
@@ -29,7 +29,7 @@ use crate::{Assist, AssistCtx, AssistId};
 // }
 //
 // ```
-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,9 +41,8 @@ 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, |edit| {
        let mut buf = String::with_capacity(512);
        if impl_def.is_some() {
@@ -124,7 +123,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())
@@ -178,7 +177,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::*;
diff --git a/crates/ra_assists/src/handlers/apply_demorgan.rs b/crates/ra_assists/src/handlers/apply_demorgan.rs
index 260b9e073..0feba5e11 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,7 +59,7 @@ 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() {
diff --git a/crates/ra_assists/src/handlers/auto_import.rs b/crates/ra_assists/src/handlers/auto_import.rs
index db6c4d2fa..78d23150d 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,7 +34,7 @@ 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() {
@@ -46,14 +42,19 @@ pub(crate) fn auto_import(ctx: AssistCtx) -> Option<Assist> {
    }
    let range = ctx.sema.original_range(&auto_import_assets.syntax_under_caret).range;
-    let mut group = ctx.add_assist_group(auto_import_assets.get_import_group_message());
+    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(range);
+            &group,
-            insert_use_statement(&auto_import_assets.syntax_under_caret, &import, edit);
+            AssistId("auto_import"),
-        });
+            format!("Import `{}`", &import),
+            range,
+            |builder| {
+                insert_use_statement(&auto_import_assets.syntax_under_caret, &import, ctx, builder);
+            },
+        );
    }
-    group.finish()
+    Some(())
 }
 #[derive(Debug)]
@@ -64,7 +65,7 @@ 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_with_descend::<ast::Path>() {
            Self::for_regular_path(path_under_caret, &ctx)
        } else {
@@ -72,7 +73,7 @@ impl AutoImportAssets {
        }
    }
-    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 {
@@ -82,7 +83,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;
@@ -105,8 +106,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)
@@ -117,7 +118,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> {
@@ -277,7 +279,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() {
@@ -384,7 +386,7 @@ mod tests {
            }
            ",
            r"
-            use PubMod1::PubStruct;
+            use PubMod3::PubStruct;
            PubSt<|>ruct
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..5c907097e
--- /dev/null
+++ b/crates/ra_assists/src/handlers/change_return_type_to_result.rs
@@ -0,0 +1,971 @@
+use ra_syntax::{
+    ast::{self, BlockExpr, Expr, LoopBodyOwner},
+    AstNode,
+    SyntaxKind::{COMMENT, WHITESPACE},
+    SyntaxNode, TextSize,
+};
+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, > { Ok(42i32) }
+// ```
+pub(crate) fn change_return_type_to_result(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
+    let fn_def = ctx.find_node_at_offset::<ast::FnDef>();
+    let fn_def = &mut fn_def?;
+    let ret_type = &fn_def.ret_type()?.type_ref()?;
+    if ret_type.syntax().text().to_string().starts_with("Result<") {
+        return None;
+    }
+    let block_expr = &fn_def.body()?;
+    let cursor_in_ret_type =
+        fn_def.ret_type()?.syntax().text_range().contains_range(ctx.frange.range);
+    if !cursor_in_ret_type {
+        return None;
+    }
+    acc.add(
+        AssistId("change_return_type_to_result"),
+        "Change return type to Result",
+        ret_type.syntax().text_range(),
+        |edit| {
+            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 {
+                edit.replace_node_and_indent(&ret_expr_arg, format!("Ok({})", ret_expr_arg));
+            }
+            edit.replace_node_and_indent(ret_type.syntax(), format!("Result<{}, >", ret_type));
+            if let Some(node_start) = result_insertion_offset(&ret_type) {
+                edit.set_cursor(node_start + TextSize::of(&format!("Result<{}, ", ret_type)));
+            }
+        },
+    )
+}
+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,
+    }
+}
+fn result_insertion_offset(ret_type: &ast::TypeRef) -> Option<TextSize> {
+    let non_ws_child = ret_type
+        .syntax()
+        .children_with_tokens()
+        .find(|it| it.kind() != COMMENT && it.kind() != WHITESPACE)?;
+    Some(non_ws_child.text_range().start())
+}
+#[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, <|>> {
+                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, <|>> {
+                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, <|>> {
+                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, <|>> {
+                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, <|>> {
+                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, <|>> {
+                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, <|>> {
+                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, <|>> {
+                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], <|>> {
+                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, <|>> {
+                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, <|>> {
+                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, <|>> {
+                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, <|>> {
+                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, <|>> {
+                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, <|>> {
+                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, <|>> {
+                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, <|>> {
+                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, <|>> {
+                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, <|>> {
+                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, <|>> {
+                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, <|>> {
+                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, <|>> {
+                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, <|>> {
+                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, <|>> {
+                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, <|>> {
+                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, <|>> {
+                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 1cd532e80..e631766ef 100644
--- a/crates/ra_assists/src/handlers/change_visibility.rs
+++ b/crates/ra_assists/src/handlers/change_visibility.rs
@@ -7,10 +7,10 @@ use ra_syntax::{
    },
    SyntaxNode, TextSize, T,
 };
-use crate::{Assist, AssistCtx, AssistId};
 use test_utils::tested_by;
+use crate::{AssistContext, AssistId, Assists};
 // Assist: change_visibility
 //
 // Adds or changes existing visibility specifier.
@@ -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,
@@ -66,8 +66,7 @@ fn add_vis(ctx: AssistCtx) -> Option<Assist> {
        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);
    })
@@ -84,24 +83,30 @@ 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");
+                edit.set_cursor(vis.syntax().text_range().start());
+            },
+        );
    }
    None
 }
@@ -110,7 +115,7 @@ fn change_vis(ctx: AssistCtx, vis: ast::Visibility) -> Option<Assist> {
 mod tests {
    use test_utils::covers;
-    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::*;
diff --git a/crates/ra_assists/src/handlers/early_return.rs b/crates/ra_assists/src/handlers/early_return.rs
index eede2fe91..810784ad5 100644
--- a/crates/ra_assists/src/handlers/early_return.rs
+++ b/crates/ra_assists/src/handlers/early_return.rs
@@ -9,7 +9,7 @@ use ra_syntax::{
 };
 use crate::{
-    assist_ctx::{Assist, AssistCtx},
+    assist_context::{AssistContext, Assists},
    utils::invert_boolean_expression,
    AssistId,
 };
@@ -36,7 +36,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;
@@ -93,9 +93,10 @@ 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();
+    let cursor_position = ctx.offset();
-    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 => {
@@ -143,7 +144,6 @@ pub(crate) fn convert_to_guarded_return(ctx: AssistCtx) -> Option<Assist> {
                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.set_cursor(cursor_position);
@@ -182,7 +182,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::*;
diff --git a/crates/ra_assists/src/handlers/fill_match_arms.rs b/crates/ra_assists/src/handlers/fill_match_arms.rs
index 8d1af9933..13c1e7e80 100644
--- a/crates/ra_assists/src/handlers/fill_match_arms.rs
+++ b/crates/ra_assists/src/handlers/fill_match_arms.rs
@@ -5,7 +5,7 @@ use itertools::Itertools;
 use ra_ide_db::RootDatabase;
 use ra_syntax::ast::{self, make, AstNode, MatchArm, NameOwner, Pat};
-use crate::{Assist, AssistCtx, AssistId};
+use crate::{AssistContext, AssistId, Assists};
 // Assist: fill_match_arms
 //
@@ -31,7 +31,7 @@ use crate::{Assist, AssistCtx, AssistId};
 //     }
 // }
 // ```
-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()?;
@@ -92,10 +92,9 @@ 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();
+    acc.add(AssistId("fill_match_arms"), "Fill match arms", target, |edit| {
        let new_arm_list = match_arm_list.remove_placeholder().append_arms(missing_arms);
-        edit.target(match_expr.syntax().text_range());
        edit.set_cursor(expr.syntax().text_range().start());
        edit.replace_ast(match_arm_list, new_arm_list);
    })
@@ -168,7 +167,7 @@ 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 crate::tests::{check_assist, check_assist_not_applicable, check_assist_target};
    use super::fill_match_arms;
diff --git a/crates/ra_assists/src/handlers/flip_binexpr.rs b/crates/ra_assists/src/handlers/flip_binexpr.rs
index 8030efb35..692ba4895 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() {
diff --git a/crates/ra_assists/src/handlers/flip_comma.rs b/crates/ra_assists/src/handlers/flip_comma.rs
index 1dacf29f8..dfe2a7fed 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,7 +38,7 @@ 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() {
diff --git a/crates/ra_assists/src/handlers/flip_trait_bound.rs b/crates/ra_assists/src/handlers/flip_trait_bound.rs
index f56769624..8a08702ab 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() {
diff --git a/crates/ra_assists/src/handlers/inline_local_variable.rs b/crates/ra_assists/src/handlers/inline_local_variable.rs
index 60ec536a7..5b26814d3 100644
--- a/crates/ra_assists/src/handlers/inline_local_variable.rs
+++ b/crates/ra_assists/src/handlers/inline_local_variable.rs
@@ -5,7 +5,10 @@ use ra_syntax::{
 };
 use test_utils::tested_by;
-use crate::{assist_ctx::ActionBuilder, Assist, AssistCtx, AssistId};
+use crate::{
+    assist_context::{AssistContext, Assists},
+    AssistId,
+};
 // Assist: inline_local_variable
 //
@@ -23,7 +26,7 @@ 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,
@@ -33,7 +36,7 @@ pub(crate) fn inline_local_variable(ctx: AssistCtx) -> Option<Assist> {
        tested_by!(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);
        return None;
    }
@@ -106,26 +109,22 @@ 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() };
+        builder.set_cursor(delete_range.start())
-                edit.replace(desc.file_range.range, replacement)
+    })
-            }
-            edit.set_cursor(delete_range.start())
-        },
-    )
 }
 #[cfg(test)]
 mod tests {
    use test_utils::covers;
-    use crate::helpers::{check_assist, check_assist_not_applicable};
+    use crate::tests::{check_assist, check_assist_not_applicable};
    use super::*;
diff --git a/crates/ra_assists/src/handlers/introduce_variable.rs b/crates/ra_assists/src/handlers/introduce_variable.rs
index 39c656305..fdf3ada0d 100644
--- a/crates/ra_assists/src/handlers/introduce_variable.rs
+++ b/crates/ra_assists/src/handlers/introduce_variable.rs
@@ -9,7 +9,7 @@ use ra_syntax::{
 use stdx::format_to;
 use test_utils::tested_by;
-use crate::{Assist, AssistCtx, AssistId};
+use crate::{AssistContext, AssistId, Assists};
 // Assist: introduce_variable
 //
@@ -27,7 +27,7 @@ use crate::{Assist, AssistCtx, AssistId};
 //     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;
    }
@@ -42,7 +42,8 @@ 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 {
@@ -79,7 +80,6 @@ pub(crate) fn introduce_variable(ctx: AssistCtx) -> Option<Assist> {
                buf.push_str(text);
            }
-            edit.target(expr.syntax().text_range());
            edit.replace(expr.syntax().text_range(), "var_name".to_string());
            edit.insert(anchor_stmt.text_range().start(), buf);
            if wrap_in_block {
@@ -136,7 +136,7 @@ fn anchor_stmt(expr: ast::Expr) -> Option<(SyntaxNode, bool)> {
 mod tests {
    use test_utils::covers;
-    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::*;
diff --git a/crates/ra_assists/src/handlers/invert_if.rs b/crates/ra_assists/src/handlers/invert_if.rs
index 682e08512..527c7caef 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,29 +44,28 @@ 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() {
diff --git a/crates/ra_assists/src/handlers/merge_imports.rs b/crates/ra_assists/src/handlers/merge_imports.rs
index 4be1238f1..ac3e53c27 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,11 @@ 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| {
+        builder.rewrite(rewriter);
        // FIXME: we only need because our diff is imprecise
-        edit.set_cursor(offset);
+        builder.set_cursor(offset);
    })
 }
@@ -125,7 +129,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::*;
diff --git a/crates/ra_assists/src/handlers/merge_match_arms.rs b/crates/ra_assists/src/handlers/merge_match_arms.rs
index 5a77d3dbc..d4e38aa6a 100644
--- a/crates/ra_assists/src/handlers/merge_match_arms.rs
+++ b/crates/ra_assists/src/handlers/merge_match_arms.rs
@@ -6,7 +6,7 @@ use ra_syntax::{
    Direction, TextSize,
 };
-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() {
@@ -45,7 +45,7 @@ pub(crate) fn merge_match_arms(ctx: AssistCtx) -> Option<Assist> {
        InExpr(TextSize),
        InPat(TextSize),
    }
-    let cursor_pos = ctx.frange.range.start();
+    let cursor_pos = ctx.offset();
    let cursor_pos = if current_expr.syntax().text_range().contains(cursor_pos) {
        CursorPos::InExpr(current_text_range.end() - cursor_pos)
    } else {
@@ -70,7 +70,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,7 +87,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,
@@ -105,7 +104,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::*;
diff --git a/crates/ra_assists/src/handlers/move_bounds.rs b/crates/ra_assists/src/handlers/move_bounds.rs
index 0f26884dc..a41aacfc3 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() {
diff --git a/crates/ra_assists/src/handlers/move_guard.rs b/crates/ra_assists/src/handlers/move_guard.rs
index b084dd9ee..fc0335b57 100644
--- a/crates/ra_assists/src/handlers/move_guard.rs
+++ b/crates/ra_assists/src/handlers/move_guard.rs
@@ -4,7 +4,7 @@ use ra_syntax::{
    TextSize,
 };
-use crate::{Assist, AssistCtx, AssistId};
+use crate::{AssistContext, AssistId, Assists};
 // Assist: move_guard_to_arm_body
 //
@@ -31,7 +31,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,8 +40,8 @@ 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()) {
            Some(tok) => {
                if ast::Whitespace::cast(tok.clone()).is_some() {
@@ -88,7 +88,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,11 +108,12 @@ 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();
            match &then_block.expr() {
@@ -132,7 +133,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() {
diff --git a/crates/ra_assists/src/handlers/raw_string.rs b/crates/ra_assists/src/handlers/raw_string.rs
index 567400b9c..c20ffe0b3 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() {
diff --git a/crates/ra_assists/src/handlers/remove_dbg.rs b/crates/ra_assists/src/handlers/remove_dbg.rs
index 4e5eb4350..8eef578cf 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")? {
@@ -57,8 +57,8 @@ 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, |edit| {
        edit.replace(macro_range, macro_content);
        edit.set_cursor(cursor_pos);
    })
@@ -90,7 +90,7 @@ 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() {
diff --git a/crates/ra_assists/src/handlers/remove_mut.rs b/crates/ra_assists/src/handlers/remove_mut.rs
index e598023b2..dce546db7 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,7 +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();
+    acc.add(AssistId("remove_mut"), "Remove `mut` keyword", target, |edit| {
        edit.set_cursor(delete_from);
        edit.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..757f6406e 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::*;
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..a59a06efa 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
@@ -4,7 +4,7 @@ use ra_syntax::{
    AstNode,
 };
-use crate::{utils::TryEnum, Assist, AssistCtx, AssistId};
+use crate::{utils::TryEnum, AssistContext, AssistId, Assists};
 // Assist: replace_if_let_with_match
 //
@@ -32,7 +32,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,17 +43,18 @@ 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);
@@ -64,7 +65,6 @@ pub(crate) fn replace_if_let_with_match(ctx: AssistCtx) -> Option<Assist> {
        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,7 +74,7 @@ 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() {
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..d3f214591 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(
@@ -67,14 +64,13 @@ pub(crate) fn replace_let_with_if_let(ctx: AssistCtx) -> Option<Assist> {
        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::*;
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 ff2463c77..1a81d8a0e 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);
+            insert_use_statement(path.syntax(), &path_to_import, ctx, 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::*;
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..a46998b8e 100644
--- a/crates/ra_assists/src/handlers/replace_unwrap_with_match.rs
+++ b/crates/ra_assists/src/handlers/replace_unwrap_with_match.rs
@@ -5,7 +5,7 @@ use ra_syntax::{
    AstNode,
 };
-use crate::{utils::TryEnum, Assist, AssistCtx, AssistId};
+use crate::{utils::TryEnum, AssistContext, AssistId, Assists};
 // Assist: replace_unwrap_with_match
 //
@@ -29,7 +29,7 @@ use crate::{utils::TryEnum, Assist, AssistCtx, AssistId};
 //     };
 // }
 // ```
-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 +37,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, |edit| {
        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();
@@ -54,7 +54,6 @@ pub(crate) fn replace_unwrap_with_match(ctx: AssistCtx) -> Option<Assist> {
        let match_expr = make::expr_match(caller.clone(), match_arm_list);
        let match_expr = IndentLevel::from_node(method_call.syntax()).increase_indent(match_expr);
-        edit.target(method_call.syntax().text_range());
        edit.set_cursor(caller.syntax().text_range().start());
        edit.replace_ast::<ast::Expr>(method_call.into(), match_expr);
    })
@@ -63,7 +62,7 @@ pub(crate) fn replace_unwrap_with_match(ctx: AssistCtx) -> Option<Assist> {
 #[cfg(test)]
 mod tests {
    use super::*;
-    use crate::helpers::{check_assist, check_assist_target};
+    use crate::tests::{check_assist, check_assist_target};
    #[test]
    fn test_replace_result_unwrap_with_match() {
diff --git a/crates/ra_assists/src/handlers/split_import.rs b/crates/ra_assists/src/handlers/split_import.rs
index f25826796..b2757e50c 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,10 +26,10 @@ pub(crate) fn split_import(ctx: AssistCtx) -> Option<Assist> {
    if new_tree == use_tree {
        return None;
    }
-    let cursor = ctx.frange.range.start();
+    let cursor = ctx.offset();
-    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);
    })
@@ -37,7 +37,7 @@ pub(crate) fn split_import(ctx: AssistCtx) -> Option<Assist> {
 #[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::*;
diff --git a/crates/ra_assists/src/handlers/unwrap_block.rs b/crates/ra_assists/src/handlers/unwrap_block.rs
index 859c70ad8..eba0631a4 100644
--- a/crates/ra_assists/src/handlers/unwrap_block.rs
+++ b/crates/ra_assists/src/handlers/unwrap_block.rs
@@ -1,4 +1,4 @@
-use crate::{Assist, AssistCtx, AssistId};
+use crate::{AssistContext, AssistId, Assists};
 use ast::LoopBodyOwner;
 use ra_fmt::unwrap_trivial_block;
@@ -21,7 +21,7 @@ use ra_syntax::{ast, match_ast, AstNode, TextRange, T};
 //     println!("foo");
 // }
 // ```
-pub(crate) fn unwrap_block(ctx: AssistCtx) -> Option<Assist> {
+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()?;
@@ -57,9 +57,9 @@ pub(crate) fn unwrap_block(ctx: AssistCtx) -> Option<Assist> {
        }
    };
-    ctx.add_assist(AssistId("unwrap_block"), "Unwrap block", |edit| {
+    let target = expr_to_unwrap.syntax().text_range();
+    acc.add(AssistId("unwrap_block"), "Unwrap block", target, |edit| {
        edit.set_cursor(expr.syntax().text_range().start());
-        edit.target(expr_to_unwrap.syntax().text_range());
        let pat_start: &[_] = &[' ', '{', '\n'];
        let expr_to_unwrap = expr_to_unwrap.to_string();
@@ -89,7 +89,7 @@ fn extract_expr(cursor_range: TextRange, block: ast::BlockExpr) -> Option<ast::E
 #[cfg(test)]
 mod tests {
-    use crate::helpers::{check_assist, check_assist_not_applicable};
+    use crate::tests::{check_assist, check_assist_not_applicable};
    use super::*;
diff --git a/crates/ra_assists/src/lib.rs b/crates/ra_assists/src/lib.rs
index 0f94f5ee8..b6dc7cb1b 100644
--- a/crates/ra_assists/src/lib.rs
+++ b/crates/ra_assists/src/lib.rs
@@ -10,118 +10,102 @@ macro_rules! eprintln {
    ($($tt:tt)*) => { stdx::eprintln!($($tt)*) };
 }
-mod assist_ctx;
+mod assist_context;
 mod marks;
 #[cfg(test)]
-mod doc_tests;
+mod tests;
 pub mod utils;
 pub mod ast_transform;
 use hir::Semantics;
-use ra_db::{FileId, FileRange};
+use ra_db::FileRange;
-use ra_ide_db::RootDatabase;
+use ra_ide_db::{source_change::SourceChange, RootDatabase};
-use ra_syntax::{TextRange, TextSize};
+use ra_syntax::TextRange;
-use ra_text_edit::TextEdit;
-pub(crate) use crate::assist_ctx::{Assist, AssistCtx};
+pub(crate) use crate::assist_context::{AssistContext, Assists};
 /// 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(Clone, Debug)]
+pub struct GroupLabel(pub String);
 #[derive(Debug, Clone)]
-pub struct AssistLabel {
+pub struct Assist {
    pub id: AssistId,
    /// Short description of the assist, as shown in the UI.
    pub label: String,
    pub group: Option<GroupLabel>,
-}
+    /// Target ranges are used to sort assists: the smaller the target range,
+    /// the more specific assist is, and so it should be sorted first.
-#[derive(Clone, Debug)]
+    pub target: TextRange,
-pub struct GroupLabel(pub String);
-impl AssistLabel {
-    pub(crate) fn new(id: AssistId, label: String, group: Option<GroupLabel>) -> AssistLabel {
-        // FIXME: make fields private, so that this invariant can't be broken
-        assert!(label.starts_with(|c: char| c.is_uppercase()));
-        AssistLabel { id, label, group }
-    }
-}
-#[derive(Debug, Clone)]
-pub struct AssistAction {
-    pub edit: TextEdit,
-    pub cursor_position: Option<TextSize>,
-    // FIXME: This belongs to `AssistLabel`
-    pub target: Option<TextRange>,
-    pub file: AssistFile,
 }
 #[derive(Debug, Clone)]
 pub struct ResolvedAssist {
-    pub label: AssistLabel,
+    pub assist: Assist,
-    pub action: AssistAction,
+    pub source_change: SourceChange,
-}
-#[derive(Debug, Clone, Copy)]
-pub enum AssistFile {
-    CurrentFile,
-    TargetFile(FileId),
 }
-impl Default for AssistFile {
+impl Assist {
-    fn default() -> Self {
+    /// Return all the assists applicable at the given position.
-        Self::CurrentFile
+    ///
+    /// Assists are returned in the "unresolved" state, that is only labels are
+    /// returned, without actual edits.
+    pub fn unresolved(db: &RootDatabase, range: FileRange) -> Vec<Assist> {
+        let sema = Semantics::new(db);
+        let ctx = AssistContext::new(sema, range);
+        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(db: &RootDatabase, range: FileRange) -> Vec<ResolvedAssist> {
-    let sema = Semantics::new(db);
+        let sema = Semantics::new(db);
-    let ctx = AssistCtx::new(&sema, range, false);
+        let ctx = AssistContext::new(sema, range);
-    handlers::all()
+        let mut acc = Assists::new_resolved(&ctx);
-        .iter()
+        handlers::all().iter().for_each(|handler| {
-        .filter_map(|f| f(ctx.clone()))
+            handler(&mut acc, &ctx);
-        .flat_map(|it| it.0)
+        });
-        .map(|a| a.label)
+        acc.finish_resolved()
-        .collect()
+    }
-}
-/// 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::{Assist, AssistCtx};
+    use crate::{AssistContext, Assists};
-    pub(crate) type Handler = fn(AssistCtx) -> Option<Assist>;
+    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 apply_demorgan;
    mod auto_import;
+    mod change_return_type_to_result;
    mod change_visibility;
    mod early_return;
    mod fill_match_arms;
@@ -138,13 +122,12 @@ 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 reorder_fields;
    mod unwrap_block;
    pub(crate) fn all() -> &'static [Handler] {
@@ -159,6 +142,7 @@ mod handlers {
            add_new::add_new,
            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,
@@ -194,150 +178,3 @@ mod handlers {
        ]
    }
 }
-#[cfg(test)]
-mod helpers {
-    use std::sync::Arc;
-    use hir::Semantics;
-    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::{handlers::Handler, AssistCtx, AssistFile};
-    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);
-    }
-    enum ExpectedResult<'a> {
-        NotApplicable,
-        After(&'a str),
-        Target(&'a str),
-    }
-    fn check(assist: 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 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 mut actual = if let AssistFile::TargetFile(file_id) = action.file {
-                    db.file_text(file_id).as_ref().to_owned()
-                } else {
-                    text_without_caret
-                };
-                action.edit.apply(&mut actual);
-                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/tests.rs b/crates/ra_assists/src/tests.rs
new file mode 100644
index 000000000..a3eacb8f1
--- /dev/null
+++ b/crates/ra_assists/src/tests.rs
@@ -0,0 +1,167 @@
+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::{
+    add_cursor, assert_eq_text, extract_offset, extract_range, extract_range_or_offset,
+    RangeOrOffset,
+};
+use crate::{handlers::Handler, Assist, 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, 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, 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 ctx = AssistContext::new(sema, 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);
+            match source_change.cursor_position {
+                None => {
+                    if let RangeOrOffset::Offset(before_cursor_pos) = range_or_offset {
+                        let off = change
+                            .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.offset),
+            };
+            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, 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, 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 6696cc832..972dbd251 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)]
@@ -23,7 +23,7 @@ impl Debug for S {
 #[test]
 fn doctest_add_derive() {
-    check(
+    check_doc_test(
        "add_derive",
        r#####"
 struct Point {
@@ -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;
@@ -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,7 +104,7 @@ fn main() {
 #[test]
 fn doctest_add_impl() {
-    check(
+    check_doc_test(
        "add_impl",
        r#####"
 struct Ctx<T: Clone> {
@@ -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 {
@@ -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> {
@@ -191,7 +191,7 @@ impl Trait<u32> for () {
 #[test]
 fn doctest_add_new() {
-    check(
+    check_doc_test(
        "add_new",
        r#####"
 struct Ctx<T: Clone> {
@@ -213,7 +213,7 @@ impl<T: Clone> Ctx<T> {
 #[test]
 fn doctest_apply_demorgan() {
-    check(
+    check_doc_test(
        "apply_demorgan",
        r#####"
 fn main() {
@@ -230,7 +230,7 @@ fn main() {
 #[test]
 fn doctest_auto_import() {
-    check(
+    check_doc_test(
        "auto_import",
        r#####"
 fn main() {
@@ -250,8 +250,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, > { Ok(42i32) }
+"#####,
+    )
+}
+#[test]
 fn doctest_change_visibility() {
-    check(
+    check_doc_test(
        "change_visibility",
        r#####"
 <|>fn frobnicate() {}
@@ -264,7 +277,7 @@ pub(crate) fn frobnicate() {}
 #[test]
 fn doctest_convert_to_guarded_return() {
-    check(
+    check_doc_test(
        "convert_to_guarded_return",
        r#####"
 fn main() {
@@ -288,7 +301,7 @@ fn main() {
 #[test]
 fn doctest_fill_match_arms() {
-    check(
+    check_doc_test(
        "fill_match_arms",
        r#####"
 enum Action { Move { distance: u32 }, Stop }
@@ -314,7 +327,7 @@ fn handle(action: Action) {
 #[test]
 fn doctest_flip_binexpr() {
-    check(
+    check_doc_test(
        "flip_binexpr",
        r#####"
 fn main() {
@@ -331,7 +344,7 @@ fn main() {
 #[test]
 fn doctest_flip_comma() {
-    check(
+    check_doc_test(
        "flip_comma",
        r#####"
 fn main() {
@@ -348,7 +361,7 @@ fn main() {
 #[test]
 fn doctest_flip_trait_bound() {
-    check(
+    check_doc_test(
        "flip_trait_bound",
        r#####"
 fn foo<T: Clone +<|> Copy>() { }
@@ -361,7 +374,7 @@ fn foo<T: Copy + Clone>() { }
 #[test]
 fn doctest_inline_local_variable() {
-    check(
+    check_doc_test(
        "inline_local_variable",
        r#####"
 fn main() {
@@ -379,7 +392,7 @@ fn main() {
 #[test]
 fn doctest_introduce_variable() {
-    check(
+    check_doc_test(
        "introduce_variable",
        r#####"
 fn main() {
@@ -397,7 +410,7 @@ fn main() {
 #[test]
 fn doctest_invert_if() {
-    check(
+    check_doc_test(
        "invert_if",
        r#####"
 fn main() {
@@ -414,7 +427,7 @@ fn main() {
 #[test]
 fn doctest_make_raw_string() {
-    check(
+    check_doc_test(
        "make_raw_string",
        r#####"
 fn main() {
@@ -431,7 +444,7 @@ fn main() {
 #[test]
 fn doctest_make_usual_string() {
-    check(
+    check_doc_test(
        "make_usual_string",
        r#####"
 fn main() {
@@ -448,7 +461,7 @@ fn main() {
 #[test]
 fn doctest_merge_imports() {
-    check(
+    check_doc_test(
        "merge_imports",
        r#####"
 use std::<|>fmt::Formatter;
@@ -462,7 +475,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 }
@@ -488,7 +501,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 }
@@ -515,7 +528,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 {
@@ -532,7 +545,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 }
@@ -559,7 +572,7 @@ fn handle(action: Action) {
 #[test]
 fn doctest_remove_dbg() {
-    check(
+    check_doc_test(
        "remove_dbg",
        r#####"
 fn main() {
@@ -576,7 +589,7 @@ fn main() {
 #[test]
 fn doctest_remove_hash() {
-    check(
+    check_doc_test(
        "remove_hash",
        r#####"
 fn main() {
@@ -593,7 +606,7 @@ fn main() {
 #[test]
 fn doctest_remove_mut() {
-    check(
+    check_doc_test(
        "remove_mut",
        r#####"
 impl Walrus {
@@ -610,7 +623,7 @@ impl Walrus {
 #[test]
 fn doctest_reorder_fields() {
-    check(
+    check_doc_test(
        "reorder_fields",
        r#####"
 struct Foo {foo: i32, bar: i32};
@@ -625,7 +638,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 }
@@ -653,7 +666,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 }
@@ -679,7 +692,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>) {}
@@ -694,7 +707,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) }
@@ -718,7 +731,7 @@ fn main() {
 #[test]
 fn doctest_split_import() {
-    check(
+    check_doc_test(
        "split_import",
        r#####"
 use std::<|>collections::HashMap;
@@ -731,7 +744,7 @@ use std::{collections::HashMap};
 #[test]
 fn doctest_unwrap_block() {
-    check(
+    check_doc_test(
        "unwrap_block",
        r#####"
 fn foo() {
diff --git a/crates/ra_assists/src/utils/insert_use.rs b/crates/ra_assists/src/utils/insert_use.rs
index c1f447efe..1214e3cd4 100644
--- a/crates/ra_assists/src/utils/insert_use.rs
+++ b/crates/ra_assists/src/utils/insert_use.rs
@@ -2,7 +2,6 @@
 // FIXME: rewrite according to the plan, outlined in
 // https://github.com/rust-analyzer/rust-analyzer/issues/3301#issuecomment-592931553
-use crate::assist_ctx::ActionBuilder;
 use hir::{self, ModPath};
 use ra_syntax::{
    ast::{self, NameOwner},
@@ -12,6 +11,8 @@ use ra_syntax::{
 };
 use ra_text_edit::TextEditBuilder;
+use crate::assist_context::{AssistBuilder, 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.
@@ -19,10 +20,11 @@ pub(crate) fn insert_use_statement(
    // Ideally the position of the cursor, used to
    position: &SyntaxNode,
    path_to_import: &ModPath,
-    edit: &mut ActionBuilder,
+    ctx: &AssistContext,
+    builder: &mut AssistBuilder,
 ) {
    let target = path_to_import.to_string().split("::").map(SmolStr::new).collect::<Vec<_>>();
-    let container = edit.ctx().sema.ancestors_with_macros(position.clone()).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());
        }
@@ -31,7 +33,7 @@ pub(crate) fn insert_use_statement(
    if let Some(container) = container {
        let action = best_action_for_target(container, position.clone(), &target);
-        make_assist(&action, &target, edit.text_edit_builder());
+        make_assist(&action, &target, builder.text_edit_builder());
    }
 }
diff --git a/crates/ra_cfg/src/lib.rs b/crates/ra_cfg/src/lib.rs
index 51d953f6e..57feabcb2 100644
--- a/crates/ra_cfg/src/lib.rs
+++ b/crates/ra_cfg/src/lib.rs
@@ -2,8 +2,6 @@
 mod cfg_expr;
-use std::iter::IntoIterator;
 use ra_syntax::SmolStr;
 use rustc_hash::FxHashSet;
@@ -48,9 +46,4 @@ impl CfgOptions {
    pub fn insert_key_value(&mut self, key: SmolStr, value: SmolStr) {
        self.key_values.insert((key, value));
    }
-    /// Shortcut to set features
-    pub fn insert_features(&mut self, iter: impl IntoIterator<Item = SmolStr>) {
-        iter.into_iter().for_each(|feat| self.insert_key_value("feature".into(), feat));
-    }
 }
diff --git a/crates/ra_db/src/fixture.rs b/crates/ra_db/src/fixture.rs
index 8248684ee..51d4c493e 100644
--- a/crates/ra_db/src/fixture.rs
+++ b/crates/ra_db/src/fixture.rs
@@ -1,4 +1,48 @@
-//! FIXME: write short doc here
+//! Fixtures are strings containing rust source code with optional metadata.
+//! A fixture without metadata is parsed into a single source file.
+//! Use this to test functionality local to one file.
+//!
+//! Example:
+//! ```
+//! r#"
+//! fn main() {
+//!     println!("Hello World")
+//! }
+//! "#
+//! ```
+//!
+//! Metadata can be added to a fixture after a `//-` comment.
+//! The basic form is specifying filenames,
+//! which is also how to define multiple files in a single test fixture
+//!
+//! Example:
+//! ```
+//! "
+//! //- /main.rs
+//! mod foo;
+//! fn main() {
+//!     foo::bar();
+//! }
+//!
+//! //- /foo.rs
+//! pub fn bar() {}
+//! "
+//! ```
+//!
+//! Metadata allows specifying all settings and variables
+//! that are available in a real rust project:
+//! - crate names via `crate:cratename`
+//! - dependencies via `deps:dep1,dep2`
+//! - configuration settings via `cfg:dbg=false,opt_level=2`
+//! - environment variables via `env:PATH=/bin,RUST_LOG=debug`
+//!
+//! Example:
+//! ```
+//! "
+//! //- /lib.rs crate:foo deps:bar,baz cfg:foo=a,bar=b env:OUTDIR=path/to,OTHER=foo
+//! fn insert_source_code_here() {}
+//! "
+//! ```
 use std::str::FromStr;
 use std::sync::Arc;
diff --git a/crates/ra_hir_ty/src/_match.rs b/crates/ra_hir_ty/src/_match.rs
index 779e78574..149f65042 100644
--- a/crates/ra_hir_ty/src/_match.rs
+++ b/crates/ra_hir_ty/src/_match.rs
@@ -573,14 +573,20 @@ pub(crate) fn is_useful(
    matrix: &Matrix,
    v: &PatStack,
 ) -> MatchCheckResult<Usefulness> {
-    // Handle the special case of enums with no variants. In that case, no match
+    // Handle two special cases:
-    // arm is useful.
+    // - enum with no variants
-    if let Ty::Apply(ApplicationTy { ctor: TypeCtor::Adt(AdtId::EnumId(enum_id)), .. }) =
+    // - `!` type
-        cx.infer[cx.match_expr].strip_references()
+    // In those cases, no match arm is useful.
-    {
+    match cx.infer[cx.match_expr].strip_references() {
-        if cx.db.enum_data(*enum_id).variants.is_empty() {
+        Ty::Apply(ApplicationTy { ctor: TypeCtor::Adt(AdtId::EnumId(enum_id)), .. }) => {
+            if cx.db.enum_data(*enum_id).variants.is_empty() {
+                return Ok(Usefulness::NotUseful);
+            }
+        }
+        Ty::Apply(ApplicationTy { ctor: TypeCtor::Never, .. }) => {
            return Ok(Usefulness::NotUseful);
        }
+        _ => (),
    }
    if v.is_empty() {
@@ -1918,6 +1924,17 @@ mod tests {
    }
    #[test]
+    fn type_never() {
+        let content = r"
+            fn test_fn(never: !) {
+                match never {}
+            }
+        ";
+        check_no_diagnostic(content);
+    }
+    #[test]
    fn enum_never_ref() {
        let content = r"
            enum Never {}
diff --git a/crates/ra_ide/src/assists.rs b/crates/ra_ide/src/assists.rs
deleted file mode 100644
index 389339a03..000000000
--- a/crates/ra_ide/src/assists.rs
+++ /dev/null
@@ -1,42 +0,0 @@
-//! FIXME: write short doc here
-use ra_assists::{resolved_assists, AssistAction};
-use ra_db::{FilePosition, FileRange};
-use ra_ide_db::RootDatabase;
-use crate::{FileId, SourceChange, SourceFileEdit};
-pub use ra_assists::AssistId;
-#[derive(Debug)]
-pub struct Assist {
-    pub id: AssistId,
-    pub label: String,
-    pub group_label: Option<String>,
-    pub source_change: SourceChange,
-}
-pub(crate) fn assists(db: &RootDatabase, frange: FileRange) -> Vec<Assist> {
-    resolved_assists(db, frange)
-        .into_iter()
-        .map(|assist| {
-            let file_id = frange.file_id;
-            Assist {
-                id: assist.label.id,
-                label: assist.label.label.clone(),
-                group_label: assist.label.group.map(|it| it.0),
-                source_change: action_to_edit(assist.action, file_id, assist.label.label.clone()),
-            }
-        })
-        .collect()
-}
-fn action_to_edit(action: AssistAction, file_id: FileId, label: String) -> SourceChange {
-    let file_id = match action.file {
-        ra_assists::AssistFile::TargetFile(it) => it,
-        _ => file_id,
-    };
-    let file_edit = SourceFileEdit { file_id, edit: action.edit };
-    SourceChange::source_file_edit(label, file_edit)
-        .with_cursor_opt(action.cursor_position.map(|offset| FilePosition { offset, file_id }))
-}
diff --git a/crates/ra_ide/src/completion/completion_item.rs b/crates/ra_ide/src/completion/completion_item.rs
index 383b23ac4..6021f7279 100644
--- a/crates/ra_ide/src/completion/completion_item.rs
+++ b/crates/ra_ide/src/completion/completion_item.rs
@@ -2,11 +2,12 @@
 use std::fmt;
-use super::completion_config::SnippetCap;
 use hir::Documentation;
 use ra_syntax::TextRange;
 use ra_text_edit::TextEdit;
+use crate::completion::completion_config::SnippetCap;
 /// `CompletionItem` describes a single completion variant in the editor pop-up.
 /// It is basically a POD with various properties. To construct a
 /// `CompletionItem`, use `new` method and the `Builder` struct.
diff --git a/crates/ra_ide/src/display/function_signature.rs b/crates/ra_ide/src/display/function_signature.rs
index db3907fe6..f16d42276 100644
--- a/crates/ra_ide/src/display/function_signature.rs
+++ b/crates/ra_ide/src/display/function_signature.rs
@@ -1,5 +1,7 @@
 //! FIXME: write short doc here
+// FIXME: this modules relies on strings and AST way too much, and it should be
+// rewritten (matklad 2020-05-07)
 use std::{
    convert::From,
    fmt::{self, Display},
@@ -202,7 +204,11 @@ impl From<&'_ ast::FnDef> for FunctionSignature {
                res.extend(param_list.params().map(|param| param.syntax().text().to_string()));
                res_types.extend(param_list.params().map(|param| {
-                    param.syntax().text().to_string().split(':').nth(1).unwrap()[1..].to_string()
+                    let param_text = param.syntax().text().to_string();
+                    match param_text.split(':').nth(1) {
+                        Some(it) => it[1..].to_string(),
+                        None => param_text,
+                    }
                }));
            }
            (has_self_param, res, res_types)
diff --git a/crates/ra_ide/src/hover.rs b/crates/ra_ide/src/hover.rs
index 54d318858..06d4f1c63 100644
--- a/crates/ra_ide/src/hover.rs
+++ b/crates/ra_ide/src/hover.rs
@@ -143,7 +143,7 @@ fn hover_text_from_name_kind(db: &RootDatabase, def: Definition) -> Option<Strin
            ModuleDef::TypeAlias(it) => from_def_source(db, it, mod_path),
            ModuleDef::BuiltinType(it) => Some(it.to_string()),
        },
-        Definition::Local(it) => Some(rust_code_markup(&it.ty(db).display_truncated(db, None))),
+        Definition::Local(it) => Some(rust_code_markup(&it.ty(db).display(db))),
        Definition::TypeParam(_) | Definition::SelfType(_) => {
            // FIXME: Hover for generic param
            None
@@ -208,7 +208,7 @@ pub(crate) fn hover(db: &RootDatabase, position: FilePosition) -> Option<RangeIn
        }
    }?;
-    res.extend(Some(rust_code_markup(&ty.display_truncated(db, None))));
+    res.extend(Some(rust_code_markup(&ty.display(db))));
    let range = sema.original_range(&node).range;
    Some(RangeInfo::new(range, res))
 }
@@ -280,6 +280,47 @@ mod tests {
    }
    #[test]
+    fn hover_shows_long_type_of_an_expression() {
+        check_hover_result(
+            r#"
+            //- /main.rs
+            struct Scan<A, B, C> {
+                a: A,
+                b: B,
+                c: C,
+            }
+            struct FakeIter<I> {
+                inner: I,
+            }
+            struct OtherStruct<T> {
+                i: T,
+            }
+            enum FakeOption<T> {
+                Some(T),
+                None,
+            }
+            fn scan<A, B, C>(a: A, b: B, c: C) -> FakeIter<Scan<OtherStruct<A>, B, C>> {
+                FakeIter { inner: Scan { a, b, c } }
+            }
+            fn main() {
+                let num: i32 = 55;
+                let closure = |memo: &mut u32, value: &u32, _another: &mut u32| -> FakeOption<u32> {
+                    FakeOption::Some(*memo + value)
+                };
+                let number = 5u32;
+                let mut iter<|> = scan(OtherStruct { i: num }, closure, number);
+            }
+            "#,
+            &["FakeIter<Scan<OtherStruct<OtherStruct<i32>>, |&mut u32, &u32, &mut u32| -> FakeOption<u32>, u32>>"],
+        );
+    }
+    #[test]
    fn hover_shows_fn_signature() {
        // Single file with result
        check_hover_result(
@@ -405,7 +446,7 @@ mod tests {
    }
    #[test]
-    fn hover_omits_default_generic_types() {
+    fn hover_default_generic_types() {
        check_hover_result(
            r#"
 //- /main.rs
@@ -417,7 +458,7 @@ struct Test<K, T = u8> {
 fn main() {
    let zz<|> = Test { t: 23, k: 33 };
 }"#,
-            &["Test<i32>"],
+            &["Test<i32, u8>"],
        );
    }
diff --git a/crates/ra_ide/src/lib.rs b/crates/ra_ide/src/lib.rs
index 09f602fe1..915199bd8 100644
--- a/crates/ra_ide/src/lib.rs
+++ b/crates/ra_ide/src/lib.rs
@@ -16,7 +16,6 @@ macro_rules! eprintln {
 }
 pub mod mock_analysis;
-mod source_change;
 mod prime_caches;
 mod status;
@@ -32,7 +31,6 @@ mod syntax_highlighting;
 mod parent_module;
 mod references;
 mod impls;
-mod assists;
 mod diagnostics;
 mod syntax_tree;
 mod folding_ranges;
@@ -65,7 +63,6 @@ use ra_syntax::{SourceFile, TextRange, TextSize};
 use crate::display::ToNav;
 pub use crate::{
-    assists::{Assist, AssistId},
    call_hierarchy::CallItem,
    completion::{
        CompletionConfig, CompletionItem, CompletionItemKind, CompletionScore, InsertTextFormat,
@@ -78,7 +75,6 @@ pub use crate::{
    inlay_hints::{InlayHint, InlayHintsConfig, InlayKind},
    references::{Declaration, Reference, ReferenceAccess, ReferenceKind, ReferenceSearchResult},
    runnables::{Runnable, RunnableKind, TestId},
-    source_change::{FileSystemEdit, SourceChange, SourceFileEdit},
    ssr::SsrError,
    syntax_highlighting::{
        Highlight, HighlightModifier, HighlightModifiers, HighlightTag, HighlightedRange,
@@ -86,6 +82,7 @@ pub use crate::{
 };
 pub use hir::Documentation;
+pub use ra_assists::AssistId;
 pub use ra_db::{
    Canceled, CrateGraph, CrateId, Edition, FileId, FilePosition, FileRange, SourceRootId,
 };
@@ -94,6 +91,7 @@ pub use ra_ide_db::{
    line_index::{LineCol, LineIndex},
    line_index_utils::translate_offset_with_edit,
    search::SearchScope,
+    source_change::{FileSystemEdit, SourceChange, SourceFileEdit},
    symbol_index::Query,
    RootDatabase,
 };
@@ -135,10 +133,12 @@ pub struct AnalysisHost {
    db: RootDatabase,
 }
-impl Default for AnalysisHost {
+#[derive(Debug)]
-    fn default() -> AnalysisHost {
+pub struct Assist {
-        AnalysisHost::new(None)
+    pub id: AssistId,
-    }
+    pub label: String,
+    pub group_label: Option<String>,
+    pub source_change: SourceChange,
 }
 impl AnalysisHost {
@@ -188,6 +188,12 @@ impl AnalysisHost {
    }
 }
+impl Default for AnalysisHost {
+    fn default() -> AnalysisHost {
+        AnalysisHost::new(None)
+    }
+}
 /// Analysis is a snapshot of a world state at a moment in time. It is the main
 /// entry point for asking semantic information about the world. When the world
 /// state is advanced using `AnalysisHost::apply_change` method, all existing
@@ -296,7 +302,7 @@ impl Analysis {
                file_id: frange.file_id,
                edit: join_lines::join_lines(&parse.tree(), frange.range),
            };
-            SourceChange::source_file_edit("join lines", file_edit)
+            SourceChange::source_file_edit("Join lines", file_edit)
        })
    }
@@ -465,7 +471,17 @@ impl Analysis {
    /// Computes assists (aka code actions aka intentions) for the given
    /// position.
    pub fn assists(&self, frange: FileRange) -> Cancelable<Vec<Assist>> {
-        self.with_db(|db| assists::assists(db, frange))
+        self.with_db(|db| {
+            ra_assists::Assist::resolved(db, frange)
+                .into_iter()
+                .map(|assist| Assist {
+                    id: assist.assist.id,
+                    label: assist.assist.label,
+                    group_label: assist.assist.group.map(|it| it.0),
+                    source_change: assist.source_change,
+                })
+                .collect()
+        })
    }
    /// Computes the set of diagnostics for the given file.
@@ -490,7 +506,7 @@ impl Analysis {
    ) -> Cancelable<Result<SourceChange, SsrError>> {
        self.with_db(|db| {
            let edits = ssr::parse_search_replace(query, parse_only, db)?;
-            Ok(SourceChange::source_file_edits("ssr", edits))
+            Ok(SourceChange::source_file_edits("Structural Search Replace", edits))
        })
    }
diff --git a/crates/ra_ide/src/references/rename.rs b/crates/ra_ide/src/references/rename.rs
index 0398d53bc..2cbb82c1a 100644
--- a/crates/ra_ide/src/references/rename.rs
+++ b/crates/ra_ide/src/references/rename.rs
@@ -712,6 +712,68 @@ mod tests {
        "###);
    }
+    #[test]
+    fn test_enum_variant_from_module_1() {
+        test_rename(
+            r#"
+    mod foo {
+        pub enum Foo {
+            Bar<|>,
+        }
+    }
+    fn func(f: foo::Foo) {
+        match f {
+            foo::Foo::Bar => {}
+        }
+    }
+    "#,
+            "Baz",
+            r#"
+    mod foo {
+        pub enum Foo {
+            Baz,
+        }
+    }
+    fn func(f: foo::Foo) {
+        match f {
+            foo::Foo::Baz => {}
+        }
+    }
+    "#,
+        );
+    }
+    #[test]
+    fn test_enum_variant_from_module_2() {
+        test_rename(
+            r#"
+    mod foo {
+        pub struct Foo {
+            pub bar<|>: uint,
+        }
+    }
+    fn foo(f: foo::Foo) {
+        let _ = f.bar;
+    }
+    "#,
+            "baz",
+            r#"
+    mod foo {
+        pub struct Foo {
+            pub baz: uint,
+        }
+    }
+    fn foo(f: foo::Foo) {
+        let _ = f.baz;
+    }
+    "#,
+        );
+    }
    fn test_rename(text: &str, new_name: &str, expected: &str) {
        let (analysis, position) = single_file_with_position(text);
        let source_change = analysis.rename(position, new_name).unwrap();
diff --git a/crates/ra_ide/src/ssr.rs b/crates/ra_ide/src/ssr.rs
index 8bf52d0fa..1873d1d0d 100644
--- a/crates/ra_ide/src/ssr.rs
+++ b/crates/ra_ide/src/ssr.rs
@@ -1,18 +1,18 @@
 //!  structural search replace
-use crate::source_change::SourceFileEdit;
+use std::{collections::HashMap, iter::once, str::FromStr};
 use ra_db::{SourceDatabase, SourceDatabaseExt};
-use ra_ide_db::symbol_index::SymbolsDatabase;
+use ra_ide_db::{symbol_index::SymbolsDatabase, RootDatabase};
-use ra_ide_db::RootDatabase;
-use ra_syntax::ast::make::try_expr_from_text;
 use ra_syntax::ast::{
-    ArgList, AstToken, CallExpr, Comment, Expr, MethodCallExpr, RecordField, RecordLit,
+    make::try_expr_from_text, ArgList, AstToken, CallExpr, Comment, Expr, MethodCallExpr,
+    RecordField, RecordLit,
 };
 use ra_syntax::{AstNode, SyntaxElement, SyntaxKind, SyntaxNode};
 use ra_text_edit::{TextEdit, TextEditBuilder};
 use rustc_hash::FxHashMap;
-use std::collections::HashMap;
-use std::{iter::once, str::FromStr};
+use crate::SourceFileEdit;
 #[derive(Debug, PartialEq)]
 pub struct SsrError(String);
diff --git a/crates/ra_ide/src/typing.rs b/crates/ra_ide/src/typing.rs
index a03da4693..6f04f0be4 100644
--- a/crates/ra_ide/src/typing.rs
+++ b/crates/ra_ide/src/typing.rs
@@ -17,15 +17,16 @@ mod on_enter;
 use ra_db::{FilePosition, SourceDatabase};
 use ra_fmt::leading_indent;
-use ra_ide_db::RootDatabase;
+use ra_ide_db::{source_change::SingleFileChange, RootDatabase};
 use ra_syntax::{
    algo::find_node_at_offset,
    ast::{self, AstToken},
    AstNode, SourceFile, TextRange, TextSize,
 };
 use ra_text_edit::TextEdit;
-use crate::{source_change::SingleFileChange, SourceChange};
+use crate::SourceChange;
 pub(crate) use on_enter::on_enter;
diff --git a/crates/ra_ide_db/src/defs.rs b/crates/ra_ide_db/src/defs.rs
index 40d0e77b5..f990e3bb9 100644
--- a/crates/ra_ide_db/src/defs.rs
+++ b/crates/ra_ide_db/src/defs.rs
@@ -6,7 +6,7 @@
 // FIXME: this badly needs rename/rewrite (matklad, 2020-02-06).
 use hir::{
-    Field, HasVisibility, ImplDef, Local, MacroDef, Module, ModuleDef, Name, PathResolution,
+    Adt, Field, HasVisibility, ImplDef, Local, MacroDef, Module, ModuleDef, Name, PathResolution,
    Semantics, TypeParam, Visibility,
 };
 use ra_prof::profile;
@@ -47,7 +47,13 @@ impl Definition {
        match self {
            Definition::Macro(_) => None,
            Definition::Field(sf) => Some(sf.visibility(db)),
-            Definition::ModuleDef(def) => module?.visibility_of(db, def),
+            Definition::ModuleDef(def) => match def {
+                ModuleDef::EnumVariant(id) => {
+                    let parent = id.parent_enum(db);
+                    module?.visibility_of(db, &ModuleDef::Adt(Adt::Enum(parent)))
+                }
+                _ => module?.visibility_of(db, def),
+            },
            Definition::SelfType(_) => None,
            Definition::Local(_) => None,
            Definition::TypeParam(_) => None,
diff --git a/crates/ra_ide_db/src/lib.rs b/crates/ra_ide_db/src/lib.rs
index e6f2d36e9..52fcd7b6f 100644
--- a/crates/ra_ide_db/src/lib.rs
+++ b/crates/ra_ide_db/src/lib.rs
@@ -10,6 +10,7 @@ pub mod change;
 pub mod defs;
 pub mod search;
 pub mod imports_locator;
+pub mod source_change;
 mod wasm_shims;
 use std::sync::Arc;
diff --git a/crates/ra_ide/src/source_change.rs b/crates/ra_ide_db/src/source_change.rs
index 10afd7825..af81a91a4 100644
--- a/crates/ra_ide/src/source_change.rs
+++ b/crates/ra_ide_db/src/source_change.rs
@@ -3,13 +3,12 @@
 //!
 //! It can be viewed as a dual for `AnalysisChange`.
-use ra_db::RelativePathBuf;
+use ra_db::{FileId, FilePosition, RelativePathBuf, SourceRootId};
-use ra_text_edit::TextEdit;
+use ra_text_edit::{TextEdit, TextSize};
-use crate::{FileId, FilePosition, SourceRootId, TextSize};
+#[derive(Debug, Clone)]
-#[derive(Debug)]
 pub struct SourceChange {
+    /// For display in the undo log in the editor
    pub label: String,
    pub source_file_edits: Vec<SourceFileEdit>,
    pub file_system_edits: Vec<FileSystemEdit>,
@@ -19,7 +18,7 @@ pub struct SourceChange {
 impl SourceChange {
    /// Creates a new SourceChange with the given label
    /// from the edits.
-    pub(crate) fn from_edits<L: Into<String>>(
+    pub fn from_edits<L: Into<String>>(
        label: L,
        source_file_edits: Vec<SourceFileEdit>,
        file_system_edits: Vec<FileSystemEdit>,
@@ -34,7 +33,7 @@ impl SourceChange {
    /// Creates a new SourceChange with the given label,
    /// containing only the given `SourceFileEdits`.
-    pub(crate) fn source_file_edits<L: Into<String>>(label: L, edits: Vec<SourceFileEdit>) -> Self {
+    pub fn source_file_edits<L: Into<String>>(label: L, edits: Vec<SourceFileEdit>) -> Self {
        let label = label.into();
        assert!(label.starts_with(char::is_uppercase));
        SourceChange {
@@ -58,13 +57,13 @@ impl SourceChange {
    /// Creates a new SourceChange with the given label,
    /// containing only a single `SourceFileEdit`.
-    pub(crate) fn source_file_edit<L: Into<String>>(label: L, edit: SourceFileEdit) -> Self {
+    pub fn source_file_edit<L: Into<String>>(label: L, edit: SourceFileEdit) -> Self {
        SourceChange::source_file_edits(label, vec![edit])
    }
    /// Creates a new SourceChange with the given label
    /// from the given `FileId` and `TextEdit`
-    pub(crate) fn source_file_edit_from<L: Into<String>>(
+    pub fn source_file_edit_from<L: Into<String>>(
        label: L,
        file_id: FileId,
        edit: TextEdit,
@@ -74,43 +73,43 @@ impl SourceChange {
    /// Creates a new SourceChange with the given label
    /// from the given `FileId` and `TextEdit`
-    pub(crate) fn file_system_edit<L: Into<String>>(label: L, edit: FileSystemEdit) -> Self {
+    pub fn file_system_edit<L: Into<String>>(label: L, edit: FileSystemEdit) -> Self {
        SourceChange::file_system_edits(label, vec![edit])
    }
    /// Sets the cursor position to the given `FilePosition`
-    pub(crate) fn with_cursor(mut self, cursor_position: FilePosition) -> Self {
+    pub fn with_cursor(mut self, cursor_position: FilePosition) -> Self {
        self.cursor_position = Some(cursor_position);
        self
    }
    /// Sets the cursor position to the given `FilePosition`
-    pub(crate) fn with_cursor_opt(mut self, cursor_position: Option<FilePosition>) -> Self {
+    pub fn with_cursor_opt(mut self, cursor_position: Option<FilePosition>) -> Self {
        self.cursor_position = cursor_position;
        self
    }
 }
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct SourceFileEdit {
    pub file_id: FileId,
    pub edit: TextEdit,
 }
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub enum FileSystemEdit {
    CreateFile { source_root: SourceRootId, path: RelativePathBuf },
    MoveFile { src: FileId, dst_source_root: SourceRootId, dst_path: RelativePathBuf },
 }
-pub(crate) struct SingleFileChange {
+pub struct SingleFileChange {
    pub label: String,
    pub edit: TextEdit,
    pub cursor_position: Option<TextSize>,
 }
 impl SingleFileChange {
-    pub(crate) fn into_source_change(self, file_id: FileId) -> SourceChange {
+    pub fn into_source_change(self, file_id: FileId) -> SourceChange {
        SourceChange {
            label: self.label,
            source_file_edits: vec![SourceFileEdit { file_id, edit: self.edit }],
diff --git a/crates/ra_project_model/src/cargo_workspace.rs b/crates/ra_project_model/src/cargo_workspace.rs
index 4027f020f..eb9f33ee8 100644
--- a/crates/ra_project_model/src/cargo_workspace.rs
+++ b/crates/ra_project_model/src/cargo_workspace.rs
@@ -87,6 +87,7 @@ pub struct PackageData {
    pub dependencies: Vec<PackageDependency>,
    pub edition: Edition,
    pub features: Vec<String>,
+    pub cfgs: Vec<String>,
    pub out_dir: Option<PathBuf>,
    pub proc_macro_dylib_path: Option<PathBuf>,
 }
@@ -168,10 +169,12 @@ impl CargoWorkspace {
        })?;
        let mut out_dir_by_id = FxHashMap::default();
+        let mut cfgs = FxHashMap::default();
        let mut proc_macro_dylib_paths = FxHashMap::default();
        if cargo_features.load_out_dirs_from_check {
            let resources = load_extern_resources(cargo_toml, cargo_features)?;
            out_dir_by_id = resources.out_dirs;
+            cfgs = resources.cfgs;
            proc_macro_dylib_paths = resources.proc_dylib_paths;
        }
@@ -197,6 +200,7 @@ impl CargoWorkspace {
                edition,
                dependencies: Vec::new(),
                features: Vec::new(),
+                cfgs: cfgs.get(&id).cloned().unwrap_or_default(),
                out_dir: out_dir_by_id.get(&id).cloned(),
                proc_macro_dylib_path: proc_macro_dylib_paths.get(&id).cloned(),
            });
@@ -278,6 +282,7 @@ impl CargoWorkspace {
 pub struct ExternResources {
    out_dirs: FxHashMap<PackageId, PathBuf>,
    proc_dylib_paths: FxHashMap<PackageId, PathBuf>,
+    cfgs: FxHashMap<PackageId, Vec<String>>,
 }
 pub fn load_extern_resources(
@@ -303,8 +308,14 @@ pub fn load_extern_resources(
    for message in cargo_metadata::parse_messages(output.stdout.as_slice()) {
        if let Ok(message) = message {
            match message {
-                Message::BuildScriptExecuted(BuildScript { package_id, out_dir, .. }) => {
+                Message::BuildScriptExecuted(BuildScript { package_id, out_dir, cfgs, .. }) => {
-                    res.out_dirs.insert(package_id, out_dir);
+                    res.out_dirs.insert(package_id.clone(), out_dir);
+                    res.cfgs.insert(
+                        package_id,
+                        // FIXME: Current `cargo_metadata` uses `PathBuf` instead of `String`,
+                        // change when https://github.com/oli-obk/cargo_metadata/pulls/112 reaches crates.io
+                        cfgs.iter().filter_map(|c| c.to_str().map(|s| s.to_owned())).collect(),
+                    );
                }
                Message::CompilerArtifact(message) => {
diff --git a/crates/ra_project_model/src/lib.rs b/crates/ra_project_model/src/lib.rs
index e4b86f1e2..88a6ffb2a 100644
--- a/crates/ra_project_model/src/lib.rs
+++ b/crates/ra_project_model/src/lib.rs
@@ -399,7 +399,18 @@ impl ProjectWorkspace {
                            let edition = cargo[pkg].edition;
                            let cfg_options = {
                                let mut opts = default_cfg_options.clone();
-                                opts.insert_features(cargo[pkg].features.iter().map(Into::into));
+                                for feature in cargo[pkg].features.iter() {
+                                    opts.insert_key_value("feature".into(), feature.into());
+                                }
+                                for cfg in cargo[pkg].cfgs.iter() {
+                                    match cfg.find('=') {
+                                        Some(split) => opts.insert_key_value(
+                                            cfg[..split].into(),
+                                            cfg[split + 1..].trim_matches('"').into(),
+                                        ),
+                                        None => opts.insert_atom(cfg.into()),
+                                    };
+                                }
                                opts
                            };
                            let mut env = Env::default();
diff --git a/crates/ra_text_edit/src/lib.rs b/crates/ra_text_edit/src/lib.rs
index 7138bbc65..3409713ff 100644
--- a/crates/ra_text_edit/src/lib.rs
+++ b/crates/ra_text_edit/src/lib.rs
@@ -4,7 +4,7 @@
 //! so `TextEdit` is the ultimate representation of the work done by
 //! rust-analyzer.
-use text_size::{TextRange, TextSize};
+pub use text_size::{TextRange, TextSize};
 /// `InsertDelete` -- a single "atomic" change to text
 ///
@@ -71,6 +71,10 @@ impl TextEdit {
        TextEdit { indels }
    }
+    pub fn is_empty(&self) -> bool {
+        self.indels.is_empty()
+    }
    pub fn as_indels(&self) -> &[Indel] {
        &self.indels
    }
diff --git a/crates/rust-analyzer/src/main_loop/handlers.rs b/crates/rust-analyzer/src/main_loop/handlers.rs
index 15e8305f8..f4353af64 100644
--- a/crates/rust-analyzer/src/main_loop/handlers.rs
+++ b/crates/rust-analyzer/src/main_loop/handlers.rs
@@ -42,6 +42,7 @@ use crate::{
    world::WorldSnapshot,
    LspError, Result,
 };
+use ra_project_model::TargetKind;
 pub fn handle_analyzer_status(world: WorldSnapshot, _: ()) -> Result<String> {
    let _p = profile("handle_analyzer_status");
@@ -384,16 +385,27 @@ pub fn handle_runnables(
    let offset = params.position.map(|it| it.conv_with(&line_index));
    let mut res = Vec::new();
    let workspace_root = world.workspace_root_for(file_id);
+    let cargo_spec = CargoTargetSpec::for_file(&world, file_id)?;
    for runnable in world.analysis().runnables(file_id)? {
        if let Some(offset) = offset {
            if !runnable.range.contains_inclusive(offset) {
                continue;
            }
        }
+        // Do not suggest binary run on other target than binary
+        if let RunnableKind::Bin = runnable.kind {
+            if let Some(spec) = &cargo_spec {
+                match spec.target_kind {
+                    TargetKind::Bin => {}
+                    _ => continue,
+                }
+            }
+        }
        res.push(to_lsp_runnable(&world, file_id, runnable)?);
    }
    // Add `cargo check` and `cargo test` for the whole package
-    match CargoTargetSpec::for_file(&world, file_id)? {
+    match cargo_spec {
        Some(spec) => {
            for &cmd in ["check", "test"].iter() {
                res.push(req::Runnable {
@@ -831,13 +843,23 @@ pub fn handle_code_lens(
    let mut lenses: Vec<CodeLens> = Default::default();
+    let cargo_spec = CargoTargetSpec::for_file(&world, file_id)?;
    // Gather runnables
    for runnable in world.analysis().runnables(file_id)? {
        let title = match &runnable.kind {
            RunnableKind::Test { .. } | RunnableKind::TestMod { .. } => "▶️\u{fe0e}Run Test",
            RunnableKind::DocTest { .. } => "▶️\u{fe0e}Run Doctest",
            RunnableKind::Bench { .. } => "Run Bench",
-            RunnableKind::Bin => "Run",
+            RunnableKind::Bin => {
+                // Do not suggest binary run on other target than binary
+                match &cargo_spec {
+                    Some(spec) => match spec.target_kind {
+                        TargetKind::Bin => "Run",
+                        _ => continue,
+                    },
+                    None => continue,
+                }
+            }
        }
        .to_string();
        let mut r = to_lsp_runnable(&world, file_id, runnable)?;
diff --git a/crates/rust-analyzer/tests/heavy_tests/main.rs b/crates/rust-analyzer/tests/heavy_tests/main.rs
index 1efa5dd63..e459e3a3c 100644
--- a/crates/rust-analyzer/tests/heavy_tests/main.rs
+++ b/crates/rust-analyzer/tests/heavy_tests/main.rs
@@ -9,7 +9,8 @@ use lsp_types::{
 };
 use rust_analyzer::req::{
    CodeActionParams, CodeActionRequest, Completion, CompletionParams, DidOpenTextDocument,
-    Formatting, GotoDefinition, HoverRequest, OnEnter, Runnables, RunnablesParams,
+    Formatting, GotoDefinition, GotoTypeDefinition, HoverRequest, OnEnter, Runnables,
+    RunnablesParams,
 };
 use serde_json::json;
 use tempfile::TempDir;
@@ -574,7 +575,7 @@ version = \"0.0.0\"
 }
 #[test]
-fn resolve_include_concat_env() {
+fn out_dirs_check() {
    if skip_slow_tests() {
        return;
    }
@@ -597,11 +598,28 @@ fn main() {
        r#"pub fn message() -> &'static str { "Hello, World!" }"#,
    )
    .unwrap();
+    println!("cargo:rustc-cfg=atom_cfg");
+    println!("cargo:rustc-cfg=featlike=\"set\"");
    println!("cargo:rerun-if-changed=build.rs");
 }
 //- src/main.rs
 include!(concat!(env!("OUT_DIR"), "/hello.rs"));
+#[cfg(atom_cfg)]
+struct A;
+#[cfg(bad_atom_cfg)]
+struct A;
+#[cfg(featlike = "set")]
+struct B;
+#[cfg(featlike = "not_set")]
+struct B;
+fn main() {
+    let va = A;
+    let vb = B;
+    message();
+}
 fn main() { message(); }
 "###,
    )
@@ -613,12 +631,98 @@ fn main() { message(); }
    let res = server.send_request::<GotoDefinition>(GotoDefinitionParams {
        text_document_position_params: TextDocumentPositionParams::new(
            server.doc_id("src/main.rs"),
-            Position::new(2, 15),
+            Position::new(14, 8),
        ),
        work_done_progress_params: Default::default(),
        partial_result_params: Default::default(),
    });
    assert!(format!("{}", res).contains("hello.rs"));
+    server.request::<GotoTypeDefinition>(
+        GotoDefinitionParams {
+            text_document_position_params: TextDocumentPositionParams::new(
+                server.doc_id("src/main.rs"),
+                Position::new(12, 9),
+            ),
+            work_done_progress_params: Default::default(),
+            partial_result_params: Default::default(),
+        },
+        json!([{
+            "originSelectionRange": {
+                "end": {
+                    "character": 10,
+                    "line": 12
+                },
+                "start": {
+                    "character": 8,
+                    "line": 12
+                }
+            },
+            "targetRange": {
+                "end": {
+                    "character": 9,
+                    "line": 3
+                },
+                "start": {
+                    "character": 0,
+                    "line": 2
+                }
+            },
+            "targetSelectionRange": {
+                "end": {
+                    "character": 8,
+                    "line": 3
+                },
+                "start": {
+                    "character": 7,
+                    "line": 3
+                }
+            },
+            "targetUri": "file:///[..]src/main.rs"
+        }]),
+    );
+    server.request::<GotoTypeDefinition>(
+        GotoDefinitionParams {
+            text_document_position_params: TextDocumentPositionParams::new(
+                server.doc_id("src/main.rs"),
+                Position::new(13, 9),
+            ),
+            work_done_progress_params: Default::default(),
+            partial_result_params: Default::default(),
+        },
+        json!([{
+            "originSelectionRange": {
+                "end": {
+                    "character": 10,
+                    "line": 13
+                },
+                "start": {
+                    "character": 8,
+                    "line":13
+                }
+            },
+            "targetRange": {
+                "end": {
+                    "character": 9,
+                    "line": 7
+                },
+                "start": {
+                    "character": 0,
+                    "line":6
+                }
+            },
+            "targetSelectionRange": {
+                "end": {
+                    "character": 8,
+                    "line": 7
+                },
+                "start": {
+                    "character": 7,
+                    "line": 7
+                }
+            },
+            "targetUri": "file:///[..]src/main.rs"
+        }]),
+    );
 }
 #[test]
diff --git a/crates/test_utils/src/lib.rs b/crates/test_utils/src/lib.rs
index b1365444a..b13e13af2 100644
--- a/crates/test_utils/src/lib.rs
+++ b/crates/test_utils/src/lib.rs
@@ -155,7 +155,7 @@ pub fn add_cursor(text: &str, offset: TextSize) -> String {
    res
 }
-#[derive(Debug)]
+#[derive(Debug, Eq, PartialEq)]
 pub struct FixtureEntry {
    pub meta: String,
    pub text: String,
@@ -170,19 +170,26 @@ pub struct FixtureEntry {
 ///  // - other meta
 ///  ```
 pub fn parse_fixture(fixture: &str) -> Vec<FixtureEntry> {
-    let margin = fixture
+    let fixture = indent_first_line(fixture);
-        .lines()
+    let margin = fixture_margin(&fixture);
-        .filter(|it| it.trim_start().starts_with("//-"))
-        .map(|it| it.len() - it.trim_start().len())
-        .next()
-        .expect("empty fixture");
    let mut lines = fixture
        .split('\n') // don't use `.lines` to not drop `\r\n`
-        .filter_map(|line| {
+        .enumerate()
+        .filter_map(|(ix, line)| {
            if line.len() >= margin {
                assert!(line[..margin].trim().is_empty());
-                Some(&line[margin..])
+                let line_content = &line[margin..];
+                if !line_content.starts_with("//-") {
+                    assert!(
+                        !line_content.contains("//-"),
+                        r#"Metadata line {} has invalid indentation. All metadata lines need to have the same indentation.
+The offending line: {:?}"#,
+                        ix,
+                        line
+                    );
+                }
+                Some(line_content)
            } else {
                assert!(line.trim().is_empty());
                None
@@ -202,6 +209,85 @@ pub fn parse_fixture(fixture: &str) -> Vec<FixtureEntry> {
    res
 }
+/// Adjusts the indentation of the first line to the minimum indentation of the rest of the lines.
+/// This allows fixtures to start off in a different indentation, e.g. to align the first line with
+/// the other lines visually:
+/// ```
+/// let fixture = "//- /lib.rs
+///                mod foo;
+///                //- /foo.rs
+///                fn bar() {}
+/// ";
+/// assert_eq!(fixture_margin(fixture),
+/// "               //- /lib.rs
+///                mod foo;
+///                //- /foo.rs
+///                fn bar() {}
+/// ")
+/// ```
+fn indent_first_line(fixture: &str) -> String {
+    if fixture.is_empty() {
+        return String::new();
+    }
+    let mut lines = fixture.lines();
+    let first_line = lines.next().unwrap();
+    if first_line.contains("//-") {
+        let rest = lines.collect::<Vec<_>>().join("\n");
+        let fixed_margin = fixture_margin(&rest);
+        let fixed_indent = fixed_margin - indent_len(first_line);
+        format!("\n{}{}\n{}", " ".repeat(fixed_indent), first_line, rest)
+    } else {
+        fixture.to_owned()
+    }
+}
+fn fixture_margin(fixture: &str) -> usize {
+    fixture
+        .lines()
+        .filter(|it| it.trim_start().starts_with("//-"))
+        .map(indent_len)
+        .next()
+        .expect("empty fixture")
+}
+fn indent_len(s: &str) -> usize {
+    s.len() - s.trim_start().len()
+}
+#[test]
+#[should_panic]
+fn parse_fixture_checks_further_indented_metadata() {
+    parse_fixture(
+        r"
+        //- /lib.rs
+          mod bar;
+          fn foo() {}
+          //- /bar.rs
+          pub fn baz() {}
+          ",
+    );
+}
+#[test]
+fn parse_fixture_can_handle_unindented_first_line() {
+    let fixture = "//- /lib.rs
+                   mod foo;
+                   //- /foo.rs
+                   struct Bar;
+";
+    assert_eq!(
+        parse_fixture(fixture),
+        parse_fixture(
+            "//- /lib.rs
+mod foo;
+//- /foo.rs
+struct Bar;
+"
+        )
+    )
+}
 /// Same as `parse_fixture`, except it allow empty fixture
 pub fn parse_single_fixture(fixture: &str) -> Option<FixtureEntry> {
    if !fixture.lines().any(|it| it.trim_start().starts_with("//-")) {