Fix custom attrs incorrectly applied to testutils fns (#1699)

### What

Move attribute filtering before `testutils_only_code` generation in
`derive_fn.rs` so that custom attribute macros on methods in
`#[contractimpl]` blocks are not incorrectly applied to generated
wrapper functions.

### Why

When a method in a `#[contractimpl]` block has a custom attribute macro,
the attribute was being:
  - Correctly filtered out of wasm-generated code
- Incorrectly passed to testutils wrapper functions (like
`__invoke_raw_slice`)

This caused `cargo test` to fail while `cargo build --target
wasm32v1-none` succeeded. For example, if an attribute macro injects
code that references `Self`, it would fail when applied to the generated
free functions where `Self` is not valid:
```
error[E0411]: cannot find type Self in this scope
```

This bug affects test-only code, and did not impact the code generation
of code that builds to wasm.

It looks like I introduced this bug in bf73a94 (#1691), which
restructured the generated wrapper functions to be emitted as free
functions instead of inside a nested module. As part of adding
`#[doc(hidden)]` and `#[allow(non_snake_case)]` to the
`testutils_only_code`, `#(#attrs)*` was also added to match the pattern
used for the other generated functions. However, this was done without
noticing that attribute filtering happened *later* in the function and
so `testutils_only_code` received unfiltered attributes while the main
code received filtered attributes:

```rust
// testutils_only_code used UNFILTERED attrs
let testutils_only_code = if cfg!(feature = "testutils") {
    Some(quote! {
        #(#attrs)*   // <-- Added in bf73a94, but unfiltered!
        pub fn #invoke_raw_slice(...) { ... }
    })
};

// Filtering happened AFTER
let attrs = attrs.iter()
    .filter(|attr| pass_through_attr_to_gen_code(attr))
    .collect();
```

The fix moves attribute filtering before testutils_only_code generation
so both use consistently filtered attributes.

This bug highlights a gap in the tests for macro composability, and so a
test has been added to close that gap.

Close #1698

### Known limitations

N/A

Author: leighmcculloch

soroban-sdk-macros/src/derive_fn.rs

@@ -169,6 +169,11 @@ pub fn derive_pub_fn(
         return Err(quote! { #(#compile_errors)* });
     }
 
+    let attrs: Vec<_> = attrs
+        .iter()
+        .filter(|attr| pass_through_attr_to_gen_code(attr))
+        .collect();
+
     let testutils_only_code = if cfg!(feature = "testutils") {
         Some(quote! {
             #[doc(hidden)]
@@ -190,12 +195,6 @@ pub fn derive_pub_fn(
         None
     };
 
-    // Filter attributes to those that should be passed through to the generated code.
-    let attrs = attrs
-        .iter()
-        .filter(|attr| pass_through_attr_to_gen_code(attr))
-        .collect::<Vec<_>>();
-
     // Generated code.
     Ok(quote! {
         #[doc(hidden)]

tests/macros/proc_macros/src/lib.rs

@@ -17,3 +17,16 @@ pub fn parse_item_fn(_metadata: TokenStream, input: TokenStream) -> TokenStream
     let item = parse_macro_input!(input as ItemFn);
     quote! { #item }.into()
 }
+
+/// An attribute macro that checks it is being used on a method of a type, not a free function.
+/// It does this by injecting code that references `Self`, which is only valid inside an impl block.
+#[proc_macro_attribute]
+pub fn check_fn_is_item_fn(_metadata: TokenStream, input: TokenStream) -> TokenStream {
+    let mut item = parse_macro_input!(input as ItemFn);
+    // Insert a statement that uses `Self` at the beginning of the function
+    let check_stmt: syn::Stmt = syn::parse_quote! {
+        let _ = core::any::type_name::<Self>();
+    };
+    item.block.stmts.insert(0, check_stmt);
+    quote! { #item }.into()
+}

tests/macros/src/lib.rs

@@ -2,7 +2,7 @@
 // validating that they are composable and compatible.
 
 #![no_std]
-use proc_macros::{parse_item_fn, parse_item_impl};
+use proc_macros::{check_fn_is_item_fn, parse_item_fn, parse_item_impl};
 use soroban_sdk::{contract, contractimpl};
 
 #[contract]
@@ -14,6 +14,10 @@ impl Contract {
     // Test that attribute macros that expect to be used on fns are composable with contractimpl.
     #[parse_item_fn]
     pub fn empty() {}
+
+    // Test that attribute macros are not copied to the generated export functions. See test below.
+    #[check_fn_is_item_fn]
+    pub fn empty2() {}
 }
 
 #[cfg(test)]
@@ -30,4 +34,24 @@ mod test {
 
         client.empty();
     }
+
+    // Test that custom attribute macros on methods in #[contractimpl] are not
+    // incorrectly applied to generated wrapper functions.
+    //
+    // The #[check_fn_is_item_fn] macro injects code that references `Self`,
+    // which is only valid inside an impl block. If #[contractimpl] incorrectly
+    // passes the attribute to generated free functions (like __invoke_raw_slice),
+    // the injected `Self` reference would cause a compile error:
+    //   "error[E0411]: cannot find type `Self` in this scope"
+    //
+    // This test passing means the attribute is correctly filtered out of
+    // generated wrapper functions and only applied to the original method.
+    #[test]
+    fn test_custom_attrs_are_not_copied_onto_generated_fns() {
+        let e = Env::default();
+        let contract_id = e.register(Contract, ());
+        let client = ContractClient::new(&e, &contract_id);
+
+        client.empty2();
+    }
 }

tests/macros/test_snapshots/test/test_custom_attrs_are_not_copied_onto_generated_fns.1.json

@@ -0,0 +1,61 @@
+{
+  "generators": {
+    "address": 1,
+    "nonce": 0,
+    "mux_id": 0
+  },
+  "auth": [
+    [],
+    []
+  ],
+  "ledger": {
+    "protocol_version": 25,
+    "sequence_number": 0,
+    "timestamp": 0,
+    "network_id": "0000000000000000000000000000000000000000000000000000000000000000",
+    "base_reserve": 0,
+    "min_persistent_entry_ttl": 4096,
+    "min_temp_entry_ttl": 16,
+    "max_entry_ttl": 6312000,
+    "ledger_entries": [
+      {
+        "entry": {
+          "last_modified_ledger_seq": 0,
+          "data": {
+            "contract_data": {
+              "ext": "v0",
+              "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM",
+              "key": "ledger_key_contract_instance",
+              "durability": "persistent",
+              "val": {
+                "contract_instance": {
+                  "executable": {
+                    "wasm": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+                  },
+                  "storage": null
+                }
+              }
+            }
+          },
+          "ext": "v0"
+        },
+        "live_until": 4095
+      },
+      {
+        "entry": {
+          "last_modified_ledger_seq": 0,
+          "data": {
+            "contract_code": {
+              "ext": "v0",
+              "hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+              "code": ""
+            }
+          },
+          "ext": "v0"
+        },
+        "live_until": 4095
+      }
+    ]
+  },
+  "events": []
+}