7708: Initial implementation of generate Default assist.

The Generate Default impl from new function.

crates/ide_assists/src/handlers/generate_default_from_new.rs

@@ -0,0 +1,221 @@
+use crate::{AssistId, assist_context::{AssistContext, Assists}};
+use syntax::{AstNode, SyntaxKind, SyntaxNode, SyntaxText, ast::{self, NameOwner}};
+use test_utils::mark;
+
+// Assist: generate_default_from_new
+//
+// Generates default implementation from new method
+//
+// ```
+// struct Example { _inner: () }
+//
+// impl Example {
+//     pu|b fn new() -> Self {
+//         Self { _inner: () }
+//     }
+// }
+// ```
+// ->
+// ```
+// struct Example { _inner: () }
+
+// impl Example {
+//     pub fn new() -> Self {
+//         Self { _inner: () }
+//     }
+// }
+
+// impl Default for Example {
+//     fn default() -> Self {
+//         Self::new()
+//     }
+// }
+// ```
+pub(crate) fn generate_default_from_new(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
+    let fn_node: ast::Fn = ctx.find_node_at_offset()?;
+    let fn_name = fn_node.name()?.to_string();
+
+    if !fn_name.eq("new") {
+        mark::hit!(other_function_than_new);
+        return None;
+    }
+
+    if fn_node.param_list()?.params().count() != 0 {
+        mark::hit!(new_function_with_parameters);
+        return None;
+    }
+
+    let insert_after = scope_for_fn_insertion_node(&fn_node.syntax())?;
+    let impl_obj = ast::Impl::cast(insert_after)?;
+    let struct_name = impl_obj.self_ty()?.syntax().text();
+
+    let default_fn_syntax = default_fn_node_for_new(struct_name);
+
+
+    acc.add(
+        AssistId("generate_default_from_new", crate::AssistKind::Generate),
+        "Generate a Default impl from a new fn",
+        impl_obj.syntax().text_range(),
+        move |builder| {
+            // TODO: indentation logic can also go here.
+            // let new_indent = IndentLevel::from_node(&insert_after);
+            let insert_location = impl_obj.syntax().text_range().end();
+            builder.insert(insert_location, default_fn_syntax);
+        },
+    )
+}
+
+fn scope_for_fn_insertion_node(node: &SyntaxNode) -> Option<SyntaxNode> {
+    node.ancestors().into_iter().find(|node| node.kind() == SyntaxKind::IMPL)
+}
+
+fn default_fn_node_for_new(struct_name: SyntaxText) -> String {
+    // TODO: Update the implementation to consider the code indentation.
+    format!(
+    r#"
+
+impl Default for {} {{
+    fn default() -> Self {{
+        Self::new()
+    }}
+}}"#
+    ,struct_name)
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::tests::{check_assist, check_assist_not_applicable};
+
+    use super::*;
+
+    #[test]
+    fn generate_default() {
+        check_assist(
+            generate_default_from_new,
+            r#"
+struct Example { _inner: () }
+
+impl Example {
+    pub fn ne$0w() -> Self {
+        Self { _inner: () }
+    }
+}
+
+fn main() {}
+"#,
+            r#"
+struct Example { _inner: () }
+
+impl Example {
+    pub fn new() -> Self {
+        Self { _inner: () }
+    }
+}
+
+impl Default for Example {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+fn main() {}
+"#,
+        );
+    }
+
+    #[test]
+    fn generate_default2() {
+        check_assist(
+            generate_default_from_new,
+            r#"
+struct Test { value: u32 }
+
+impl Test {
+    pub fn ne$0w() -> Self {
+        Self { value: 0 }
+    }
+}
+"#,
+            r#"
+struct Test { value: u32 }
+
+impl Test {
+    pub fn new() -> Self {
+        Self { value: 0 }
+    }
+}
+
+impl Default for Test {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn new_function_with_parameters() {
+        mark::check!(new_function_with_parameters);
+        check_assist_not_applicable(generate_default_from_new,
+        r#"
+struct Example { _inner: () }
+
+impl Example {
+    pub fn $0new(value: ()) -> Self {
+        Self { _inner: value }
+    }
+}
+"#
+        );
+    }
+
+    #[test]
+    fn other_function_than_new() {
+        mark::check!(other_function_than_new);
+        check_assist_not_applicable(generate_default_from_new,
+        r#"
+struct Example { _inner: () }
+
+impl Exmaple {
+    pub fn a$0dd() -> Self {
+        Self { _inner: () }
+    }
+}
+
+"#
+        );
+    }
+
+//     #[test]
+//     fn default_block_is_already_present() {
+//         check_assist_not_applicable(generate_default_from_new,
+//         r#"
+// struct Example { _inner: () }
+
+// impl Exmaple {
+//     pub fn n$0ew() -> Self {
+//         Self { _inner: () }
+//     }
+// }
+
+// impl Default for Example {
+//     fn default() -> Self {
+//         Self::new()
+//     }
+// }
+// "#,
+//         );
+//     }
+
+    #[test]
+    fn standalone_new_function() {
+        check_assist_not_applicable(generate_default_from_new,
+        r#"
+fn n$0ew() -> u32 {
+    0
+}
+"#
+        );
+    }
+}

crates/ide_assists/src/lib.rs

@@ -127,6 +127,7 @@ mod handlers {
     mod flip_comma;
     mod flip_trait_bound;
     mod generate_default_from_enum_variant;
+    mod generate_default_from_new;
     mod generate_derive;
     mod generate_enum_is_method;
     mod generate_enum_projection_method;
@@ -189,6 +190,7 @@ mod handlers {
             flip_comma::flip_comma,
             flip_trait_bound::flip_trait_bound,
             generate_default_from_enum_variant::generate_default_from_enum_variant,
+            generate_default_from_new::generate_default_from_new,
             generate_derive::generate_derive,
             generate_enum_is_method::generate_enum_is_method,
             generate_enum_projection_method::generate_enum_as_method,