Explicit preparation phase without STATE

crates/cli/.gitignore

@@ -0,0 +1,6 @@
+/target
+Cargo.lock
+/.vscode
+/.idea
+/tmp
+expand.rs

crates/macros/.gitignore

@@ -0,0 +1,6 @@
+/target
+Cargo.lock
+/.vscode
+/.idea
+/tmp
+expand.rs

crates/macros/src/class.rs

@@ -41,10 +41,7 @@ pub struct AttrArgs {
     flags: Option<Expr>,
 }
 
-pub fn parser(args: AttributeArgs, mut input: ItemStruct) -> Result<TokenStream> {
-    let args = AttrArgs::from_list(&args)
-        .map_err(|e| anyhow!("Unable to parse attribute arguments: {:?}", e))?;
-
+fn prepare(args: AttrArgs, mut input: ItemStruct) -> Result<(TokenStream, Class)> {
     let mut parent = None;
     let mut interfaces = vec![];
     let mut properties = HashMap::new();
@@ -132,6 +129,23 @@ pub fn parser(args: AttributeArgs, mut input: ItemStruct) -> Result<TokenStream>
         ..Default::default()
     };
 
+    Ok((
+        quote! {
+            #input
+
+            ::ext_php_rs::class_derives!(#ident);
+        },
+        class,
+    ))
+}
+
+pub fn parser(args: AttributeArgs, input: ItemStruct) -> Result<TokenStream> {
+    let args = AttrArgs::from_list(&args)
+        .map_err(|e| anyhow!("Unable to parse attribute arguments: {:?}", e))?;
+
+    let ident = &input.ident.clone();
+    let (tokens, class) = prepare(args, input)?;
+
     let mut state = STATE.lock();
 
     if state.built_module {
@@ -144,11 +158,7 @@ pub fn parser(args: AttributeArgs, mut input: ItemStruct) -> Result<TokenStream>
 
     state.classes.insert(ident.to_string(), class);
 
-    Ok(quote! {
-        #input
-
-        ::ext_php_rs::class_derives!(#ident);
-    })
+    Ok(tokens)
 }
 
 #[derive(Debug)]

crates/macros/src/constant.rs

@@ -15,6 +15,13 @@ pub struct Constant {
     pub value: String,
 }
 
+fn prepare(input: ItemConst) -> Result<TokenStream> {
+    Ok(quote! {
+        #[allow(dead_code)]
+        #input
+    })
+}
+
 pub fn parser(input: ItemConst) -> Result<TokenStream> {
     let mut state = STATE.lock();
 
@@ -28,10 +35,7 @@ pub fn parser(input: ItemConst) -> Result<TokenStream> {
         value: input.expr.to_token_stream().to_string(),
     });
 
-    Ok(quote! {
-        #[allow(dead_code)]
-        #input
-    })
+    prepare(input)
 }
 
 impl Constant {

crates/macros/src/function.rs

@@ -40,12 +40,7 @@ pub struct Function {
     pub output: Option<(String, bool)>,
 }
 
-pub fn parser(args: AttributeArgs, input: ItemFn) -> Result<(TokenStream, Function)> {
-    let attr_args = match AttrArgs::from_list(&args) {
-        Ok(args) => args,
-        Err(e) => bail!("Unable to parse attribute arguments: {:?}", e),
-    };
-
+fn prepare(attr_args: AttrArgs, input: ItemFn) -> Result<(TokenStream, Function)> {
     let ItemFn { sig, .. } = &input;
     let Signature {
         ident,
@@ -89,24 +84,41 @@ pub fn parser(args: AttributeArgs, input: ItemFn) -> Result<(TokenStream, Functi
         }
     };
 
-    let mut state = STATE.lock();
-
-    if state.built_module && !attr_args.ignore_module {
-        bail!("The `#[php_module]` macro must be called last to ensure functions are registered. To ignore this error, pass the `ignore_module` option into this attribute invocation: `#[php_function(ignore_module)]`");
-    }
+    let name = if let Some(name) = attr_args.name {
+        name
+    } else {
+        ident.to_string()
+    };
 
     let function = Function {
-        name: attr_args.name.unwrap_or_else(|| ident.to_string()),
+        name,
         docs: get_docs(&input.attrs),
         ident: internal_ident.to_string(),
         args,
         optional,
         output: return_type,
     };
 
+    Ok((func, function))
+}
+
+pub fn parser(args: AttributeArgs, input: ItemFn) -> Result<TokenStream> {
+    let attr_args = match AttrArgs::from_list(&args) {
+        Ok(args) => args,
+        Err(e) => bail!("Unable to parse attribute arguments: {:?}", e),
+    };
+    let ignore_module = attr_args.ignore_module;
+    let (func, function) = prepare(attr_args, input)?;
+
+    let mut state = STATE.lock();
+
+    if state.built_module && !ignore_module {
+        bail!("The `#[php_module]` macro must be called last to ensure functions are registered. To ignore this error, pass the `ignore_module` option into this attribute invocation: `#[php_function(ignore_module)]`");
+    }
+
     state.functions.push(function.clone());
 
-    Ok((func, function))
+    Ok(func)
 }
 
 fn build_args(

crates/macros/src/impl_.rs

@@ -5,6 +5,7 @@ use quote::quote;
 use std::collections::HashMap;
 use syn::{Attribute, AttributeArgs, ItemImpl, Lit, Meta, NestedMeta};
 
+use crate::class::Class;
 use crate::helpers::get_docs;
 use crate::{
     class::{Property, PropertyAttr},
@@ -94,31 +95,14 @@ pub enum PropAttrTy {
     Setter,
 }
 
-pub fn parser(args: AttributeArgs, input: ItemImpl) -> Result<TokenStream> {
-    let args = AttrArgs::from_list(&args)
-        .map_err(|e| anyhow!("Unable to parse attribute arguments: {:?}", e))?;
-
+// note: this takes a mutable argument as it mutates a class
+fn prepare(args: AttrArgs, input: ItemImpl, class: &mut Class) -> Result<TokenStream> {
     let ItemImpl { self_ty, items, .. } = input;
-    let class_name = self_ty.to_token_stream().to_string();
 
     if input.trait_.is_some() {
         bail!("This macro cannot be used on trait implementations.");
     }
 
-    let mut state = crate::STATE.lock();
-
-    if state.startup_function.is_some() {
-        bail!(
-            "Impls must be declared before you declare your startup function and module function."
-        );
-    }
-
-    let class = state.classes.get_mut(&class_name).ok_or_else(|| {
-        anyhow!(
-            "You must use `#[php_class]` on the struct before using this attribute on the impl."
-        )
-    })?;
-
     let tokens = items
         .into_iter()
         .map(|item| {
@@ -178,6 +162,29 @@ pub fn parser(args: AttributeArgs, input: ItemImpl) -> Result<TokenStream> {
     Ok(output)
 }
 
+pub fn parser(args: AttributeArgs, input: ItemImpl) -> Result<TokenStream> {
+    let args = AttrArgs::from_list(&args)
+        .map_err(|e| anyhow!("Unable to parse attribute arguments: {:?}", e))?;
+
+    let mut state = crate::STATE.lock();
+
+    if state.startup_function.is_some() {
+        bail!(
+            "Impls must be declared before you declare your startup function and module function."
+        );
+    }
+
+    let class_name = input.self_ty.to_token_stream().to_string();
+
+    let class = state.classes.get_mut(&class_name).ok_or_else(|| {
+        anyhow!(
+            "You must use `#[php_class]` on the struct before using this attribute on the impl."
+        )
+    })?;
+
+    prepare(args, input, class)
+}
+
 pub fn parse_attribute(attr: &Attribute) -> Result<Option<ParsedAttribute>> {
     let name = attr.path.to_token_stream().to_string();
     let meta = attr

crates/macros/src/lib.rs

@@ -69,7 +69,7 @@ pub fn php_function(args: TokenStream, input: TokenStream) -> TokenStream {
     let input = parse_macro_input!(input as ItemFn);
 
     match function::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

@@ -1,5 +1,3 @@
-use std::sync::MutexGuard;
-
 use anyhow::{anyhow, bail, Result};
 use proc_macro2::{Ident, Span, TokenStream};
 use quote::quote;
@@ -11,56 +9,36 @@ use crate::{
     startup_function, State, STATE,
 };
 
-pub fn parser(input: ItemFn) -> Result<TokenStream> {
+fn prepare<'a>(
+    input: ItemFn,
+    functions: &[Function],
+    startup_fn: Option<&TokenStream>,
+    startup_function_name: Option<&str>,
+    classes: impl Iterator<Item = &'a Class>,
+    describe: &TokenStream,
+) -> Result<TokenStream> {
     let ItemFn { sig, block, .. } = input;
     let Signature { output, inputs, .. } = sig;
     let stmts = &block.stmts;
 
-    let mut state = STATE.lock();
-
-    if state.built_module {
-        bail!("You may only define a module with the `#[php_module]` attribute once.");
-    }
-
-    state.built_module = true;
-
     // Generate startup function if one hasn't already been tagged with the macro.
-    let startup_fn = if (!state.classes.is_empty() || !state.constants.is_empty())
-        && state.startup_function.is_none()
-    {
-        drop(state);
-
-        let parsed = syn::parse2(quote! {
-            fn php_module_startup() {}
-        })
-        .map_err(|_| anyhow!("Unable to generate PHP module startup function."))?;
-        let startup = startup_function::parser(None, parsed)?;
 
-        state = STATE.lock();
-        Some(startup)
-    } else {
-        None
-    };
-
-    let functions = state
-        .functions
+    let functions = functions
         .iter()
         .map(|func| func.get_builder())
         .collect::<Vec<_>>();
-    let startup = state.startup_function.as_ref().map(|ident| {
+    let startup = startup_function_name.as_ref().map(|ident| {
         let ident = Ident::new(ident, Span::call_site());
         quote! {
             .startup_function(#ident)
         }
     });
-    let registered_classes_impls = state
-        .classes
-        .values()
+    let registered_classes_impls = classes
         .map(generate_registered_class_impl)
         .collect::<Result<Vec<_>>>()?;
-    let describe_fn = generate_stubs(&state);
+    let describe_fn = generate_stubs(describe);
 
-    let result = quote! {
+    Ok(quote! {
         #(#registered_classes_impls)*
 
         #startup_fn
@@ -90,8 +68,46 @@ pub fn parser(input: ItemFn) -> Result<TokenStream> {
         }
 
         #describe_fn
+    })
+}
+
+fn prepare_startup() -> Result<TokenStream> {
+    let parsed = syn::parse2(quote! {
+        fn php_module_startup() {}
+    })
+    .map_err(|_| anyhow!("Unable to generate PHP module startup function."))?;
+    startup_function::parser(None, parsed)
+}
+
+pub fn parser(input: ItemFn) -> Result<TokenStream> {
+    let mut state = STATE.lock();
+
+    if state.built_module {
+        bail!("You may only define a module with the `#[php_module]` attribute once.");
+    }
+
+    state.built_module = true;
+
+    // Generate startup function if one hasn't already been tagged with the macro.
+    let startup_fn = if (!state.classes.is_empty() || !state.constants.is_empty())
+        && state.startup_function.is_none()
+    {
+        drop(state);
+        let prepared = prepare_startup()?;
+        state = STATE.lock();
+        Some(prepared)
+    } else {
+        None
     };
-    Ok(result)
+
+    prepare(
+        input,
+        &state.functions,
+        startup_fn.as_ref(),
+        state.startup_function.as_deref(),
+        state.classes.values(),
+        &state.describe(),
+    )
 }
 
 /// Generates an implementation for `RegisteredClass` on the given class.
@@ -151,9 +167,7 @@ pub trait Describe {
     fn describe(&self) -> TokenStream;
 }
 
-fn generate_stubs(state: &MutexGuard<State>) -> TokenStream {
-    let module = state.describe();
-
+fn generate_stubs(module: &TokenStream) -> TokenStream {
     quote! {
         #[cfg(debug_assertions)]
         #[no_mangle]