feat(enum): add support for string backed enums

Refs: #178

Author: Xenira

crates/macros/src/enum_.rs

@@ -1,10 +1,10 @@
 use std::convert::TryFrom;
 
-use darling::FromAttributes;
+use darling::{util::Flag, FromAttributes};
 use itertools::Itertools;
 use proc_macro2::TokenStream;
 use quote::{quote, ToTokens};
-use syn::{Expr, Fields, Ident, ItemEnum, Lit};
+use syn::{Fields, Ident, ItemEnum, Lit};
 
 use crate::{
     helpers::get_docs,
@@ -18,7 +18,7 @@ struct PhpEnumAttribute {
     #[darling(flatten)]
     rename: PhpRename,
     #[darling(default)]
-    allow_discriminants: bool,
+    allow_native_discriminants: Flag,
     rename_cases: Option<RenameRule>,
     vis: Option<Visibility>,
     attrs: Vec<syn::Attribute>,
@@ -29,7 +29,7 @@ struct PhpEnumAttribute {
 struct PhpEnumVariantAttribute {
     #[darling(flatten)]
     rename: PhpRename,
-    discriminant: Option<Expr>,
+    discriminant: Option<Lit>,
     // TODO: Implement doc support for enum variants
     #[allow(dead_code)]
     attrs: Vec<syn::Attribute>,
@@ -47,8 +47,8 @@ pub fn parser(mut input: ItemEnum) -> Result<TokenStream> {
         if variant.fields != Fields::Unit {
             bail!("Enum cases must be unit variants, found: {:?}", variant);
         }
-        if !php_attr.allow_discriminants && variant.discriminant.is_some() {
-            bail!(variant => "Native discriminants are currently not exported to PHP. To set a discriminant, use the `#[php(allow_discriminants)]` attribute on the enum. To export discriminants, set the #[php(discriminant = ...)] attribute on the enum case.");
+        if !php_attr.allow_native_discriminants.is_present() && variant.discriminant.is_some() {
+            bail!(variant => "Native discriminants are currently not exported to PHP. To set a discriminant, use the `#[php(allow_native_discriminants)]` attribute on the enum. To export discriminants, set the #[php(discriminant = ...)] attribute on the enum case.");
         }
 
         let variant_attr = PhpEnumVariantAttribute::from_attributes(&variant.attrs)?;
@@ -219,21 +219,17 @@ enum Discriminant {
     Integer(i64),
 }
 
-impl TryFrom<&Expr> for Discriminant {
+impl TryFrom<&Lit> for Discriminant {
     type Error = syn::Error;
 
-    fn try_from(expr: &Expr) -> Result<Self> {
-        match expr {
-            Expr::Lit(expr) => match &expr.lit {
-                Lit::Str(s) => Ok(Discriminant::String(s.value())),
-                Lit::Int(i) => i.base10_parse::<i64>().map(Discriminant::Integer).map_err(
-                    |_| err!(expr => "Invalid integer literal for enum case: {:?}", expr.lit),
-                ),
-                _ => bail!(expr => "Unsupported discriminant type: {:?}", expr.lit),
-            },
-            _ => {
-                bail!(expr => "Unsupported discriminant type, expected a literal of type string or i64, found: {:?}", expr);
-            }
+    fn try_from(lit: &Lit) -> Result<Self> {
+        match lit {
+            Lit::Str(s) => Ok(Discriminant::String(s.value())),
+            Lit::Int(i) => i
+                .base10_parse::<i64>()
+                .map(Discriminant::Integer)
+                .map_err(|_| err!(lit => "Invalid integer literal for enum case: {:?}", lit)),
+            _ => bail!(lit => "Unsupported discriminant type: {:?}", lit),
         }
     }
 }
@@ -242,7 +238,7 @@ impl ToTokens for Discriminant {
     fn to_tokens(&self, tokens: &mut TokenStream) {
         tokens.extend(match self {
             Discriminant::String(s) => {
-                quote! { ::ext_php_rs::enum_::Discriminant::String(#s.to_string()) }
+                quote! { ::ext_php_rs::enum_::Discriminant::String(#s) }
             }
             Discriminant::Integer(i) => {
                 quote! { ::ext_php_rs::enum_::Discriminant::Int(#i) }

src/builders/enum_builder.rs

@@ -6,7 +6,7 @@ use crate::{
     error::Result,
     ffi::{zend_enum_add_case, zend_register_internal_enum},
     flags::{DataType, MethodFlags},
-    types::ZendStr,
+    types::{ZendStr, Zval},
     zend::FunctionEntry,
 };
 
@@ -73,7 +73,7 @@ impl EnumBuilder {
             let name = ZendStr::new(case.name, true);
             let value = match &case.discriminant {
                 Some(value) => {
-                    let value = value.into_zval(false)?;
+                    let value: Zval = value.try_into()?;
                     let mut zv = core::mem::ManuallyDrop::new(value);
                     (&raw mut zv).cast()
                 }

src/enum_.rs

@@ -1,6 +1,10 @@
 //! This module defines the `PhpEnum` trait and related types for Rust enums that are exported to PHP.
 use crate::{
-    convert::IntoZval, describe::DocComments, error::Result, flags::DataType, types::Zval,
+    convert::IntoZval,
+    describe::DocComments,
+    error::{Error, Result},
+    flags::DataType,
+    types::Zval,
 };
 
 /// Implemented on Rust enums which are exported to PHP.
@@ -39,17 +43,13 @@ pub enum Discriminant {
     String(&'static str),
 }
 
-impl Discriminant {
-    /// Converts the discriminant to a PHP value.
-    ///
-    /// # Errors
-    ///
-    /// Returns an error if the conversion fails. See [`String`] and [`i64`] [`IntoZval`] implementations
-    /// for more details on potential errors.
-    pub fn into_zval(&self, persistent: bool) -> Result<Zval> {
-        match self {
-            Discriminant::Int(i) => i.into_zval(persistent),
-            Discriminant::String(s) => s.into_zval(persistent),
+impl TryFrom<&Discriminant> for Zval {
+    type Error = Error;
+
+    fn try_from(value: &Discriminant) -> Result<Self> {
+        match value {
+            Discriminant::Int(i) => i.into_zval(false),
+            Discriminant::String(s) => s.into_zval(true),
         }
     }
 }

tests/src/integration/enum_/enum.php

@@ -6,6 +6,14 @@
 var_dump($enum_variant);
 assert($enum_variant === TestEnum::Variant1);
 assert($enum_variant !== TestEnum::Variant2);
+assert(TestEnum::cases() === [TestEnum::Variant1, TestEnum::Variant2]);
 
-$backed = IntBackedEnum::Variant1;
-assert($backed->value === 1);
+assert(IntBackedEnum::Variant1->value === 1);
+assert(IntBackedEnum::from(2) === IntBackedEnum::Variant2);
+assert(IntBackedEnum::tryFrom(1) === IntBackedEnum::Variant1);
+assert(IntBackedEnum::tryFrom(3) === null);
+
+assert(StringBackedEnum::Variant1->value === 'foo');
+assert(StringBackedEnum::from('bar') === StringBackedEnum::Variant2);
+assert(StringBackedEnum::tryFrom('foo') === StringBackedEnum::Variant1);
+assert(StringBackedEnum::tryFrom('baz') === null);

tests/src/integration/enum_/mod.rs

@@ -1,7 +1,7 @@
 use ext_php_rs::{php_enum, prelude::ModuleBuilder};
 
 #[php_enum]
-#[php(allow_discriminants)]
+#[php(allow_native_discriminants)]
 pub enum TestEnum {
     // #[php(discriminant = 2)]
     Variant1,
@@ -17,16 +17,19 @@ pub enum IntBackedEnum {
     Variant2,
 }
 
-// #[php_enum]
-// pub enum StringBackedEnum {
-//     #[php(discriminant = "foo")]
-//     Variant1,
-//     #[php(discriminant = "bar")]
-//     Variant2,
-// }
+#[php_enum]
+pub enum StringBackedEnum {
+    #[php(discriminant = "foo")]
+    Variant1,
+    #[php(discriminant = "bar")]
+    Variant2,
+}
 
 pub fn build_module(builder: ModuleBuilder) -> ModuleBuilder {
-    builder.r#enum::<TestEnum>().r#enum::<IntBackedEnum>()
+    builder
+        .r#enum::<TestEnum>()
+        .r#enum::<IntBackedEnum>()
+        .r#enum::<StringBackedEnum>()
 }
 
 #[cfg(test)]