1 files changed, 223 insertions, 118 deletions

diff --git a/crates/ra_assists/src/handlers/add_missing_impl_members.rs b/crates/ra_assists/src/handlers/add_missing_impl_members.rs
index 2d6d44980..abacd4065 100644
--- a/crates/ra_assists/src/handlers/add_missing_impl_members.rs
+++ b/crates/ra_assists/src/handlers/add_missing_impl_members.rs
@@ -1,13 +1,18 @@
 use hir::HasSource;
 use ra_syntax::{
-    ast::{self, edit, make, AstNode, NameOwner},
+    ast::{
+        self,
+        edit::{self, AstNodeEdit, IndentLevel},
+        make, AstNode, NameOwner,
+    },
     SmolStr,
 };
 
 use crate::{
+    assist_context::{AssistContext, Assists},
     ast_transform::{self, AstTransform, QualifyPaths, SubstituteTypeParams},
-    utils::{get_missing_impl_items, resolve_target_trait},
-    Assist, AssistCtx, AssistId,
+    utils::{get_missing_assoc_items, render_snippet, resolve_target_trait, Cursor},
+    AssistId,
 };
 
 #[derive(PartialEq)]
@@ -40,12 +45,15 @@ enum AddMissingImplMembersMode {
 // }
 //
 // impl Trait<u32> for () {
-//     fn foo(&self) -> u32 { todo!() }
+//     fn foo(&self) -> u32 {
+//         ${0:todo!()}
+//     }
 //
 // }
 // ```
-pub(crate) fn add_missing_impl_members(ctx: AssistCtx) -> Option<Assist> {
+pub(crate) fn add_missing_impl_members(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
     add_missing_impl_members_inner(
+        acc,
         ctx,
         AddMissingImplMembersMode::NoDefaultMethods,
         "add_impl_missing_members",
@@ -81,12 +89,13 @@ pub(crate) fn add_missing_impl_members(ctx: AssistCtx) -> Option<Assist> {
 // impl Trait for () {
 //     Type X = ();
 //     fn foo(&self) {}
-//     fn bar(&self) {}
+//     $0fn bar(&self) {}
 //
 // }
 // ```
-pub(crate) fn add_missing_default_members(ctx: AssistCtx) -> Option<Assist> {
+pub(crate) fn add_missing_default_members(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
     add_missing_impl_members_inner(
+        acc,
         ctx,
         AddMissingImplMembersMode::DefaultMethodsOnly,
         "add_impl_default_members",
@@ -95,36 +104,37 @@ pub(crate) fn add_missing_default_members(ctx: AssistCtx) -> Option<Assist> {
 }
 
 fn add_missing_impl_members_inner(
-    ctx: AssistCtx,
+    acc: &mut Assists,
+    ctx: &AssistContext,
     mode: AddMissingImplMembersMode,
     assist_id: &'static str,
     label: &'static str,
-) -> Option<Assist> {
+) -> Option<()> {
     let _p = ra_prof::profile("add_missing_impl_members_inner");
-    let impl_node = ctx.find_node_at_offset::<ast::ImplDef>()?;
-    let impl_item_list = impl_node.item_list()?;
+    let impl_def = ctx.find_node_at_offset::<ast::ImplDef>()?;
+    let impl_item_list = impl_def.item_list()?;
 
-    let trait_ = resolve_target_trait(&ctx.sema, &impl_node)?;
+    let trait_ = resolve_target_trait(&ctx.sema, &impl_def)?;
 
-    let def_name = |item: &ast::ImplItem| -> Option<SmolStr> {
+    let def_name = |item: &ast::AssocItem| -> Option<SmolStr> {
         match item {
-            ast::ImplItem::FnDef(def) => def.name(),
-            ast::ImplItem::TypeAliasDef(def) => def.name(),
-            ast::ImplItem::ConstDef(def) => def.name(),
+            ast::AssocItem::FnDef(def) => def.name(),
+            ast::AssocItem::TypeAliasDef(def) => def.name(),
+            ast::AssocItem::ConstDef(def) => def.name(),
         }
         .map(|it| it.text().clone())
     };
 
-    let missing_items = get_missing_impl_items(&ctx.sema, &impl_node)
+    let missing_items = get_missing_assoc_items(&ctx.sema, &impl_def)
         .iter()
         .map(|i| match i {
-            hir::AssocItem::Function(i) => ast::ImplItem::FnDef(i.source(ctx.db).value),
-            hir::AssocItem::TypeAlias(i) => ast::ImplItem::TypeAliasDef(i.source(ctx.db).value),
-            hir::AssocItem::Const(i) => ast::ImplItem::ConstDef(i.source(ctx.db).value),
+            hir::AssocItem::Function(i) => ast::AssocItem::FnDef(i.source(ctx.db).value),
+            hir::AssocItem::TypeAlias(i) => ast::AssocItem::TypeAliasDef(i.source(ctx.db).value),
+            hir::AssocItem::Const(i) => ast::AssocItem::ConstDef(i.source(ctx.db).value),
         })
         .filter(|t| def_name(&t).is_some())
         .filter(|t| match t {
-            ast::ImplItem::FnDef(def) => match mode {
+            ast::AssocItem::FnDef(def) => match mode {
                 AddMissingImplMembersMode::DefaultMethodsOnly => def.body().is_some(),
                 AddMissingImplMembersMode::NoDefaultMethods => def.body().is_none(),
             },
@@ -136,44 +146,59 @@ fn add_missing_impl_members_inner(
         return None;
     }
 
-    let sema = ctx.sema;
-
-    ctx.add_assist(AssistId(assist_id), label, |edit| {
-        let n_existing_items = impl_item_list.impl_items().count();
-        let source_scope = sema.scope_for_def(trait_);
-        let target_scope = sema.scope(impl_item_list.syntax());
+    let target = impl_def.syntax().text_range();
+    acc.add(AssistId(assist_id), label, target, |builder| {
+        let n_existing_items = impl_item_list.assoc_items().count();
+        let source_scope = ctx.sema.scope_for_def(trait_);
+        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))
             .map(|it| match it {
-                ast::ImplItem::FnDef(def) => ast::ImplItem::FnDef(add_body(def)),
+                ast::AssocItem::FnDef(def) => ast::AssocItem::FnDef(add_body(def)),
                 _ => it,
             })
             .map(|it| edit::remove_attrs_and_docs(&it));
         let new_impl_item_list = impl_item_list.append_items(items);
-        let cursor_position = {
-            let first_new_item = new_impl_item_list.impl_items().nth(n_existing_items).unwrap();
-            first_new_item.syntax().text_range().start()
+        let first_new_item = new_impl_item_list.assoc_items().nth(n_existing_items).unwrap();
+
+        let original_range = impl_item_list.syntax().text_range();
+        match ctx.config.snippet_cap {
+            None => builder.replace(original_range, new_impl_item_list.to_string()),
+            Some(cap) => {
+                let mut cursor = Cursor::Before(first_new_item.syntax());
+                let placeholder;
+                if let ast::AssocItem::FnDef(func) = &first_new_item {
+                    if let Some(m) = func.syntax().descendants().find_map(ast::MacroCall::cast) {
+                        if m.syntax().text() == "todo!()" {
+                            placeholder = m;
+                            cursor = Cursor::Replace(placeholder.syntax());
+                        }
+                    }
+                }
+                builder.replace_snippet(
+                    cap,
+                    original_range,
+                    render_snippet(cap, new_impl_item_list.syntax(), cursor),
+                )
+            }
         };
-
-        edit.replace_ast(impl_item_list, new_impl_item_list);
-        edit.set_cursor(cursor_position);
     })
 }
 
 fn add_body(fn_def: ast::FnDef) -> ast::FnDef {
-    if fn_def.body().is_none() {
-        fn_def.with_body(make::block_from_expr(make::expr_todo()))
-    } else {
-        fn_def
+    if fn_def.body().is_some() {
+        return fn_def;
     }
+    let body = make::block_expr(None, Some(make::expr_todo())).indent(IndentLevel(1));
+    fn_def.with_body(body)
 }
 
 #[cfg(test)]
 mod tests {
-    use crate::helpers::{check_assist, check_assist_not_applicable};
+    use crate::tests::{check_assist, check_assist_not_applicable};
 
     use super::*;
 
@@ -181,7 +206,7 @@ mod tests {
     fn test_add_missing_impl_members() {
         check_assist(
             add_missing_impl_members,
-            "
+            r#"
 trait Foo {
     type Output;
 
@@ -197,8 +222,8 @@ struct S;
 impl Foo for S {
     fn bar(&self) {}
 <|>
-}",
-            "
+}"#,
+            r#"
 trait Foo {
     type Output;
 
@@ -213,12 +238,16 @@ struct S;
 
 impl Foo for S {
     fn bar(&self) {}
-    <|>type Output;
+    $0type Output;
     const CONST: usize = 42;
-    fn foo(&self) { todo!() }
-    fn baz(&self) { todo!() }
+    fn foo(&self) {
+        todo!()
+    }
+    fn baz(&self) {
+        todo!()
+    }
 
-}",
+}"#,
         );
     }
 
@@ -226,7 +255,7 @@ impl Foo for S {
     fn test_copied_overriden_members() {
         check_assist(
             add_missing_impl_members,
-            "
+            r#"
 trait Foo {
     fn foo(&self);
     fn bar(&self) -> bool { true }
@@ -238,8 +267,8 @@ struct S;
 impl Foo for S {
     fn bar(&self) {}
 <|>
-}",
-            "
+}"#,
+            r#"
 trait Foo {
     fn foo(&self);
     fn bar(&self) -> bool { true }
@@ -250,9 +279,11 @@ struct S;
 
 impl Foo for S {
     fn bar(&self) {}
-    <|>fn foo(&self) { todo!() }
+    fn foo(&self) {
+        ${0:todo!()}
+    }
 
-}",
+}"#,
         );
     }
 
@@ -260,16 +291,18 @@ impl Foo for S {
     fn test_empty_impl_def() {
         check_assist(
             add_missing_impl_members,
-            "
+            r#"
 trait Foo { fn foo(&self); }
 struct S;
-impl Foo for S { <|> }",
-            "
+impl Foo for S { <|> }"#,
+            r#"
 trait Foo { fn foo(&self); }
 struct S;
 impl Foo for S {
-    <|>fn foo(&self) { todo!() }
-}",
+    fn foo(&self) {
+        ${0:todo!()}
+    }
+}"#,
         );
     }
 
@@ -277,16 +310,18 @@ impl Foo for S {
     fn fill_in_type_params_1() {
         check_assist(
             add_missing_impl_members,
-            "
+            r#"
 trait Foo<T> { fn foo(&self, t: T) -> &T; }
 struct S;
-impl Foo<u32> for S { <|> }",
-            "
+impl Foo<u32> for S { <|> }"#,
+            r#"
 trait Foo<T> { fn foo(&self, t: T) -> &T; }
 struct S;
 impl Foo<u32> for S {
-    <|>fn foo(&self, t: u32) -> &u32 { todo!() }
-}",
+    fn foo(&self, t: u32) -> &u32 {
+        ${0:todo!()}
+    }
+}"#,
         );
     }
 
@@ -294,16 +329,18 @@ impl Foo<u32> for S {
     fn fill_in_type_params_2() {
         check_assist(
             add_missing_impl_members,
-            "
+            r#"
 trait Foo<T> { fn foo(&self, t: T) -> &T; }
 struct S;
-impl<U> Foo<U> for S { <|> }",
-            "
+impl<U> Foo<U> for S { <|> }"#,
+            r#"
 trait Foo<T> { fn foo(&self, t: T) -> &T; }
 struct S;
 impl<U> Foo<U> for S {
-    <|>fn foo(&self, t: U) -> &U { todo!() }
-}",
+    fn foo(&self, t: U) -> &U {
+        ${0:todo!()}
+    }
+}"#,
         );
     }
 
@@ -311,16 +348,18 @@ impl<U> Foo<U> for S {
     fn test_cursor_after_empty_impl_def() {
         check_assist(
             add_missing_impl_members,
-            "
+            r#"
 trait Foo { fn foo(&self); }
 struct S;
-impl Foo for S {}<|>",
-            "
+impl Foo for S {}<|>"#,
+            r#"
 trait Foo { fn foo(&self); }
 struct S;
 impl Foo for S {
-    <|>fn foo(&self) { todo!() }
-}",
+    fn foo(&self) {
+        ${0:todo!()}
+    }
+}"#,
         )
     }
 
@@ -328,22 +367,24 @@ impl Foo for S {
     fn test_qualify_path_1() {
         check_assist(
             add_missing_impl_members,
-            "
+            r#"
 mod foo {
     pub struct Bar;
     trait Foo { fn foo(&self, bar: Bar); }
 }
 struct S;
-impl foo::Foo for S { <|> }",
-            "
+impl foo::Foo for S { <|> }"#,
+            r#"
 mod foo {
     pub struct Bar;
     trait Foo { fn foo(&self, bar: Bar); }
 }
 struct S;
 impl foo::Foo for S {
-    <|>fn foo(&self, bar: foo::Bar) { todo!() }
-}",
+    fn foo(&self, bar: foo::Bar) {
+        ${0:todo!()}
+    }
+}"#,
         );
     }
 
@@ -351,22 +392,24 @@ impl foo::Foo for S {
     fn test_qualify_path_generic() {
         check_assist(
             add_missing_impl_members,
-            "
+            r#"
 mod foo {
     pub struct Bar<T>;
     trait Foo { fn foo(&self, bar: Bar<u32>); }
 }
 struct S;
-impl foo::Foo for S { <|> }",
-            "
+impl foo::Foo for S { <|> }"#,
+            r#"
 mod foo {
     pub struct Bar<T>;
     trait Foo { fn foo(&self, bar: Bar<u32>); }
 }
 struct S;
 impl foo::Foo for S {
-    <|>fn foo(&self, bar: foo::Bar<u32>) { todo!() }
-}",
+    fn foo(&self, bar: foo::Bar<u32>) {
+        ${0:todo!()}
+    }
+}"#,
         );
     }
 
@@ -374,22 +417,24 @@ impl foo::Foo for S {
     fn test_qualify_path_and_substitute_param() {
         check_assist(
             add_missing_impl_members,
-            "
+            r#"
 mod foo {
     pub struct Bar<T>;
     trait Foo<T> { fn foo(&self, bar: Bar<T>); }
 }
 struct S;
-impl foo::Foo<u32> for S { <|> }",
-            "
+impl foo::Foo<u32> for S { <|> }"#,
+            r#"
 mod foo {
     pub struct Bar<T>;
     trait Foo<T> { fn foo(&self, bar: Bar<T>); }
 }
 struct S;
 impl foo::Foo<u32> for S {
-    <|>fn foo(&self, bar: foo::Bar<u32>) { todo!() }
-}",
+    fn foo(&self, bar: foo::Bar<u32>) {
+        ${0:todo!()}
+    }
+}"#,
         );
     }
 
@@ -398,15 +443,15 @@ impl foo::Foo<u32> for S {
         // when substituting params, the substituted param should not be qualified!
         check_assist(
             add_missing_impl_members,
-            "
+            r#"
 mod foo {
     trait Foo<T> { fn foo(&self, bar: T); }
     pub struct Param;
 }
 struct Param;
 struct S;
-impl foo::Foo<Param> for S { <|> }",
-            "
+impl foo::Foo<Param> for S { <|> }"#,
+            r#"
 mod foo {
     trait Foo<T> { fn foo(&self, bar: T); }
     pub struct Param;
@@ -414,8 +459,10 @@ mod foo {
 struct Param;
 struct S;
 impl foo::Foo<Param> for S {
-    <|>fn foo(&self, bar: Param) { todo!() }
-}",
+    fn foo(&self, bar: Param) {
+        ${0:todo!()}
+    }
+}"#,
         );
     }
 
@@ -423,15 +470,15 @@ impl foo::Foo<Param> for S {
     fn test_qualify_path_associated_item() {
         check_assist(
             add_missing_impl_members,
-            "
+            r#"
 mod foo {
     pub struct Bar<T>;
     impl Bar<T> { type Assoc = u32; }
     trait Foo { fn foo(&self, bar: Bar<u32>::Assoc); }
 }
 struct S;
-impl foo::Foo for S { <|> }",
-            "
+impl foo::Foo for S { <|> }"#,
+            r#"
 mod foo {
     pub struct Bar<T>;
     impl Bar<T> { type Assoc = u32; }
@@ -439,8 +486,10 @@ mod foo {
 }
 struct S;
 impl foo::Foo for S {
-    <|>fn foo(&self, bar: foo::Bar<u32>::Assoc) { todo!() }
-}",
+    fn foo(&self, bar: foo::Bar<u32>::Assoc) {
+        ${0:todo!()}
+    }
+}"#,
         );
     }
 
@@ -448,15 +497,15 @@ impl foo::Foo for S {
     fn test_qualify_path_nested() {
         check_assist(
             add_missing_impl_members,
-            "
+            r#"
 mod foo {
     pub struct Bar<T>;
     pub struct Baz;
     trait Foo { fn foo(&self, bar: Bar<Baz>); }
 }
 struct S;
-impl foo::Foo for S { <|> }",
-            "
+impl foo::Foo for S { <|> }"#,
+            r#"
 mod foo {
     pub struct Bar<T>;
     pub struct Baz;
@@ -464,8 +513,10 @@ mod foo {
 }
 struct S;
 impl foo::Foo for S {
-    <|>fn foo(&self, bar: foo::Bar<foo::Baz>) { todo!() }
-}",
+    fn foo(&self, bar: foo::Bar<foo::Baz>) {
+        ${0:todo!()}
+    }
+}"#,
         );
     }
 
@@ -473,22 +524,24 @@ impl foo::Foo for S {
     fn test_qualify_path_fn_trait_notation() {
         check_assist(
             add_missing_impl_members,
-            "
+            r#"
 mod foo {
     pub trait Fn<Args> { type Output; }
     trait Foo { fn foo(&self, bar: dyn Fn(u32) -> i32); }
 }
 struct S;
-impl foo::Foo for S { <|> }",
-            "
+impl foo::Foo for S { <|> }"#,
+            r#"
 mod foo {
     pub trait Fn<Args> { type Output; }
     trait Foo { fn foo(&self, bar: dyn Fn(u32) -> i32); }
 }
 struct S;
 impl foo::Foo for S {
-    <|>fn foo(&self, bar: dyn Fn(u32) -> i32) { todo!() }
-}",
+    fn foo(&self, bar: dyn Fn(u32) -> i32) {
+        ${0:todo!()}
+    }
+}"#,
         );
     }
 
@@ -496,10 +549,10 @@ impl foo::Foo for S {
     fn test_empty_trait() {
         check_assist_not_applicable(
             add_missing_impl_members,
-            "
+            r#"
 trait Foo;
 struct S;
-impl Foo for S { <|> }",
+impl Foo for S { <|> }"#,
         )
     }
 
@@ -507,13 +560,13 @@ impl Foo for S { <|> }",
     fn test_ignore_unnamed_trait_members_and_default_methods() {
         check_assist_not_applicable(
             add_missing_impl_members,
-            "
+            r#"
 trait Foo {
     fn (arg: u32);
     fn valid(some: u32) -> bool { false }
 }
 struct S;
-impl Foo for S { <|> }",
+impl Foo for S { <|> }"#,
         )
     }
 
@@ -543,8 +596,10 @@ trait Foo {
 }
 struct S;
 impl Foo for S {
-    <|>type Output;
-    fn foo(&self) { todo!() }
+    $0type Output;
+    fn foo(&self) {
+        todo!()
+    }
 }"#,
         )
     }
@@ -553,7 +608,7 @@ impl Foo for S {
     fn test_default_methods() {
         check_assist(
             add_missing_default_members,
-            "
+            r#"
 trait Foo {
     type Output;
 
@@ -563,8 +618,8 @@ trait Foo {
     fn foo(some: u32) -> bool;
 }
 struct S;
-impl Foo for S { <|> }",
-            "
+impl Foo for S { <|> }"#,
+            r#"
 trait Foo {
     type Output;
 
@@ -575,8 +630,58 @@ trait Foo {
 }
 struct S;
 impl Foo for S {
-    <|>fn valid(some: u32) -> bool { false }
-}",
+    $0fn valid(some: u32) -> bool { false }
+}"#,
+        )
+    }
+
+    #[test]
+    fn test_generic_single_default_parameter() {
+        check_assist(
+            add_missing_impl_members,
+            r#"
+trait Foo<T = Self> {
+    fn bar(&self, other: &T);
+}
+
+struct S;
+impl Foo for S { <|> }"#,
+            r#"
+trait Foo<T = Self> {
+    fn bar(&self, other: &T);
+}
+
+struct S;
+impl Foo for S {
+    fn bar(&self, other: &Self) {
+        ${0:todo!()}
+    }
+}"#,
+        )
+    }
+
+    #[test]
+    fn test_generic_default_parameter_is_second() {
+        check_assist(
+            add_missing_impl_members,
+            r#"
+trait Foo<T1, T2 = Self> {
+    fn bar(&self, this: &T1, that: &T2);
+}
+
+struct S<T>;
+impl Foo<T> for S<T> { <|> }"#,
+            r#"
+trait Foo<T1, T2 = Self> {
+    fn bar(&self, this: &T1, that: &T2);
+}
+
+struct S<T>;
+impl Foo<T> for S<T> {
+    fn bar(&self, this: &T, that: &Self) {
+        ${0:todo!()}
+    }
+}"#,
         )
     }
 }