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

1 files changed, 124 insertions, 0 deletions

diff --git a/mingling_macros/src/func/group_structural.rs b/mingling_macros/src/func/group_structural.rs
new file mode 100644
index 0000000..2bd2f83
--- /dev/null
+++ b/mingling_macros/src/func/group_structural.rs
@@ -0,0 +1,124 @@
+use proc_macro::TokenStream;
+use quote::quote;
+use syn::{Ident, TypePath};
+
+use crate::get_global_set;
+
+/// `group_structural!` — like `group!` but also marks the type as supporting
+/// structured output via `StructuralData`.
+pub(crate) fn group_structural(input: TokenStream) -> TokenStream {
+    // Parse the same input as group!
+    let input_parsed = syn::parse_macro_input!(input as GroupStructuralInput);
+
+    let is_aliased = matches!(&input_parsed, GroupStructuralInput::Aliased { .. });
+
+    let (type_path, type_name, alias_stmt) = match &input_parsed {
+        GroupStructuralInput::Plain(type_path) => {
+            let name = type_path
+                .path
+                .segments
+                .last()
+                .expect("TypePath must have at least one segment")
+                .ident
+                .clone();
+            (type_path.clone(), name, quote! {})
+        }
+        GroupStructuralInput::Aliased { alias, type_path } => {
+            let alias_stmt = quote! {
+                pub(crate) type #alias = #type_path;
+            };
+            (type_path.clone(), alias.clone(), alias_stmt)
+        }
+    };
+
+    let type_name_str = type_name.to_string();
+
+    // Register in STRUCTURED_TYPES
+    get_global_set(&crate::STRUCTURED_TYPES)
+        .lock()
+        .unwrap()
+        .insert(type_name_str);
+
+    let program_path = crate::default_program_path();
+
+    // Generate unique module name
+    let segments: Vec<String> = type_path
+        .path
+        .segments
+        .iter()
+        .map(|seg| seg.ident.to_string().to_lowercase())
+        .collect();
+    let module_name = Ident::new(
+        &format!("internal_group_{}", segments.join("_")),
+        proc_macro2::Span::call_site(),
+    );
+
+    // Generate the appropriate `use` statement for the original type
+    let type_use = if type_path.path.segments.len() > 1 {
+        quote! { #[allow(unused_imports)] use #type_path; }
+    } else {
+        let ident = type_path
+            .path
+            .segments
+            .last()
+            .expect("TypePath must have at least one segment")
+            .ident
+            .clone();
+        quote! { #[allow(unused_imports)] use super::#ident; }
+    };
+
+    let alias_use = if is_aliased {
+        quote! { use super::#type_name; }
+    } else {
+        quote! {}
+    };
+
+    let expanded = quote! {
+        #alias_stmt
+        #[allow(non_camel_case_types)]
+        mod #module_name {
+            use #program_path as __MinglingProgram;
+            #type_use
+            #alias_use
+
+            /// SAFETY: This is an internal implementation of the `pack_structural!` macro,
+            /// guaranteeing that the enum value registered by the `register_type!` macro
+            /// is exactly the same as the actual return value,
+            /// which can be confirmed via the `Ident` in the `quote!` block.
+            unsafe impl ::mingling::Grouped<__MinglingProgram> for #type_name {
+                fn member_id() -> __MinglingProgram {
+                    __MinglingProgram::#type_name
+                }
+            }
+
+            impl ::mingling::__private::StructuralDataSealed<crate::ThisProgram> for #type_name {}
+            impl ::mingling::__private::StructuralData<crate::ThisProgram> for #type_name {}
+
+            ::mingling::macros::register_type!(#type_name);
+        }
+    };
+
+    expanded.into()
+}
+
+/// Input for `group_structural!` — same format as `group!`.
+enum GroupStructuralInput {
+    Plain(TypePath),
+    Aliased { alias: Ident, type_path: TypePath },
+}
+
+impl syn::parse::Parse for GroupStructuralInput {
+    fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
+        let fork = input.fork();
+        let _first: Ident = fork.parse()?;
+        if fork.peek(syn::Token![=]) {
+            let alias: Ident = input.parse()?;
+            let _eq: syn::Token![=] = input.parse()?;
+            let type_path: TypePath = input.parse()?;
+            Ok(GroupStructuralInput::Aliased { alias, type_path })
+        } else {
+            let type_path: TypePath = input.parse()?;
+            Ok(GroupStructuralInput::Plain(type_path))
+        }
+    }
+}