chore: More php_interface proc attribute macro

chore: Add pub in impl_

Author: Norbytus

crates/macros/src/impl_.rs

@@ -62,15 +62,15 @@ impl RenameRule {
 
 /// Method visibilities.
 #[derive(Debug)]
-enum MethodVis {
+pub enum MethodVis {
     Public,
     Private,
     Protected,
 }
 
 /// Method types.
 #[derive(Debug)]
-enum MethodTy {
+pub enum MethodTy {
     /// Regular PHP method.
     Normal,
     /// Constructor method.
@@ -122,21 +122,21 @@ pub fn parser(args: TokenStream, mut input: ItemImpl) -> Result<TokenStream> {
 
 /// Arguments applied to methods.
 #[derive(Debug)]
-struct MethodArgs {
+pub struct MethodArgs {
     /// Method name. Only applies to PHP (not the Rust method name).
-    name: String,
+    pub name: String,
     /// The first optional argument of the function signature.
-    optional: Option<Ident>,
+    pub optional: Option<Ident>,
     /// Default values for optional arguments.
-    defaults: HashMap<Ident, Lit>,
+    pub defaults: HashMap<Ident, Lit>,
     /// Visibility of the method (public, protected, private).
-    vis: MethodVis,
+    pub vis: MethodVis,
     /// Method type.
-    ty: MethodTy,
+    pub ty: MethodTy,
 }
 
 impl MethodArgs {
-    fn new(name: String) -> Self {
+    pub fn new(name: String) -> Self {
         let ty = if name == "__construct" {
             MethodTy::Constructor
         } else {
@@ -151,7 +151,7 @@ impl MethodArgs {
         }
     }
 
-    fn parse(&mut self, attrs: &mut Vec<syn::Attribute>) -> Result<()> {
+    pub fn parse(&mut self, attrs: &mut Vec<syn::Attribute>) -> Result<()> {
         let mut unparsed = vec![];
         unparsed.append(attrs);
         for attr in unparsed {
@@ -216,7 +216,7 @@ struct ParsedImpl<'a> {
 }
 
 #[derive(Debug)]
-struct FnBuilder {
+pub struct FnBuilder {
     /// Tokens which represent the FunctionBuilder for this function.
     pub builder: TokenStream,
     /// The visibility of this method.
@@ -226,7 +226,7 @@ struct FnBuilder {
 }
 
 #[derive(Debug)]
-struct Constant<'a> {
+pub struct Constant<'a> {
     /// Name of the constant in PHP land.
     name: String,
     /// Identifier of the constant in Rust land.

crates/macros/src/interface.rs

@@ -1,8 +1,92 @@
-use crate::prelude::*;
+use std::collections::HashMap;
+
+use crate::{
+    function::{Args, CallType, Function, MethodReceiver},
+    helpers::get_docs,
+    impl_::{Constant, FnBuilder, MethodArgs, MethodTy},
+    prelude::*,
+};
+use darling::{ast::NestedMeta, FromMeta, ToTokens};
 use proc_macro2::TokenStream;
 use quote::quote;
-use syn::TraitItem;
+use syn::{Ident, ItemTrait, Lit, TraitItem, TraitItemFn};
+
+#[derive(Debug, Default, FromMeta)]
+#[darling(default)]
+pub struct StructArgs {
+    /// The name of the PHP interface. Defaults to the same name as the trait.
+    name: Option<String>,
+}
+
+#[derive(Debug)]
+struct ParsedTrait<'a> {
+    path: &'a syn::Path,
+    constructor: Option<Function<'a>>,
+    functions: Vec<FnBuilder>,
+    constants: Vec<Constant<'a>>,
+}
+
+impl<'a> ParsedTrait<'a> {
+    fn parse(&mut self, items: impl Iterator<Item = &'a mut syn::TraitItem>) -> Result<()> {
+        for item in items {
+            match item {
+                syn::TraitItem::Fn(method) => {
+                    let name = method.sig.ident.to_string();
+                    let docs = get_docs(&method.attrs);
+                    let mut opts = MethodArgs::new(name);
+                    opts.parse(&mut method.attrs)?;
+                    let args = Args::parse_from_fnargs(method.sig.inputs.iter(), opts.defaults)?;
+                    let mut func =
+                        Function::new(&method.sig, Some(opts.name), args, opts.optional, docs)?;
+
+                    if matches!(opts.ty, MethodTy::Constructor) {
+                        if self.constructor.replace(func).is_some() {
+                            bail!(method => "Only one constructor can be provided per class.");
+                        }
+                    } else {
+                        let call_type = CallType::Method {
+                            class: self.path,
+                            receiver: if func.args.receiver.is_some() {
+                                // `&self` or `&mut self`
+                                MethodReceiver::Class
+                            } else if func
+                                .args
+                                .typed
+                                .first()
+                                .map(|arg| arg.name == "self_")
+                                .unwrap_or_default()
+                            {
+                                // `self_: &[mut] ZendClassObject<Self>`
+                                // Need to remove arg from argument list
+                                func.args.typed.pop();
+                                MethodReceiver::ZendClassObject
+                            } else {
+                                // Static method
+                                MethodReceiver::Static
+                            },
+                        };
+                        let builder = func.function_builder(call_type)?;
+                        self.functions.push(FnBuilder {
+                            builder,
+                            vis: opts.vis,
+                            r#abstract: false,
+                        });
+                    }
+                }
+                _ => {}
+            }
+        }
+        Ok(())
+    }
+}
+
+pub fn parser(args: TokenStream, input: ItemTrait) -> Result<TokenStream> {
+    let meta = NestedMeta::parse_meta_list(args)?;
+
+    let args = match StructArgs::from_list(&meta) {
+        Ok(args) => args,
+        Err(e) => bail!("Failed to parse struct arguments: {:?}", e),
+    };
 
-pub fn parser(args: TokenStream, input: TraitItem) -> Result<TokenStream> {
-    Ok(quote! {()})
+    Ok(quote! {})
 }

crates/macros/src/lib.rs

@@ -14,7 +14,7 @@ mod zval;
 use proc_macro::TokenStream;
 use syn::{
     parse_macro_input, DeriveInput, ItemConst, ItemFn, ItemForeignMod, ItemImpl, ItemStruct,
-    TraitItem,
+    ItemTrait, TraitItem,
 };
 
 extern crate proc_macro;
@@ -213,7 +213,7 @@ pub fn php_class(args: TokenStream, input: TokenStream) -> TokenStream {
 /// ```
 #[proc_macro_attribute]
 pub fn php_interface(args: TokenStream, input: TokenStream) -> TokenStream {
-    let input = parse_macro_input!(input as TraitItem);
+    let input = parse_macro_input!(input as ItemTrait);
 
     interface::parser(args.into(), input)
         .unwrap_or_else(|e| e.to_compile_error())