feat: Change const registration for interface

Author: Norbytus

crates/macros/src/interface.rs

@@ -34,48 +34,9 @@ pub fn parser(mut input: ItemTrait) -> Result<TokenStream> {
     let name = attr.rename.rename(ident.to_string(), RenameRule::Pascal);
     input.attrs.clean_php();
 
-    let methods: Vec<FnBuilder> = input
-        .items
-        .iter_mut()
-        .flat_map(|item: &mut TraitItem| match item {
-            TraitItem::Fn(f) => Some(f),
-            _ => None,
-        })
-        .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 methods: Vec<FnBuilder> = input.parse()?;
 
-    let impl_const: Vec<&TraitItemConst> = input
-        .items
-        .iter()
-        .flat_map(|item| match item {
-            TraitItem::Const(c) => Some(c),
-            _ => None,
-        })
-        .flat_map(|c| {
-            if c.default.is_none() {
-                bail!("Interface const cannot be empty");
-            }
-            Ok(c)
-        })
-        .collect();
+    let constants: Vec<Constant> = input.parse()?;
 
     let implements = attr.extends;
 
@@ -84,10 +45,6 @@ pub fn parser(mut input: ItemTrait) -> Result<TokenStream> {
 
         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;
 
@@ -153,7 +110,7 @@ pub fn parser(mut input: ItemTrait) -> Result<TokenStream> {
                 }
 
                 fn get_constants(self) -> &'static [(&'static str, &'static dyn ::ext_php_rs::convert::IntoZvalDyn, &'static [&'static str])] {
-                    &[#(#constants),*]
+                    &[]
                 }
             }
 
@@ -242,6 +199,33 @@ trait Parse<'a, T> {
     fn parse(&'a mut self) -> Result<T>;
 }
 
+impl<'a> Parse<'a, Vec<FnBuilder>> for ItemTrait {
+    fn parse(&'a mut self) -> Result<Vec<FnBuilder>> {
+    Ok(self
+        .items
+        .iter_mut()
+        .filter_map(|item: &mut TraitItem| match item {
+            TraitItem::Fn(f) => Some(f),
+            _ => None,
+        })
+        .flat_map(Parse::parse)
+        .collect())
+    }
+}
+
+impl<'a> Parse<'a, Vec<Constant<'a>>> for ItemTrait {
+    fn parse(&'a mut self) -> Result<Vec<Constant<'a>>> {
+        Ok(self.items
+        .iter_mut()
+        .filter_map(|item: &mut TraitItem| match item {
+            TraitItem::Const(c) => Some(c),
+            _ => None,
+        })
+        .flat_map(Parse::parse)
+        .collect())
+    }
+}
+
 impl<'a> Parse<'a, Constant<'a>> for TraitItemConst {
     fn parse(&'a mut self) -> Result<Constant<'a>> {
         let attr = PhpConstAttribute::from_attributes(&self.attrs)?;

src/builders/class.rs

@@ -381,46 +381,6 @@ impl ClassBuilder {
     }
 }
 
-pub struct InterfaceBuilder {
-    class_builder: ClassBuilder,
-}
-
-impl InterfaceBuilder {
-    pub fn new<T: Into<String>>(name: T) -> Self {
-        Self {
-            class_builder: ClassBuilder::new(name),
-        }
-    }
-
-    pub fn implements(mut self, interface: ClassEntryInfo) -> Self {
-        self.class_builder = self.class_builder.implements(interface);
-
-        self
-    }
-
-    pub fn method(mut self, func: FunctionBuilder<'static>, flags: MethodFlags) -> Self {
-        self.class_builder = self.class_builder.method(func, flags);
-
-        self
-    }
-
-    pub fn dyn_constant<T: Into<String>>(
-        mut self,
-        name: T,
-        value: &'static dyn IntoZvalDyn,
-        docs: DocComments,
-    ) -> Result<Self> {
-        self.class_builder = self.class_builder.dyn_constant(name, value, docs)?;
-
-        Ok(self)
-    }
-
-    pub fn builder(mut self) -> ClassBuilder {
-        self.class_builder = self.class_builder.flags(ClassFlags::Interface);
-        self.class_builder
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use crate::test::test_function;

src/builders/interface.rs

@@ -0,0 +1,45 @@
+use crate::builders::FunctionBuilder;
+use crate::flags::{ClassFlags, MethodFlags};
+use crate::{builders::ClassBuilder, class::ClassEntryInfo, convert::IntoZvalDyn, describe::DocComments};
+use crate::error::Result;
+
+pub struct InterfaceBuilder {
+    class_builder: ClassBuilder,
+}
+
+impl InterfaceBuilder {
+    pub fn new<T: Into<String>>(name: T) -> Self {
+        Self {
+            class_builder: ClassBuilder::new(name),
+        }
+    }
+
+    pub fn implements(mut self, interface: ClassEntryInfo) -> Self {
+        self.class_builder = self.class_builder.implements(interface);
+
+        self
+    }
+
+    pub fn method(mut self, func: FunctionBuilder<'static>, flags: MethodFlags) -> Self {
+        self.class_builder = self.class_builder.method(func, flags);
+
+        self
+    }
+
+    pub fn dyn_constant<T: Into<String>>(
+        mut self,
+        name: T,
+        value: &'static dyn IntoZvalDyn,
+        docs: DocComments,
+    ) -> Result<Self> {
+        self.class_builder = self.class_builder.dyn_constant(name, value, docs)?;
+
+        Ok(self)
+    }
+
+    pub fn builder(mut self) -> ClassBuilder {
+        self.class_builder = self.class_builder.flags(ClassFlags::Interface);
+        self.class_builder
+    }
+}
+

src/builders/mod.rs

@@ -5,6 +5,7 @@ mod class;
 #[cfg(feature = "enum")]
 mod enum_builder;
 mod function;
+mod interface;
 #[cfg(all(php82, feature = "embed"))]
 mod ini;
 mod module;

src/builders/module.rs

@@ -2,7 +2,7 @@ use std::{convert::TryFrom, ffi::CString, mem, ptr};
 
 use super::{ClassBuilder, FunctionBuilder};
 use crate::{
-    builders::class::InterfaceBuilder,
+    builders::interface::InterfaceBuilder,
     class::RegisteredClass,
     constant::IntoConst,
     describe::DocComments,

src/interface.rs

@@ -0,0 +1,5 @@
+use crate::{convert::IntoZval, describe::DocComments};
+
+pub trait RegisteredInterface {
+    fn constants() -> &'static [(&'static str, &'static impl IntoZval, DocComments)];
+}

src/lib.rs

@@ -21,6 +21,7 @@ pub mod flags;
 pub mod macros;
 pub mod boxed;
 pub mod class;
+pub mod interface;
 #[cfg(any(docs, feature = "closure"))]
 #[cfg_attr(docs, doc(cfg(feature = "closure")))]
 pub mod closure;