fix(sol-macro): derive Default for dynamic arrays of non-Default elements

A dynamic Solidity array maps to Vec<T>, whose Default impl holds for any T.
can_derive_default still required the element type to be Default for dynamic
arrays, so a struct/error with a field like MyEnum[] lost its Default derive
under #[sol(all_derives)] even though Vec<MyEnum>: Default.

Only require the element to be Default (and length <= 32) for fixed-size arrays
([T; N]); dynamic arrays are always Default.

Author: satyakwok

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

@@ -229,10 +229,12 @@ impl ExpCtxt<'_> {
     /// Returns whether the given type can derive the [`Default`] trait.
     pub(crate) fn can_derive_default(&self, ty: &Type) -> bool {
         match ty {
-            Type::Array(a) => {
-                self.eval_array_size(a).is_none_or(|sz| sz <= MAX_SUPPORTED_ARRAY_LEN)
-                    && self.can_derive_default(&a.ty)
-            }
+            Type::Array(a) => match self.eval_array_size(a) {
+                // Dynamic arrays are `Vec<T>`, whose `Default` impl holds for any `T`.
+                None => true,
+                // Fixed arrays are `[T; N]`: `Default` needs `T: Default` and `N <= 32`.
+                Some(sz) => sz <= MAX_SUPPORTED_ARRAY_LEN && self.can_derive_default(&a.ty),
+            },
             Type::Tuple(tuple) => {
                 if tuple.types.len() > MAX_SUPPORTED_TUPLE_LEN {
                     false

crates/sol-types/tests/derives.rs

@@ -130,3 +130,25 @@ fn test_all_derives_overloaded_events() {
     set.insert(b);
     assert_eq!(set.len(), 1);
 }
+
+// A dynamic array maps to `Vec<T>`, whose `Default` impl holds for any `T` (empty vec).
+// So a struct with a dynamic-array field of a non-`Default` element (an enum) should
+// still derive `Default` under `#[sol(all_derives)]`.
+#[test]
+fn test_default_dynamic_array_of_non_default_elem() {
+    sol! {
+        #[sol(all_derives)]
+        contract DynArrDefault {
+            enum E { A, B }
+            struct S {
+                E[] xs;
+                uint256 n;
+            }
+        }
+    }
+
+    use DynArrDefault::*;
+    let s = S::default();
+    assert!(s.xs.is_empty());
+    assert_eq!(s.n, U256::ZERO);
+}