extends StateClass

Author: brettmc

examples/http-client/src/errors.rs

@@ -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("Exception");
+    class.extends_name("Exception");
     class
 }
 

examples/http-server/src/errors.rs

@@ -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("Exception");
+    class.extends_name("Exception");
     class
 }

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

@@ -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("Exception");
+       class.extends_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("Exception");
+   #     class.extends_name("Exception");
    #     class
    # }
    #

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

@@ -38,13 +38,17 @@ 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).
+
 If you want the class `Foo` extends `Bar`, and implements interface `Stringable`:
 
 ```rust,no_run
 use phper::classes::{ClassEntity, ClassEntry, Interface};
 
 let mut foo = ClassEntity::new("Foo");
-foo.extends("Bar");
+foo.extends_name("Bar");
 foo.implements(Interface::from_name("Stringable"));
 ```
 

phper/src/classes.rs

@@ -427,7 +427,7 @@ pub struct ClassEntity<T: 'static> {
     state_constructor: Rc<StateConstructor>,
     method_entities: Vec<MethodEntity>,
     property_entities: Vec<PropertyEntity>,
-    parent: Option<String>,
+    parent: Option<Box<dyn Fn() -> &'static ClassEntry>>,
     interfaces: Vec<Interface>,
     constants: Vec<ConstantEntity>,
     bind_class: StateClass<T>,
@@ -556,13 +556,54 @@ impl<T: 'static> ClassEntity<T> {
     /// # Examples
     ///
     /// ```no_run
+    /// use phper::{
+    ///     classes::{ClassEntity, ClassEntry},
+    ///     modules::Module,
+    ///     php_get_module,
+    /// };
+    ///
+    /// #[php_get_module]
+    /// pub fn get_module() -> Module {
+    ///     let mut module = Module::new(
+    ///         env!("CARGO_CRATE_NAME"),
+    ///         env!("CARGO_PKG_VERSION"),
+    ///         env!("CARGO_PKG_AUTHORS"),
+    ///     );
+    ///
+    ///     let foo = module.add_class(ClassEntity::new("Foo"));
+    ///     let mut bar = ClassEntity::new("Bar");
+    ///     bar.extends(&foo);
+    ///
+    /// 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("Exception");
+    /// class.extends_name("Exception");
     /// ```
-    pub fn extends(&mut self, parent_name: impl Into<String>) {
-        self.parent = Some(parent_name.into());
+    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);
+            })
+        }));
     }
 
     /// Register class to `implements` the interface, due to the class can
@@ -631,11 +672,8 @@ 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 name) = self.parent {
-                let entry = ClassEntry::from_globals(name).unwrap_or_else(|err| {
-                    panic!("Unable to resolve parent class: {}: {}", name,err);
-                });
-                entry.as_ptr() as *mut _
+            let parent: *mut zend_class_entry = if let Some(ref parent_fn) = self.parent {
+                parent_fn().as_ptr() as *mut _
             } else {
                 null_mut()
             };

tests/integration/src/classes.rs

@@ -11,7 +11,7 @@
 use phper::{
     alloc::RefClone,
     classes::{
-        ClassEntity, ClassEntry, Interface, InterfaceEntity, Visibility,
+        ClassEntity, ClassEntry, Interface, InterfaceEntity, StateClass, Visibility,
     },
     functions::{Argument, ReturnType},
     modules::Module,
@@ -22,11 +22,11 @@ use std::{collections::HashMap, convert::Infallible};
 
 pub fn integrate(module: &mut Module) {
     integrate_a(module);
-    integrate_foo(module);
+    let foo = integrate_foo(module);
     integrate_i_bar(module);
     integrate_static_props(module);
     integrate_i_constants(module);
-    integrate_bar_extends_foo(module);
+    integrate_bar_extends_foo(module, &foo);
     #[cfg(phper_major_version = "8")]
     integrate_stringable(module);
 }
@@ -78,7 +78,7 @@ struct Foo {
     array: HashMap<i64, ZVal>,
 }
 
-fn integrate_foo(module: &mut Module) {
+fn integrate_foo(module: &mut Module) -> StateClass<Foo> {
     let mut class = ClassEntity::new_with_state_constructor("IntegrationTest\\Foo", || Foo {
         position: 0,
         array: Default::default(),
@@ -169,7 +169,7 @@ fn integrate_foo(module: &mut Module) {
         .argument(Argument::new("offset").with_type_hint(ArgumentTypeHint::Mixed))
         .return_type(ReturnType::new(ReturnTypeHint::Void));
 
-    module.add_class(class);
+    module.add_class(class)
 }
 
 fn integrate_i_bar(module: &mut Module) {
@@ -224,9 +224,9 @@ fn integrate_static_props(module: &mut Module) {
     module.add_class(class);
 }
 
-fn integrate_bar_extends_foo(module: &mut Module) {
+fn integrate_bar_extends_foo(module: &mut Module, foo: &StateClass<Foo>) {
     let mut cls = ClassEntity::new(r"IntegrationTest\BarExtendsFoo");
-    cls.extends(r"IntegrationTest\Foo");
+    cls.extends(foo);
     cls.add_method("test", Visibility::Public, |_,_| {
         phper::ok(())
     });