feat(enum): implement TryFrom and Into for backed enum

Refs: #178

Author: Xenira

crates/macros/src/enum_.rs

@@ -107,6 +107,7 @@ pub fn parser(mut input: ItemEnum) -> Result<TokenStream> {
         docs,
         cases,
         None, // TODO: Implement flags support
+        discriminant_type,
     );
 
     Ok(quote! {
@@ -121,6 +122,7 @@ pub fn parser(mut input: ItemEnum) -> Result<TokenStream> {
 pub struct Enum<'a> {
     ident: &'a Ident,
     name: String,
+    discriminant_type: DiscriminantType,
     docs: Vec<String>,
     cases: Vec<EnumCase>,
     flags: Option<String>,
@@ -133,12 +135,14 @@ impl<'a> Enum<'a> {
         docs: Vec<String>,
         cases: Vec<EnumCase>,
         flags: Option<String>,
+        discriminant_type: DiscriminantType,
     ) -> Self {
         let name = attrs.rename.rename(ident.to_string(), RenameRule::Pascal);
 
         Self {
             ident,
             name,
+            discriminant_type,
             docs,
             cases,
             flags,
@@ -245,16 +249,93 @@ impl<'a> Enum<'a> {
             }
         }
     }
+
+    pub fn impl_try_from(&self) -> TokenStream {
+        if self.discriminant_type == DiscriminantType::None {
+            return quote! {};
+        }
+        let discriminant_type = match self.discriminant_type {
+            DiscriminantType::Integer => quote! { i64 },
+            DiscriminantType::String => quote! { &str },
+            DiscriminantType::None => unreachable!("Discriminant type should not be None here"),
+        };
+        let ident = &self.ident;
+        let cases = self.cases.iter().map(|case| {
+            let ident = &case.ident;
+            match case
+                .discriminant
+                .as_ref()
+                .expect("Discriminant should be set")
+            {
+                Discriminant::String(s) => quote! { #s => Ok(Self::#ident) },
+                Discriminant::Integer(i) => quote! { #i => Ok(Self::#ident) },
+            }
+        });
+
+        quote! {
+            impl TryFrom<#discriminant_type> for #ident {
+                type Error = ::ext_php_rs::error::Error;
+
+                fn try_from(value: #discriminant_type) -> ::ext_php_rs::error::Result<Self> {
+                    match value {
+                        #(
+                            #cases,
+                        )*
+                        _ => Err(::ext_php_rs::error::Error::InvalidProperty),
+                    }
+                }
+            }
+        }
+    }
+
+    pub fn impl_into(&self) -> TokenStream {
+        if self.discriminant_type == DiscriminantType::None {
+            return quote! {};
+        }
+        let discriminant_type = match self.discriminant_type {
+            DiscriminantType::Integer => quote! { i64 },
+            DiscriminantType::String => quote! { &'static str },
+            DiscriminantType::None => unreachable!("Discriminant type should not be None here"),
+        };
+        let ident = &self.ident;
+        let cases = self.cases.iter().map(|case| {
+            let ident = &case.ident;
+            match case
+                .discriminant
+                .as_ref()
+                .expect("Discriminant should be set")
+            {
+                Discriminant::String(s) => quote! { Self::#ident => #s },
+                Discriminant::Integer(i) => quote! { Self::#ident => #i },
+            }
+        });
+
+        quote! {
+            impl Into<#discriminant_type> for #ident {
+                fn into(self) -> #discriminant_type {
+                    match self {
+                        #(
+                            #cases,
+                        )*
+                    }
+                }
+            }
+        }
+    }
 }
 
 impl ToTokens for Enum<'_> {
     fn to_tokens(&self, tokens: &mut TokenStream) {
         let class = self.registered_class();
         let enum_impl = self.registered_enum();
+        let impl_try_from = self.impl_try_from();
+        let impl_into = self.impl_into();
 
         tokens.extend(quote! {
             #class
             #enum_impl
+            #impl_try_from
+            #impl_into
         });
     }
 }

tests/src/integration/enum_/enum.php

@@ -3,7 +3,6 @@
 declare(strict_types=1);
 
 $enum_variant = TestEnum::Variant1;
-var_dump($enum_variant);
 assert($enum_variant === TestEnum::Variant1);
 assert($enum_variant !== TestEnum::Variant2);
 assert(TestEnum::cases() === [TestEnum::Variant1, TestEnum::Variant2]);
@@ -18,4 +17,4 @@
 assert(StringBackedEnum::tryFrom('foo') === StringBackedEnum::Variant1);
 assert(StringBackedEnum::tryFrom('baz') === null);
 
-assert(test_enum(TestEnum::Variant2) === TestEnum::Variant1);
+assert(test_enum(TestEnum::Variant1) === StringBackedEnum::Variant2);

tests/src/integration/enum_/mod.rs

@@ -1,4 +1,4 @@
-use ext_php_rs::{php_enum, php_function, prelude::ModuleBuilder, wrap_function};
+use ext_php_rs::{error::Result, php_enum, php_function, prelude::ModuleBuilder, wrap_function};
 
 #[php_enum]
 #[php(allow_native_discriminants)]
@@ -26,10 +26,11 @@ pub enum StringBackedEnum {
 }
 
 #[php_function]
-pub fn test_enum(a: TestEnum) -> TestEnum {
+pub fn test_enum(a: TestEnum) -> Result<StringBackedEnum> {
+    let str: &str = StringBackedEnum::Variant2.into();
     match a {
-        TestEnum::Variant1 => TestEnum::Variant2,
-        TestEnum::Variant2 => TestEnum::Variant1,
+        TestEnum::Variant1 => str.try_into(),
+        TestEnum::Variant2 => Ok(StringBackedEnum::Variant1),
     }
 }