@layerzerolabs/protocol-stellar-v2 0.2.20 → 0.2.22

package/contracts/common-macros/src/storage.rs

@@ -6,198 +6,125 @@ use heck::ToSnakeCase;
 use itertools::Itertools;
 use proc_macro2::{Ident, TokenStream};
 use quote::{format_ident, quote};
-use syn::{Expr, Fields, FieldsNamed, Type, Variant};
+use syn::{Attribute, Expr, Fields, FieldsNamed, Type, Variant};
 
 // ============================================================================
-// Types & Parsing
+// Public API
 // ============================================================================
 
-/// Storage type parsed from `#[instance(Type)]`, `#[persistent(Type)]`, or `#[temporary(Type)]`.
-#[derive(Debug, Clone)]
-enum StorageType {
-    Instance(Type),
-    Persistent(Type),
-    Temporary(Type),
-}
-
-impl StorageType {
-    fn value_type(&self) -> &Type {
-        match self {
-            Self::Instance(t) | Self::Persistent(t) | Self::Temporary(t) => t,
-        }
+/// Generates the storage API from the `#[storage]` attribute macro.
+pub fn generate_storage(attr: TokenStream, input: TokenStream) -> TokenStream {
+    if !attr.is_empty() {
+        panic!("the #[storage] attribute does not accept arguments");
     }
 
-    fn is_instance(&self) -> bool {
-        matches!(self, Self::Instance(_))
-    }
+    let item_enum: syn::ItemEnum = syn::parse2(input).unwrap_or_else(|e| panic!("failed to parse enum: {}", e));
+    let enum_name = &item_enum.ident;
+    let vis = &item_enum.vis;
+
+    let variants: Vec<_> = item_enum.variants.iter().map(gen_enum_variant).collect();
+    let methods: Vec<_> = item_enum.variants.iter().map(|v| gen_accessor_methods(enum_name, v)).collect();
+
+    quote! {
+        #[soroban_sdk::contracttype]
+        #vis enum #enum_name { #(#variants,)* }
 
-    fn is_persistent(&self) -> bool {
-        matches!(self, Self::Persistent(_))
+        impl #enum_name { #(#methods)* }
     }
+}
 
-    /// Returns the storage accessor method name.
-    fn accessor_name(&self) -> &'static str {
+/// Checks if a type is a primitive (pass-by-value) type.
+pub(crate) fn is_primitive_type(ty: &Type) -> bool {
+    const PRIMITIVES: &[&str] = &["u32", "i32", "u64", "i64", "u128", "i128", "bool"];
+    matches!(ty, Type::Path(p) if p.path.segments.len() == 1
+        && PRIMITIVES.contains(&p.path.segments[0].ident.to_string().as_str()))
+}
+
+// ============================================================================
+// Types
+// ============================================================================
+
+/// Storage kind: instance, persistent, or temporary.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum StorageKind {
+    Instance,
+    Persistent,
+    Temporary,
+}
+
+impl StorageKind {
+    fn name(self) -> &'static str {
         match self {
-            Self::Instance(_) => "instance",
-            Self::Persistent(_) => "persistent",
-            Self::Temporary(_) => "temporary",
+            Self::Instance => "instance",
+            Self::Persistent => "persistent",
+            Self::Temporary => "temporary",
         }
     }
-}
 
-impl TryFrom<&syn::Attribute> for StorageType {
-    type Error = String;
-
-    fn try_from(attr: &syn::Attribute) -> std::result::Result<Self, Self::Error> {
-        let ident = attr.path().get_ident().ok_or("identifier expected to be instance, persistent, or temporary")?;
-        let value_type = attr.parse_args::<Type>().map_err(|e| format!("failed to parse value type: {}", e))?;
+    /// Generates `env.storage().{kind}()`.
+    fn accessor(self) -> TokenStream {
+        let method = format_ident!("{}", self.name());
+        quote! { env.storage().#method() }
+    }
 
-        match ident.to_string().as_str() {
-            "instance" => Ok(Self::Instance(value_type)),
-            "persistent" => Ok(Self::Persistent(value_type)),
-            "temporary" => Ok(Self::Temporary(value_type)),
-            other => Err(format!("unknown storage type: {}", other)),
+    /// Generates TTL extension code.
+    ///
+    /// - `use_stored_config=true`: reads TTL config from storage (for auto-extension)
+    /// - `use_stored_config=false`: uses local `threshold`/`extend_to` variables (for manual)
+    fn gen_ttl_extension(self, use_stored_config: bool) -> TokenStream {
+        let accessor = self.accessor();
+        let extend_call = if self == Self::Instance {
+            quote! { #accessor.extend_ttl(threshold, extend_to); }
+        } else {
+            quote! { #accessor.extend_ttl(&key, threshold, extend_to); }
+        };
+
+        if use_stored_config {
+            let method = format_ident!("{}", self.name());
+            quote! {
+                if let Some(utils::ttl_configurable::TtlConfig { threshold, extend_to }) =
+                    utils::ttl_configurable::TtlConfigStorage::#method(env)
+                {
+                    #extend_call
+                }
+            }
+        } else {
+            extend_call
         }
     }
 }
 
-/// Parsed configuration for a single storage enum variant.
+/// Parsed configuration for a storage enum variant.
 #[derive(Debug, Clone)]
-pub(crate) struct StorageVariantConfig {
+struct VariantConfig {
     name: String,
-    storage_type: StorageType,
+    kind: StorageKind,
+    value_type: Type,
     default_value: Option<Expr>,
-    no_ttl_extension: bool,
+    auto_ttl: bool,
 }
 
-impl StorageVariantConfig {
-    /// Returns generated function names for this storage variant.
-    fn function_names(&self) -> FunctionNames {
+impl VariantConfig {
+    /// Returns (getter, setter, remover, set_or_remove, has, ttl_extender) function names.
+    fn method_names(&self) -> (Ident, Ident, Ident, Ident, Ident, Ident) {
         let base = &self.name;
-        FunctionNames {
-            getter: format_ident!("{}", base),
-            setter: format_ident!("set_{}", base),
-            remover: format_ident!("remove_{}", base),
-            set_or_remove: format_ident!("set_or_remove_{}", base),
-            ttl_extender: format_ident!("extend_{}_ttl", base),
-            has: format_ident!("has_{}", base),
-        }
+        (
+            format_ident!("{}", base),
+            format_ident!("set_{}", base),
+            format_ident!("remove_{}", base),
+            format_ident!("set_or_remove_{}", base),
+            format_ident!("has_{}", base),
+            format_ident!("extend_{}_ttl", base),
+        )
     }
 }
 
-impl TryFrom<&Variant> for StorageVariantConfig {
-    type Error = String;
-
-    fn try_from(variant: &Variant) -> std::result::Result<Self, Self::Error> {
-        let attrs = &variant.attrs;
-
-        // Known attribute identifiers for this macro ("doc" allows /// comments on variants)
-        const KNOWN_ATTRS: &[&str] =
-            &["doc", "instance", "persistent", "temporary", "default", "name", "no_ttl_extension"];
-
-        // Check for unsupported attributes
-        if let Some(unknown) = attrs
-            .iter()
-            .filter_map(|attr| attr.path().get_ident())
-            .find(|ident| !KNOWN_ATTRS.contains(&ident.to_string().as_str()))
-        {
-            return Err(format!(
-                "unknown attribute '{}' on variant '{}'. Supported attributes are: {}",
-                unknown,
-                variant.ident,
-                KNOWN_ATTRS.join(", ")
-            ));
-        }
-
-        // Parse storage type (exactly one required)
-        let storage_type =
-            attrs.iter().filter_map(|attr| StorageType::try_from(attr).ok()).exactly_one().map_err(|e| {
-                format!(
-                    "storage type must be specified exactly once as \
-                     '#[instance(Type)]', '#[persistent(Type)]', or '#[temporary(Type)]': {}",
-                    e
-                )
-            })?;
-
-        // Parse optional default value
-        let default_value = attrs
-            .iter()
-            .filter(|attr| attr.path().is_ident("default"))
-            .at_most_one()
-            .map_err(|_| "multiple default values specified")?
-            .map(|attr| attr.parse_args::<Expr>())
-            .transpose()
-            .map_err(|e| format!("failed to parse default value: {}", e))?;
-
-        // Parse optional name override for storage key generation
-        // If no #[name("custom_name")] attribute is provided, defaults to snake_case of variant name
-        let name = attrs
-            .iter()
-            .filter(|attr| attr.path().is_ident("name"))
-            .at_most_one()
-            .map_err(|_| "multiple name attributes specified")?
-            .map(|attr| attr.parse_args::<syn::LitStr>().map(|lit| lit.value()))
-            .transpose()
-            .map_err(|e| format!("failed to parse name attribute: {}", e))?
-            .unwrap_or_else(|| variant.ident.to_string().to_snake_case());
-
-        // Parse optional #[no_ttl_extension] to skip automatic TTL extension (persistent only)
-        let no_ttl_extension = attrs
-            .iter()
-            .filter(|attr| attr.path().is_ident("no_ttl_extension"))
-            .at_most_one()
-            .map_err(|_| "multiple #[no_ttl_extension] attributes specified")?
-            .is_some();
-        if no_ttl_extension && !storage_type.is_persistent() {
-            return Err("#[no_ttl_extension] can only be used with #[persistent(...)] storage".to_string());
-        }
-
-        Ok(Self { storage_type, default_value, name, no_ttl_extension })
-    }
-}
-
-/// Generated function names for a storage variant.
-struct FunctionNames {
-    getter: Ident,
-    setter: Ident,
-    remover: Ident,
-    set_or_remove: Ident,
-    ttl_extender: Ident,
-    has: Ident,
-}
-
 // ============================================================================
-// Code Generation
+// Enum Variant Code Generation
 // ============================================================================
 
-/// Generates the storage API from the `#[storage]` attribute macro.
-pub(crate) fn generate_storage(attr: TokenStream, input: TokenStream) -> TokenStream {
-    let item_enum: syn::ItemEnum = syn::parse2(input).unwrap_or_else(|e| panic!("failed to parse enum: {}", e));
-
-    // Ensure no arguments are passed to #[storage]
-    if !attr.is_empty() {
-        panic!("the #[storage] attribute does not accept arguments");
-    }
-
-    let enum_name = &item_enum.ident;
-    let contracttype_variants: Vec<_> = item_enum.variants.iter().map(gen_contracttype_variant).collect();
-    let inherent_impls: Vec<_> = item_enum.variants.iter().map(|v| gen_storage_functions(enum_name, v)).collect();
-
-    let visibility = &item_enum.vis;
-    quote! {
-        #[soroban_sdk::contracttype]
-        #visibility enum #enum_name {
-            #(#contracttype_variants,)*
-        }
-
-        impl #enum_name {
-            #(#inherent_impls)*
-        }
-    }
-}
-
 /// Generates contracttype enum variant: `Variant` or `Variant(Type1, Type2, ...)`.
-fn gen_contracttype_variant(variant: &Variant) -> TokenStream {
+fn gen_enum_variant(variant: &Variant) -> TokenStream {
     let name = &variant.ident;
     match &variant.fields {
         Fields::Unit => quote! { #name },
@@ -209,125 +136,94 @@ fn gen_contracttype_variant(variant: &Variant) -> TokenStream {
     }
 }
 
-/// Generates all storage accessor functions for a variant.
-fn gen_storage_functions(enum_name: &Ident, variant: &Variant) -> TokenStream {
-    let config = StorageVariantConfig::try_from(variant)
+/// Generates all storage accessor methods for a variant.
+fn gen_accessor_methods(enum_name: &Ident, variant: &Variant) -> TokenStream {
+    let config = VariantConfig::try_from(variant)
         .unwrap_or_else(|e| panic!("failed to parse storage variant for {}: {}", variant.ident, e));
 
-    let FunctionNames { getter, setter, remover, set_or_remove, has, ttl_extender } = config.function_names();
+    let (getter, setter, remover, set_or_remove, has, ttl_extender) = config.method_names();
+    let params = gen_params(variant);
+    let args = gen_args(variant);
+    let key = gen_key(enum_name, variant);
+    let accessor = config.kind.accessor();
+    let value_type = &config.value_type;
 
-    let fn_params = gen_fn_params(variant);
-    let fn_args = gen_fn_args(variant);
-    let storage_key = gen_storage_key(variant, enum_name);
-    let storage_acc = gen_storage_accessor(&config.storage_type);
-    let value_type = config.storage_type.value_type();
+    // TTL extension tokens
+    let auto_ttl = if config.auto_ttl { config.kind.gen_ttl_extension(true) } else { TokenStream::new() };
+    let manual_ttl = config.kind.gen_ttl_extension(false);
 
-    // Automatic TTL extension for persistent storage (unless #[no_ttl_extension] is specified)
-    let auto_ttl_extend = if config.storage_type.is_persistent() && !config.no_ttl_extension {
-        gen_ttl_extension(&config.storage_type, true)
+    // Getter return type and expression
+    let (ret_type, ret_expr) = match &config.default_value {
+        Some(default) => (quote! { #value_type }, quote! { value.unwrap_or(#default) }),
+        None => (quote! { Option<#value_type> }, quote! { value }),
+    };
+    let ttl_on_get = if config.auto_ttl {
+        quote! { if value.is_some() { #auto_ttl } }
     } else {
         TokenStream::new()
     };
 
-    let getter_impl = gen_getter_fn(
-        &getter,
-        &fn_params,
-        &storage_key,
-        &storage_acc,
-        value_type,
-        &config.default_value,
-        &auto_ttl_extend,
-    );
-
-    // Manual TTL extension (user provides threshold/extend_to)
-    let manual_ttl_extend = gen_ttl_extension(&config.storage_type, false);
-
-    // Has implementation (conditionally includes TTL extension)
-    let has_impl = if auto_ttl_extend.is_empty() {
-        quote! { #storage_acc.has(&key) }
+    // Has check body
+    let has_body = if config.auto_ttl {
+        quote! { let exists = #accessor.has(&key); if exists { #auto_ttl } exists }
     } else {
-        quote! {
-            let exists = #storage_acc.has(&key);
-            if exists { #auto_ttl_extend }
-            exists
-        }
+        quote! { #accessor.has(&key) }
     };
 
     quote! {
-        #getter_impl
+        pub fn #getter(#params) -> #ret_type {
+            let key = #key;
+            let value = #accessor.get::<_, #value_type>(&key);
+            #ttl_on_get
+            #ret_expr
+        }
 
-        pub fn #setter(#fn_params, value: &#value_type) {
-            let key = #storage_key;
-            #storage_acc.set(&key, value);
-            #auto_ttl_extend
+        pub fn #setter(#params, value: &#value_type) {
+            let key = #key;
+            #accessor.set(&key, value);
+            #auto_ttl
         }
 
-        pub fn #remover(#fn_params) {
-            let key = #storage_key;
-            #storage_acc.remove(&key);
+        pub fn #remover(#params) {
+            let key = #key;
+            #accessor.remove(&key);
         }
 
-        pub fn #set_or_remove(#fn_params, value: &Option<#value_type>) {
+        pub fn #set_or_remove(#params, value: &Option<#value_type>) {
             match value.as_ref() {
-                Some(v) => Self::#setter(#fn_args, v),
-                None => Self::#remover(#fn_args),
+                Some(v) => Self::#setter(#args, v),
+                None => Self::#remover(#args),
             }
         }
 
-        pub fn #has(#fn_params) -> bool {
-            let key = #storage_key;
-            #has_impl
+        pub fn #has(#params) -> bool {
+            let key = #key;
+            #has_body
         }
 
-        pub fn #ttl_extender(#fn_params, threshold: u32, extend_to: u32) {
-            let key = #storage_key;
-            #manual_ttl_extend
+        pub fn #ttl_extender(#params, threshold: u32, extend_to: u32) {
+            let key = #key;
+            #manual_ttl
         }
     }
 }
 
-/// Generates the storage accessor: `env.storage().instance()` etc.
-fn gen_storage_accessor(storage_type: &StorageType) -> TokenStream {
-    let method = format_ident!("{}", storage_type.accessor_name());
-    quote! { env.storage().#method() }
-}
-
-/// Generates TTL extension code.
-/// - use_stored_config=true: fetches TTL config from TtlConfigStorage, only extends if config is set
-/// - use_stored_config=false: uses local variables `threshold` and `extend_to` (for manual extension)
-fn gen_ttl_extension(storage_type: &StorageType, use_stored_config: bool) -> TokenStream {
-    let accessor = gen_storage_accessor(storage_type);
-    let extend_call = if storage_type.is_instance() {
-        quote! { #accessor.extend_ttl(threshold, extend_to); }
-    } else {
-        quote! { #accessor.extend_ttl(&key, threshold, extend_to); }
-    };
+// ============================================================================
+// Parameter & Key Generation Helpers
+// ============================================================================
 
-    if use_stored_config {
-        let method = format_ident!("{}", storage_type.accessor_name());
-        quote! {
-            if let Some(utils::ttl_configurable::TtlConfig { threshold, extend_to }) = utils::ttl_configurable::TtlConfigStorage::#method(env) {
-                #extend_call
-            }
-        }
-    } else {
-        extend_call
+/// Extracts (name, type) pairs from variant fields.
+fn extract_fields(variant: &Variant) -> Vec<(&Ident, &Type)> {
+    match &variant.fields {
+        Fields::Unit => vec![],
+        Fields::Named(named) => named.named.iter().map(|f| (f.ident.as_ref().unwrap(), &f.ty)).collect(),
+        _ => panic!("only unit variants or named fields are supported in storage enums"),
     }
 }
 
-/// Checks if a type is a primitive type
-pub(crate) fn is_primitive_type(ty: &Type) -> bool {
-    let Type::Path(type_path) = ty else { return false };
-    let Some(segment) = type_path.path.segments.first() else { return false };
-    type_path.path.segments.len() == 1
-        && matches!(segment.ident.to_string().as_str(), "u32" | "i32" | "u64" | "i64" | "u128" | "i128" | "bool")
-}
-
 /// Generates function parameters: `env: &Env` or `env: &Env, field1: Type1, ...`.
-/// For primitive types (u32, i32, u64, i64, u128, i128, bool), uses pass-by-value.
-/// For other types, uses pass-by-reference.
-fn gen_fn_params(variant: &Variant) -> TokenStream {
-    let fields = extract_named_fields(&variant.fields);
+fn gen_params(variant: &Variant) -> TokenStream {
+    let fields = extract_fields(variant);
     if fields.is_empty() {
         quote! { env: &soroban_sdk::Env }
     } else {
@@ -342,73 +238,136 @@ fn gen_fn_params(variant: &Variant) -> TokenStream {
     }
 }
 
-/// Generates function argument list for calls: `env, field1, field2, ...`.
-fn gen_fn_args(variant: &Variant) -> TokenStream {
-    let fields = extract_named_fields(&variant.fields);
+/// Generates function arguments: `env` or `env, field1, field2, ...`.
+fn gen_args(variant: &Variant) -> TokenStream {
+    let fields = extract_fields(variant);
     if fields.is_empty() {
         quote! { env }
     } else {
-        let field_names = fields.iter().map(|(name, _)| name);
-        quote! { env, #(#field_names),* }
+        let names = fields.iter().map(|(name, _)| *name);
+        quote! { env, #(#names),* }
     }
 }
 
-/// Generates key constructor: `Enum::Variant` or `Enum::Variant(field1, field2)`.
-/// For non-primitive types that are passed by reference, clones them.
-fn gen_storage_key(variant: &Variant, enum_name: &Ident) -> TokenStream {
-    let fields = extract_named_fields(&variant.fields);
+/// Generates storage key: `Enum::Variant` or `Enum::Variant(field1.clone(), ...)`.
+fn gen_key(enum_name: &Ident, variant: &Variant) -> TokenStream {
     let variant_ident = &variant.ident;
+    let fields = extract_fields(variant);
+
     if fields.is_empty() {
         quote! { #enum_name::#variant_ident }
     } else {
-        let field_names = fields.iter().map(|(name, ty)| {
+        let args = fields.iter().map(|(name, ty)| {
             if is_primitive_type(ty) {
                 quote! { #name }
             } else {
                 quote! { #name.clone() }
             }
         });
-        quote! { #enum_name::#variant_ident(#(#field_names),*) }
+        quote! { #enum_name::#variant_ident(#(#args),*) }
     }
 }
 
-/// Extracts (name, type) pairs from named fields.
-fn extract_named_fields(fields: &Fields) -> Vec<(&Ident, &Type)> {
-    match fields {
-        Fields::Unit => vec![],
-        Fields::Named(named) => named.named.iter().map(|f| (f.ident.as_ref().unwrap(), &f.ty)).collect(),
-        _ => panic!("only unit variants or named fields are supported in storage enums"),
+// ============================================================================
+// Attribute Parsing
+// ============================================================================
+
+/// Known attributes for storage variants ("doc" allows /// comments).
+const KNOWN_ATTRS: &[&str] = &["doc", "instance", "persistent", "temporary", "default", "name", "no_ttl_extension"];
+
+impl TryFrom<&Variant> for VariantConfig {
+    type Error = String;
+
+    fn try_from(variant: &Variant) -> Result<Self, Self::Error> {
+        let attrs = &variant.attrs;
+        validate_attrs(attrs, &variant.ident)?;
+
+        let (kind, value_type) = parse_storage_type(attrs)?;
+        let default_value = parse_default(attrs)?;
+        let name = parse_name(attrs)?.unwrap_or_else(|| variant.ident.to_string().to_snake_case());
+        let no_ttl_extension = parse_no_ttl_extension(attrs)?;
+
+        if no_ttl_extension && kind != StorageKind::Persistent {
+            return Err("#[no_ttl_extension] can only be used with #[persistent(...)] storage".to_string());
+        }
+
+        Ok(Self {
+            name,
+            kind,
+            value_type,
+            default_value,
+            auto_ttl: kind == StorageKind::Persistent && !no_ttl_extension,
+        })
     }
 }
 
-/// Generates the getter function with appropriate return type and TTL handling.
-fn gen_getter_fn(
-    name: &Ident,
-    params: &TokenStream,
-    key: &TokenStream,
-    accessor: &TokenStream,
-    value_type: &Type,
-    default_value: &Option<Expr>,
-    auto_ttl_extend: &TokenStream,
-) -> TokenStream {
-    let (return_type, return_expr) = match default_value {
-        Some(expr) => (quote! { #value_type }, quote! { value.unwrap_or(#expr) }),
-        None => (quote! { Option<#value_type> }, quote! { value }),
-    };
-
-    // If auto TTL extension is enabled, check if the value is not None and extend the TTL
-    let ttl_check = if auto_ttl_extend.is_empty() {
-        TokenStream::new()
-    } else {
-        quote! { if value.is_some() { #auto_ttl_extend } }
-    };
+fn validate_attrs(attrs: &[Attribute], variant_ident: &Ident) -> Result<(), String> {
+    for attr in attrs {
+        let path = attr.path();
+        let name = path.get_ident().map(|i| i.to_string()).unwrap_or_else(|| quote!(#path).to_string());
 
-    quote! {
-        pub fn #name(#params) -> #return_type {
-            let key = #key;
-            let value = #accessor.get::<_, #value_type>(&key);
-            #ttl_check
-            #return_expr
+        if !KNOWN_ATTRS.contains(&name.as_str()) {
+            return Err(format!(
+                "unknown attribute '{}' on variant '{}'. Supported attributes are: {}",
+                name,
+                variant_ident,
+                KNOWN_ATTRS.join(", ")
+            ));
         }
     }
+    Ok(())
+}
+
+fn parse_storage_type(attrs: &[Attribute]) -> Result<(StorageKind, Type), String> {
+    attrs
+        .iter()
+        .filter_map(|attr| {
+            let ident = attr.path().get_ident()?;
+            let kind = match ident.to_string().as_str() {
+                "instance" => StorageKind::Instance,
+                "persistent" => StorageKind::Persistent,
+                "temporary" => StorageKind::Temporary,
+                _ => return None,
+            };
+            Some((kind, attr.parse_args::<Type>().ok()?))
+        })
+        .exactly_one()
+        .map_err(|e| {
+            format!(
+                "storage type must be specified exactly once as \
+                 '#[instance(Type)]', '#[persistent(Type)]', or '#[temporary(Type)]': {}",
+                e
+            )
+        })
+}
+
+fn parse_default(attrs: &[Attribute]) -> Result<Option<Expr>, String> {
+    attrs
+        .iter()
+        .filter(|attr| attr.path().is_ident("default"))
+        .at_most_one()
+        .map_err(|_| "multiple default values specified")?
+        .map(|attr| attr.parse_args::<Expr>())
+        .transpose()
+        .map_err(|e| format!("failed to parse default value: {}", e))
+}
+
+fn parse_name(attrs: &[Attribute]) -> Result<Option<String>, String> {
+    attrs
+        .iter()
+        .filter(|attr| attr.path().is_ident("name"))
+        .at_most_one()
+        .map_err(|_| "multiple name attributes specified")?
+        .map(|attr| attr.parse_args::<syn::LitStr>().map(|lit| lit.value()))
+        .transpose()
+        .map_err(|e| format!("failed to parse name attribute: {}", e))
+}
+
+fn parse_no_ttl_extension(attrs: &[Attribute]) -> Result<bool, String> {
+    Ok(attrs
+        .iter()
+        .filter(|attr| attr.path().is_ident("no_ttl_extension"))
+        .at_most_one()
+        .map_err(|_| "multiple #[no_ttl_extension] attributes specified")?
+        .is_some())
 }