Support ref fields on contractevent structs (#1499)

### What
Add support for reference fields in `contractevent` structs, allowing
borrowed values to be used in event fields.

  ### Why
When publishing events that are made up of user-defined-types, this
gives the developer the option of not copying the value into the event,
instead referencing it wherever it is. This may present some
optimisation opportunities over being forced to copy the value into the
struct. Nothing about this change requires the use of references, it
merely makes it allowed rather than disallowed.

Close #1491

Author: leighmcculloch

soroban-sdk-macros/src/derive_enum.rs

@@ -352,7 +352,7 @@ fn map_tuple_variant(
     let spec_case = {
         let field_types = fields
             .iter()
-            .map(|f| match map_type(&f.ty, false) {
+            .map(|f| match map_type(&f.ty, false, false) {
                 Ok(t) => t,
                 Err(e) => {
                     errors.push(e);

soroban-sdk-macros/src/derive_event.rs

@@ -83,6 +83,7 @@ fn derive_impls(args: &ContractEventArgs, input: &DeriveInput) -> Result<TokenSt
     let mut errors = Error::accumulator();
 
     let ident = &input.ident;
+    let (gen_impl, gen_types, gen_where) = input.generics.split_for_impl();
     let path = &args.crate_path;
 
     let prefix_topics = if let Some(prefix_topics) = &args.topics {
@@ -133,7 +134,7 @@ fn derive_impls(args: &ContractEventArgs, input: &DeriveInput) -> Result<TokenSt
                 }))
                 .unwrap_or_default();
             let type_ = errors
-                .handle_in(|| Ok(map_type(&field.ty, false)?))
+                .handle_in(|| Ok(map_type(&field.ty, true, false)?))
                 .unwrap_or_default();
             ScSpecEventParamV0 {
                 location,
@@ -183,7 +184,7 @@ fn derive_impls(args: &ContractEventArgs, input: &DeriveInput) -> Result<TokenSt
         #export_gen
         pub static #spec_ident: [u8; #spec_xdr_len] = #ident::spec_xdr();
 
-        impl #ident {
+        impl #gen_impl #ident #gen_types #gen_where {
             pub const fn spec_xdr() -> [u8; #spec_xdr_len] {
                 *#spec_xdr_lit
             }
@@ -207,7 +208,7 @@ fn derive_impls(args: &ContractEventArgs, input: &DeriveInput) -> Result<TokenSt
         use #path::IntoVal;
         (
             #(&#prefix_topics_symbols,)*
-            #(&self.#topic_idents,)*
+            #({ let v: #path::Val = self.#topic_idents.into_val(env); v },)*
         ).into_val(env)
     };
 
@@ -227,24 +228,22 @@ fn derive_impls(args: &ContractEventArgs, input: &DeriveInput) -> Result<TokenSt
         .map(|i| i.to_string())
         .collect::<Vec<_>>();
     let data_to_val = match args.data_format {
-        DataFormat::SingleValue if data_params_count == 0 => {
-            quote! {
-                #path::Val::VOID.to_val()
-            }
-        }
-        DataFormat::SingleValue => {
-            quote! {
-                use #path::IntoVal;
-                #(self.#data_idents.into_val(env))*
-            }
-        }
+        DataFormat::SingleValue if data_params_count == 0 => quote! {
+            #path::Val::VOID.to_val()
+        },
+        DataFormat::SingleValue => quote! {
+            use #path::IntoVal;
+            #(self.#data_idents.into_val(env))*
+        },
         DataFormat::Vec if data_params_count == 0 => quote! {
             use #path::IntoVal;
             #path::Vec::<#path::Val>::new(env).into_val(env)
         },
         DataFormat::Vec => quote! {
             use #path::IntoVal;
-            (#(&self.#data_idents,)*).into_val(env)
+            (
+                #({ let v: #path::Val = self.#data_idents.into_val(env); v },)*
+            ).into_val(env)
         },
         DataFormat::Map => quote! {
             use #path::{EnvBase,IntoVal,unwrap::UnwrapInfallible};
@@ -260,7 +259,7 @@ fn derive_impls(args: &ContractEventArgs, input: &DeriveInput) -> Result<TokenSt
     let output = quote! {
         #spec_gen
 
-        impl #path::Event for #ident {
+        impl #gen_impl #path::Event for #ident #gen_types #gen_where {
             fn topics(&self, env: &#path::Env) -> #path::Vec<#path::Val> {
                 #topics_to_vec_val
             }
@@ -269,7 +268,7 @@ fn derive_impls(args: &ContractEventArgs, input: &DeriveInput) -> Result<TokenSt
             }
         }
 
-        impl #ident {
+        impl #gen_impl #ident #gen_types #gen_where {
             fn publish(&self, env: &#path::Env) {
                 <_ as #path::Event>::publish(self, env);
             }

soroban-sdk-macros/src/derive_fn.rs

@@ -61,7 +61,7 @@ pub fn derive_pub_fn(
                 let allow_hash = ident == "__check_auth" && i == 0;
 
                 // Error if the type of the fn is not mappable.
-                if let Err(e) = map_type(&pat_ty.ty, allow_hash) {
+                if let Err(e) = map_type(&pat_ty.ty, false, allow_hash) {
                     errors.push(e);
                 }
 

soroban-sdk-macros/src/derive_spec_fn.rs

@@ -68,7 +68,7 @@ pub fn derive_fn_spec(
                 // signature_payload of type Bytes (32 size), to be a Hash.
                 let allow_hash = ident == "__check_auth" && i == 0;
 
-                match map_type(&pat_type.ty, allow_hash) {
+                match map_type(&pat_type.ty, false, allow_hash) {
                     Ok(type_) => {
                         let name = name.try_into().unwrap_or_else(|_| {
                             const MAX: u32 = 30;
@@ -107,7 +107,7 @@ pub fn derive_fn_spec(
 
     // Prepare the output.
     let spec_result = match output {
-        ReturnType::Type(_, ty) => vec![match map_type(ty, true) {
+        ReturnType::Type(_, ty) => vec![match map_type(ty, false, true) {
             Ok(spec) => spec,
             Err(e) => {
                 errors.push(e);

soroban-sdk-macros/src/derive_struct.rs

@@ -42,7 +42,7 @@ pub fn derive_type_struct(
                     errors.push(Error::new(field_ident.span(), format!("struct field name is too long: {}, max is {MAX}", field_name.len())));
                     StringM::<MAX>::default()
                 }),
-                type_: match map_type(&field.ty, false) {
+                type_: match map_type(&field.ty,false, false) {
                     Ok(t) => t,
                     Err(e) => {
                         errors.push(e);

soroban-sdk-macros/src/derive_struct_tuple.rs

@@ -36,7 +36,7 @@ pub fn derive_type_struct_tuple(
             let field_spec = ScSpecUdtStructFieldV0 {
                 doc: docs_from_attrs(&field.attrs),
                 name: field_name.try_into().unwrap_or_else(|_| StringM::default()),
-                type_: match map_type(&field.ty, false) {
+                type_: match map_type(&field.ty, false, false) {
                     Ok(t) => t,
                     Err(e) => {
                         errors.push(e);

soroban-sdk-macros/src/map_type.rs

@@ -3,6 +3,7 @@ use stellar_xdr::{
     ScSpecTypeBytesN, ScSpecTypeDef, ScSpecTypeMap, ScSpecTypeOption, ScSpecTypeResult,
     ScSpecTypeTuple, ScSpecTypeUdt, ScSpecTypeVec,
 };
+use syn::TypeReference;
 use syn::{
     spanned::Spanned, Error, Expr, ExprLit, GenericArgument, Lit, Path, PathArguments, PathSegment,
     Type, TypePath, TypeTuple,
@@ -16,8 +17,9 @@ pub const G1_SERIALIZED_SIZE: u32 = FP_SERIALIZED_SIZE * 2;
 pub const G2_SERIALIZED_SIZE: u32 = FP2_SERIALIZED_SIZE * 2;
 
 #[allow(clippy::too_many_lines)]
-pub fn map_type(t: &Type, allow_hash: bool) -> Result<ScSpecTypeDef, Error> {
+pub fn map_type(t: &Type, allow_ref: bool, allow_hash: bool) -> Result<ScSpecTypeDef, Error> {
     match t {
+        Type::Reference(TypeReference { elem, .. }) => map_type(elem, allow_ref, allow_hash),
         Type::Path(TypePath {
             qself: None,
             path: Path { segments, .. },
@@ -100,8 +102,8 @@ pub fn map_type(t: &Type, allow_hash: bool) -> Result<ScSpecTypeDef, Error> {
                                 ))?,
                             };
                             Ok(ScSpecTypeDef::Result(Box::new(ScSpecTypeResult {
-                                ok_type: Box::new(map_type(ok, false)?),
-                                error_type: Box::new(map_type(err, false)?),
+                                ok_type: Box::new(map_type(ok, allow_ref, false)?),
+                                error_type: Box::new(map_type(err, allow_ref, false)?),
                             })))
                         }
                         "Option" => {
@@ -113,7 +115,7 @@ pub fn map_type(t: &Type, allow_hash: bool) -> Result<ScSpecTypeDef, Error> {
                             ))?,
                         };
                             Ok(ScSpecTypeDef::Option(Box::new(ScSpecTypeOption {
-                                value_type: Box::new(map_type(t, false)?),
+                                value_type: Box::new(map_type(t, allow_ref, false)?),
                             })))
                         }
                         "Vec" => {
@@ -125,7 +127,7 @@ pub fn map_type(t: &Type, allow_hash: bool) -> Result<ScSpecTypeDef, Error> {
                                 ))?,
                             };
                             Ok(ScSpecTypeDef::Vec(Box::new(ScSpecTypeVec {
-                                element_type: Box::new(map_type(t, false)?),
+                                element_type: Box::new(map_type(t, allow_ref, false)?),
                             })))
                         }
                         "Map" => {
@@ -137,8 +139,8 @@ pub fn map_type(t: &Type, allow_hash: bool) -> Result<ScSpecTypeDef, Error> {
                                 ))?,
                             };
                             Ok(ScSpecTypeDef::Map(Box::new(ScSpecTypeMap {
-                                key_type: Box::new(map_type(k, false)?),
-                                value_type: Box::new(map_type(v, false)?),
+                                key_type: Box::new(map_type(k, allow_ref, false)?),
+                                value_type: Box::new(map_type(v, allow_ref, false)?),
                             })))
                         }
                         "BytesN" => {
@@ -179,7 +181,7 @@ pub fn map_type(t: &Type, allow_hash: bool) -> Result<ScSpecTypeDef, Error> {
         }
         Type::Tuple(TypeTuple { elems, .. }) => {
             let map_type_reject_hash =
-                |t: &Type| -> Result<ScSpecTypeDef, Error> { map_type(t, false) };
+                |t: &Type| -> Result<ScSpecTypeDef, Error> { map_type(t, allow_ref, false) };
             Ok(ScSpecTypeDef::Tuple(Box::new(ScSpecTypeTuple {
                 value_types: elems
                     .iter()

soroban-sdk/src/tests/contract_event.rs

@@ -491,3 +491,54 @@ fn test_data_map_no_data() {
         ],
     );
 }
+
+#[test]
+fn test_ref_fields() {
+    let env = Env::default();
+
+    #[contract]
+    pub struct Contract;
+    let id = env.register(Contract, ());
+
+    #[contractevent]
+    pub struct MyEvent<'a> {
+        #[topic]
+        name: &'a Symbol,
+        value: &'a Symbol,
+        value2: u32,
+    }
+
+    env.as_contract(&id, || {
+        MyEvent {
+            name: &symbol_short!("hi"),
+            value: &symbol_short!("yo"),
+            value2: 2,
+        }
+        .publish(&env);
+    });
+
+    assert_eq!(
+        env.events().all(),
+        vec![
+            &env,
+            (
+                id,
+                // Expect these event topics.
+                (symbol_short!("my_event"), symbol_short!("hi")).into_val(&env),
+                // Expect this event body.
+                map![
+                    &env,
+                    (
+                        symbol_short!("value"),
+                        <_ as IntoVal<Env, Val>>::into_val(&symbol_short!("yo"), &env),
+                    ),
+                    (
+                        symbol_short!("value2"),
+                        <_ as IntoVal<Env, Val>>::into_val(&2u32, &env),
+                    ),
+                ]
+                .into_val(&env)
+            ),
+        ],
+    );
+}

soroban-sdk/test_snapshots/tests/contract_event/test_ref_fields.1.json

@@ -0,0 +1,118 @@
+{
+  "generators": {
+    "address": 1,
+    "nonce": 0,
+    "mux_id": 0
+  },
+  "auth": [
+    [],
+    []
+  ],
+  "ledger": {
+    "protocol_version": 23,
+    "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": [
+      [
+        {
+          "contract_data": {
+            "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM",
+            "key": "ledger_key_contract_instance",
+            "durability": "persistent"
+          }
+        },
+        [
+          {
+            "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"
+          },
+          4095
+        ]
+      ],
+      [
+        {
+          "contract_code": {
+            "hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+          }
+        },
+        [
+          {
+            "last_modified_ledger_seq": 0,
+            "data": {
+              "contract_code": {
+                "ext": "v0",
+                "hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+                "code": ""
+              }
+            },
+            "ext": "v0"
+          },
+          4095
+        ]
+      ]
+    ]
+  },
+  "events": [
+    {
+      "event": {
+        "ext": "v0",
+        "contract_id": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM",
+        "type_": "contract",
+        "body": {
+          "v0": {
+            "topics": [
+              {
+                "symbol": "my_event"
+              },
+              {
+                "symbol": "hi"
+              }
+            ],
+            "data": {
+              "map": [
+                {
+                  "key": {
+                    "symbol": "value"
+                  },
+                  "val": {
+                    "symbol": "yo"
+                  }
+                },
+                {
+                  "key": {
+                    "symbol": "value2"
+                  },
+                  "val": {
+                    "u32": 2
+                  }
+                }
+              ]
+            }
+          }
+        }
+      },
+      "failed_call": false
+    }
+  ]
+}