Allow returning of object references (#55)

* Allow returning of object references

`TYPE` is now also on `IntoZval` which means `FromZval` does not need to
be implemented on return types

* Clippy lints

Author: davidcole1340

example/skel/src/allocator.rs

@@ -19,16 +19,22 @@ impl PhpAllocator {
 
 unsafe impl GlobalAlloc for PhpAllocator {
     unsafe fn alloc(&self, layout: std::alloc::Layout) -> *mut u8 {
-        _emalloc(
+        let ptr = _emalloc(
             layout.size() as _,
             std::ptr::null_mut(),
             0,
             std::ptr::null_mut(),
             0,
-        ) as *mut u8
+        ) as *mut u8;
+
+        eprintln!("allocating {} bytes at {:?}", layout.size(), ptr);
+
+        ptr
     }
 
-    unsafe fn dealloc(&self, ptr: *mut u8, _: std::alloc::Layout) {
+    unsafe fn dealloc(&self, ptr: *mut u8, layout: std::alloc::Layout) {
+        eprintln!("deallocating {} bytes at {:?}", layout.size(), ptr);
+
         _efree(
             ptr as *mut _,
             std::ptr::null_mut(),

example/skel/src/lib.rs

@@ -1,16 +1,8 @@
 mod allocator;
 
-use std::{collections::HashMap, convert::TryFrom, mem::MaybeUninit};
-
 use allocator::PhpAllocator;
 use ext_php_rs::{
-    call_user_func, info_table_end, info_table_row, info_table_start,
-    php::{
-        class::ClassEntry,
-        exceptions::PhpException,
-        module::ModuleEntry,
-        types::{array::ZendHashTable, callable::Callable, zval::Zval},
-    },
+    php::{class::ClassEntry, exceptions::PhpException},
     php_class,
     prelude::*,
 };
@@ -121,6 +113,27 @@ pub fn test_exception() -> Result<i32, PhpException<'static>> {
     ))
 }
 
+#[php_class]
+#[derive(Default)]
+pub struct Test {
+    test: String,
+}
+
+#[php_impl]
+impl Test {
+    pub fn get(&mut self) -> &Test {
+        self
+    }
+
+    pub fn set_str(&mut self, str: String) {
+        self.test = str;
+    }
+
+    pub fn get_str(&self) -> String {
+        self.test.clone()
+    }
+}
+
 #[php_module]
 pub fn module(module: ModuleBuilder) -> ModuleBuilder {
     // module.info_function(php_module_info)

example/skel/test.php

@@ -2,5 +2,12 @@
 
 include __DIR__.'/vendor/autoload.php';
 
-var_dump(test_str("Hello wordl"));
-# var_dump(test_exception());
+var_dump('program starting');
+$x = new Test();
+$x->set_str('Hello World');
+var_dump($x->get_str());
+var_dump($x->get());
+var_dump($x->get_str());
+// var_dump($x);
+var_dump('program done');
+// var_dump($x->get_str());

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

@@ -418,7 +418,7 @@ impl Function {
 
             // TODO allow reference returns?
             quote! {
-                .returns(<#ty as ::ext_php_rs::php::types::zval::FromZval>::TYPE, false, #nullable)
+                .returns(<#ty as ::ext_php_rs::php::types::zval::IntoZval>::TYPE, false, #nullable)
             }
         });
 

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

@@ -216,7 +216,7 @@ impl Method {
 
             // TODO allow reference returns?
             quote! {
-                .returns(<#ty as ::ext_php_rs::php::types::zval::FromZval>::TYPE, false, #nullable)
+                .returns(<#ty as ::ext_php_rs::php::types::zval::IntoZval>::TYPE, false, #nullable)
             }
         });
 

guide/src/types/index.md

@@ -22,3 +22,6 @@ There is one special case - `Result<T, E>`, where T implements `IntoZval` and
 `E` implements `Into<PhpException>`. This can only be used as a function/method
 return type. If the error variant is encountered, `E` is converted into a
 `PhpException` and thrown.
+
+For a type to be returnable, it must implement `IntoZval`, while for it to be
+valid as a parameter, it must implement `FromZval`.

src/php/args.rs

@@ -5,7 +5,7 @@ use std::convert::{TryFrom, TryInto};
 use super::{
     enums::DataType,
     execution_data::ExecutionData,
-    types::zval::{IntoZval, Zval},
+    types::zval::{IntoZvalDyn, Zval},
 };
 
 use crate::{
@@ -94,7 +94,7 @@ impl<'a> Arg<'a> {
     /// # Parameters
     ///
     /// * `params` - A list of parameters to call the function with.
-    pub fn try_call(&self, params: Vec<&dyn IntoZval>) -> Result<Zval> {
+    pub fn try_call(&self, params: Vec<&dyn IntoZvalDyn>) -> Result<Zval> {
         self.zval().ok_or(Error::Callable)?.try_call(params)
     }
 }

src/php/types/binary.rs

@@ -68,6 +68,8 @@ impl<T: Pack> TryFrom<Zval> for Binary<T> {
 }
 
 impl<T: Pack> IntoZval for Binary<T> {
+    const TYPE: DataType = DataType::String;
+
     fn set_zval(&self, zv: &mut Zval, _: bool) -> Result<()> {
         zv.set_binary(&self.0);
         Ok(())

src/php/types/callable.rs

@@ -2,7 +2,7 @@
 
 use std::ops::Deref;
 
-use super::zval::{IntoZval, Zval};
+use super::zval::{IntoZvalDyn, Zval};
 use crate::{
     bindings::_call_user_function_impl,
     errors::{Error, Result},
@@ -92,7 +92,7 @@ impl<'a> Callable<'a> {
     /// # Parameters
     ///
     /// * `params` - A list of parameters to call the function with.
-    pub fn try_call(&self, params: Vec<&dyn IntoZval>) -> Result<Zval> {
+    pub fn try_call(&self, params: Vec<&dyn IntoZvalDyn>) -> Result<Zval> {
         if !self.0.is_callable() {
             return Err(Error::Callable);
         }

src/php/types/object.rs

@@ -18,7 +18,10 @@ use crate::{
         ZEND_PROPERTY_ISSET,
     },
     errors::{Error, Result},
-    php::{class::ClassEntry, execution_data::ExecutionData, types::string::ZendString},
+    php::{
+        class::ClassEntry, enums::DataType, execution_data::ExecutionData,
+        types::string::ZendString,
+    },
 };
 
 use super::{
@@ -154,6 +157,11 @@ impl ZendObject {
     fn mut_ptr(&self) -> *mut Self {
         (self as *const Self) as *mut Self
     }
+
+    /// Increments the objects reference counter by 1.
+    pub(crate) fn refcount_inc(&mut self) {
+        self.gc.refcount += 1;
+    }
 }
 
 impl Debug for ZendObject {
@@ -179,7 +187,7 @@ impl Debug for ZendObject {
 ///
 /// Implements a function `create_object` which is passed to a PHP class entry to instantiate the
 /// object that will represent an object.
-pub trait ZendObjectOverride {
+pub trait ZendObjectOverride: Default {
     /// Creates a new Zend object. Also allocates space for type T on which the trait is
     /// implemented on.
     ///
@@ -201,6 +209,19 @@ pub trait ZendObjectOverride {
     fn set_class(ce: &'static ClassEntry);
 }
 
+impl<T: ZendObjectOverride> IntoZval for &T {
+    const TYPE: DataType = DataType::Object;
+
+    fn set_zval(&self, zv: &mut Zval, _: bool) -> Result<()> {
+        unsafe {
+            let obj = ZendClassObject::from_obj_ptr(*self).ok_or(Error::InvalidPointer)?;
+            zv.set_object(&mut obj.std);
+        }
+
+        Ok(())
+    }
+}
+
 /// A Zend class object which is allocated when a PHP
 /// class object is instantiated. Overrides the default
 /// handler when the user provides a type T of the struct
@@ -262,6 +283,20 @@ impl<T: Default> ZendClassObject<T> {
             ptr.as_mut()
         }
     }
+
+    /// Returns a reference to the [`ZendClassObject`] of a given object `T`.
+    ///
+    /// # Parameters
+    ///
+    /// * `obj` - The object to get the [`ZendClassObject`] for.
+    ///
+    /// # Safety
+    ///
+    /// Caller must guarantee that the given `obj` was created by Zend, which means that it
+    /// is immediately followed by a [`zend_object`].
+    pub(crate) unsafe fn from_obj_ptr(obj: &T) -> Option<&mut Self> {
+        ((obj as *const T) as *mut Self).as_mut()
+    }
 }
 
 impl<T: Default + Debug> Debug for ZendClassObject<T> {