taler-rust

lib.rs (6295B)

---

 /*
   This file is part of TALER
   Copyright (C) 2026 Taler Systems SA
 
   TALER is free software; you can redistribute it and/or modify it under the
   terms of the GNU Affero General Public License as published by the Free Software
   Foundation; either version 3, or (at your option) any later version.
 
   TALER is distributed in the hope that it will be useful, but WITHOUT ANY
   WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
   A PARTICULAR PURPOSE.  See the GNU Affero General Public License for more details.
 
   You should have received a copy of the GNU Affero General Public License along with
   TALER; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
 */
 
 use proc_macro::TokenStream;
 use quote::quote;
 use syn::{Data, DeriveInput, Error, Expr, Lit, Meta, parse_macro_input};
 
 #[proc_macro_derive(EnumMeta, attributes(enum_meta, code))]
 pub fn derive_domain_code(input: TokenStream) -> TokenStream {
     let input = parse_macro_input!(input as DeriveInput);
     let name = &input.ident;
 
     // Parse features
     let mut enabled_doc = false;
     let mut enabled_code = false;
     let mut enabled_str = false;
 
     for attr in &input.attrs {
         if attr.path().is_ident("enum_meta")
             && let Err(e) = attr.parse_nested_meta(|meta| {
                 if meta.path.is_ident("Description") {
                     enabled_doc = true;
                 } else if meta.path.is_ident("DomainCode") {
                     enabled_code = true;
                 } else if meta.path.is_ident("Str") {
                     enabled_str = true;
                 } else {
                     return Err(meta.error("unknown enum_meta option"));
                 }
                 Ok(())
             })
         {
             return e.to_compile_error().into();
         }
     }
 
     let variants = if let Data::Enum(data) = &input.data {
         &data.variants
     } else {
         return Error::new(input.ident.span(), "EnumMeta only supports enums")
             .to_compile_error()
             .into();
     };
 
     // Helper: extract the first string literal from a name-value attribute.
     let extract_str_attr = |variant: &syn::Variant, ident: &str| -> Option<String> {
         variant.attrs.iter().find_map(|a| {
             if a.path().is_ident(ident)
                 && let Meta::NameValue(nv) = &a.meta
                 && let Expr::Lit(expr) = &nv.value
                 && let Lit::Str(s) = &expr.lit
             {
                 Some(s.value())
             } else {
                 None
             }
         })
     };
 
     let mut entries = Vec::new();
     let mut description_arms = Vec::new();
     let mut code_arms = Vec::new();
     let mut from_str_arms = Vec::new();
     let mut as_ref_arms = Vec::new();
 
     for variant in variants {
         let v_ident = &variant.ident;
         let v_str = v_ident.to_string();
 
         // Single pass: collect doc and code in one go, then use what's needed.
         let doc =
             enabled_doc.then(|| extract_str_attr(variant, "doc").map(|s| s.trim().to_string()));
         let code = (enabled_code).then(|| extract_str_attr(variant, "code"));
 
         if let Some(doc) = doc {
             let doc = match doc {
                 Some(d) => d,
                 None => {
                     return Error::new(
                         v_ident.span(),
                         format!("variant `{v_str}` is missing `/// documentation`"),
                     )
                     .to_compile_error()
                     .into();
                 }
             };
             description_arms.push(quote! { Self::#v_ident => #doc });
         }
 
         if let Some(code) = code {
             let code = match code {
                 Some(c) => c,
                 None => {
                     return Error::new(
                         v_ident.span(),
                         format!("variant `{v_str}` is missing `#[code = \"...\"]`"),
                     )
                     .to_compile_error()
                     .into();
                 }
             };
             from_str_arms.push(quote! { #code => Ok(Self::#v_ident) });
             code_arms.push(quote! { Self::#v_ident => #code });
         } else if enabled_str {
             from_str_arms.push(quote! { #v_str => Ok(Self::#v_ident) });
         }
 
         if enabled_str {
             as_ref_arms.push(quote! { Self::#v_ident => #v_str });
         }
         entries.push(quote! { Self::#v_ident, });
     }
 
     let mut expanded = quote! {
         impl #name {
             /// Returns a slice of all enum variants.
             pub const entries: &'static [Self] = &[#(#entries)*];
         }
     };
 
     if enabled_doc {
         expanded.extend(quote! {
             impl #name {
                 /// Returns the documentation description associated
                 pub fn description(&self) -> &'static str {
                     match self { #(#description_arms),* }
                 }
             }
         });
     }
 
     if enabled_code {
         expanded.extend(quote! {
             impl #name {
                 /// Returns the domain code associated
                 pub fn code(&self) -> &'static str {
                     match self { #(#code_arms),* }
                 }
             }
         });
     }
 
     if enabled_str {
         expanded.extend(quote! {
             impl AsRef<str> for #name {
                 fn as_ref(&self) -> &str {
                     match self { #(#as_ref_arms),* }
                 }
             }
 
             impl std::fmt::Display for #name {
                 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                     f.write_str(self.as_ref())
                 }
             }
         });
     }
 
     if enabled_code || enabled_str {
         let unknown_label = if enabled_code { "code" } else { "name" };
         expanded.extend(quote! {
             impl std::str::FromStr for #name {
                 type Err = String;
                 fn from_str(s: &str) -> Result<Self, Self::Err> {
                     match s {
                         #(#from_str_arms,)*
                         _ => Err(format!("Unknown {0} for {1}: {2}", #unknown_label, stringify!(#name), s))
                     }
                 }
             }
         });
     }
 
     TokenStream::from(expanded)
 }