Graph-based spec shaking v2

Cargo.toml

@@ -6,6 +6,7 @@ members = [
     "soroban-sdk-macros",
     "soroban-meta",
     "soroban-spec",
+    "soroban-spec-markers",
     "soroban-spec-rust",
     "soroban-ledger-snapshot",
     "soroban-token-sdk",
@@ -23,6 +24,7 @@ soroban-sdk = { version = "26.0.0-rc.1", path = "soroban-sdk" }
 soroban-sdk-macros = { version = "26.0.0-rc.1", path = "soroban-sdk-macros" }
 soroban-meta = { version = "26.0.0-rc.1", path = "soroban-meta" }
 soroban-spec = { version = "26.0.0-rc.1", path = "soroban-spec" }
+soroban-spec-markers = { version = "26.0.0-rc.1", path = "soroban-spec-markers", default-features = false }
 soroban-spec-rust = { version = "26.0.0-rc.1", path = "soroban-spec-rust" }
 soroban-ledger-snapshot = { version = "26.0.0-rc.1", path = "soroban-ledger-snapshot" }
 soroban-token-sdk = { version = "26.0.0-rc.1", path = "soroban-token-sdk" }

Makefile

@@ -19,11 +19,12 @@ test: fmt build-test-wasms test-only
 # hazmat granular features are excluded because all hazmat features are tested
 # together with the umbrella hazmat feature.
 test-only:
-	cargo hack --feature-powerset --ignore-unknown-features --features testutils \
-		--exclude-features docs \
-		--exclude-features hazmat-crypto \
-		--exclude-features hazmat-address \
-		test
+	SOROBAN_SDK_BUILD_SYSTEM_SUPPORTS_SPEC_SHAKING_V2=1 \
+		cargo hack --feature-powerset --ignore-unknown-features --features testutils \
+			--exclude-features docs \
+			--exclude-features hazmat-crypto \
+			--exclude-features hazmat-address \
+			test
 
 build: build-libs build-test-wasms
 

soroban-sdk-macros/Cargo.toml

@@ -16,6 +16,7 @@ doctest = false
 
 [dependencies]
 soroban-spec = { workspace = true }
+soroban-spec-markers = { workspace = true, features = ["alloc", "hash"] }
 soroban-spec-rust = { workspace = true }
 soroban-env-common = { workspace = true }
 stellar-xdr = { workspace = true, features = ["curr", "std"] }

soroban-sdk-macros/src/derive_contractimpl_trait_default_fns_not_overridden.rs

@@ -70,7 +70,12 @@ fn derive(args: &Args) -> Result<TokenStream2, Error> {
         Some(trait_ident),
         &args.client_name,
     ));
-    output.extend(derive_fns_spec(&args.spec_name, &fns, spec_export));
+    output.extend(derive_fns_spec(
+        &args.crate_path,
+        &args.spec_name,
+        &fns,
+        spec_export,
+    ));
     output.extend(derive_client_impl(
         &args.crate_path,
         &args.client_name,

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, ToTokens};
+use quote::{format_ident, quote};
 use syn::{
     ext::IdentExt as _, spanned::Spanned, Attribute, DataEnum, Error, Fields, Ident, Path,
     Visibility,
@@ -36,12 +36,12 @@ pub fn derive_type_enum(
     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
+        case_type_id_refs,
+    ): (Vec<_>, Vec<_>, Vec<_>, Vec<_>, Vec<_>, Vec<_>, Vec<_>) = variants
         .iter()
         .enumerate()
         .map(|(case_num, variant)| {
@@ -80,9 +80,6 @@ pub fn derive_type_enum(
                 _ => {}
             }
 
-            // Collect field types for SpecShakingMarker
-            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 {
@@ -91,6 +88,7 @@ pub fn derive_type_enum(
                     try_into,
                     try_from_xdr,
                     into_xdr,
+                    type_id_refs,
                 } = map_tuple_variant(
                     path,
                     enum_ident,
@@ -105,11 +103,11 @@ pub fn derive_type_enum(
                 (
                     spec_case,
                     case_name_str_lit,
-                    field_types,
                     try_from,
                     try_into,
                     try_from_xdr,
                     into_xdr,
+                    type_id_refs,
                 )
             } else {
                 let VariantTokens {
@@ -118,6 +116,7 @@ pub fn derive_type_enum(
                     try_into,
                     try_from_xdr,
                     into_xdr,
+                    type_id_refs,
                 } = map_empty_variant(
                     path,
                     enum_ident,
@@ -130,11 +129,11 @@ pub fn derive_type_enum(
                 (
                     spec_case,
                     case_name_str_lit,
-                    field_types,
                     try_from,
                     try_into,
                     try_from_xdr,
                     into_xdr,
+                    type_id_refs,
                 )
             }
         })
@@ -146,21 +145,31 @@ pub fn derive_type_enum(
         return quote! { #(#compile_errors)* };
     }
 
-    // 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.unraw().to_string().try_into().unwrap(),
-            cases: spec_cases.try_into().unwrap(),
-        });
-        Some(spec_entry.to_xdr(DEFAULT_XDR_RW_LIMITS).unwrap())
+    // Compute spec XDR once. Spec shaking v2 emits SpecTypeId even for
+    // `export = false` types so graph records can be built without exporting
+    // those types to `contractspecv0`.
+    let spec_entry = ScSpecEntry::UdtUnionV0(ScSpecUdtUnionV0 {
+        doc: docs_from_attrs(attrs),
+        lib: lib.as_deref().unwrap_or_default().try_into().unwrap(),
+        name: enum_ident.unraw().to_string().try_into().unwrap(),
+        cases: spec_cases.try_into().unwrap(),
+    });
+    let spec_xdr = spec_entry.to_xdr(DEFAULT_XDR_RW_LIMITS).unwrap();
+    let spec_shaking_gen = if cfg!(feature = "experimental_spec_shaking_v2") {
+        shaking::generate_udt_shaking(
+            path,
+            enum_ident,
+            &spec_xdr,
+            case_type_id_refs.into_iter().flatten().collect(),
+            spec,
+            false,
+        )
     } else {
         None
     };
 
     // Generated code spec.
-    let spec_gen = if let Some(ref spec_xdr) = spec_xdr {
+    let spec_gen = if spec {
         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!(
@@ -176,41 +185,17 @@ pub fn derive_type_enum(
                     *#spec_xdr_lit
                 }
             }
-        })
-    } else {
-        None
-    };
 
-    // SpecShakingMarker impl - only generated when spec is true and the
-    // experimental_spec_shaking_v2 feature is enabled.
-    let spec_shaking_impl = if cfg!(feature = "experimental_spec_shaking_v2") {
-        spec_xdr.as_ref().map(|spec_xdr| {
-            // Flatten all variant field types for shaking 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()
-                });
-            shaking::generate_marker_impl(
-                path,
-                quote!(#enum_ident),
-                spec_xdr,
-                all_field_types.cloned(),
-                None,
-                None,
-                None,
-            )
+            #spec_shaking_gen
         })
     } else {
-        None
+        spec_shaking_gen
     };
 
     // Output.
     let mut output = quote! {
         #spec_gen
 
-        #spec_shaking_impl
-
         impl #path::TryFromVal<#path::Env, #path::Val> for #enum_ident {
             type Error = #path::ConversionError;
             #[inline(always)]
@@ -329,6 +314,7 @@ struct VariantTokens {
     try_into: TokenStream2,
     try_from_xdr: TokenStream2,
     into_xdr: TokenStream2,
+    type_id_refs: Vec<TokenStream2>,
 }
 
 fn map_empty_variant(
@@ -380,6 +366,7 @@ fn map_empty_variant(
         try_into,
         try_from_xdr,
         into_xdr,
+        type_id_refs: Vec::new(),
     }
 }
 
@@ -433,7 +420,14 @@ fn map_tuple_variant(
             type_: field_types,
         })
     };
-
+    let type_id_refs = if cfg!(feature = "experimental_spec_shaking_v2") {
+        fields
+            .iter()
+            .flat_map(|field| shaking::type_id_refs(path, &field.ty))
+            .collect::<Vec<_>>()
+    } else {
+        Vec::new()
+    };
     let num_fields = fields.iter().len();
     let try_from = {
         let field_convs = fields
@@ -519,5 +513,6 @@ fn map_tuple_variant(
         try_into,
         try_from_xdr,
         into_xdr,
+        type_id_refs,
     }
 }

soroban-sdk-macros/src/derive_enum_int.rs

@@ -68,21 +68,24 @@ pub fn derive_type_enum_int(
         return quote! { #(#compile_errors)* };
     }
 
-    // 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.unraw().to_string().try_into().unwrap(),
-            cases: spec_cases.try_into().unwrap(),
-        });
-        Some(spec_entry.to_xdr(DEFAULT_XDR_RW_LIMITS).unwrap())
+    // Compute spec XDR once. Spec shaking v2 emits SpecTypeId even for
+    // `export = false` types so graph records can be built without exporting
+    // those types to `contractspecv0`.
+    let spec_entry = ScSpecEntry::UdtEnumV0(ScSpecUdtEnumV0 {
+        doc: docs_from_attrs(attrs),
+        lib: lib.as_deref().unwrap_or_default().try_into().unwrap(),
+        name: enum_ident.unraw().to_string().try_into().unwrap(),
+        cases: spec_cases.try_into().unwrap(),
+    });
+    let spec_xdr = spec_entry.to_xdr(DEFAULT_XDR_RW_LIMITS).unwrap();
+    let spec_shaking_gen = if cfg!(feature = "experimental_spec_shaking_v2") {
+        shaking::generate_udt_shaking(path, enum_ident, &spec_xdr, Vec::new(), spec, false)
     } else {
         None
     };
 
     // Generated code spec.
-    let spec_gen = if let Some(ref spec_xdr) = spec_xdr {
+    let spec_gen = if spec {
         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!(
@@ -98,35 +101,17 @@ pub fn derive_type_enum_int(
                     *#spec_xdr_lit
                 }
             }
-        })
-    } else {
-        None
-    };
 
-    // SpecShakingMarker impl - only generated when spec is true and the
-    // experimental_spec_shaking_v2 feature is enabled.
-    let spec_shaking_impl = if cfg!(feature = "experimental_spec_shaking_v2") {
-        spec_xdr.as_ref().map(|spec_xdr| {
-            shaking::generate_marker_impl(
-                path,
-                quote!(#enum_ident),
-                spec_xdr,
-                std::iter::empty(),
-                None,
-                None,
-                None,
-            )
+            #spec_shaking_gen
         })
     } else {
-        None
+        spec_shaking_gen
     };
 
     // Output.
     let mut output = quote! {
         #spec_gen
 
-        #spec_shaking_impl
-
         impl #path::TryFromVal<#path::Env, #path::Val> for #enum_ident {
             type Error = #path::ConversionError;
             #[inline(always)]