Fixes

Author: danog

src/types/object.rs

@@ -6,11 +6,11 @@ use std::{convert::TryInto, fmt::Debug, ops::DerefMut};
 use crate::{
     boxed::{ZBox, ZBoxable},
     class::RegisteredClass,
-    convert::{FromZendObject, FromZval, FromZvalMut, IntoZval},
+    convert::{FromZendObject, FromZval, FromZvalMut, IntoZval, IntoZvalDyn},
     error::{Error, Result},
     ffi::{
         ext_php_rs_zend_object_release, zend_call_known_function, zend_object, zend_objects_new,
-        HashTable, ZEND_ISEMPTY, ZEND_PROPERTY_EXISTS, ZEND_PROPERTY_ISSET,
+        HashTable, ZEND_ISEMPTY, ZEND_PROPERTY_EXISTS, ZEND_PROPERTY_ISSET, zend_hash_str_find_ptr_lc, zend_function,
     },
     flags::DataType,
     rc::PhpRc,
@@ -121,6 +121,39 @@ impl ZendObject {
         (self.ce as *const ClassEntry).eq(&(T::get_metadata().ce() as *const _))
     }
 
+
+    #[inline(always)]
+    pub fn try_call_method(&self, name: &str, params: Vec<&dyn IntoZvalDyn>) -> Result<Zval> {
+        let mut retval = Zval::new();
+        let len = params.len();
+        let params = params
+            .into_iter()
+            .map(|val| val.as_zval(false))
+            .collect::<Result<Vec<_>>>()?;
+        let packed = params.into_boxed_slice();
+
+        unsafe {
+            let res = zend_hash_str_find_ptr_lc(
+                &(*self.ce).function_table,
+                name.as_ptr() as *const i8,
+                name.len()
+            ) as *mut zend_function;
+            if res.is_null() {
+                return Err(Error::Callable)
+            }
+            zend_call_known_function(
+                res,
+                self as *const _ as *mut _,
+                self.ce,
+                &mut retval,
+                len as _,
+                packed.as_ptr() as *mut _,
+                std::ptr::null_mut(),
+            )
+        };
+
+        Ok(retval)
+    }
     /// Attempts to read a property from the Object. Returns a result containing
     /// the value of the property if it exists and can be read, and an
     /// [`Error`] otherwise.

src/types/zval.rs

@@ -206,6 +206,11 @@ impl Zval {
         }
     }
 
+    #[inline(always)]
+    pub fn try_call_method(&self, name: &str, params: Vec<&dyn IntoZvalDyn>) -> Result<Zval> {
+        self.object().ok_or(Error::Object)?.try_call_method(name, params)
+    }
+
     /// Returns the value of the zval if it is a reference.
     pub fn reference(&self) -> Option<&Zval> {
         if self.is_reference() {

src/zend/fibers.rs

@@ -38,9 +38,7 @@ pub struct EventLoop {
     notify_receiver: File,
 
     get_current_suspension: Function,
-    suspend: Function,
-    resume: Function,
-    
+
     dummy: [u8; 1],
 }
 
@@ -61,8 +59,6 @@ impl EventLoop {
             notify_receiver: unsafe { File::from_raw_fd(notify_receiver) },
             dummy: [0; 1],
             get_current_suspension: Function::try_from_method("\\Revolt\\EventLoop", "getSuspension").ok_or("\\Revolt\\EventLoop::getSuspension does not exist")?,
-            suspend: Function::try_from_method("\\Revolt\\EventLoop\\Suspension", "suspend").ok_or("\\Revolt\\Suspension::suspend does not exist")?,
-            resume: Function::try_from_method("\\Revolt\\EventLoop\\Suspension", "resume").ok_or("\\Revolt\\Suspension::resume does not exist")?
         })
     }
 
@@ -75,7 +71,7 @@ impl EventLoop {
 
         for fiber_id in self.receiver.try_iter() {
             if let Some(fiber) = self.fibers.get_index_mut(fiber_id) {
-                self.resume.try_call_obj(fiber, vec![])?;
+                fiber.object_mut().unwrap().try_call_method("resume", vec![])?;
                 self.fibers.remove_index(fiber_id);
             }
         }
@@ -92,9 +88,8 @@ impl EventLoop {
     pub fn suspend() {
         EVENTLOOP.with_borrow_mut(|c| {
             let c = c.as_mut().unwrap();
-            let mut suspension = call_user_func!(c.get_current_suspension).unwrap();
-            c.suspend.try_call_obj(&mut suspension, vec![])
-        }).unwrap();
+            call_user_func!(c.get_current_suspension).unwrap().try_call_method("suspend", vec![]).unwrap();
+        });
     }
 
     pub fn get_sender(&self) -> Sender<u64> {

src/zend/function.rs

@@ -2,7 +2,7 @@
 
 use std::{fmt::Debug, os::raw::c_char, ptr::self};
 
-use crate::{ffi::{zend_function_entry, zend_fetch_function_str, zend_function, zend_hash_str_find_ptr_lc, zend_call_known_function}, convert::IntoZvalDyn, types::Zval, error::{Result, Error}};
+use crate::{ffi::{zend_function_entry, zend_fetch_function_str, zend_function, zend_hash_str_find_ptr_lc, zend_call_known_function}, convert::IntoZvalDyn, types::Zval, error::Result};
 
 use super::ClassEntry;
 
@@ -101,7 +101,7 @@ impl Function {
     /// assert_eq!(result.long(), Some(1));
     /// ```
     #[inline(always)]
-    pub fn try_call(&mut self, params: Vec<&dyn IntoZvalDyn>) -> Result<Zval> {
+    pub fn try_call(&self, params: Vec<&dyn IntoZvalDyn>) -> Result<Zval> {
         let mut retval = Zval::new();
         let len = params.len();
         let params = params
@@ -112,7 +112,7 @@ impl Function {
 
         unsafe {
             zend_call_known_function(
-                self as *mut _,
+                self as *const _ as *mut _,
                 std::ptr::null_mut(),
                 std::ptr::null_mut(),
                 &mut retval,
@@ -124,30 +124,4 @@ impl Function {
 
         Ok(retval)
     }
-
-    #[inline(always)]
-    pub fn try_call_obj(&mut self, obj: &mut Zval, params: Vec<&dyn IntoZvalDyn>) -> Result<Zval> {
-        let obj = obj.object_mut().ok_or(Error::Object)?;
-        let mut retval = Zval::new();
-        let len = params.len();
-        let params = params
-            .into_iter()
-            .map(|val| val.as_zval(false))
-            .collect::<Result<Vec<_>>>()?;
-        let packed = params.into_boxed_slice();
-
-        unsafe {
-            zend_call_known_function(
-                self as *mut _,
-                obj as *mut _,
-                obj.ce,
-                &mut retval,
-                len as _,
-                packed.as_ptr() as *mut _,
-                std::ptr::null_mut(),
-            )
-        };
-
-        Ok(retval)
-    }
-}
+}