feat(sol!)!: gen unit/tuple structs for call types with 0/1 param (#884)

* feat(`sol!`)!: gen unit/tuple structs for call types with 0/1 param

* fix: expand as tuple struct only if single unnamed param

Author: yash-atreya

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

@@ -62,12 +62,12 @@ pub(super) fn expand(cx: &ExpCtxt<'_>, function: &ItemFunction) -> Result<TokenS
     let call_tuple = expand_tuple_types(parameters.types(), cx).0;
     let return_tuple = expand_tuple_types(returns.types(), cx).0;
 
-    let converts = expand_from_into_tuples(&call_name, parameters, cx, FieldKind::Original);
+    let converts = expand_from_into_tuples(&call_name, parameters, cx, FieldKind::Deconstruct);
     let return_converts = expand_from_into_tuples(&return_name, returns, cx, FieldKind::Original);
 
     let signature = cx.function_signature(function);
     let selector = crate::utils::selector(&signature);
-    let tokenize_impl = expand_tokenize(parameters, cx, FieldKind::Original);
+    let tokenize_impl = expand_tokenize(parameters, cx, FieldKind::Deconstruct);
 
     let call_doc = docs.then(|| {
         let selector = hex::encode_prefixed(selector.array.as_slice());
@@ -99,16 +99,31 @@ pub(super) fn expand(cx: &ExpCtxt<'_>, function: &ItemFunction) -> Result<TokenS
         }
     });
 
+    let call_struct = if parameters.is_empty() {
+        quote! {
+            pub struct #call_name;
+        }
+    } else if parameters.len() == 1 && parameters[0].name.is_none() {
+        let ty = cx.expand_rust_type(&parameters[0].ty);
+        quote! {
+            pub struct #call_name(pub #ty);
+        }
+    } else {
+        quote! {
+            pub struct #call_name {
+                #(#call_fields),*
+            }
+        }
+    };
+
     let alloy_sol_types = &cx.crates.sol_types;
 
     let tokens = quote! {
         #(#call_attrs)*
         #call_doc
         #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
         #[derive(Clone)]
-        pub struct #call_name {
-            #(#call_fields),*
-        }
+        #call_struct
 
         #(#return_attrs)*
         #return_doc

crates/sol-macro/doctests/function_like.rs

@@ -29,10 +29,10 @@ fn function() {
     let _ = overloaded_0Call {};
     assert_call_signature::<overloaded_0Call>("overloaded()");
 
-    let _ = overloaded_1Call { _0: U256::from(1) };
+    let _ = overloaded_1Call(U256::from(1));
     assert_call_signature::<overloaded_1Call>("overloaded(uint256)");
 
-    let _ = overloaded_2Call { _0: "hello".into() };
+    let _ = overloaded_2Call("hello".into());
     assert_call_signature::<overloaded_2Call>("overloaded(string)");
 
     // Exactly the same as `function variableGetter(uint256) returns (bool)`.

crates/sol-types/tests/macros/sol/mod.rs

@@ -254,10 +254,10 @@ fn getter_names() {
     let _ = Getters::valueCall {};
     let _ = Getters::valueReturn { value: String::new() };
 
-    let _ = Getters::arrayCall { _0: U256::ZERO };
+    let _ = Getters::arrayCall(U256::ZERO);
     let _ = Getters::arrayReturn { _0: String::new() };
 
-    let _ = Getters::mapCall { _0: B256::ZERO };
+    let _ = Getters::mapCall(B256::ZERO);
     let _ = Getters::mapReturn { _0: String::new() };
 
     let _ = Getters::mapWithNamesCall { k: B256::ZERO };
@@ -497,17 +497,17 @@ fn rust_keywords() {
                 bytes32 box;
             }
 
-            function mod(address impl) returns (bool is, bool fn);
+            function mod(address impl, address some) returns (bool is, bool fn);
         }
     }
     use r#dyn::*;
 
     let _ = r#const { r#unsafe: true, r#box: Default::default() };
-    let m = modCall { r#impl: Address::ZERO };
+    let m = modCall { r#impl: Address::ZERO, some: Address::ZERO };
     let _ = dynCalls::r#mod(m);
     let _ = modReturn { is: true, r#fn: false };
     assert_eq!(r#const::NAME, "const");
-    assert_eq!(modCall::SIGNATURE, "mod(address)");
+    assert_eq!(modCall::SIGNATURE, "mod(address,address)");
 }
 
 #[test]
@@ -543,7 +543,7 @@ fn most_rust_keywords() {
                 assert_eq!($raw::NAME, stringify!($kw));
                 assert_ne!($raw::NAME, stringify!($raw));
                 assert_eq!(<[<$kw Call>]>::SIGNATURE, concat!(stringify!($kw), "(bytes1)"));
-                let _ = [<$kw Call>] { $raw: [0u8; 1].into() };
+                let _ = [<$kw Call>] { $raw: [0u8; 1].into()};
                 assert_eq!(error::$raw::SIGNATURE, concat!(stringify!($kw), "(bytes2)"));
                 let _ = error::$raw { $raw: [0u8; 2].into() };
                 assert_eq!(event::$raw::SIGNATURE, concat!(stringify!($kw), "(bytes3)"));
@@ -914,16 +914,16 @@ fn contract_derive_default() {
     sol! {
         #[derive(Debug, Default)]
         contract MyContract {
-            function f1();
-            function f2();
+            function f1(address);
+            function f2(address b);
             event e1();
             event e2();
             error c();
         }
     }
 
-    let MyContract::f1Call {} = MyContract::f1Call::default();
-    let MyContract::f2Call {} = MyContract::f2Call::default();
+    let MyContract::f1Call(_) = MyContract::f1Call::default();
+    let MyContract::f2Call { b: _ } = MyContract::f2Call::default();
     let MyContract::e1 {} = MyContract::e1::default();
     let MyContract::e2 {} = MyContract::e2::default();
     #[allow(clippy::default_constructed_unit_structs)]