Embed markers for used types/events to enable spec filtering

soroban-sdk-macros/Cargo.toml

@@ -30,3 +30,4 @@ heck = "0.5.0"
 
 [features]
 testutils = []
+experimental_spec_resolver_v2 = []

soroban-sdk-macros/src/derive_enum.rs

@@ -1,6 +1,6 @@
 use itertools::MultiUnzip;
 use proc_macro2::{Literal, TokenStream as TokenStream2};
-use quote::{format_ident, quote};
+use quote::{format_ident, quote, ToTokens};
 use syn::{spanned::Spanned, Attribute, DataEnum, Error, Fields, Ident, Path, Visibility};
 
 use stellar_xdr::curr as stellar_xdr;
@@ -9,7 +9,7 @@ use stellar_xdr::{
     ScSpecUdtUnionCaseVoidV0, ScSpecUdtUnionV0, StringM, VecM, WriteXdr, SCSYMBOL_LIMIT,
 };
 
-use crate::{doc::docs_from_attrs, map_type::map_type, DEFAULT_XDR_RW_LIMITS};
+use crate::{doc::docs_from_attrs, map_type::map_type, spec_marker, DEFAULT_XDR_RW_LIMITS};
 
 pub fn derive_type_enum(
     path: &Path,
@@ -30,14 +30,15 @@ pub fn derive_type_enum(
             format!("enum {} must have variants", enum_ident),
         ));
     }
-    let (spec_cases, case_name_str_lits, try_froms, try_intos, try_from_xdrs, into_xdrs): (
-        Vec<_>,
-        Vec<_>,
-        Vec<_>,
-        Vec<_>,
-        Vec<_>,
-        Vec<_>,
-    ) = variants
+    let (
+        spec_cases,
+        case_name_str_lits,
+        variant_field_types,
+        try_froms,
+        try_intos,
+        try_from_xdrs,
+        into_xdrs,
+    ): (Vec<_>, Vec<_>, Vec<Vec<_>>, Vec<_>, Vec<_>, Vec<_>, Vec<_>) = variants
         .iter()
         .enumerate()
         .map(|(case_num, variant)| {
@@ -75,6 +76,10 @@ pub fn derive_type_enum(
                 }
                 _ => {}
             }
+
+            // Collect field types for IncludeSpecMarker
+            let field_types: Vec<_> = variant.fields.iter().map(|f| &f.ty).collect();
+
             let is_unit_variant = variant.fields == Fields::Unit;
             if !is_unit_variant {
                 let VariantTokens {
@@ -97,6 +102,7 @@ pub fn derive_type_enum(
                 (
                     spec_case,
                     case_name_str_lit,
+                    field_types,
                     try_from,
                     try_into,
                     try_from_xdr,
@@ -121,6 +127,7 @@ pub fn derive_type_enum(
                 (
                     spec_case,
                     case_name_str_lit,
+                    field_types,
                     try_from,
                     try_into,
                     try_from_xdr,
@@ -136,15 +143,21 @@ pub fn derive_type_enum(
         return quote! { #(#compile_errors)* };
     }
 
-    // Generated code spec.
-    let spec_gen = if spec {
+    // Compute spec XDR once if spec is enabled.
+    let spec_xdr = if spec {
         let spec_entry = ScSpecEntry::UdtUnionV0(ScSpecUdtUnionV0 {
             doc: docs_from_attrs(attrs),
             lib: lib.as_deref().unwrap_or_default().try_into().unwrap(),
             name: enum_ident.to_string().try_into().unwrap(),
             cases: spec_cases.try_into().unwrap(),
         });
-        let spec_xdr = spec_entry.to_xdr(DEFAULT_XDR_RW_LIMITS).unwrap();
+        Some(spec_entry.to_xdr(DEFAULT_XDR_RW_LIMITS).unwrap())
+    } else {
+        None
+    };
+
+    // Generated code spec.
+    let spec_gen = if let Some(ref spec_xdr) = spec_xdr {
         let spec_xdr_lit = proc_macro2::Literal::byte_string(spec_xdr.as_slice());
         let spec_xdr_len = spec_xdr.len();
         let spec_ident = format_ident!("__SPEC_XDR_TYPE_{}", enum_ident.to_string().to_uppercase());
@@ -162,10 +175,36 @@ pub fn derive_type_enum(
         None
     };
 
+    // IncludeSpecMarker impl - only generated when spec is true and the
+    // experimental_spec_resolver_v2 feature is enabled.
+    let include_spec_impl = if cfg!(feature = "experimental_spec_resolver_v2") {
+        spec_xdr.as_ref().map(|spec_xdr| {
+            // Flatten all variant field types for include_spec_marker calls, deduplicating
+            // to avoid redundant calls for types that appear in multiple variants.
+            let all_field_types =
+                itertools::Itertools::unique_by(variant_field_types.iter().flatten(), |t| {
+                    t.to_token_stream().to_string()
+                });
+            spec_marker::generate_include_spec_marker_impl(
+                path,
+                quote!(#enum_ident),
+                spec_xdr,
+                all_field_types.cloned(),
+                None,
+                None,
+                None,
+            )
+        })
+    } else {
+        None
+    };
+
     // Output.
     let mut output = quote! {
         #spec_gen
 
+        #include_spec_impl
+
         impl #path::TryFromVal<#path::Env, #path::Val> for #enum_ident {
             type Error = #path::ConversionError;
             #[inline(always)]

soroban-sdk-macros/src/derive_enum_int.rs

@@ -7,7 +7,7 @@ use syn::{spanned::Spanned, Attribute, DataEnum, Error, ExprLit, Ident, Lit, Pat
 
 use stellar_xdr::{ScSpecEntry, ScSpecUdtEnumCaseV0, WriteXdr};
 
-use crate::{doc::docs_from_attrs, DEFAULT_XDR_RW_LIMITS};
+use crate::{doc::docs_from_attrs, spec_marker, DEFAULT_XDR_RW_LIMITS};
 
 // TODO: Add conversions to/from ScVal types.
 
@@ -65,15 +65,21 @@ pub fn derive_type_enum_int(
         return quote! { #(#compile_errors)* };
     }
 
-    // Generated code spec.
-    let spec_gen = if spec {
+    // Compute spec XDR once if spec is enabled.
+    let spec_xdr = if spec {
         let spec_entry = ScSpecEntry::UdtEnumV0(ScSpecUdtEnumV0 {
             doc: docs_from_attrs(attrs),
             lib: lib.as_deref().unwrap_or_default().try_into().unwrap(),
             name: enum_ident.to_string().try_into().unwrap(),
             cases: spec_cases.try_into().unwrap(),
         });
-        let spec_xdr = spec_entry.to_xdr(DEFAULT_XDR_RW_LIMITS).unwrap();
+        Some(spec_entry.to_xdr(DEFAULT_XDR_RW_LIMITS).unwrap())
+    } else {
+        None
+    };
+
+    // Generated code spec.
+    let spec_gen = if let Some(ref spec_xdr) = spec_xdr {
         let spec_xdr_lit = proc_macro2::Literal::byte_string(spec_xdr.as_slice());
         let spec_xdr_len = spec_xdr.len();
         let spec_ident = format_ident!("__SPEC_XDR_TYPE_{}", enum_ident.to_string().to_uppercase());
@@ -91,10 +97,30 @@ pub fn derive_type_enum_int(
         None
     };
 
+    // IncludeSpecMarker impl - only generated when spec is true and the
+    // experimental_spec_resolver_v2 feature is enabled.
+    let include_spec_impl = if cfg!(feature = "experimental_spec_resolver_v2") {
+        spec_xdr.as_ref().map(|spec_xdr| {
+            spec_marker::generate_include_spec_marker_impl(
+                path,
+                quote!(#enum_ident),
+                spec_xdr,
+                std::iter::empty(),
+                None,
+                None,
+                None,
+            )
+        })
+    } else {
+        None
+    };
+
     // Output.
     let mut output = quote! {
         #spec_gen
 
+        #include_spec_impl
+
         impl #path::TryFromVal<#path::Env, #path::Val> for #enum_ident {
             type Error = #path::ConversionError;
             #[inline(always)]

soroban-sdk-macros/src/derive_error_enum_int.rs

@@ -5,7 +5,7 @@ use stellar_xdr::curr as stellar_xdr;
 use stellar_xdr::{ScSpecEntry, ScSpecUdtErrorEnumCaseV0, ScSpecUdtErrorEnumV0, StringM, WriteXdr};
 use syn::{spanned::Spanned, Attribute, DataEnum, Error, ExprLit, Ident, Lit, Path};
 
-use crate::{doc::docs_from_attrs, DEFAULT_XDR_RW_LIMITS};
+use crate::{doc::docs_from_attrs, spec_marker, DEFAULT_XDR_RW_LIMITS};
 
 pub fn derive_type_error_enum_int(
     path: &Path,
@@ -63,15 +63,21 @@ pub fn derive_type_error_enum_int(
         return quote! { #(#compile_errors)* };
     }
 
-    // Generated code spec.
-    let spec_gen = if spec {
+    // Compute spec XDR once if spec is enabled.
+    let spec_xdr = if spec {
         let spec_entry = ScSpecEntry::UdtErrorEnumV0(ScSpecUdtErrorEnumV0 {
             doc: docs_from_attrs(attrs),
             lib: lib.as_deref().unwrap_or_default().try_into().unwrap(),
             name: enum_ident.to_string().try_into().unwrap(),
             cases: spec_cases.try_into().unwrap(),
         });
-        let spec_xdr = spec_entry.to_xdr(DEFAULT_XDR_RW_LIMITS).unwrap();
+        Some(spec_entry.to_xdr(DEFAULT_XDR_RW_LIMITS).unwrap())
+    } else {
+        None
+    };
+
+    // Generated code spec.
+    let spec_gen = if let Some(ref spec_xdr) = spec_xdr {
         let spec_xdr_lit = proc_macro2::Literal::byte_string(spec_xdr.as_slice());
         let spec_xdr_len = spec_xdr.len();
         let spec_ident = format_ident!("__SPEC_XDR_TYPE_{}", enum_ident.to_string().to_uppercase());
@@ -89,10 +95,30 @@ pub fn derive_type_error_enum_int(
         None
     };
 
+    // IncludeSpecMarker impl - only generated when spec is true and the
+    // experimental_spec_resolver_v2 feature is enabled.
+    let include_spec_impl = if cfg!(feature = "experimental_spec_resolver_v2") {
+        spec_xdr.as_ref().map(|spec_xdr| {
+            spec_marker::generate_include_spec_marker_impl(
+                path,
+                quote!(#enum_ident),
+                spec_xdr,
+                std::iter::empty(),
+                None,
+                None,
+                None,
+            )
+        })
+    } else {
+        None
+    };
+
     // Output.
     quote! {
         #spec_gen
 
+        #include_spec_impl
+
         impl TryFrom<#path::Error> for #enum_ident {
             type Error = #path::Error;
             #[inline(always)]

soroban-sdk-macros/src/derive_event.rs

@@ -1,6 +1,6 @@
 use crate::{
     attribute::remove_attributes_from_item, default_crate_path, doc::docs_from_attrs,
-    map_type::map_type, symbol, DEFAULT_XDR_RW_LIMITS,
+    map_type::map_type, spec_marker, symbol, DEFAULT_XDR_RW_LIMITS,
 };
 use darling::{ast::NestedMeta, Error, FromMeta};
 use heck::ToSnakeCase;
@@ -108,7 +108,7 @@ fn derive_impls(args: &ContractEventArgs, input: &DeriveInput) -> Result<TokenSt
     let fields =
         match &input.data {
             Data::Struct(struct_) => match &struct_.fields {
-                Fields::Named(fields) => fields.named.iter(),
+                Fields::Named(fields) => fields.named.iter().collect::<Vec<_>>(),
                 Fields::Unnamed(_) => Err(Error::custom(
                     "structs with unnamed fields are not supported as contract events",
                 )
@@ -124,8 +124,12 @@ fn derive_impls(args: &ContractEventArgs, input: &DeriveInput) -> Result<TokenSt
                 .with_span(&input.span()))?,
         };
 
+    // Collect field types for IncludeSpecMarker
+    let field_types: Vec<_> = fields.iter().map(|f| &f.ty).collect();
+
     // Map each field of the struct to a spec for a param.
     let params = fields
+        .iter()
         .map(|field| {
             let ident = field.ident.as_ref().unwrap();
             let is_topic = field.attrs.iter().any(|a| a.path().is_ident("topic"));
@@ -193,6 +197,13 @@ fn derive_impls(args: &ContractEventArgs, input: &DeriveInput) -> Result<TokenSt
         "__SPEC_XDR_EVENT_{}",
         input.ident.to_string().to_uppercase()
     );
+    let include_spec_call = if export && cfg!(feature = "experimental_spec_resolver_v2") {
+        Some(quote! { <Self as #path::IncludeSpecMarker>::include_spec_marker(); })
+    } else {
+        None
+    };
+
+    // Generated code spec.
     let spec_gen = quote! {
         #export_gen
         pub static #spec_ident: [u8; #spec_xdr_len] = #ident::spec_xdr();
@@ -204,6 +215,22 @@ fn derive_impls(args: &ContractEventArgs, input: &DeriveInput) -> Result<TokenSt
         }
     };
 
+    // IncludeSpecMarker impl - only generated when export is true and the
+    // experimental_spec_resolver_v2 feature is enabled.
+    let include_spec_impl = if export && cfg!(feature = "experimental_spec_resolver_v2") {
+        Some(spec_marker::generate_include_spec_marker_impl(
+            path,
+            quote!(#ident),
+            &spec_xdr,
+            field_types.iter().cloned(),
+            Some(quote!(#gen_impl)),
+            Some(quote!(#gen_types)),
+            Some(quote!(#gen_where)),
+        ))
+    } else {
+        None
+    };
+
     // Prepare Topics Conversion to Vec<Val>.
     let prefix_topics_symbols = prefix_topics.iter().map(|t| {
         symbol::short_or_long(
@@ -279,6 +306,8 @@ fn derive_impls(args: &ContractEventArgs, input: &DeriveInput) -> Result<TokenSt
     let output = quote! {
         #spec_gen
 
+        #include_spec_impl
+
         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
@@ -290,6 +319,7 @@ fn derive_impls(args: &ContractEventArgs, input: &DeriveInput) -> Result<TokenSt
 
         impl #gen_impl #ident #gen_types #gen_where {
             pub fn publish(&self, env: &#path::Env) {
+                #include_spec_call
                 <_ as #path::Event>::publish(self, env);
             }
         }