feat: Add methods, const registration for interface

Author: Norbytus

crates/macros/src/class.rs

@@ -1,7 +1,7 @@
 use darling::util::Flag;
 use darling::{FromAttributes, FromMeta, ToTokens};
 use proc_macro2::TokenStream;
-use quote::quote;
+use quote::{quote, TokenStreamExt};
 use syn::{Attribute, Expr, Fields, ItemStruct};
 
 use crate::helpers::get_docs;
@@ -28,8 +28,17 @@ pub struct StructAttributes {
 
 #[derive(FromMeta, Debug)]
 pub struct ClassEntryAttribute {
-    ce: syn::Expr,
-    stub: String,
+    pub ce: syn::Expr,
+    pub stub: String,
+}
+
+impl ToTokens for ClassEntryAttribute {
+    fn to_tokens(&self, tokens: &mut TokenStream) {
+        let ce = &self.ce;
+        let stub = &self.stub;
+        let token = quote! { (#ce, #stub) };
+        tokens.append_all(token);
+    }
 }
 
 pub fn parser(mut input: ItemStruct) -> Result<TokenStream> {
@@ -157,10 +166,8 @@ fn generate_registered_class_impl(
     };
 
     let extends = if let Some(extends) = extends {
-        let ce = &extends.ce;
-        let stub = &extends.stub;
         quote! {
-            Some((#ce, #stub))
+            Some(#extends)
         }
     } else {
         quote! { None }

crates/macros/src/function.rs

@@ -131,6 +131,41 @@ impl<'a> Function<'a> {
         format_ident!("_internal_{}", &self.ident)
     }
 
+    pub fn abstract_function_builder(&self) -> TokenStream {
+        let name = &self.name;
+        let (required, not_required) = self.args.split_args(self.optional.as_ref());
+
+        // `entry` impl
+        let required_args = required
+            .iter()
+            .map(TypedArg::arg_builder)
+            .collect::<Vec<_>>();
+        let not_required_args = not_required
+            .iter()
+            .map(TypedArg::arg_builder)
+            .collect::<Vec<_>>();
+
+        let returns = self.build_returns();
+        let docs = if self.docs.is_empty() {
+            quote! {}
+        } else {
+            let docs = &self.docs;
+            quote! {
+                .docs(&[#(#docs),*])
+            }
+        };
+
+        quote! {
+            ::ext_php_rs::builders::FunctionBuilder::new_abstract(#name)
+            #(.arg(#required_args))*
+            .not_required()
+            #(.arg(#not_required_args))*
+            #returns
+            #docs
+        }
+
+    }
+
     /// Generates the function builder for the function.
     pub fn function_builder(&self, call_type: CallType) -> TokenStream {
         let name = &self.name;

crates/macros/src/impl_.rs

@@ -125,7 +125,7 @@ struct ParsedImpl<'a> {
 }
 
 #[derive(Debug, Eq, Hash, PartialEq)]
-enum MethodModifier {
+pub enum MethodModifier {
     Abstract,
     Static,
 }
@@ -141,7 +141,7 @@ impl quote::ToTokens for MethodModifier {
 }
 
 #[derive(Debug)]
-struct FnBuilder {
+pub struct FnBuilder {
     /// Tokens which represent the `FunctionBuilder` for this function.
     pub builder: TokenStream,
     /// The visibility of this method.
@@ -151,13 +151,19 @@ struct FnBuilder {
 }
 
 #[derive(Debug)]
-struct Constant<'a> {
+pub struct Constant<'a> {
     /// Name of the constant in PHP land.
-    name: String,
+    pub name: String,
     /// Identifier of the constant in Rust land.
-    ident: &'a syn::Ident,
+    pub ident: &'a syn::Ident,
     /// Documentation for the constant.
-    docs: Vec<String>,
+    pub docs: Vec<String>,
+}
+
+impl<'a> Constant<'a> {
+    pub fn new(name: String, ident: &'a syn::Ident, docs: Vec<String>) -> Self {
+        Self {name, ident, docs}
+    }
 }
 
 impl<'a> ParsedImpl<'a> {

crates/macros/src/interface.rs

@@ -1,45 +1,94 @@
+use std::collections::{HashMap, HashSet};
+
+use darling::util::Flag;
 use darling::{FromAttributes};
 use proc_macro2::TokenStream;
 use quote::{format_ident, quote};
-use syn::{ItemTrait, TraitItem, TraitItemFn};
-use crate::helpers::CleanPhpAttr;
+use syn::{Expr, Ident, ItemTrait, Path, TraitItem, TraitItemConst, TraitItemFn};
+use crate::class::ClassEntryAttribute;
+use crate::constant::PhpConstAttribute;
+use crate::function::{Args, Function};
+use crate::helpers::{get_docs, CleanPhpAttr};
 
-use crate::parsing::{PhpRename, RenameRule};
+use crate::impl_::{Constant, FnBuilder, MethodModifier};
+use crate::parsing::{PhpRename, RenameRule, Visibility};
 use crate::prelude::*;
 
 #[derive(FromAttributes, Debug, Default)]
 #[darling(attributes(php), forward_attrs(doc), default)]
 pub struct StructAttributes {
     #[darling(flatten)]
     rename: PhpRename,
+    #[darling(multiple)]
+    extends: Vec<ClassEntryAttribute>,
 }
 
 pub fn parser(mut input: ItemTrait) -> Result<TokenStream> {
     let attr = StructAttributes::from_attributes(&input.attrs)?;
     let ident = &input.ident;
 
     let interface_name = format_ident!("PhpInterface{ident}");
+    let ts = quote! { #interface_name };
+    let path: Path = syn::parse2(ts)?;
+
     let name = attr.rename.rename(ident.to_string(), RenameRule::Pascal);
     input.attrs.clean_php();
 
-    let mut interface_methods: Vec<TraitItemFn> = Vec::new();
-    for i in input.items.clone().into_iter() {
-        match i {
-            TraitItem::Fn(f) => {
-                if f.default.is_some() {
-                    bail!("Interface could not have default impl");
+    let methods: Vec<FnBuilder> = input.items.iter_mut()
+        .flat_map(
+            |item: &mut TraitItem| {
+                match item {
+                    TraitItem::Fn(f) => Some(f),
+                    _ => None,
                 }
-                interface_methods.push(f);
+            })
+        .flat_map(|f| f.parse())
+        .collect();
+
+    let constants: Vec<_> = input.items.iter_mut()
+        .flat_map(|item: &mut TraitItem| {
+            match item {
+                TraitItem::Const(c) => Some(c),
+                _ => None,
             }
-            _ => {}
+        })
+        .flat_map(|c| c.parse())
+        .map(|c| {
+            let name = &c.name;
+            let ident = c.ident;
+            let docs = &c.docs;
+            quote! {
+                (#name, &#path::#ident, &[#(#docs),*])
+            }
+        })
+        .collect();
+
+    let impl_const: Vec<&TraitItemConst> = input.items.iter().flat_map(|item| {
+        match item {
+            TraitItem::Const(c) => Some(c),
+            _ => None,
         }
-    };
+    })
+    .map(|c| {
+            if c.default.is_none() {
+                bail!("Interface const canot be empty");
+            }
+            Ok(c)
+        })
+        .flat_map(|c| c)
+        .collect();
+
+    let implements = attr.extends;
 
     Ok(quote! {
         #input
 
         pub struct #interface_name;
 
+        impl #interface_name {
+            #(pub #impl_const)*
+        }
+
         impl ::ext_php_rs::class::RegisteredClass for #interface_name {
             const CLASS_NAME: &'static str = #name;
 
@@ -51,7 +100,9 @@ pub fn parser(mut input: ItemTrait) -> Result<TokenStream> {
 
             const FLAGS: ::ext_php_rs::flags::ClassFlags = ::ext_php_rs::flags::ClassFlags::Interface;
 
-            const IMPLEMENTS: &'static [::ext_php_rs::class::ClassEntryInfo] = &[];
+            const IMPLEMENTS: &'static [::ext_php_rs::class::ClassEntryInfo] = &[
+                #(#implements,)*
+            ];
 
             fn get_metadata() -> &'static ::ext_php_rs::class::ClassMetadata<Self> {
                 static METADATA: ::ext_php_rs::class::ClassMetadata<#interface_name> =
@@ -64,7 +115,7 @@ pub fn parser(mut input: ItemTrait) -> Result<TokenStream> {
                 ::ext_php_rs::builders::FunctionBuilder<'static>,
                 ::ext_php_rs::flags::MethodFlags,
             )> {
-                vec![ ]
+                vec![#(#methods),*]
             }
 
             fn constructor() -> Option<::ext_php_rs::class::ConstructorMeta<Self>> {
@@ -76,14 +127,37 @@ pub fn parser(mut input: ItemTrait) -> Result<TokenStream> {
                 &'static dyn ext_php_rs::convert::IntoZvalDyn,
                 ext_php_rs::describe::DocComments,
             )] {
-                &[]
+                use ::ext_php_rs::internal::class::PhpClassImpl;
+                ::ext_php_rs::internal::class::PhpClassImplCollector::<Self>::default().get_constants()
             }
 
             fn get_properties<'a>() -> std::collections::HashMap<&'static str, ::ext_php_rs::internal::property::PropertyInfo<'a, Self>> {
                 HashMap::new()
             }
 
         }
+            impl ::ext_php_rs::internal::class::PhpClassImpl<#path>
+                for ::ext_php_rs::internal::class::PhpClassImplCollector<#path>
+            {
+                fn get_methods(self) -> ::std::vec::Vec<
+                    (::ext_php_rs::builders::FunctionBuilder<'static>, ::ext_php_rs::flags::MethodFlags)
+                > {
+                    vec![]
+                }
+
+                fn get_method_props<'a>(self) -> ::std::collections::HashMap<&'static str, ::ext_php_rs::props::Property<'a, #path>> {
+                    todo!()
+                }
+
+                fn get_constructor(self) -> ::std::option::Option<::ext_php_rs::class::ConstructorMeta<#path>> {
+                    None
+                }
+
+                fn get_constants(self) -> &'static [(&'static str, &'static dyn ::ext_php_rs::convert::IntoZvalDyn, &'static [&'static str])] {
+                    &[#(#constants),*]
+                }
+            }
+
 
         impl<'a> ::ext_php_rs::convert::FromZendObject<'a> for &'a #interface_name {
             #[inline]
@@ -150,3 +224,75 @@ pub fn parser(mut input: ItemTrait) -> Result<TokenStream> {
         }
     })
 }
+
+#[derive(FromAttributes, Default, Debug)]
+#[darling(default, attributes(php), forward_attrs(doc))]
+pub struct PhpFunctionInterfaceAttribute {
+    #[darling(flatten)]
+    rename: PhpRename,
+    defaults: HashMap<Ident, Expr>,
+    optional: Option<Ident>,
+    vis: Option<Visibility>,
+    attrs: Vec<syn::Attribute>,
+    getter: Flag,
+    setter: Flag,
+    constructor: Flag,
+}
+
+trait Parse<'a, T> {
+    fn parse(&'a mut self) -> Result<T>;
+}
+
+impl<'a> Parse<'a, Constant<'a>> for TraitItemConst {
+    fn parse(&'a mut self) -> Result<Constant<'a>> {
+        let attr = PhpConstAttribute::from_attributes(&self.attrs)?;
+        let name = self.ident.to_string();
+        let docs = get_docs(&attr.attrs)?;
+        self.attrs.clean_php();
+
+        Ok(Constant::new(name, &self.ident, docs))
+    }
+}
+
+impl<'a> Parse<'a, FnBuilder> for TraitItemFn {
+    fn parse(&'a mut self) -> Result<FnBuilder> {
+        let php_attr = PhpFunctionInterfaceAttribute::from_attributes(
+            &self.attrs
+        )?;
+        if self.default.is_some() {
+            bail!("Interface could not have default impl");
+        }
+
+        let mut args = Args::parse_from_fnargs(
+            self.sig.inputs.iter(),
+            php_attr.defaults
+        )?;
+        let docs = get_docs(&php_attr.attrs)?;
+
+        self.attrs.clean_php();
+
+        let mut modifiers: HashSet<MethodModifier> = HashSet::new();
+        modifiers.insert(MethodModifier::Abstract);
+        if args.typed.first().is_some_and(|arg| arg.name == "self_") {
+            args.typed.pop();
+        } else if args.receiver.is_none() {
+            modifiers.insert(MethodModifier::Static);
+        };
+
+        let f = Function::new(
+            &self.sig,
+            php_attr
+                .rename
+                .rename(self.sig.ident.to_string(), RenameRule::Camel),
+            args,
+            php_attr.optional,
+            docs,
+        );
+
+        Ok(FnBuilder {
+            builder: f.abstract_function_builder(),
+            vis: php_attr.vis.unwrap_or(Visibility::Public),
+            modifiers,
+        })
+    }
+}