feat(enum): implement IntoZval and FromZval for enums

Refs: #178

Author: Xenira

Cargo.toml

@@ -25,7 +25,7 @@ skeptic = "0.13"
 
 [build-dependencies]
 anyhow = "1"
-bindgen = "0.68.1"
+bindgen = "0.70"
 cc = "1.0"
 skeptic = "0.13"
 

allowed_bindings.rs

@@ -88,6 +88,7 @@ bind! {
     zend_declare_property,
     zend_do_implement_interface,
     zend_enum_add_case,
+    zend_enum_get_case,
     zend_enum_new,
     zend_execute_data,
     zend_function_entry,

crates/macros/src/enum_.rs

@@ -101,13 +101,13 @@ pub fn parser(mut input: ItemEnum) -> Result<TokenStream> {
         }
     }
 
-    let enum_props = Enum {
-        ident: &input.ident,
-        attrs: php_attr,
+    let enum_props = Enum::new(
+        &input.ident,
+        &php_attr,
         docs,
         cases,
-        flags: None, // TODO: Implement flags support
-    };
+        None, // TODO: Implement flags support
+    );
 
     Ok(quote! {
         #[allow(dead_code)]
@@ -120,28 +120,45 @@ pub fn parser(mut input: ItemEnum) -> Result<TokenStream> {
 #[derive(Debug)]
 pub struct Enum<'a> {
     ident: &'a Ident,
-    attrs: PhpEnumAttribute,
+    name: String,
     docs: Vec<String>,
     cases: Vec<EnumCase>,
-    // TODO: Implement flags support
-    #[allow(dead_code)]
     flags: Option<String>,
 }
 
-impl ToTokens for Enum<'_> {
-    fn to_tokens(&self, tokens: &mut TokenStream) {
+impl<'a> Enum<'a> {
+    fn new(
+        ident: &'a Ident,
+        attrs: &PhpEnumAttribute,
+        docs: Vec<String>,
+        cases: Vec<EnumCase>,
+        flags: Option<String>,
+    ) -> Self {
+        let name = attrs.rename.rename(ident.to_string(), RenameRule::Pascal);
+
+        Self {
+            ident,
+            name,
+            docs,
+            cases,
+            flags,
+        }
+    }
+
+    fn registered_class(&self) -> TokenStream {
         let ident = &self.ident;
-        let enum_name = self
-            .attrs
-            .rename
-            .rename(ident.to_string(), RenameRule::Pascal);
-        let flags = quote! { ::ext_php_rs::flags::ClassFlags::Enum };
+        let name = &self.name;
+        let flags = self
+            .flags
+            .as_ref()
+            .map(|f| quote! { | #f })
+            .unwrap_or_default();
+        let flags = quote! { ::ext_php_rs::flags::ClassFlags::Enum #flags };
         let docs = &self.docs;
-        let cases = &self.cases;
 
-        let class = quote! {
+        quote! {
             impl ::ext_php_rs::class::RegisteredClass for #ident {
-                const CLASS_NAME: &'static str = #enum_name;
+                const CLASS_NAME: &'static str = #name;
                 const BUILDER_MODIFIER: ::std::option::Option<
                     fn(::ext_php_rs::builders::ClassBuilder) -> ::ext_php_rs::builders::ClassBuilder
                 > = None;
@@ -186,14 +203,54 @@ impl ToTokens for Enum<'_> {
                     ::ext_php_rs::internal::class::PhpClassImplCollector::<Self>::default().get_constants()
                 }
             }
-        };
-        let enum_impl = quote! {
-            impl ::ext_php_rs::enum_::PhpEnum for #ident {
+        }
+    }
+
+    fn registered_enum(&self) -> TokenStream {
+        let ident = &self.ident;
+        let cases = &self.cases;
+        let case_from_names = self.cases.iter().map(|case| {
+            let ident = &case.ident;
+            let name = &case.name;
+            quote! {
+                #name => Ok(Self::#ident)
+            }
+        });
+        let case_to_names = self.cases.iter().map(|case| {
+            let ident = &case.ident;
+            let name = &case.name;
+            quote! {
+                Self::#ident => #name
+            }
+        });
+
+        quote! {
+            impl ::ext_php_rs::enum_::RegisteredEnum for #ident {
                 const CASES: &'static [::ext_php_rs::enum_::EnumCase] = &[
                     #(#cases,)*
                 ];
+
+                fn from_name(name: &str) -> ::ext_php_rs::error::Result<Self> {
+                    match name {
+                        #(#case_from_names,)*
+                        _ => Err(::ext_php_rs::error::Error::InvalidProperty),
+                    }
+                }
+
+                fn to_name(&self) -> &'static str {
+                    match self {
+                        #(#case_to_names,)*
+                    }
+                }
             }
-        };
+        }
+    }
+}
+
+impl ToTokens for Enum<'_> {
+    fn to_tokens(&self, tokens: &mut TokenStream) {
+        let class = self.registered_class();
+        let enum_impl = self.registered_enum();
 
         tokens.extend(quote! {
             #class

docsrs_bindings.rs

@@ -1,4 +1,4 @@
-/* automatically generated by rust-bindgen 0.68.1 */
+/* automatically generated by rust-bindgen 0.70.1 */
 
 #[repr(C)]
 #[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
@@ -2723,6 +2723,12 @@ extern "C" {
         value: *mut zval,
     );
 }
+extern "C" {
+    pub fn zend_enum_get_case(
+        ce: *mut zend_class_entry,
+        name: *mut zend_string,
+    ) -> *mut zend_object;
+}
 extern "C" {
     pub static mut zend_ce_throwable: *mut zend_class_entry;
 }

src/builders/enum_builder.rs

@@ -7,7 +7,7 @@ use crate::{
     ffi::{zend_enum_add_case, zend_register_internal_enum},
     flags::{DataType, MethodFlags},
     types::{ZendStr, Zval},
-    zend::FunctionEntry,
+    zend::{ClassEntry, FunctionEntry},
 };
 
 #[must_use]
@@ -16,6 +16,7 @@ pub struct EnumBuilder {
     pub(crate) methods: Vec<(FunctionBuilder<'static>, MethodFlags)>,
     pub(crate) cases: Vec<&'static EnumCase>,
     pub(crate) datatype: DataType,
+    register: Option<fn(&'static mut ClassEntry)>,
 }
 
 impl EnumBuilder {
@@ -25,6 +26,7 @@ impl EnumBuilder {
             methods: Vec::default(),
             cases: Vec::default(),
             datatype: DataType::Undef,
+            register: None,
         }
     }
 
@@ -48,6 +50,17 @@ impl EnumBuilder {
         self
     }
 
+    /// Function to register the class with PHP. This function is called after
+    /// the class is built.
+    ///
+    /// # Parameters
+    ///
+    /// * `register` - The function to call to register the class.
+    pub fn registration(mut self, register: fn(&'static mut ClassEntry)) -> Self {
+        self.register = Some(register);
+        self
+    }
+
     pub fn register(self) -> Result<()> {
         let mut methods = self
             .methods
@@ -84,6 +97,12 @@ impl EnumBuilder {
             }
         }
 
+        if let Some(register) = self.register {
+            register(unsafe { &mut *class });
+        } else {
+            panic!("Enum was not registered with a registration function",);
+        }
+
         Ok(())
     }
 }

src/builders/module.rs

@@ -2,7 +2,7 @@ use std::{convert::TryFrom, ffi::CString, mem, ptr};
 
 use super::{ClassBuilder, FunctionBuilder};
 #[cfg(feature = "enum")]
-use crate::{builders::enum_builder::EnumBuilder, enum_::PhpEnum};
+use crate::{builders::enum_builder::EnumBuilder, enum_::RegisteredEnum};
 use crate::{
     class::RegisteredClass,
     constant::IntoConst,
@@ -215,7 +215,7 @@ impl ModuleBuilder<'_> {
     #[cfg(feature = "enum")]
     pub fn r#enum<T>(mut self) -> Self
     where
-        T: RegisteredClass + PhpEnum,
+        T: RegisteredClass + RegisteredEnum,
     {
         self.enums.push(|| {
             let mut builder = EnumBuilder::new(T::CLASS_NAME);
@@ -226,7 +226,9 @@ impl ModuleBuilder<'_> {
                 builder = builder.add_method(method, flags);
             }
 
-            builder
+            builder.registration(|ce| {
+                T::get_metadata().set_ce(ce);
+            })
         });
 
         self

src/enum_.rs

@@ -1,17 +1,107 @@
 //! This module defines the `PhpEnum` trait and related types for Rust enums that are exported to PHP.
+use std::ptr;
+
 use crate::{
-    convert::IntoZval,
+    boxed::ZBox,
+    class::RegisteredClass,
+    convert::{FromZendObject, FromZval, IntoZendObject, IntoZval},
     describe::DocComments,
     error::{Error, Result},
-    flags::DataType,
-    types::Zval,
+    ffi::zend_enum_get_case,
+    flags::{ClassFlags, DataType},
+    types::{ZendObject, ZendStr, Zval},
 };
 
 /// Implemented on Rust enums which are exported to PHP.
-pub trait PhpEnum {
+pub trait RegisteredEnum {
     /// The cases of the enum.
     const CASES: &'static [EnumCase];
+
+    /// # Errors
+    ///
+    /// - [`Error::InvalidProperty`] if the enum does not have a case with the given name, an error is returned.
+    fn from_name(name: &str) -> Result<Self>
+    where
+        Self: Sized;
+
+    /// Returns the variant name of the enum as it is registered in PHP.
+    fn to_name(&self) -> &'static str;
+}
+
+impl<T> FromZendObject<'_> for T
+where
+    T: RegisteredEnum,
+{
+    fn from_zend_object(obj: &ZendObject) -> Result<Self> {
+        if !ClassFlags::from_bits_truncate(unsafe { (*obj.ce).ce_flags }).contains(ClassFlags::Enum)
+        {
+            return Err(Error::InvalidProperty);
+        }
+
+        let name = obj
+            .get_properties()?
+            .get("name")
+            .and_then(Zval::indirect)
+            .and_then(Zval::str)
+            .ok_or(Error::InvalidProperty)?;
+
+        T::from_name(name)
+    }
+}
+
+impl<T> FromZval<'_> for T
+where
+    T: RegisteredEnum + RegisteredClass,
+{
+    const TYPE: DataType = DataType::Object(Some(T::CLASS_NAME));
+
+    fn from_zval(zval: &Zval) -> Option<Self> {
+        zval.object()
+            .and_then(|obj| Self::from_zend_object(obj).ok())
+    }
+}
+
+impl<T> IntoZendObject for T
+where
+    T: RegisteredEnum + RegisteredClass,
+{
+    fn into_zend_object(self) -> Result<ZBox<ZendObject>> {
+        let mut name = ZendStr::new(T::to_name(&self), false);
+        let variant = unsafe {
+            zend_enum_get_case(
+                ptr::from_ref(T::get_metadata().ce()).cast_mut(),
+                &raw mut *name,
+            )
+        };
+
+        Ok(unsafe { ZBox::from_raw(variant) })
+    }
+}
+
+impl<T> IntoZval for T
+where
+    T: RegisteredEnum + RegisteredClass,
+{
+    const TYPE: DataType = DataType::Object(Some(T::CLASS_NAME));
+    const NULLABLE: bool = false;
+
+    fn set_zval(self, zv: &mut Zval, _persistent: bool) -> Result<()> {
+        let obj = self.into_zend_object()?;
+        zv.set_object(obj.into_raw());
+        Ok(())
+    }
 }
+// impl<'a, T> IntoZval for T
+// where
+//     T: RegisteredEnum + RegisteredClass + IntoZendObject
+// {
+//     const TYPE: DataType = DataType::Object(Some(T::CLASS_NAME));
+//     const NULLABLE: bool = false;
+//
+//     fn set_zval(self, zv: &mut Zval, persistent: bool) -> Result<()> {
+//         let obj = self.into_zend_object()?;
+//     }
+// }
 
 /// Represents a case in a PHP enum.
 pub struct EnumCase {

tests/src/integration/enum_/enum.php

@@ -17,3 +17,5 @@
 assert(StringBackedEnum::from('bar') === StringBackedEnum::Variant2);
 assert(StringBackedEnum::tryFrom('foo') === StringBackedEnum::Variant1);
 assert(StringBackedEnum::tryFrom('baz') === null);
+
+assert(test_enum(TestEnum::Variant2) === TestEnum::Variant1);