Merge #9835

9835: feat: Generate default trait fn impl when generating `Hash`. r=Veykril a=yoshuawuyts

Implements a default trait function body when generating the `Hash` trait for a type. Thanks!

r? `@Veykril` 

Co-authored-by: Yoshua Wuyts <yoshuawuyts@gmail.com>

crates/ide/src/hover.rs

@@ -2732,8 +2732,8 @@ fn foo() {
                                     file_id: FileId(
                                         1,
                                     ),
-                                    full_range: 252..434,
-                                    focus_range: 291..297,
+                                    full_range: 253..435,
+                                    focus_range: 292..298,
                                     name: "Future",
                                     kind: Trait,
                                     description: "pub trait Future",

crates/ide_assists/src/handlers/replace_derive_with_manual_impl.rs

@@ -366,6 +366,83 @@ impl Default for Foo {
         Self {  }
     }
 }
+"#,
+        )
+    }
+
+    #[test]
+    fn add_custom_impl_hash_record_struct() {
+        check_assist(
+            replace_derive_with_manual_impl,
+            r#"
+//- minicore: hash
+#[derive(Has$0h)]
+struct Foo {
+    bin: usize,
+    bar: usize,
+}
+"#,
+            r#"
+struct Foo {
+    bin: usize,
+    bar: usize,
+}
+
+impl core::hash::Hash for Foo {
+    $0fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
+        self.bin.hash(state);
+        self.bar.hash(state);
+    }
+}
+"#,
+        )
+    }
+
+    #[test]
+    fn add_custom_impl_hash_tuple_struct() {
+        check_assist(
+            replace_derive_with_manual_impl,
+            r#"
+//- minicore: hash
+#[derive(Has$0h)]
+struct Foo(usize, usize);
+"#,
+            r#"
+struct Foo(usize, usize);
+
+impl core::hash::Hash for Foo {
+    $0fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
+        self.0.hash(state);
+        self.1.hash(state);
+    }
+}
+"#,
+        )
+    }
+
+    #[test]
+    fn add_custom_impl_hash_enum() {
+        check_assist(
+            replace_derive_with_manual_impl,
+            r#"
+//- minicore: hash
+#[derive(Has$0h)]
+enum Foo {
+    Bar,
+    Baz,
+}
+"#,
+            r#"
+enum Foo {
+    Bar,
+    Baz,
+}
+
+impl core::hash::Hash for Foo {
+    $0fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
+        core::mem::discriminant(self).hash(state);
+    }
+}
 "#,
         )
     }

crates/ide_assists/src/utils/gen_trait_fn_body.rs

@@ -18,6 +18,7 @@ pub(crate) fn gen_trait_fn_body(
     match trait_path.segment()?.name_ref()?.text().as_str() {
         "Debug" => gen_debug_impl(adt, func),
         "Default" => gen_default_impl(adt, func),
+        "Hash" => gen_hash_impl(adt, func),
         _ => None,
     }
 }
@@ -151,3 +152,63 @@ fn gen_default_impl(adt: &ast::Adt, func: &ast::Fn) -> Option<()> {
         }
     }
 }
+
+/// Generate a `Hash` impl based on the fields and members of the target type.
+fn gen_hash_impl(adt: &ast::Adt, func: &ast::Fn) -> Option<()> {
+    fn gen_hash_call(target: ast::Expr) -> ast::Stmt {
+        let method = make::name_ref("hash");
+        let arg = make::expr_path(make::ext::ident_path("state"));
+        let expr = make::expr_method_call(target, method, make::arg_list(Some(arg)));
+        let stmt = make::expr_stmt(expr);
+        stmt.into()
+    }
+
+    let body = match adt {
+        // `Hash` cannot be derived for unions, so no default impl can be provided.
+        ast::Adt::Union(_) => return None,
+
+        // => std::mem::discriminant(self).hash(state);
+        ast::Adt::Enum(_) => {
+            let root = make::ext::ident_path("core");
+            let submodule = make::ext::ident_path("mem");
+            let fn_name = make::ext::ident_path("discriminant");
+            let fn_name = make::path_concat(submodule, fn_name);
+            let fn_name = make::expr_path(make::path_concat(root, fn_name));
+
+            let arg = make::expr_path(make::ext::ident_path("self"));
+            let fn_call = make::expr_call(fn_name, make::arg_list(Some(arg)));
+            let stmt = gen_hash_call(fn_call);
+
+            make::block_expr(Some(stmt), None).indent(ast::edit::IndentLevel(1))
+        }
+        ast::Adt::Struct(strukt) => match strukt.field_list() {
+            // => self.<field>.hash(state);*
+            Some(ast::FieldList::RecordFieldList(field_list)) => {
+                let mut stmts = vec![];
+                for field in field_list.fields() {
+                    let base = make::expr_path(make::ext::ident_path("self"));
+                    let target = make::expr_field(base, &field.name()?.to_string());
+                    stmts.push(gen_hash_call(target));
+                }
+                make::block_expr(stmts, None).indent(ast::edit::IndentLevel(1))
+            }
+
+            // => self.<field_index>.hash(state);*
+            Some(ast::FieldList::TupleFieldList(field_list)) => {
+                let mut stmts = vec![];
+                for (i, _) in field_list.fields().enumerate() {
+                    let base = make::expr_path(make::ext::ident_path("self"));
+                    let target = make::expr_field(base, &format!("{}", i));
+                    stmts.push(gen_hash_call(target));
+                }
+                make::block_expr(stmts, None).indent(ast::edit::IndentLevel(1))
+            }
+
+            // No fields in the body means there's nothing to hash.
+            None => return None,
+        },
+    };
+
+    ted::replace(func.body()?.syntax(), body.clone_for_update().syntax());
+    Some(())
+}

crates/test_utils/src/minicore.rs

@@ -25,6 +25,7 @@
 //!     iterator: option
 //!     iterators: iterator, fn
 //!     default: sized
+//!     hash:
 //!     clone: sized
 //!     copy: clone
 //!     from: sized
@@ -87,6 +88,16 @@ pub mod default {
 }
 // endregion:default
 
+// region:hash
+pub mod hash {
+    pub trait Hasher {}
+
+    pub trait Hash {
+        fn hash<H: Hasher>(&self, state: &mut H);
+    }
+}
+// endregion:hash
+
 // region:clone
 pub mod clone {
     #[lang = "clone"]