fix(sol-macro-expander): propagate all_derives and extra_derives to periphery SC structs (#1011)

* Fix derives

* Simplify

* Do not affect functions_enum

* Avoid extra enum expander

* Doc

* Comment

Author: squadgazzz

crates/sol-macro-expander/src/expand/contract.rs

@@ -141,9 +141,7 @@ pub(super) fn expand(cx: &mut ExpCtxt<'_>, contract: &ItemContract) -> Result<To
             item_tokens.extend(cx.expand_item(&item)?);
         }
     }
-    cx.attrs = prev_cx_attrs;
 
-    let enum_expander = CallLikeExpander { cx, contract_name: name.clone(), extra_methods };
     // Remove any `Default` derives.
     let mut enum_attrs = item_attrs;
     for attr in &mut enum_attrs {
@@ -166,14 +164,7 @@ pub(super) fn expand(cx: &mut ExpCtxt<'_>, contract: &ItemContract) -> Result<To
         attr.meta = parse_quote! { derive(#(#derives),*) };
     }
 
-    let functions_enum = (!functions.is_empty()).then(|| {
-        let mut attrs = enum_attrs.clone();
-        let doc_str = format!("Container for all the [`{name}`](self) function calls.");
-        attrs.push(parse_quote!(#[doc = #doc_str]));
-        attrs.push(parse_quote!(#[derive(Clone)]));
-        enum_expander.expand(ToExpand::Functions(&functions), attrs)
-    });
-
+    let enum_expander = CallLikeExpander { cx, contract_name: name.clone(), extra_methods };
     let errors_enum = (!errors.is_empty()).then(|| {
         let mut attrs = enum_attrs.clone();
         let doc_str = format!("Container for all the [`{name}`](self) custom errors.");
@@ -183,13 +174,25 @@ pub(super) fn expand(cx: &mut ExpCtxt<'_>, contract: &ItemContract) -> Result<To
     });
 
     let events_enum = (!events.is_empty()).then(|| {
-        let mut attrs = enum_attrs;
+        let mut attrs = enum_attrs.clone();
         let doc_str = format!("Container for all the [`{name}`](self) events.");
         attrs.push(parse_quote!(#[doc = #doc_str]));
         attrs.push(parse_quote!(#[derive(Clone)]));
         enum_expander.expand(ToExpand::Events(&events), attrs)
     });
 
+    // Do not propagate contract-level derives to the functions enum.
+    cx.attrs = prev_cx_attrs;
+
+    let functions_enum = (!functions.is_empty()).then(|| {
+        let mut attrs = enum_attrs;
+        let doc_str = format!("Container for all the [`{name}`](self) function calls.");
+        attrs.push(parse_quote!(#[doc = #doc_str]));
+        attrs.push(parse_quote!(#[derive(Clone)]));
+        let enum_expander = CallLikeExpander { cx, contract_name: name.clone(), extra_methods };
+        enum_expander.expand(ToExpand::Functions(&functions), attrs)
+    });
+
     let mod_descr_doc = (docs && docs_str(&mod_attrs).trim().is_empty())
         .then(|| mk_doc("Module containing a contract's types and functions."));
     let mod_iface_doc = (docs && !docs_str(&mod_attrs).contains("```solidity\n"))

crates/sol-types/tests/derives.rs

@@ -0,0 +1,88 @@
+//! Comprehensive test for contract-level derives applying to all generated types.
+//! Tests all_derives and extra_derives on contracts with events and errors.
+
+use alloy_primitives::{Address, U256};
+use alloy_sol_types::sol;
+use std::{collections::HashSet, hash::Hash};
+
+#[test]
+fn test_all_derives() {
+    sol! {
+        #[sol(all_derives)]
+        contract AllDerivesContract {
+            function transfer(address to, uint256 amount) external returns (bool);
+            event Transfer(address indexed from, address indexed to, uint256 value);
+            error InsufficientBalance(uint256 requested, uint256 available);
+        }
+    }
+
+    use AllDerivesContract::*;
+
+    let event1 = Transfer { from: Address::ZERO, to: Address::ZERO, value: U256::from(50) };
+    let event2 = Transfer { from: Address::ZERO, to: Address::ZERO, value: U256::from(50) };
+    let events_enum1 = AllDerivesContractEvents::Transfer(event1);
+    let events_enum2 = AllDerivesContractEvents::Transfer(event2);
+
+    let error1 = InsufficientBalance { requested: U256::from(100), available: U256::from(50) };
+    let error2 = InsufficientBalance { requested: U256::from(100), available: U256::from(50) };
+    let errors_enum1 = AllDerivesContractErrors::InsufficientBalance(error1);
+    let errors_enum2 = AllDerivesContractErrors::InsufficientBalance(error2);
+
+    // Test PartialEq and Debug
+    assert_eq!(errors_enum1, errors_enum2);
+    assert_eq!(events_enum1, events_enum2);
+
+    // Test Hash and Eq derives
+    let mut events_set = HashSet::new();
+    events_set.insert(events_enum1);
+    events_set.insert(events_enum2);
+    // Should not increase size since they're equal
+    assert_eq!(events_set.len(), 1);
+
+    let mut errors_set = HashSet::new();
+    errors_set.insert(errors_enum1);
+    errors_set.insert(errors_enum2);
+    // Should not increase size since they're equal
+    assert_eq!(errors_set.len(), 1);
+}
+
+#[test]
+fn test_extra_derives() {
+    sol! {
+        #[sol(extra_derives(PartialEq, Eq, Hash, Debug))]
+        contract ExtraDerivesContract {
+            function transfer(address to, uint256 amount) external returns (bool);
+            event Transfer(address indexed from, address indexed to, uint256 value);
+            error InsufficientBalance(uint256 requested, uint256 available);
+        }
+    }
+
+    use ExtraDerivesContract::*;
+
+    let event1 = Transfer { from: Address::ZERO, to: Address::ZERO, value: U256::from(50) };
+    let event2 = Transfer { from: Address::ZERO, to: Address::ZERO, value: U256::from(50) };
+    let events_enum1 = ExtraDerivesContractEvents::Transfer(event1);
+    let events_enum2 = ExtraDerivesContractEvents::Transfer(event2);
+
+    let error1 = InsufficientBalance { requested: U256::from(100), available: U256::from(50) };
+    let error2 = InsufficientBalance { requested: U256::from(100), available: U256::from(50) };
+    let errors_enum1 = ExtraDerivesContractErrors::InsufficientBalance(error1);
+    let errors_enum2 = ExtraDerivesContractErrors::InsufficientBalance(error2);
+
+    // Test PartialEq and Debug
+    assert_eq!(errors_enum1, errors_enum2);
+    assert_eq!(events_enum1, events_enum2);
+
+    // Test Hash and Eq derives
+    let mut events_set = HashSet::new();
+    events_set.insert(events_enum1);
+    events_set.insert(events_enum2);
+    // Should not increase size since they're equal
+    assert_eq!(events_set.len(), 1);
+
+    let mut errors_set = HashSet::new();
+    errors_set.insert(errors_enum1);
+    errors_set.insert(errors_enum2);
+    // Should not increase size since they're equal
+    assert_eq!(errors_set.len(), 1);
+}