feat(macros): split monolith into one-macro-per-file modules

1 files changed, 71 insertions, 0 deletions

diff --git a/mingling_macros/src/func/register_help.rs b/mingling_macros/src/func/register_help.rs
new file mode 100644
index 0000000..e715244
--- /dev/null
+++ b/mingling_macros/src/func/register_help.rs
@@ -0,0 +1,71 @@
+use proc_macro::TokenStream;
+use quote::ToTokens;
+use syn::TypePath;
+use syn::spanned::Spanned;
+
+use crate::get_global_set;
+
+pub(crate) fn register_help(input: TokenStream) -> TokenStream {
+    // Parse the input as a comma-separated list of arguments
+    let input_parsed = syn::parse_macro_input!(input with syn::punctuated::Punctuated<syn::Expr, syn::Token![,]>::parse_terminated);
+
+    // Check if there are exactly two elements
+    if input_parsed.len() != 2 {
+        return syn::Error::new(
+            input_parsed.span(),
+            "Expected exactly two comma-separated arguments: `EntryType, StructName`",
+        )
+        .to_compile_error()
+        .into();
+    }
+
+    // Extract the two elements
+    let entry_type_expr = &input_parsed[0];
+    let struct_name_expr = &input_parsed[1];
+
+    // Convert expressions to TypePath and Ident
+    let entry_type = match syn::parse2::<TypePath>(entry_type_expr.to_token_stream()) {
+        Ok(ty) => ty,
+        Err(e) => return e.to_compile_error().into(),
+    };
+
+    let struct_name = match syn::parse2::<syn::Ident>(struct_name_expr.to_token_stream()) {
+        Ok(ident) => ident,
+        Err(e) => return e.to_compile_error().into(),
+    };
+
+    // Register the help request mapping
+    let help_entry = build_help_entry(&struct_name, &entry_type);
+    let entry_str = help_entry.to_string();
+
+    // Check if entry was already pre-inserted by `#[help]` attribute
+    let mut helps = get_global_set(&crate::HELP_REQUESTS).lock().unwrap();
+    if helps.contains(&entry_str) {
+        // Already registered by `#[help]`, no duplicate check needed
+        return quote::quote! {}.into();
+    }
+
+    // Check for duplicate variant (different struct, same type)
+    let variant_name = entry_type.path.segments.last().unwrap().ident.to_string();
+    if let Err(err) =
+        crate::check_duplicate_variant(&helps, &entry_str, &variant_name, "help", entry_type.span())
+    {
+        return err.into();
+    }
+
+    helps.insert(entry_str);
+
+    quote::quote! {}.into()
+}
+
+fn build_help_entry(struct_name: &syn::Ident, entry_type: &TypePath) -> proc_macro2::TokenStream {
+    let enum_variant = entry_type.path.segments.last().unwrap().ident.clone();
+    quote::quote! {
+        Self::#enum_variant => {
+            // SAFETY: The member_id check ensures that `any` contains a value of type `#entry_type`,
+            // so downcasting to `#entry_type` is safe.
+            let value = unsafe { any.downcast::<#entry_type>().unwrap_unchecked() };
+            <#struct_name as ::mingling::HelpRequest>::render_help(value)
+        }
+    }
+}