Remove generic type of Objects.

Author: jmjoy

phper/src/classes.rs

@@ -15,14 +15,15 @@ use crate::{
     arrays::ZArr,
     errors::{ClassNotFoundError, InitializeObjectError, StateTypeError},
     functions::{Argument, Function, FunctionEntity, FunctionEntry, Method},
-    objects::{ExtendObject, ZObj},
+    objects::{ExtendObject, ZObj, ZObject},
     strings::ZStr,
     sys::*,
     types::Scalar,
     values::ZVal,
 };
 use dashmap::DashMap;
 use once_cell::sync::OnceCell;
+use phper_alloc::ToRefOwned;
 use std::{
     any::{Any, TypeId},
     convert::TryInto,
@@ -214,17 +215,15 @@ impl ClassEntry {
 
     /// Create the object from class, without calling `__construct`, be careful
     /// when `__construct` is necessary.
-    pub fn init_object(&self) -> crate::Result<ZObject> {
+    pub(crate) fn init_object(&self) -> crate::Result<ZObject> {
         unsafe {
             let ptr = self.as_ptr() as *mut _;
-            let mut val = ZVal::from(());
+            let mut val = ZVal::default();
             if !phper_object_init_ex(val.as_mut_ptr(), ptr) {
                 Err(InitializeObjectError::new(self.get_name().to_str()?.to_owned()).into())
             } else {
-                let object = (*val.as_mut_ptr()).value.obj;
-                forget(val);
-                let object: EBox<ZObj> = EBox::from_raw(object.cast());
-                Ok(object)
+                let ptr = phper_z_obj_p(val.as_mut_ptr());
+                Ok(ZObj::from_mut_ptr(ptr).to_ref_owned())
             }
         }
     }
@@ -283,7 +282,7 @@ impl ClassEntity {
             .parent()
             .map(|s| ClassEntry::from_globals(s).unwrap());
 
-        let class: *mut ClassEntry<()> = match parent {
+        let class: *mut ClassEntry = match parent {
             Some(parent) => {
                 zend_register_internal_class_ex(&mut class_ce, parent.as_ptr() as *mut _).cast()
             }

phper/src/functions.rs

@@ -93,7 +93,7 @@ where
         &self, execute_data: &mut ExecuteData, arguments: &mut [ZVal], return_value: &mut ZVal,
     ) {
         unsafe {
-            let this = execute_data.get_this::<T>().unwrap();
+            let this = execute_data.get_this().unwrap();
             let r = (self.f)(this, arguments);
             *return_value = r.into();
         }
@@ -242,7 +242,7 @@ impl ZendFunction {
         }
     }
 
-    pub(crate) fn call<T: 'static>(
+    pub(crate) fn call(
         &mut self, mut object: Option<&mut ZObj>, mut arguments: impl AsMut<[ZVal]>,
     ) -> crate::Result<EBox<ZVal>> {
         let arguments = arguments.as_mut();
@@ -256,7 +256,7 @@ impl ZendFunction {
         let called_scope = unsafe {
             let mut called_scope = object
                 .as_mut()
-                .map(|o| o.get_class::<T>().as_ptr() as *mut zend_class_entry)
+                .map(|o| o.get_class().as_ptr() as *mut zend_class_entry)
                 .unwrap_or(null_mut());
             if called_scope.is_null() {
                 called_scope = self.inner.common.scope;

phper/src/objects.rs

@@ -207,13 +207,13 @@ pub struct ZObject {
 
 impl ZObject {
     /// Another way to new object like [crate::classes::ClassEntry::new_object].
-    pub fn new(class_entry: &ClassEntry, arguments: &mut [ZVal]) -> crate::Result<EBox<Self>> {
+    pub fn new(class_entry: &ClassEntry, arguments: &mut [ZVal]) -> crate::Result<Self> {
         class_entry.new_object(arguments)
     }
 
     pub fn new_by_class_name(
         class_name: impl AsRef<str>, arguments: &mut [ZVal],
-    ) -> crate::Result<EBox<Self>> {
+    ) -> crate::Result<Self> {
         let class_entry = ClassEntry::from_globals(class_name)?;
         Self::new(class_entry, arguments)
     }

phper/src/values.rs

@@ -16,7 +16,7 @@ use crate::{
     classes::ClassEntry,
     errors::{ExpectTypeError, NotRefCountedTypeError, Throwable, TypeError},
     functions::{call_internal, ZendFunction},
-    objects::ZObj,
+    objects::{ZObj, ZObject},
     resources::ZRes,
     strings::{ZStr, ZString},
     sys::*,
@@ -98,8 +98,8 @@ impl ExecuteData {
     ///
     /// The type of `T` should be careful.
     pub unsafe fn get_this(&mut self) -> Option<&mut ZObj> {
-        let ptr = phper_get_this(&mut self.inner) as *mut ZVal;
-        ptr.as_mut().map(|val| val.as_mut_z_obj())
+        let val = ZVal::from_mut_ptr(phper_get_this(&mut self.inner));
+        val.as_mut_z_obj()
     }
 
     /// TODO Do not return owned object, because usually Val should not be drop.
@@ -499,8 +499,8 @@ impl From<ZArray> for ZVal {
     }
 }
 
-impl From<ZObj> for ZVal {
-    fn from(mut obj: ZObj) -> Self {
+impl From<ZObject> for ZVal {
+    fn from(mut obj: ZObject) -> Self {
         unsafe {
             let mut val = MaybeUninit::<ZVal>::uninit();
             phper_zval_obj(obj.as_mut_ptr().cast(), obj.into_raw());