simplify testcase

Author: brettmc

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

@@ -38,8 +38,8 @@ class Foo {}
 
 ## Extends & implements
 
-To allow a class to extend another, you can use `ClassEntity.extends(StateClass<T>)` for classes implemented
-in your module. A StateClass can either be obtained by registering your own class against the module, or
+To allow a class to extend another, you can use `ClassEntity.extends(StateClass<T>)`.
+A StateClass can either be obtained by registering your own class against the module, or
 by  looking up the class by name (for example, for PHP built-in classes like `Exception`).
 
 If you want class `Foo` extends `Bar`, and implements interface `Stringable`:
@@ -195,3 +195,51 @@ class MyHashMap {
 
 }
 ```
+
+## Circular class dependencies
+If you wish to register classes which depend on each other, you can retrieve the bound class (`StateClass<T>`)
+from a `ClassEntity`, and use it in functions and methods:
+
+```rust,no_run
+use phper::{
+    classes::{ClassEntity, StateClass, Visibility},
+    modules::Module,
+};
+
+let mut module = Module::new(
+    env!("CARGO_CRATE_NAME"),
+    env!("CARGO_PKG_VERSION"),
+    env!("CARGO_PKG_AUTHORS"),
+);
+
+let mut a_cls = ClassEntity::new("A");
+let mut b_cls = ClassEntity::new("B");
+let a_bound_class = a_cls.bound_class();
+let b_bound_class = b_cls.bound_class();
+
+a_cls.add_static_method("createB", Visibility::Public, move |_| {
+    let object = b_bound_class.init_object()?;
+    Ok::<_, phper::Error>(object)
+});
+b_cls.add_static_method("createA", Visibility::Public, move |_| {
+    let object = a_bound_class.init_object()?;
+    Ok::<_, phper::Error>(object)
+});
+
+module.add_class(a_cls);
+module.add_class(b_cls);
+```
+
+This is equivalent to the following PHP code:
+```php
+class A {
+  public static function createB(): B {
+    return new B();
+  }
+}
+class B {
+  public static function createA(): A {
+    return new A();
+  }
+}
+```

tests/integration/src/classes.rs

@@ -17,7 +17,6 @@ use phper::{
     values::ZVal,
 };
 use std::{collections::HashMap, convert::Infallible};
-use std::rc::Rc;
 
 pub fn integrate(module: &mut Module) {
     integrate_a(module);
@@ -238,46 +237,28 @@ fn integrate_dependent_classes(module: &mut Module) {
     let mut a_cls = ClassEntity::new(A_CLS);
     let mut b_cls = ClassEntity::new(B_CLS);
 
-    // Placeholder, will clone StateClass into closures after registration
-    let a_cls_ref = std::rc::Rc::new(std::cell::RefCell::new(None));
-    let b_cls_ref = std::rc::Rc::new(std::cell::RefCell::new(None));
-
-    {
-        let b_cls_ref = Rc::clone(&b_cls_ref);
-        a_cls.add_static_method("createB", Visibility::Public, move |_| {
-            let borrow = b_cls_ref.borrow();
-            let b_state: &StateClass<()> = borrow
-                .as_ref()
-                .expect("B class not registered");
-            let obj = b_state.init_object()?;
-            Ok::<_, phper::Error>(obj)
-        })
-        .return_type(ReturnType::new(ReturnTypeHint::ClassEntry(String::from(B_CLS))));
-    }
-
-    {
-        let a_cls_ref = Rc::clone(&a_cls_ref);
-        b_cls.add_static_method("createA", Visibility::Public, move |_| {
-            let borrow = a_cls_ref.borrow();
-            let a_state: &StateClass<()> = borrow
-                .as_ref()
-                .expect("A class not registered");
-            let obj = a_state.init_object()?;
-            Ok::<_, phper::Error>(obj)
-        })
-        .return_type(ReturnType::new(ReturnTypeHint::ClassEntry(String::from(A_CLS))));
-    }
+    let a_bound_class = a_cls.bound_class();
+    let b_bound_class = b_cls.bound_class();
 
+    a_cls
+        .add_static_method("createB", Visibility::Public, move |_| {
+            let object = b_bound_class.init_object()?;
+            Ok::<_, phper::Error>(object)
+        })
+        .return_type(ReturnType::new(ReturnTypeHint::ClassEntry(B_CLS.into())));
 
-    // Register both classes and save the StateClass into shared RefCells
-    let a_state = module.add_class(a_cls);
-    let b_state = module.add_class(b_cls);
+    b_cls
+        .add_static_method("createA", Visibility::Public, move |_| {
+            let object = a_bound_class.init_object()?;
+            Ok::<_, phper::Error>(object)
+        })
+        .return_type(ReturnType::new(ReturnTypeHint::ClassEntry(A_CLS.into())));
 
-    *a_cls_ref.borrow_mut() = Some(a_state);
-    *b_cls_ref.borrow_mut() = Some(b_state);
+    // Register both classes
+    module.add_class(a_cls);
+    module.add_class(b_cls);
 }
 
-
 #[cfg(phper_major_version = "8")]
 fn integrate_stringable(module: &mut Module) {
     use phper::{functions::ReturnType, types::ReturnTypeHint};