Add ability to define properties when using macros (#56)

* Panic instead of return result when adding property

This will almost always be unwrapped

* Remove unused `set_refcount` function

Wasn't valid either way

* Add ability to get and set properties on class objects

* Updated documentation adding properties

Author: davidcole1340

example/skel/src/allocator.rs

@@ -27,13 +27,13 @@ unsafe impl GlobalAlloc for PhpAllocator {
             0,
         ) as *mut u8;
 
-        eprintln!("allocating {} bytes at {:?}", layout.size(), ptr);
+        // eprintln!("allocating {} bytes at {:?}", layout.size(), ptr);
 
         ptr
     }
 
     unsafe fn dealloc(&self, ptr: *mut u8, layout: std::alloc::Layout) {
-        eprintln!("deallocating {} bytes at {:?}", layout.size(), ptr);
+        // eprintln!("deallocating {} bytes at {:?}", layout.size(), ptr);
 
         _efree(
             ptr as *mut _,

example/skel/src/lib.rs

@@ -101,19 +101,21 @@ pub fn test_str(input: &str) -> &str {
 //     info_table_end!();
 // }
 
-#[php_class(name = "Redis\\Exception\\RedisClientException")]
-#[extends(ClassEntry::exception())]
-#[derive(Default)]
-struct RedisException;
+// #[php_class(name = "Redis\\Exception\\RedisClientException")]
+// #[extends(ClassEntry::exception())]
+// #[derive(Default)]
+// struct RedisException;
 
-#[php_function]
-pub fn test_exception() -> Result<i32, PhpException<'static>> {
-    Err(PhpException::from_class::<RedisException>(
-        "Hello world".into(),
-    ))
-}
+// #[php_function]
+// pub fn test_exception() -> Result<i32, PhpException<'static>> {
+//     Err(PhpException::from_class::<RedisException>(
+//         "Hello world".into(),
+//     ))
+// }
 
 #[php_class]
+#[property(test = 0)]
+#[property(another = "Hello world")]
 #[derive(Default)]
 pub struct Test {
     test: String,
@@ -122,6 +124,10 @@ pub struct Test {
 #[php_impl]
 impl Test {
     pub fn get(&mut self) -> &Test {
+        use ext_php_rs::php::types::object::ZendObjectOverride;
+
+        dbg!(unsafe { self.get_property::<String>("test") });
+        unsafe { self.set_property("test", "another string") };
         self
     }
 

example/skel/test.php

@@ -7,6 +7,8 @@
 $x->set_str('Hello World');
 var_dump($x->get_str());
 var_dump($x->get());
+# $x->test = 'hello world';
+var_dump($x->get());
 var_dump($x->get_str());
 // var_dump($x);
 var_dump('program done');

ext-php-rs-derive/src/class.rs

@@ -1,9 +1,11 @@
+use std::collections::HashMap;
+
 use crate::STATE;
 use anyhow::{anyhow, bail, Result};
 use darling::{FromMeta, ToTokens};
 use proc_macro2::{Ident, Span, TokenStream};
 use quote::quote;
-use syn::{Attribute, AttributeArgs, Expr, ItemStruct};
+use syn::{Attribute, AttributeArgs, Expr, ItemStruct, Token};
 
 #[derive(Debug, Default)]
 pub struct Class {
@@ -12,12 +14,14 @@ pub struct Class {
     pub interfaces: Vec<String>,
     pub methods: Vec<crate::method::Method>,
     pub constants: Vec<crate::constant::Constant>,
+    pub properties: HashMap<String, (String, Option<String>)>,
 }
 
 #[derive(Debug)]
 pub enum ParsedAttribute {
     Extends(Expr),
     Implements(Expr),
+    Property(Box<PropertyAttr>),
 }
 
 #[derive(Default, Debug, FromMeta)]
@@ -32,6 +36,7 @@ pub fn parser(args: AttributeArgs, mut input: ItemStruct) -> Result<TokenStream>
 
     let mut parent = None;
     let mut interfaces = vec![];
+    let mut properties = HashMap::<String, (String, Option<String>)>::new();
 
     input.attrs = {
         let mut unused = vec![];
@@ -44,6 +49,15 @@ pub fn parser(args: AttributeArgs, mut input: ItemStruct) -> Result<TokenStream>
                     ParsedAttribute::Implements(class) => {
                         interfaces.push(class.to_token_stream().to_string());
                     }
+                    ParsedAttribute::Property(attr) => {
+                        properties.insert(
+                            attr.name.to_string(),
+                            (
+                                attr.default.to_token_stream().to_string(),
+                                attr.flags.map(|flags| flags.to_token_stream().to_string()),
+                            ),
+                        );
+                    }
                 },
                 None => unused.push(attr),
             }
@@ -93,6 +107,7 @@ pub fn parser(args: AttributeArgs, mut input: ItemStruct) -> Result<TokenStream>
         class_name,
         parent,
         interfaces,
+        properties,
         ..Default::default()
     };
 
@@ -111,6 +126,31 @@ pub fn parser(args: AttributeArgs, mut input: ItemStruct) -> Result<TokenStream>
     Ok(output)
 }
 
+#[derive(Debug)]
+pub struct PropertyAttr {
+    pub name: Ident,
+    pub default: Expr,
+    pub flags: Option<Expr>,
+}
+
+impl syn::parse::Parse for PropertyAttr {
+    fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
+        let name: Ident = input.parse()?;
+        let _: Token![=] = input.parse()?;
+        let default: Expr = input.parse()?;
+        let flags = input
+            .parse::<Token![,]>()
+            .and_then(|_| input.parse::<Expr>())
+            .ok();
+
+        Ok(PropertyAttr {
+            name,
+            default,
+            flags,
+        })
+    }
+}
+
 fn parse_attribute(attr: &Attribute) -> Result<Option<ParsedAttribute>> {
     let name = attr.path.to_token_stream().to_string();
 
@@ -127,6 +167,13 @@ fn parse_attribute(attr: &Attribute) -> Result<Option<ParsedAttribute>> {
                 .map_err(|_| anyhow!("Unable to parse `#[{}]` attribute.", name))?;
             Some(ParsedAttribute::Implements(meta))
         }
+        "property" => {
+            let attr: PropertyAttr = attr
+                .parse_args()
+                .map_err(|_| anyhow!("Unable to parse `#[{}]` attribute.", name))?;
+
+            Some(ParsedAttribute::Property(Box::new(attr)))
+        }
         _ => None,
     })
 }

ext-php-rs-derive/src/startup_function.rs

@@ -21,7 +21,8 @@ pub fn parser(input: ItemFn) -> Result<TokenStream> {
     let func = quote! {
         #[doc(hidden)]
         pub extern "C" fn #ident(ty: i32, module_number: i32) -> i32 {
-            pub use ::ext_php_rs::php::constants::IntoConst;
+            use ::ext_php_rs::php::constants::IntoConst;
+            use ::ext_php_rs::php::flags::PropertyFlags;
 
             fn internal() {
                 #(#stmts)*
@@ -82,12 +83,41 @@ fn build_classes(classes: &HashMap<String, Class>) -> Result<Vec<TokenStream>> {
                     Ok(quote! { .implements(#expr) })
                 })
                 .collect::<Result<Vec<_>>>()?;
+            let properties = class
+                .properties
+                .iter()
+                .map(|(name, (default, flags))| {
+                    let default_expr: Expr = syn::parse_str(default).map_err(|_| {
+                        anyhow!(
+                            "Invalid default value given for property `{}` type: `{}`",
+                            name,
+                            default
+                        )
+                    })?;
+                    let flags_expr: Expr = syn::parse_str(
+                        flags
+                            .as_ref()
+                            .map(|flags| flags.as_str())
+                            .unwrap_or("PropertyFlags::Public"),
+                    )
+                    .map_err(|_| {
+                        anyhow!(
+                            "Invalid default value given for property `{}` type: `{}`",
+                            name,
+                            default
+                        )
+                    })?;
+
+                    Ok(quote! { .property(#name, #default_expr, #flags_expr) })
+                })
+                .collect::<Result<Vec<_>>>()?;
 
             Ok(quote! {{
                 let class = ::ext_php_rs::php::class::ClassBuilder::new(#class_name)
                     #(#methods)*
                     #(#constants)*
                     #(#interfaces)*
+                    #(#properties)*
                     #parent
                     .object_override::<#ident>()
                     .build()

guide/src/macros/impl.md

@@ -69,7 +69,11 @@ impl Human {
     }
 
     pub fn introduce(&self) {
-        println!("My name is {} and I am {} years old.", self.name, self.age);
+        use ext_php_rs::php::types::object::ZendObjectOverride;
+        
+        // SAFETY: The `Human` struct is only constructed from PHP.
+        let address: String = unsafe { self.get_property("address") }.unwrap();
+        println!("My name is {} and I am {} years old. I live at {}.", self.name, self.age, address);
     }
 
     pub fn get_max_age() -> i32 {

guide/src/macros/structs.md

@@ -30,15 +30,20 @@ placed underneath the `#[php_class]` attribute.
 - `#[implements(ce)]` - Implements the given interface on the class. Can be used
   multiple times. `ce` must be a valid Rust expression when it is called inside
   the `#[php_module]` function.
+- `#[property(name = default[, flags])]` - Adds a PHP property to the class. Can
+  be get and set through functions defined through the trait
+  `ZendObjectOverride`.
 
 ## Example
 
-This example creates a PHP class `Human`:
+This example creates a PHP class `Human`, adding a PHP property `address` with
+an empty string as the default value.
 
 ```rust
 # extern crate ext_php_rs;
 # use ext_php_rs::prelude::*;
 #[php_class]
+#[property(address = "")]
 #[derive(Default)]
 pub struct Human {
     name: String,
@@ -65,3 +70,14 @@ pub fn throw_exception() -> Result<i32, PhpException<'static>> {
     Err(PhpException::from_class::<RedisException>("Not good!".into()))
 }
 ```
+
+Creating a class with a private property called `test`:
+
+```rust
+# extern crate ext_php_rs;
+# use ext_php_rs::prelude::*;
+#[php_class]
+#[property(test = "Default value", PropertyFlags::Private)]
+#[derive(Default)]
+pub struct TestClass;
+```

src/php/class.rs

@@ -204,23 +204,28 @@ impl<'a> ClassBuilder<'a> {
     /// Adds a property to the class. The initial type of the property is given by the type
     /// of the given default. Note that the user can change the type.
     ///
-    /// Returns a result containing the class builder if the property was successfully added.
-    ///
     /// # Parameters
     ///
     /// * `name` - The name of the property to add to the class.
     /// * `default` - The default value of the property.
     /// * `flags` - Flags relating to the property. See [`PropertyFlags`].
+    ///
+    /// # Panics
+    ///
+    /// Function will panic if the given `default` cannot be converted into a [`Zval`].
     pub fn property<T: Into<String>>(
         mut self,
         name: T,
         default: impl IntoZval,
         flags: PropertyFlags,
-    ) -> Result<Self> {
-        let default = default.as_zval(true)?;
+    ) -> Self {
+        let default = match default.as_zval(true) {
+            Ok(default) => default,
+            Err(_) => panic!("Invalid default value for property `{}`.", name.into()),
+        };
 
         self.properties.push((name.into(), default, flags));
-        Ok(self)
+        self
     }
 
     /// Adds a constant to the class. The type of the constant is defined by the type of the given

src/php/types/object.rs

@@ -26,7 +26,7 @@ use crate::{
 
 use super::{
     array::ZendHashTable,
-    zval::{IntoZval, Zval},
+    zval::{FromZval, IntoZval, Zval},
 };
 
 pub type ZendObject = zend_object;
@@ -97,10 +97,6 @@ impl ZendObject {
         let name = ZendString::new(name, false)?;
         let mut value = value.as_zval(false)?;
 
-        if value.is_string() {
-            value.set_refcount(0);
-        }
-
         unsafe {
             self.handlers()?.write_property.ok_or(Error::InvalidScope)?(
                 self,
@@ -207,6 +203,49 @@ pub trait ZendObjectOverride: Default {
     /// the class with PHP.
     #[doc(hidden)]
     fn set_class(ce: &'static ClassEntry);
+
+    /// Attempts to retrieve a property from the class object.
+    ///
+    /// # Parameters
+    ///
+    /// * `name` - The name of the property.
+    ///
+    /// # Returns
+    ///
+    /// Returns a given type `T` inside an option which is the value of the zval, or [`None`]
+    /// if the property could not be found.
+    ///
+    /// # Safety
+    ///
+    /// Caller must guarantee that the object the function is called on is immediately followed
+    /// by a [`zend_object`], which is true when the object was instantiated from  [`ZendClassObject`].
+    unsafe fn get_property<'a, T: FromZval<'a>>(&'a self, name: &str) -> Option<T> {
+        let obj = ZendClassObject::<Self>::from_obj_ptr(self)?;
+        let zv = obj.std.get_property(name).ok()?;
+        zv.try_into().ok()
+    }
+
+    /// Attempts to set the value of a property on the class object.
+    ///
+    /// # Parameters
+    ///
+    /// * `name` - The name of the property to set.
+    /// * `value` - The value to set the property to.
+    ///
+    /// # Returns
+    ///
+    /// Returns nothing in an option if the property was successfully set. Returns none if setting
+    /// the value failed.
+    ///
+    /// # Safety
+    ///
+    /// Caller must guarantee that the object the function is called on is immediately followed
+    /// by a [`zend_object`], which is true when the object was instantiated from  [`ZendClassObject`].
+    unsafe fn set_property(&mut self, name: &str, value: impl IntoZval) -> Option<()> {
+        let obj = ZendClassObject::<Self>::from_obj_ptr(self)?;
+        obj.std.set_property(name, value).ok()?;
+        Some(())
+    }
 }
 
 impl<T: ZendObjectOverride> IntoZval for &T {

src/php/types/zval.rs

@@ -360,11 +360,6 @@ impl<'a> Zval {
         self.value.arr = val.into_ptr();
     }
 
-    /// Sets the reference count of the Zval.
-    pub(crate) fn set_refcount(&mut self, rc: u32) {
-        unsafe { (*self.value.counted).gc.refcount = rc }
-    }
-
     /// Used to drop the Zval but keep the value of the zval intact.
     ///
     /// This is important when copying the value of the zval, as the actual value