Propagate sol! derive attrs to non-interface JSON ABI items

Author: voith

crates/json-abi/tests/abi/BlurExchange.sol

@@ -95,4 +95,3 @@ struct Order {
     uint256 salt;
     bytes extraParams;
 }
-

crates/json-abi/tests/abi/Bootstrap.sol

@@ -34,4 +34,3 @@ struct BootstrapConfig {
     address module;
     bytes data;
 }
-

crates/json-abi/tests/abi/ContractUsingGlobals.json

@@ -0,0 +1,88 @@
+[
+	{
+		"inputs": [
+			{
+				"components": [
+					{
+						"internalType": "uint256",
+						"name": "value",
+						"type": "uint256"
+					},
+					{
+						"internalType": "enum GlobalEnum",
+						"name": "enum_",
+						"type": "uint8"
+					}
+				],
+				"internalType": "struct GlobalStruct",
+				"name": "payload",
+				"type": "tuple"
+			}
+		],
+		"name": "GlobalError",
+		"type": "error"
+	},
+	{
+		"anonymous": false,
+		"inputs": [
+			{
+				"components": [
+					{
+						"internalType": "uint256",
+						"name": "value",
+						"type": "uint256"
+					},
+					{
+						"internalType": "enum GlobalEnum",
+						"name": "enum_",
+						"type": "uint8"
+					}
+				],
+				"indexed": false,
+				"internalType": "struct GlobalStruct",
+				"name": "payload",
+				"type": "tuple"
+			},
+			{
+				"indexed": false,
+				"internalType": "GlobalUDT",
+				"name": "amount",
+				"type": "uint256"
+			}
+		],
+		"name": "GlobalEvent",
+		"type": "event"
+	},
+	{
+		"inputs": [
+			{
+				"components": [
+					{
+						"internalType": "enum GlobalEnum",
+						"name": "kind",
+						"type": "uint8"
+					},
+					{
+						"internalType": "uint256",
+						"name": "count",
+						"type": "uint256"
+					}
+				],
+				"internalType": "struct Interface.InterfaceStruct",
+				"name": "data",
+				"type": "tuple"
+			}
+		],
+		"name": "emitGlobalEvent",
+		"outputs": [],
+		"stateMutability": "nonpayable",
+		"type": "function"
+	},
+	{
+		"inputs": [],
+		"name": "triggerError",
+		"outputs": [],
+		"stateMutability": "pure",
+		"type": "function"
+	}
+]

crates/json-abi/tests/abi/ContractUsingGlobals.sol

@@ -0,0 +1,21 @@
+library Interface {
+    struct InterfaceStruct {
+        GlobalEnum kind;
+        uint256 count;
+    }
+}
+
+interface ContractUsingGlobals {
+    error GlobalError(GlobalStruct payload);
+
+    event GlobalEvent(GlobalStruct payload, GlobalUDT amount);
+
+    function emitGlobalEvent(Interface.InterfaceStruct memory data) external;
+    function triggerError() external pure;
+}
+type GlobalEnum is uint8;
+type GlobalUDT is uint256;
+struct GlobalStruct {
+    uint256 value;
+    GlobalEnum enum_;
+}

crates/json-abi/tests/abi/DelegationManager.sol

@@ -128,4 +128,3 @@ interface DelegationManager {
     function updateOperatorMetadataURI(string memory metadataURI) external;
 }
 type DelegatedShares is uint256;
-

crates/json-abi/tests/abi/Fastlane.sol

@@ -94,4 +94,3 @@ struct ValidatorPreferences {
     uint256 minAutoshipAmount;
     address validatorPayableAddress;
 }
-

crates/json-abi/tests/abi/Seaport.sol

@@ -184,4 +184,3 @@ struct SpentItem {
     uint256 identifier;
     uint256 amount;
 }
-

crates/json-abi/tests/abi/UniswapV3Position.sol

@@ -8,4 +8,3 @@ struct Range {
     int24 upperTick;
     uint24 feeTier;
 }
-

crates/json-abi/tests/abi/WithStructs.sol

@@ -101,4 +101,3 @@ struct ValidatorPreferences {
     uint256 minAutoshipAmount;
     address validatorPayableAddress;
 }
-

crates/sol-macro-input/src/json.rs

@@ -18,42 +18,22 @@ impl SolInput {
 
         let mut abi = abi.ok_or_else(|| syn::Error::new(name.span(), "ABI not found in JSON"))?;
         let sol = abi_to_sol(&name, &mut abi);
-        let mut all_tokens = tokens_for_sol(&name, &sol)?.into_iter();
+        let all_tokens = tokens_for_sol(&name, &sol)?;
+        let mut ast: ast::File = syn::parse2(all_tokens).map_err(|e| {
+            let msg = format!(
+                "failed to parse ABI-generated tokens into a Solidity AST for `{name}`: {e}.\n\
+                 This is a bug. We would appreciate a bug report: \
+                 https://github.com/alloy-rs/core/issues/new/choose"
+            );
+            syn::Error::new(name.span(), msg)
+        })?;
 
         let (inner_attrs, attrs) = attrs
             .into_iter()
             .partition::<Vec<_>, _>(|attr| matches!(attr.style, AttrStyle::Inner(_)));
 
         let (derives, sol_derives) = extract_derive_attrs(&attrs);
 
-        let mut library_tokens_iter = all_tokens
-            .by_ref()
-            .take_while(|tt| !matches!(tt, TokenTree::Ident(id) if id == "interface"))
-            .skip_while(|tt| matches!(tt, TokenTree::Ident(id) if id == "library"))
-            .peekable();
-
-        let library_tokens = library_tokens_iter.by_ref();
-
-        let mut libraries = Vec::new();
-
-        while library_tokens.peek().is_some() {
-            let sol_library_tokens: TokenStream = std::iter::once(TokenTree::Ident(id("library")))
-                .chain(
-                    library_tokens
-                        .take_while(|tt| !matches!(tt, TokenTree::Ident(id) if id == "library")),
-                )
-                .collect();
-
-            let tokens = quote! {
-                #(#derives)*
-                #(#sol_derives)*
-                #sol_library_tokens
-            };
-
-            libraries.push(tokens);
-        }
-        let sol_interface_tokens: TokenStream =
-            std::iter::once(TokenTree::Ident(id("interface"))).chain(all_tokens).collect();
         let bytecode = bytecode.map(|bytes| {
             let s = bytes.to_string();
             quote!(bytecode = #s,)
@@ -63,44 +43,34 @@ impl SolInput {
             quote!(deployed_bytecode = #s)
         });
 
-        let attrs_iter = attrs.iter();
-        let doc_str = format!(
-            "\n\n\
-Generated by the following Solidity interface...
-```solidity
-{sol}
-```
-
-...which was generated by the following JSON ABI:
-```json
-{json_s}
-```",
-            json_s = serde_json::to_string_pretty(&abi).unwrap()
-        );
-        let tokens = quote! {
-            #(#inner_attrs)*
-            #(#libraries)*
-
-            #(#attrs_iter)*
-            #[doc = #doc_str]
-            #[sol(#bytecode #deployed_bytecode)]
-            #sol_interface_tokens
+        let ctx = ApplyAttrsCtx {
+            derives: &derives,
+            sol_derives: &sol_derives,
+            interface_attrs: &attrs,
+            bytecode: bytecode.as_ref(),
+            deployed_bytecode: deployed_bytecode.as_ref(),
+            sol: &sol,
+            abi: &abi,
         };
-
-        let ast: ast::File = syn::parse2(tokens).map_err(|e| {
-            let msg = format!(
-                "failed to parse ABI-generated tokens into a Solidity AST for `{name}`: {e}.\n\
-                 This is a bug. We would appreciate a bug report: \
-                 https://github.com/alloy-rs/core/issues/new/choose"
-            );
-            syn::Error::new(name.span(), msg)
-        })?;
+        apply_attrs_to_items(&mut ast.items, &ctx);
+        ast.attrs.extend(inner_attrs);
 
         let kind = SolInputKind::Sol(ast);
         Ok(SolInput { attrs, path, kind })
     }
 }
 
+/// Shared context for applying user attributes to ABI-derived items.
+struct ApplyAttrsCtx<'a> {
+    derives: &'a [&'a syn::Attribute],
+    sol_derives: &'a [&'a syn::Attribute],
+    interface_attrs: &'a [syn::Attribute],
+    bytecode: Option<&'a TokenStream>,
+    deployed_bytecode: Option<&'a TokenStream>,
+    sol: &'a str,
+    abi: &'a JsonAbi,
+}
+
 // doesn't parse Json
 
 fn abi_to_sol(name: &Ident, abi: &mut JsonAbi) -> String {
@@ -153,18 +123,87 @@ fn extract_derive_attrs(attrs: &[syn::Attribute]) -> (Vec<&syn::Attribute>, Vec<
     })
 }
 
-#[inline]
-#[track_caller]
-fn id(s: impl AsRef<str>) -> Ident {
-    // Ident::new panics on Rust keywords and `r#` prefixes
-    syn::parse_str(s.as_ref()).unwrap()
+/// Applies derive/`sol` attributes to ABI-derived items.
+///
+/// - Non-interface contracts, structs, enums, and UDVTs get the user-specified derive and `sol`
+///   attributes cloned onto them.
+/// - The single interface gets the outer attributes, a generated doc (including the original
+///   Solidity/JSON ABI), and the `#[sol(bytecode = ..., deployed_bytecode = ...)]` attribute.
+fn apply_attrs_to_items(items: &mut [ast::Item], ctx: &ApplyAttrsCtx<'_>) {
+    for item in items {
+        match item {
+            ast::Item::Contract(contract) if contract.kind.is_interface() => {
+                apply_interface_attrs(contract, ctx);
+            }
+            ast::Item::Contract(contract) => {
+                extend_attrs(&mut contract.attrs, ctx.derives, ctx.sol_derives);
+            }
+            ast::Item::Struct(strukt) => {
+                extend_attrs(&mut strukt.attrs, ctx.derives, ctx.sol_derives);
+            }
+            ast::Item::Udt(udt) => {
+                extend_attrs(&mut udt.attrs, ctx.derives, ctx.sol_derives);
+            }
+            // Globals from `to_sol` are only structs, UDVTs; enums are flattened to `uint8`,
+            // while errors/functions/events,etc are emitted in the interface.
+            _ => debug_assert!(false, "unexpected global item type"),
+        }
+    }
+}
+
+/// Merge user outer attrs with generated docs/metadata for the sole interface.
+fn apply_interface_attrs(contract: &mut ast::ItemContract, ctx: &ApplyAttrsCtx<'_>) {
+    let bytecode = ctx.bytecode;
+    let deployed_bytecode = ctx.deployed_bytecode;
+    let doc_str = format!(
+        "\n\n\
+Generated by the following Solidity interface...\
+```solidity\
+{sol}\
+```\
+\n\
+...which was generated by the following JSON ABI:\
+```json\
+{json_s}\
+```",
+        sol = ctx.sol,
+        json_s = serde_json::to_string_pretty(ctx.abi).unwrap(),
+    );
+    let doc_attr: syn::Attribute = syn::parse_quote!(#[doc = #doc_str]);
+    let sol_attr: syn::Attribute = syn::parse_quote!(#[sol(#bytecode #deployed_bytecode)]);
+
+    let mut merged = ctx.interface_attrs.to_vec();
+    merged.push(doc_attr);
+    merged.push(sol_attr);
+    contract.attrs = merged;
+}
+
+/// Clone user-specified `derive`/`sol(...)` attributes onto the given item.
+/// Used for globals (structs/UDVTs) and non-interface contracts emitted by `to_sol`.
+fn extend_attrs(
+    attrs: &mut Vec<syn::Attribute>,
+    derives: &[&syn::Attribute],
+    sol_derives: &[&syn::Attribute],
+) {
+    attrs.reserve(derives.len() + sol_derives.len());
+    for attr in derives {
+        attrs.push((*attr).clone());
+    }
+    for attr in sol_derives {
+        attrs.push((*attr).clone());
+    }
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
     use std::path::{Path, PathBuf};
 
+    fn id(s: impl AsRef<str>) -> Ident {
+        // Ident::new panics on Rust keywords and `r#` prefixes
+        syn::parse_str(s.as_ref()).unwrap()
+    }
+
     #[test]
     #[cfg_attr(miri, ignore = "no fs")]
     fn abi() {