feat(macro): add outer macro for classes

Refs: 335

Author: Xenira

crates/macros/src/class.rs

@@ -9,6 +9,7 @@ use syn::{Attribute, AttributeArgs, Expr, Fields, FieldsNamed, ItemStruct, LitSt
 
 #[derive(Debug, Default)]
 pub struct Class {
+    pub name: String,
     pub class_name: String,
     pub struct_path: String,
     pub parent: Option<String>,
@@ -40,7 +41,7 @@ pub struct AttrArgs {
     flags: Option<Expr>,
 }
 
-pub fn parser(args: AttributeArgs, mut input: ItemStruct) -> Result<TokenStream> {
+pub fn parser(args: AttributeArgs, mut input: ItemStruct) -> Result<(TokenStream, Class)> {
     let args = AttrArgs::from_list(&args)
         .map_err(|e| anyhow!("Unable to parse attribute arguments: {:?}", e))?;
 
@@ -51,7 +52,11 @@ pub fn parser(args: AttributeArgs, mut input: ItemStruct) -> Result<TokenStream>
 
     input.attrs = {
         let mut unused = vec![];
-        for attr in input.attrs.into_iter() {
+        for attr in input
+            .attrs
+            .into_iter()
+            .filter(|a| !a.path.is_ident("php_class"))
+        {
             match parse_attribute(&attr)? {
                 Some(parsed) => match parsed {
                     ParsedAttribute::Extends(class) => {
@@ -120,6 +125,7 @@ pub fn parser(args: AttributeArgs, mut input: ItemStruct) -> Result<TokenStream>
     let struct_path = ident.to_string();
     let flags = args.flags.map(|flags| flags.to_token_stream().to_string());
     let class = Class {
+        name: ident.to_string(),
         class_name,
         struct_path,
         parent,
@@ -131,23 +137,14 @@ pub fn parser(args: AttributeArgs, mut input: ItemStruct) -> Result<TokenStream>
         ..Default::default()
     };
 
-    // let mut state = STATE.lock();
-    //
-    // if state.built_module {
-    //     bail!("The `#[php_module]` macro must be called last to ensure functions and classes are registered.");
-    // }
-    //
-    // if state.startup_function.is_some() {
-    //     bail!("The `#[php_startup]` macro must be called after all the classes have been defined.");
-    // }
-    //
-    // state.classes.insert(ident.to_string(), class);
+    Ok((
+        quote! {
+            #input
 
-    Ok(quote! {
-        #input
-
-        ::ext_php_rs::class_derives!(#ident);
-    })
+            ::ext_php_rs::class_derives!(#ident);
+        },
+        class,
+    ))
 }
 
 #[derive(Debug)]

crates/macros/src/lib.rs

@@ -60,7 +60,7 @@ pub fn php_class(args: TokenStream, input: TokenStream) -> TokenStream {
     let input = parse_macro_input!(input as ItemStruct);
 
     match class::parser(args, input) {
-        Ok(parsed) => parsed,
+        Ok((parsed, _)) => parsed,
         Err(e) => syn::Error::new(Span::call_site(), e).to_compile_error(),
     }
     .into()

crates/macros/src/module.rs

@@ -46,6 +46,16 @@ pub fn parser(input: ItemMod) -> Result<TokenStream> {
                 builder.add_constant(c.clone());
                 continue;
             }
+            Item::Struct(s) => {
+                if s.attrs
+                    .iter()
+                    .find(|a| a.path.is_ident("php_class"))
+                    .is_some()
+                {
+                    builder.add_class(s.clone());
+                    continue;
+                }
+            }
             _ => {}
         }
         builder.add_unmapped(item.clone());

crates/macros/src/module_builder.rs

@@ -3,12 +3,15 @@ use darling::FromMeta;
 use proc_macro2::{Span, TokenStream};
 use quote::quote;
 use syn::{
-    spanned::Spanned as _, Attribute, AttributeArgs, Ident, Item, ItemConst, ItemFn, NestedMeta,
+    spanned::Spanned as _, Attribute, AttributeArgs, Ident, Item, ItemConst, ItemFn, ItemStruct,
+    NestedMeta,
 };
 
 use crate::{
+    class::{self, Class},
     constant::{self, Constant},
     function::{self, Function},
+    module::generate_registered_class_impl,
     startup_function,
 };
 
@@ -17,6 +20,7 @@ pub(crate) struct ModuleBuilder {
     pub functions: Vec<ItemFn>,
     pub startup_function: Option<ItemFn>,
     pub constants: Vec<ItemConst>,
+    pub classes: Vec<ItemStruct>,
     pub unmapped: Vec<Item>,
 }
 
@@ -37,27 +41,39 @@ impl ModuleBuilder {
         self.constants.push(constant);
     }
 
+    pub fn add_class(&mut self, class: ItemStruct) {
+        self.classes.push(class);
+    }
+
     pub fn add_unmapped(&mut self, item: Item) {
         self.unmapped.push(item);
     }
 
     pub fn build(&self) -> TokenStream {
+        let (class_stream, classes) = self.build_classes();
         let (function_stream, functions) = self.build_functions();
         let (constant_stream, constants) = self.build_constants();
-        let (startup_function, startup_ident) = self.build_startup_function(&constants).unwrap();
+        let (startup_function, startup_ident) =
+            self.build_startup_function(&classes, &constants).unwrap();
 
         let functions = functions
             .iter()
             .map(|func| func.get_builder())
             .collect::<Vec<_>>();
+        let registered_classes_impls = classes
+            .iter()
+            .map(|class| generate_registered_class_impl(class))
+            .collect::<Result<Vec<_>, _>>()
+            .unwrap();
         let unmapped = &self.unmapped;
 
         // let describe_fn = generate_stubs(&state);
 
         quote! {
-            // #(#registered_classes_impls)*
 
             mod module {
+                #class_stream
+                #(#registered_classes_impls)*
                 #function_stream
                 #constant_stream
                 #startup_function
@@ -128,20 +144,47 @@ impl ModuleBuilder {
         )
     }
 
-    fn build_startup_function(&self, constants: &Vec<Constant>) -> Result<(TokenStream, Ident)> {
+    fn build_classes(&self) -> (TokenStream, Vec<Class>) {
+        let structs = self
+            .classes
+            .iter()
+            .map(|class| {
+                let args = class
+                    .attrs
+                    .iter()
+                    .find(|attr| attr.path.is_ident("php_class"));
+                let args = parse_metadata(args.unwrap());
+                class::parser(args, class.clone())
+            })
+            .collect::<Result<Vec<_>, _>>()
+            .unwrap();
+
+        let tokens = structs.iter().map(|(tokens, _)| tokens);
+
+        (
+            quote! { #(#tokens)* },
+            structs.into_iter().map(|(_, c)| c).collect(),
+        )
+    }
+
+    fn build_startup_function(
+        &self,
+        classes: &Vec<Class>,
+        constants: &Vec<Constant>,
+    ) -> Result<(TokenStream, Ident)> {
         self.startup_function
             .as_ref()
             .map(|f| {
                 let attr = f.attrs.iter().find(|a| a.path.is_ident("php_startup"));
                 let args = parse_attr(attr.unwrap()).unwrap();
-                startup_function::parser(Some(args), f, constants)
+                startup_function::parser(Some(args), f, classes, constants)
             })
             .unwrap_or_else(|| {
                 let parsed = syn::parse2(quote! {
                     fn php_module_startup() {}
                 })
                 .map_err(|_| anyhow!("Unable to generate PHP module startup function."))?;
-                startup_function::parser(None, &parsed, constants)
+                startup_function::parser(None, &parsed, classes, constants)
             })
     }
 }

crates/macros/src/startup_function.rs

@@ -17,6 +17,7 @@ pub(crate) struct StartupArgs {
 pub fn parser(
     args: Option<StartupArgs>,
     input: &ItemFn,
+    classes: &Vec<Class>,
     constants: &Vec<Constant>,
 ) -> Result<(TokenStream, Ident)> {
     let args = args.unwrap_or_default();
@@ -25,7 +26,7 @@ pub fn parser(
     let Signature { ident, .. } = sig;
     let stmts = &block.stmts;
 
-    // let classes = build_classes(&state.classes)?;
+    let classes = build_classes(classes)?;
     let constants = build_constants(&constants);
     let (before, after) = if args.before {
         (Some(quote! { internal(ty, module_number); }), None)
@@ -46,7 +47,7 @@ pub fn parser(
             ::ext_php_rs::internal::ext_php_rs_startup();
 
             #before
-            // #(#classes)*
+            #(#classes)*
             #(#constants)*
             #after
 
@@ -58,13 +59,13 @@ pub fn parser(
 }
 
 /// Returns a vector of `ClassBuilder`s for each class.
-fn build_classes(classes: &HashMap<String, Class>) -> Result<Vec<TokenStream>> {
+fn build_classes(classes: &Vec<Class>) -> Result<Vec<TokenStream>> {
     classes
         .iter()
-        .map(|(name, class)| {
+        .map(|class| {
             let Class { class_name, .. } = &class;
-            let ident = Ident::new(name, Span::call_site());
-            let meta = Ident::new(&format!("_{name}_META"), Span::call_site());
+            let ident = Ident::new(&class.name, Span::call_site());
+            let meta = Ident::new(&format!("_{}_META", ident), Span::call_site());
             let methods = class.methods.iter().map(|method| {
                 let builder = method.get_builder(&ident);
                 let flags = method.get_flags();