extends(StateClass)

import ClassEntity::extends(StateClass) code from jmjoy:phper-fork:extends

Author: brettmc

examples/http-client/src/errors.rs

@@ -9,7 +9,7 @@
 // See the Mulan PSL v2 for more details.
 
 use phper::{
-    classes::{ClassEntity, ClassEntry},
+    classes::{ClassEntity, ClassEntry, StateClass},
     errors::{Throwable, exception_class},
 };
 
@@ -19,7 +19,7 @@ const EXCEPTION_CLASS_NAME: &str = "HttpClient\\HttpClientException";
 pub fn make_exception_class() -> ClassEntity<()> {
     let mut class = ClassEntity::new(EXCEPTION_CLASS_NAME);
     // The `extends` is same as the PHP class `extends`.
-    class.extends_name("Exception");
+    class.extends(StateClass::from_name("Exception"));
     class
 }
 

examples/http-server/src/errors.rs

@@ -9,7 +9,7 @@
 // See the Mulan PSL v2 for more details.
 
 use phper::{
-    classes::{ClassEntity, ClassEntry},
+    classes::{ClassEntity, ClassEntry, StateClass},
     errors::{Throwable, exception_class},
 };
 use std::error::Error;
@@ -43,6 +43,6 @@ impl From<HttpServerError> for phper::Error {
 pub fn make_exception_class() -> ClassEntity<()> {
     let mut class = ClassEntity::new(EXCEPTION_CLASS_NAME);
     // As an Exception class, inheriting from the base Exception class is important.
-    class.extends_name("Exception");
+    class.extends(StateClass::from_name("Exception"));
     class
 }

phper-doc/doc/_02_quick_start/_02_write_a_simple_http_client/index.md

@@ -91,7 +91,7 @@ Now let's begin to finish the logic.
 
    ```rust
    use phper::{
-       classes::{ClassEntry, ClassEntity},
+       classes::{ClassEntry, ClassEntity, StateClass},
        errors::{exception_class, Throwable},
    };
 
@@ -101,7 +101,7 @@ Now let's begin to finish the logic.
    pub fn make_exception_class() -> ClassEntity<()> {
        let mut class = ClassEntity::new(EXCEPTION_CLASS_NAME);
        // The `extends` is same as the PHP class `extends`.
-       class.extends_name("Exception");
+       class.extends(StateClass::from_name("Exception"));
        class
    }
 
@@ -155,7 +155,7 @@ Now let's begin to finish the logic.
    # pub fn make_exception_class() -> ClassEntity<()> {
    #     let mut class = ClassEntity::new(EXCEPTION_CLASS_NAME);
    #     // The `extends` is same as the PHP class `extends`.
-   #     class.extends_name("Exception");
+   #     class.extends(StateClass::from_name("Exception"));
    #     class
    # }
    #

phper-doc/doc/_06_module/_06_register_class/index.md

@@ -39,16 +39,16 @@ class Foo {}
 ## Extends & implements
 
 To allow a class to extend another, you can either use `ClassEntity.extends(StateClass<T>)` for classes implemented
-in your module, or `ClassEntity.extends_name(String)` for built-ins (although, `extends_name` should actually work
-for any class).
+in your module.
 
-If you want the class `Foo` extends `Bar`, and implements interface `Stringable`:
+If you want class `Foo` extends `Bar`, and implements interface `Stringable`:
 
 ```rust,no_run
 use phper::classes::{ClassEntity, ClassEntry, Interface};
 
+let mut bar = ClassEntity::new("Bar").bind_class();
 let mut foo = ClassEntity::new("Foo");
-foo.extends_name("Bar");
+foo.extends(bar);
 foo.implements(Interface::from_name("Stringable"));
 ```
 

phper/src/classes.rs

@@ -28,7 +28,7 @@ use std::{
     ffi::{CString, c_char, c_void},
     fmt::Debug,
     marker::PhantomData,
-    mem::{ManuallyDrop, replace, size_of, zeroed},
+    mem::{ManuallyDrop, replace, size_of, transmute, zeroed},
     os::raw::c_int,
     ptr,
     ptr::null_mut,
@@ -287,13 +287,26 @@ fn find_global_class_entry_ptr(name: impl AsRef<str>) -> *mut zend_class_entry {
 /// ```
 pub struct StateClass<T> {
     inner: Rc<RefCell<*mut zend_class_entry>>,
+    name: Option<String>,
     _p: PhantomData<T>,
 }
 
+impl StateClass<()> {
+    /// Create from name, which will be looked up from globals.
+    pub fn from_name(name: impl Into<String>) -> Self {
+        Self {
+            inner: Rc::new(RefCell::new(null_mut())),
+            name: Some(name.into()),
+            _p: PhantomData,
+        }
+    }
+}
+
 impl<T> StateClass<T> {
     fn null() -> Self {
         Self {
             inner: Rc::new(RefCell::new(null_mut())),
+            name: None,
             _p: PhantomData,
         }
     }
@@ -304,7 +317,11 @@ impl<T> StateClass<T> {
 
     /// Converts to class entry.
     pub fn as_class_entry(&self) -> &ClassEntry {
-        unsafe { ClassEntry::from_mut_ptr(*self.inner.borrow()) }
+        if let Some(name) = &self.name {
+            ClassEntry::from_globals(name).unwrap()
+        } else {
+            unsafe { ClassEntry::from_mut_ptr(*self.inner.borrow()) }
+        }
     }
 
     /// Create the object from class and call `__construct` with arguments.
@@ -333,6 +350,7 @@ impl<T> Clone for StateClass<T> {
     fn clone(&self) -> Self {
         Self {
             inner: self.inner.clone(),
+            name: self.name.clone(),
             _p: self._p,
         }
     }
@@ -427,7 +445,7 @@ pub struct ClassEntity<T: 'static> {
     state_constructor: Rc<StateConstructor>,
     method_entities: Vec<MethodEntity>,
     property_entities: Vec<PropertyEntity>,
-    parent: Option<Box<dyn Fn() -> &'static ClassEntry>>,
+    parent: Option<StateClass<()>>,
     interfaces: Vec<Interface>,
     constants: Vec<ConstantEntity>,
     bind_class: StateClass<T>,
@@ -557,7 +575,7 @@ impl<T: 'static> ClassEntity<T> {
     ///
     /// ```no_run
     /// use phper::{
-    ///     classes::{ClassEntity, ClassEntry},
+    ///     classes::{ClassEntity, ClassEntry, StateClass},
     ///     modules::Module,
     ///     php_get_module,
     /// };
@@ -572,38 +590,18 @@ impl<T: 'static> ClassEntity<T> {
     ///
     ///     let foo = module.add_class(ClassEntity::new("Foo"));
     ///     let mut bar = ClassEntity::new("Bar");
-    ///     bar.extends(&foo);
+    ///     bar.extends(foo);
+    ///     module.add_class(bar);
+    ///
+    ///     let mut ex = ClassEntity::new("MyException");
+    ///     ex.extends(StateClass::from_name("Exception"));
+    ///     module.add_class(ex);
     ///
     ///     module
     /// }
     /// ```
-    pub fn extends<U: 'static>(&mut self, parent: &StateClass<U>) {
-        let parent = parent.clone();
-        self.parent = Some(Box::new(move || {
-            let entry: &'static ClassEntry =
-                unsafe { std::mem::transmute(parent.as_class_entry()) };
-            entry
-        }));
-    }
-
-    /// Register class to `extends` the parent class, by name. Similar to
-    /// `extends`, this is useful for built-ins.
-    ///
-    /// # Examples
-    ///
-    /// ```no_run
-    /// use phper::classes::{ClassEntity, ClassEntry};
-    ///
-    /// let mut class = ClassEntity::new("MyException");
-    /// class.extends_name("Exception");
-    /// ```
-    pub fn extends_name(&mut self, name: impl Into<String>) {
-        let name = name.into();
-        self.parent = Some(Box::new(move || {
-            ClassEntry::from_globals(&name).unwrap_or_else(|_| {
-                panic!("Unable to resolve parent class: {}", name);
-            })
-        }));
+    pub fn extends<S: 'static>(&mut self, parent: StateClass<S>) {
+        self.parent = Some(unsafe { transmute::<StateClass<S>, StateClass<()>>(parent) });
     }
 
     /// Register class to `implements` the interface, due to the class can
@@ -672,11 +670,12 @@ impl<T: 'static> ClassEntity<T> {
     #[allow(clippy::useless_conversion)]
     pub(crate) unsafe fn init(&self) -> *mut zend_class_entry {
         unsafe {
-            let parent: *mut zend_class_entry = if let Some(ref parent_fn) = self.parent {
-                parent_fn().as_ptr() as *mut _
-            } else {
-                null_mut()
-            };
+            let parent: *mut zend_class_entry = self
+                .parent
+                .as_ref()
+                .map(|parent| parent.as_class_entry())
+                .map(|entry| entry.as_ptr() as *mut _)
+                .unwrap_or(null_mut());
 
             let class_ce = phper_init_class_entry_ex(
                 self.class_name.as_ptr().cast(),

tests/integration/src/classes.rs

@@ -24,7 +24,7 @@ pub fn integrate(module: &mut Module) {
     integrate_i_bar(module);
     integrate_static_props(module);
     integrate_i_constants(module);
-    integrate_bar_extends_foo(module, &foo_class);
+    integrate_bar_extends_foo(module, foo_class);
     #[cfg(phper_major_version = "8")]
     integrate_stringable(module);
 }
@@ -222,7 +222,7 @@ fn integrate_static_props(module: &mut Module) {
     module.add_class(class);
 }
 
-fn integrate_bar_extends_foo(module: &mut Module, foo_class: &StateClass<Foo>) {
+fn integrate_bar_extends_foo(module: &mut Module, foo_class: StateClass<Foo>) {
     let mut cls = ClassEntity::new(r"IntegrationTest\BarExtendsFoo");
     cls.extends(foo_class);
     cls.add_method("test", Visibility::Public, |_, _| phper::ok(()));