Add try_from into FromZval trait (#62)

Allows generic implementations of the trait

Author: davidcole1340

example/skel/src/lib.rs

@@ -128,6 +128,11 @@ pub struct Test {
     pub test: String,
 }
 
+#[php_function]
+pub fn take_test(test: &Test) -> String {
+    test.test.clone()
+}
+
 #[php_class]
 #[derive(Default)]
 struct PhpFuture {
@@ -150,11 +155,9 @@ impl PhpFuture {
     }
 
     pub fn obj(&self) -> ClassObject<Test> {
-        let obj = ClassObject::new(Test {
+        ClassObject::new(Test {
             test: "Hello world from class entry :)".into(),
-        });
-
-        obj
+        })
     }
 
     pub fn return_self(&self) -> ClassRef<PhpFuture> {

src/php/args.rs

@@ -1,16 +1,12 @@
 //! Builder and objects relating to function and method arguments.
 
-use std::{
-    convert::{TryFrom, TryInto},
-    ffi::CString,
-    ptr,
-};
+use std::{ffi::CString, ptr};
 
 use super::{
     enums::DataType,
     execution_data::ExecutionData,
     types::{
-        zval::{IntoZvalDyn, Zval},
+        zval::{FromZval, IntoZvalDyn, Zval},
         ZendType,
     },
 };
@@ -85,8 +81,8 @@ impl<'a> Arg<'a> {
     /// Attempts to retrieve the value of the argument.
     /// This will be None until the ArgParser is used to parse
     /// the arguments.
-    pub fn val<T: TryFrom<&'a Zval>>(&self) -> Option<T> {
-        self.zval.and_then(|zv| zv.try_into().ok())
+    pub fn val<T: FromZval<'a>>(&self) -> Option<T> {
+        self.zval.and_then(|zv| T::from_zval(zv))
     }
 
     /// Attempts to return a reference to the arguments internal Zval.

src/php/types/array.rs

@@ -18,12 +18,11 @@ use crate::{
         HT_MIN_SIZE,
     },
     errors::{Error, Result},
-    php::enums::DataType,
 };
 
 use super::{
     string::ZendString,
-    zval::{IntoZval, Zval},
+    zval::{FromZval, IntoZval, Zval},
 };
 
 /// Result type returned after attempting to insert an element into a hash table.
@@ -369,7 +368,7 @@ build_iter!(IntoIter, ZendHashTable<'a>);
 
 impl<'a, V> TryFrom<ZendHashTable<'a>> for HashMap<String, V>
 where
-    V: TryFrom<&'a Zval>,
+    V: FromZval<'a>,
 {
     type Error = Error;
 
@@ -379,8 +378,7 @@ where
         for (idx, key, val) in zht.into_iter() {
             hm.insert(
                 key.unwrap_or_else(|| idx.to_string()),
-                val.try_into()
-                    .map_err(|_| Error::ZvalConversion(DataType::Null))?,
+                V::from_zval(val).ok_or(Error::ZvalConversion(val.get_type()?))?,
             );
         }
 
@@ -432,16 +430,13 @@ where
 /// a type `T`.
 impl<'a, V> TryFrom<ZendHashTable<'a>> for Vec<V>
 where
-    V: TryFrom<&'a Zval>,
+    V: FromZval<'a>,
 {
     type Error = Error;
 
     fn try_from(ht: ZendHashTable<'a>) -> Result<Self> {
         ht.into_iter()
-            .map(|(_, _, v)| {
-                v.try_into()
-                    .map_err(|_| Error::ZvalConversion(DataType::Null))
-            })
+            .map(|(_, _, v)| V::from_zval(v).ok_or(Error::ZvalConversion(v.get_type()?)))
             .collect::<Result<Vec<_>>>()
     }
 }

src/php/types/binary.rs

@@ -1,7 +1,7 @@
 //! Types relating to binary data transmission between Rust and PHP.
 
 use std::{
-    convert::{TryFrom, TryInto},
+    convert::TryFrom,
     iter::FromIterator,
     ops::{Deref, DerefMut},
 };
@@ -44,26 +44,19 @@ impl<T: Pack> DerefMut for Binary<T> {
     }
 }
 
-impl<'a, T: Pack> FromZval<'a> for Binary<T> {
+impl<T: Pack> FromZval<'_> for Binary<T> {
     const TYPE: DataType = DataType::String;
-}
-
-impl<T: Pack> TryFrom<&Zval> for Binary<T> {
-    type Error = Error;
 
-    fn try_from(value: &Zval) -> Result<Self> {
-        match value.binary() {
-            Some(b) => Ok(Binary(b)),
-            None => Err(Error::Callable),
-        }
+    fn from_zval(zval: &Zval) -> Option<Self> {
+        zval.binary().map(Binary)
     }
 }
 
 impl<T: Pack> TryFrom<Zval> for Binary<T> {
     type Error = Error;
 
     fn try_from(value: Zval) -> Result<Self> {
-        (&value).try_into()
+        Self::from_zval(&value).ok_or(Error::ZvalConversion(value.get_type()?))
     }
 }
 

src/php/types/object.rs

@@ -343,6 +343,38 @@ impl<T: RegisteredClass> IntoZval for T {
     }
 }
 
+impl<'a, T: RegisteredClass> FromZval<'a> for &'a T {
+    const TYPE: DataType = DataType::Object;
+
+    fn from_zval(zval: &'a Zval) -> Option<Self> {
+        let obj = zval.object()?;
+
+        if obj.is_instance::<T>() {
+            // SAFETY: If the zend object is an instance of `T`, we can guarantee that the memory before
+            // it is occupied by an instance of `T`.
+            unsafe { ((obj as *mut ZendObject) as *mut T).offset(-1).as_ref() }
+        } else {
+            None
+        }
+    }
+}
+
+impl<'a, T: RegisteredClass> FromZval<'a> for &'a mut T {
+    const TYPE: DataType = DataType::Object;
+
+    fn from_zval(zval: &'a Zval) -> Option<Self> {
+        let obj = zval.object()?;
+
+        if obj.is_instance::<T>() {
+            // SAFETY: If the zend object is an instance of `T`, we can guarantee that the memory before
+            // it is occupied by an instance of `T`.
+            unsafe { ((obj as *mut ZendObject) as *mut T).offset(-1).as_mut() }
+        } else {
+            None
+        }
+    }
+}
+
 /// Implemented on Rust types which are exported to PHP. Allows users to get and set PHP properties on
 /// the object.
 pub trait RegisteredClass: Default + Sized
@@ -375,7 +407,7 @@ where
     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()
+        T::from_zval(zv)
     }
 
     /// Attempts to set the value of a property on the class object.

src/php/types/zval.rs

@@ -629,53 +629,44 @@ where
 
 /// Allows zvals to be converted into Rust types in a fallible way. Reciprocal of the [`IntoZval`]
 /// trait.
-///
-/// This trait requires the [`TryFrom`] trait to be implemented. All this trait does is contain the
-/// type of data that is expected when parsing the value, which is used when parsing arguments.
-pub trait FromZval<'a>: TryFrom<&'a Zval> {
+pub trait FromZval<'a>: Sized {
     /// The corresponding type of the implemented value in PHP.
     const TYPE: DataType;
+
+    /// Attempts to retrieve an instance of `Self` from a reference to a [`Zval`].
+    ///
+    /// # Parameters
+    ///
+    /// * `zval` - Zval to get value from.
+    fn from_zval(zval: &'a Zval) -> Option<Self>;
 }
 
 impl<'a, T> FromZval<'a> for Option<T>
 where
     T: FromZval<'a>,
 {
     const TYPE: DataType = T::TYPE;
-}
 
-// Converting to an option is infallible.
-impl<'a, T> From<&'a Zval> for Option<T>
-where
-    T: FromZval<'a>,
-{
-    fn from(val: &'a Zval) -> Self {
-        val.try_into().ok()
+    fn from_zval(zval: &'a Zval) -> Option<Self> {
+        Some(T::from_zval(zval))
     }
 }
 
 macro_rules! try_from_zval {
     ($type: ty, $fn: ident, $dt: ident) => {
-        impl<'a> FromZval<'a> for $type {
+        impl FromZval<'_> for $type {
             const TYPE: DataType = DataType::$dt;
-        }
-
-        impl TryFrom<&Zval> for $type {
-            type Error = Error;
 
-            fn try_from(value: &Zval) -> Result<Self> {
-                value
-                    .$fn()
-                    .and_then(|val| val.try_into().ok())
-                    .ok_or(Error::ZvalConversion(value.get_type()?))
+            fn from_zval(zval: &Zval) -> Option<Self> {
+                zval.$fn().and_then(|val| val.try_into().ok())
             }
         }
 
         impl TryFrom<Zval> for $type {
             type Error = Error;
 
             fn try_from(value: Zval) -> Result<Self> {
-                (&value).try_into()
+                Self::from_zval(&value).ok_or(Error::ZvalConversion(value.get_type()?))
             }
         }
     };
@@ -698,44 +689,27 @@ try_from_zval!(f64, double, Double);
 try_from_zval!(bool, bool, Bool);
 try_from_zval!(String, string, String);
 
-impl<'a> FromZval<'a> for f32 {
+impl FromZval<'_> for f32 {
     const TYPE: DataType = DataType::Double;
-}
-
-impl<'a> TryFrom<&'a Zval> for f32 {
-    type Error = Error;
 
-    fn try_from(value: &'a Zval) -> Result<Self> {
-        value
-            .double()
-            .map(|v| v as f32)
-            .ok_or(Error::ZvalConversion(value.get_type()?))
+    fn from_zval(zval: &Zval) -> Option<Self> {
+        zval.double().map(|v| v as f32)
     }
 }
 
 impl<'a> FromZval<'a> for &'a str {
     const TYPE: DataType = DataType::String;
-}
-
-impl<'a> TryFrom<&'a Zval> for &'a str {
-    type Error = Error;
 
-    fn try_from(value: &'a Zval) -> Result<Self> {
-        value.str().ok_or(Error::ZvalConversion(value.get_type()?))
+    fn from_zval(zval: &'a Zval) -> Option<Self> {
+        zval.str()
     }
 }
 
 impl<'a> FromZval<'a> for ZendHashTable<'a> {
     const TYPE: DataType = DataType::Array;
-}
-
-impl<'a> TryFrom<&'a Zval> for ZendHashTable<'a> {
-    type Error = Error;
 
-    fn try_from(value: &'a Zval) -> Result<Self> {
-        value
-            .array()
-            .ok_or(Error::ZvalConversion(value.get_type()?))
+    fn from_zval(zval: &'a Zval) -> Option<Self> {
+        zval.array()
     }
 }
 
@@ -744,19 +718,9 @@ where
     T: FromZval<'a>,
 {
     const TYPE: DataType = DataType::Array;
-}
-
-impl<'a, T> TryFrom<&'a Zval> for Vec<T>
-where
-    T: FromZval<'a>,
-{
-    type Error = Error;
 
-    fn try_from(value: &'a Zval) -> Result<Self> {
-        value
-            .array()
-            .ok_or(Error::ZvalConversion(value.get_type()?))?
-            .try_into()
+    fn from_zval(zval: &'a Zval) -> Option<Self> {
+        zval.array().and_then(|arr| arr.try_into().ok())
     }
 }
 
@@ -779,19 +743,9 @@ where
     T: FromZval<'a>,
 {
     const TYPE: DataType = DataType::Array;
-}
 
-impl<'a, T> TryFrom<&'a Zval> for HashMap<String, T>
-where
-    T: FromZval<'a>,
-{
-    type Error = Error;
-
-    fn try_from(value: &'a Zval) -> Result<Self> {
-        value
-            .array()
-            .ok_or(Error::ZvalConversion(value.get_type()?))?
-            .try_into()
+    fn from_zval(zval: &'a Zval) -> Option<Self> {
+        zval.array().and_then(|arr| arr.try_into().ok())
     }
 }
 
@@ -811,13 +765,9 @@ where
 
 impl<'a> FromZval<'a> for Callable<'a> {
     const TYPE: DataType = DataType::Callable;
-}
-
-impl<'a> TryFrom<&'a Zval> for Callable<'a> {
-    type Error = Error;
 
-    fn try_from(value: &'a Zval) -> Result<Self> {
-        Callable::new(value)
+    fn from_zval(zval: &'a Zval) -> Option<Self> {
+        Callable::new(zval).ok()
     }
 }