5 files changed, 117 insertions, 184 deletions

diff --git a/crates/ra_editor/src/assists/add_derive.rs b/crates/ra_editor/src/assists/add_derive.rs
index 33d9d2c31..1e2cd4f30 100644
--- a/crates/ra_editor/src/assists/add_derive.rs
+++ b/crates/ra_editor/src/assists/add_derive.rs
@@ -1,85 +1,73 @@
-use ra_text_edit::TextEditBuilder;
 use ra_syntax::{
     ast::{self, AstNode, AttrsOwner},
-    SourceFileNode,
     SyntaxKind::{WHITESPACE, COMMENT},
     TextUnit,
 };
 
-use crate::{
-    find_node_at_offset,
-    assists::LocalEdit,
-};
+use crate::assists::{AssistCtx, Assist};
 
-pub fn add_derive<'a>(
-    file: &'a SourceFileNode,
-    offset: TextUnit,
-) -> Option<impl FnOnce() -> LocalEdit + 'a> {
-    let nominal = find_node_at_offset::<ast::NominalDef>(file.syntax(), offset)?;
+pub fn add_derive(ctx: AssistCtx) -> Option<Assist> {
+    let nominal = ctx.node_at_offset::<ast::NominalDef>()?;
     let node_start = derive_insertion_offset(nominal)?;
-    return Some(move || {
+    ctx.build("add `#[derive]`", |edit| {
         let derive_attr = nominal
             .attrs()
             .filter_map(|x| x.as_call())
             .filter(|(name, _arg)| name == "derive")
             .map(|(_name, arg)| arg)
             .next();
-        let mut edit = TextEditBuilder::new();
         let offset = match derive_attr {
             None => {
-                edit.insert(node_start, "#[derive()]\n".to_string());
+                edit.insert(node_start, "#[derive()]\n");
                 node_start + TextUnit::of_str("#[derive(")
             }
             Some(tt) => tt.syntax().range().end() - TextUnit::of_char(')'),
         };
-        LocalEdit {
-            label: "add `#[derive]`".to_string(),
-            edit: edit.finish(),
-            cursor_position: Some(offset),
-        }
-    });
+        edit.set_cursor(offset)
+    })
+}
 
-    // Insert `derive` after doc comments.
-    fn derive_insertion_offset(nominal: ast::NominalDef) -> Option<TextUnit> {
-        let non_ws_child = nominal
-            .syntax()
-            .children()
-            .find(|it| it.kind() != COMMENT && it.kind() != WHITESPACE)?;
-        Some(non_ws_child.range().start())
-    }
+// Insert `derive` after doc comments.
+fn derive_insertion_offset(nominal: ast::NominalDef) -> Option<TextUnit> {
+    let non_ws_child = nominal
+        .syntax()
+        .children()
+        .find(|it| it.kind() != COMMENT && it.kind() != WHITESPACE)?;
+    Some(non_ws_child.range().start())
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::test_utils::check_action;
+    use crate::assists::check_assist;
 
     #[test]
     fn add_derive_new() {
-        check_action(
+        check_assist(
+            add_derive,
             "struct Foo { a: i32, <|>}",
             "#[derive(<|>)]\nstruct Foo { a: i32, }",
-            |file, off| add_derive(file, off).map(|f| f()),
         );
-        check_action(
+        check_assist(
+            add_derive,
             "struct Foo { <|> a: i32, }",
             "#[derive(<|>)]\nstruct Foo {  a: i32, }",
-            |file, off| add_derive(file, off).map(|f| f()),
         );
     }
 
     #[test]
     fn add_derive_existing() {
-        check_action(
+        check_assist(
+            add_derive,
             "#[derive(Clone)]\nstruct Foo { a: i32<|>, }",
             "#[derive(Clone<|>)]\nstruct Foo { a: i32, }",
-            |file, off| add_derive(file, off).map(|f| f()),
         );
     }
 
     #[test]
     fn add_derive_new_with_doc_comment() {
-        check_action(
+        check_assist(
+            add_derive,
             "
 /// `Foo` is a pretty important struct.
 /// It does stuff.
@@ -91,7 +79,6 @@ struct Foo { a: i32<|>, }
 #[derive(<|>)]
 struct Foo { a: i32, }
             ",
-            |file, off| add_derive(file, off).map(|f| f()),
         );
     }
 }
diff --git a/crates/ra_editor/src/assists/add_impl.rs b/crates/ra_editor/src/assists/add_impl.rs
index 50e00688e..9353e2717 100644
--- a/crates/ra_editor/src/assists/add_impl.rs
+++ b/crates/ra_editor/src/assists/add_impl.rs
@@ -1,23 +1,16 @@
 use join_to_string::join;
-use ra_text_edit::TextEditBuilder;
 use ra_syntax::{
     ast::{self, AstNode, NameOwner, TypeParamsOwner},
-    SourceFileNode,
     TextUnit,
 };
 
-use crate::{find_node_at_offset, assists::LocalEdit};
+use crate::assists::{AssistCtx, Assist};
 
-pub fn add_impl<'a>(
-    file: &'a SourceFileNode,
-    offset: TextUnit,
-) -> Option<impl FnOnce() -> LocalEdit + 'a> {
-    let nominal = find_node_at_offset::<ast::NominalDef>(file.syntax(), offset)?;
+pub fn add_impl(ctx: AssistCtx) -> Option<Assist> {
+    let nominal = ctx.node_at_offset::<ast::NominalDef>()?;
     let name = nominal.name()?;
-
-    Some(move || {
+    ctx.build("add impl", |edit| {
         let type_params = nominal.type_param_list();
-        let mut edit = TextEditBuilder::new();
         let start_offset = nominal.syntax().range().end();
         let mut buf = String::new();
         buf.push_str("\n\nimpl");
@@ -40,38 +33,33 @@ pub fn add_impl<'a>(
                 .to_buf(&mut buf);
         }
         buf.push_str(" {\n");
-        let offset = start_offset + TextUnit::of_str(&buf);
+        edit.set_cursor(start_offset + TextUnit::of_str(&buf));
         buf.push_str("\n}");
         edit.insert(start_offset, buf);
-        LocalEdit {
-            label: "add impl".to_string(),
-            edit: edit.finish(),
-            cursor_position: Some(offset),
-        }
     })
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::test_utils::check_action;
+    use crate::assists::check_assist;
 
     #[test]
     fn test_add_impl() {
-        check_action(
+        check_assist(
+            add_impl,
             "struct Foo {<|>}\n",
             "struct Foo {}\n\nimpl Foo {\n<|>\n}\n",
-            |file, off| add_impl(file, off).map(|f| f()),
         );
-        check_action(
+        check_assist(
+            add_impl,
             "struct Foo<T: Clone> {<|>}",
             "struct Foo<T: Clone> {}\n\nimpl<T: Clone> Foo<T> {\n<|>\n}",
-            |file, off| add_impl(file, off).map(|f| f()),
         );
-        check_action(
+        check_assist(
+            add_impl,
             "struct Foo<'a, T: Foo<'a>> {<|>}",
             "struct Foo<'a, T: Foo<'a>> {}\n\nimpl<'a, T: Foo<'a>> Foo<'a, T> {\n<|>\n}",
-            |file, off| add_impl(file, off).map(|f| f()),
         );
     }
 
diff --git a/crates/ra_editor/src/assists/change_visibility.rs b/crates/ra_editor/src/assists/change_visibility.rs
index 98c218f32..379e88d3c 100644
--- a/crates/ra_editor/src/assists/change_visibility.rs
+++ b/crates/ra_editor/src/assists/change_visibility.rs
@@ -1,90 +1,74 @@
-use ra_text_edit::TextEditBuilder;
 use ra_syntax::{
-    SourceFileNode,
-    algo::find_leaf_at_offset,
     SyntaxKind::{VISIBILITY, FN_KW, MOD_KW, STRUCT_KW, ENUM_KW, TRAIT_KW, FN_DEF, MODULE, STRUCT_DEF, ENUM_DEF, TRAIT_DEF},
-    TextUnit,
 };
 
-use crate::assists::LocalEdit;
+use crate::assists::{AssistCtx, Assist};
 
-pub fn change_visibility<'a>(
-    file: &'a SourceFileNode,
-    offset: TextUnit,
-) -> Option<impl FnOnce() -> LocalEdit + 'a> {
-    let syntax = file.syntax();
-
-    let keyword = find_leaf_at_offset(syntax, offset).find(|leaf| match leaf.kind() {
+pub fn change_visibility(ctx: AssistCtx) -> Option<Assist> {
+    let keyword = ctx.leaf_at_offset().find(|leaf| match leaf.kind() {
         FN_KW | MOD_KW | STRUCT_KW | ENUM_KW | TRAIT_KW => true,
         _ => false,
     })?;
     let parent = keyword.parent()?;
     let def_kws = vec![FN_DEF, MODULE, STRUCT_DEF, ENUM_DEF, TRAIT_DEF];
-    let node_start = parent.range().start();
-    Some(move || {
-        let mut edit = TextEditBuilder::new();
-
-        if !def_kws.iter().any(|&def_kw| def_kw == parent.kind())
-            || parent.children().any(|child| child.kind() == VISIBILITY)
-        {
-            return LocalEdit {
-                label: "make pub crate".to_string(),
-                edit: edit.finish(),
-                cursor_position: Some(offset),
-            };
-        }
+    // Parent is not a definition, can't add visibility
+    if !def_kws.iter().any(|&def_kw| def_kw == parent.kind()) {
+        return None;
+    }
+    // Already have visibility, do nothing
+    if parent.children().any(|child| child.kind() == VISIBILITY) {
+        return None;
+    }
 
-        edit.insert(node_start, "pub(crate) ".to_string());
-        LocalEdit {
-            label: "make pub crate".to_string(),
-            edit: edit.finish(),
-            cursor_position: Some(node_start),
-        }
+    let node_start = parent.range().start();
+    ctx.build("make pub crate", |edit| {
+        edit.insert(node_start, "pub(crate) ");
+        edit.set_cursor(node_start);
     })
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::test_utils::check_action;
+    use crate::assists::check_assist;
 
     #[test]
     fn test_change_visibility() {
-        check_action(
+        check_assist(
+            change_visibility,
             "<|>fn foo() {}",
             "<|>pub(crate) fn foo() {}",
-            |file, off| change_visibility(file, off).map(|f| f()),
         );
-        check_action(
+        check_assist(
+            change_visibility,
             "f<|>n foo() {}",
             "<|>pub(crate) fn foo() {}",
-            |file, off| change_visibility(file, off).map(|f| f()),
         );
-        check_action(
+        check_assist(
+            change_visibility,
             "<|>struct Foo {}",
             "<|>pub(crate) struct Foo {}",
-            |file, off| change_visibility(file, off).map(|f| f()),
         );
-        check_action("<|>mod foo {}", "<|>pub(crate) mod foo {}", |file, off| {
-            change_visibility(file, off).map(|f| f())
-        });
-        check_action(
+        check_assist(
+            change_visibility,
+            "<|>mod foo {}",
+            "<|>pub(crate) mod foo {}",
+        );
+        check_assist(
+            change_visibility,
             "<|>trait Foo {}",
             "<|>pub(crate) trait Foo {}",
-            |file, off| change_visibility(file, off).map(|f| f()),
         );
-        check_action("m<|>od {}", "<|>pub(crate) mod {}", |file, off| {
-            change_visibility(file, off).map(|f| f())
-        });
-        check_action(
+        check_assist(change_visibility, "m<|>od {}", "<|>pub(crate) mod {}");
+        check_assist(
+            change_visibility,
             "pub(crate) f<|>n foo() {}",
             "pub(crate) f<|>n foo() {}",
-            |file, off| change_visibility(file, off).map(|f| f()),
         );
-        check_action(
+        check_assist(
+            change_visibility,
             "unsafe f<|>n foo() {}",
             "<|>pub(crate) unsafe fn foo() {}",
-            |file, off| change_visibility(file, off).map(|f| f()),
         );
     }
 }
diff --git a/crates/ra_editor/src/assists/flip_comma.rs b/crates/ra_editor/src/assists/flip_comma.rs
index d8727db0d..a343413cc 100644
--- a/crates/ra_editor/src/assists/flip_comma.rs
+++ b/crates/ra_editor/src/assists/flip_comma.rs
@@ -1,45 +1,31 @@
-use ra_text_edit::TextEditBuilder;
 use ra_syntax::{
-    algo::find_leaf_at_offset,
-    Direction, SourceFileNode,
+    Direction,
     SyntaxKind::COMMA,
-    TextUnit,
 };
 
-use crate::assists::{LocalEdit, non_trivia_sibling};
+use crate::assists::{non_trivia_sibling, AssistCtx, Assist};
 
-pub fn flip_comma<'a>(
-    file: &'a SourceFileNode,
-    offset: TextUnit,
-) -> Option<impl FnOnce() -> LocalEdit + 'a> {
-    let syntax = file.syntax();
-
-    let comma = find_leaf_at_offset(syntax, offset).find(|leaf| leaf.kind() == COMMA)?;
+pub fn flip_comma(ctx: AssistCtx) -> Option<Assist> {
+    let comma = ctx.leaf_at_offset().find(|leaf| leaf.kind() == COMMA)?;
     let prev = non_trivia_sibling(comma, Direction::Prev)?;
     let next = non_trivia_sibling(comma, Direction::Next)?;
-    Some(move || {
-        let mut edit = TextEditBuilder::new();
-        edit.replace(prev.range(), next.text().to_string());
-        edit.replace(next.range(), prev.text().to_string());
-        LocalEdit {
-            label: "flip comma".to_string(),
-            edit: edit.finish(),
-            cursor_position: None,
-        }
+    ctx.build("flip comma", |edit| {
+        edit.replace(prev.range(), next.text());
+        edit.replace(next.range(), prev.text());
     })
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::test_utils::check_action;
+    use crate::assists::check_assist;
 
     #[test]
-    fn test_swap_comma() {
-        check_action(
+    fn flip_comma_works_for_function_parameters() {
+        check_assist(
+            flip_comma,
             "fn foo(x: i32,<|> y: Result<(), ()>) {}",
             "fn foo(y: Result<(), ()>,<|> x: i32) {}",
-            |file, off| flip_comma(file, off).map(|f| f()),
         )
     }
 }
diff --git a/crates/ra_editor/src/assists/introduce_variable.rs b/crates/ra_editor/src/assists/introduce_variable.rs
index 17ab521fa..782861023 100644
--- a/crates/ra_editor/src/assists/introduce_variable.rs
+++ b/crates/ra_editor/src/assists/introduce_variable.rs
@@ -1,19 +1,13 @@
-use ra_text_edit::TextEditBuilder;
 use ra_syntax::{
-    algo::{find_covering_node},
     ast::{self, AstNode},
-    SourceFileNode,
-    SyntaxKind::{WHITESPACE},
-    SyntaxNodeRef, TextRange, TextUnit,
+    SyntaxKind::WHITESPACE,
+    SyntaxNodeRef, TextUnit,
 };
 
-use crate::assists::LocalEdit;
+use crate::assists::{AssistCtx, Assist};
 
-pub fn introduce_variable<'a>(
-    file: &'a SourceFileNode,
-    range: TextRange,
-) -> Option<impl FnOnce() -> LocalEdit + 'a> {
-    let node = find_covering_node(file.syntax(), range);
+pub fn introduce_variable<'a>(ctx: AssistCtx) -> Option<Assist> {
+    let node = ctx.covering_node();
     let expr = node.ancestors().filter_map(ast::Expr::cast).next()?;
 
     let anchor_stmt = anchor_stmt(expr)?;
@@ -21,9 +15,8 @@ pub fn introduce_variable<'a>(
     if indent.kind() != WHITESPACE {
         return None;
     }
-    return Some(move || {
+    ctx.build("introduce variable", move |edit| {
         let mut buf = String::new();
-        let mut edit = TextEditBuilder::new();
 
         buf.push_str("let var_name = ");
         expr.syntax().text().push_to(&mut buf);
@@ -40,43 +33,39 @@ pub fn introduce_variable<'a>(
             edit.replace(expr.syntax().range(), "var_name".to_string());
             edit.insert(anchor_stmt.range().start(), buf);
         }
-        let cursor_position = anchor_stmt.range().start() + TextUnit::of_str("let ");
-        LocalEdit {
-            label: "introduce variable".to_string(),
-            edit: edit.finish(),
-            cursor_position: Some(cursor_position),
-        }
-    });
+        edit.set_cursor(anchor_stmt.range().start() + TextUnit::of_str("let "));
+    })
+}
 
-    /// Statement or last in the block expression, which will follow
-    /// the freshly introduced var.
-    fn anchor_stmt(expr: ast::Expr) -> Option<SyntaxNodeRef> {
-        expr.syntax().ancestors().find(|&node| {
-            if ast::Stmt::cast(node).is_some() {
+/// Statement or last in the block expression, which will follow
+/// the freshly introduced var.
+fn anchor_stmt(expr: ast::Expr) -> Option<SyntaxNodeRef> {
+    expr.syntax().ancestors().find(|&node| {
+        if ast::Stmt::cast(node).is_some() {
+            return true;
+        }
+        if let Some(expr) = node
+            .parent()
+            .and_then(ast::Block::cast)
+            .and_then(|it| it.expr())
+        {
+            if expr.syntax() == node {
                 return true;
             }
-            if let Some(expr) = node
-                .parent()
-                .and_then(ast::Block::cast)
-                .and_then(|it| it.expr())
-            {
-                if expr.syntax() == node {
-                    return true;
-                }
-            }
-            false
-        })
-    }
+        }
+        false
+    })
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::test_utils::check_action_range;
+    use crate::assists::check_assist_range;
 
     #[test]
     fn test_introduce_var_simple() {
-        check_action_range(
+        check_assist_range(
+            introduce_variable,
             "
 fn foo() {
     foo(<|>1 + 1<|>);
@@ -86,13 +75,13 @@ fn foo() {
     let <|>var_name = 1 + 1;
     foo(var_name);
 }",
-            |file, range| introduce_variable(file, range).map(|f| f()),
         );
     }
 
     #[test]
     fn test_introduce_var_expr_stmt() {
-        check_action_range(
+        check_assist_range(
+            introduce_variable,
             "
 fn foo() {
     <|>1 + 1<|>;
@@ -101,13 +90,13 @@ fn foo() {
 fn foo() {
     let <|>var_name = 1 + 1;
 }",
-            |file, range| introduce_variable(file, range).map(|f| f()),
         );
     }
 
     #[test]
     fn test_introduce_var_part_of_expr_stmt() {
-        check_action_range(
+        check_assist_range(
+            introduce_variable,
             "
 fn foo() {
     <|>1<|> + 1;
@@ -117,13 +106,13 @@ fn foo() {
     let <|>var_name = 1;
     var_name + 1;
 }",
-            |file, range| introduce_variable(file, range).map(|f| f()),
         );
     }
 
     #[test]
     fn test_introduce_var_last_expr() {
-        check_action_range(
+        check_assist_range(
+            introduce_variable,
             "
 fn foo() {
     bar(<|>1 + 1<|>)
@@ -133,13 +122,13 @@ fn foo() {
     let <|>var_name = 1 + 1;
     bar(var_name)
 }",
-            |file, range| introduce_variable(file, range).map(|f| f()),
         );
     }
 
     #[test]
     fn test_introduce_var_last_full_expr() {
-        check_action_range(
+        check_assist_range(
+            introduce_variable,
             "
 fn foo() {
     <|>bar(1 + 1)<|>
@@ -149,7 +138,6 @@ fn foo() {
     let <|>var_name = bar(1 + 1);
     var_name
 }",
-            |file, range| introduce_variable(file, range).map(|f| f()),
         );
     }