Add ability to send Rust closures to PHP (#58)

* Start work on returning new objects

Change `IntoZval` to consume `self`

* Add conversion from vector reference to PHP hashtable through clones

* `set_binary` now only takes `Vec`

Used to take `AsRef<[T]>` to allow users to pass arrays, however, this
causes the data to be cloned even if the user passes a `Vec`.

* Rename `as_zval` to `into_zval` to match Rust conventions

* Started work on closures

* Finish implementation of closures

* Document closures, add to prelude, feature gate

* Fixed closure example

Author: davidcole1340

.github/workflows/build.yml

@@ -47,7 +47,7 @@ jobs:
           LIBCLANG_PATH: ${{ runner.temp }}/llvm-${{ matrix.llvm }}/lib
         with:
           command: build
-          args: --release
+          args: --release --features alloc,closure
       - name: Test guide examples
         run: |
           mdbook test guide -L target/release/deps

Cargo.toml

@@ -22,7 +22,9 @@ cc = "1.0.67"
 [features]
 zts = []
 debug = []
+
 alloc = []
+closure = []
 
 [workspace]
 members = [

example/skel/Cargo.toml

@@ -7,7 +7,7 @@ edition = "2018"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-ext-php-rs = { path = "../../", features = ["alloc"] }
+ext-php-rs = { path = "../../", features = ["alloc", "closure"] }
 
 [lib]
 name = "skel"

example/skel/php

@@ -6,4 +6,4 @@ case "$(uname)" in
     *) EXT="so" ;;
 esac
 
-php -dextension=$PWD/../../target/debug/libskel.$EXT "${@}"
+cargo build && php -dextension=$PWD/../../target/debug/libskel.$EXT "${@}"

example/skel/src/lib.rs

@@ -1,7 +1,18 @@
 mod allocator;
 
 use allocator::PhpAllocator;
-use ext_php_rs::{php_class, prelude::*};
+use ext_php_rs::{
+    php::{
+        exceptions::PhpException,
+        types::{
+            callable::Callable,
+            closure::Closure,
+            object::{ClassObject, ClassRef},
+        },
+    },
+    php_class,
+    prelude::*,
+};
 
 // #[php_function]
 // pub fn hello_world() -> String {
@@ -112,21 +123,47 @@ static GLOBAL: PhpAllocator = PhpAllocator::new();
 #[php_class]
 #[property(test = 0)]
 #[property(another = "Hello world")]
-#[derive(Default)]
+#[derive(Default, Debug, Clone)]
 pub struct Test {
-    test: String,
+    pub test: String,
+}
+
+#[php_class]
+#[derive(Default)]
+struct PhpFuture {
+    then: Option<Callable<'static>>,
 }
 
 #[php_impl]
-impl Test {
-    pub fn get(&mut self) -> &Test {
-        use ext_php_rs::php::types::object::ZendObjectOverride;
+impl PhpFuture {
+    pub fn then(&mut self, then: Callable<'static>) {
+        self.then = Some(then);
+    }
 
-        dbg!(unsafe { self.get_property::<String>("test") });
-        unsafe { self.set_property("test", "another string") };
-        self
+    pub fn now(&self) -> Result<(), PhpException> {
+        if let Some(then) = &self.then {
+            then.try_call(vec![&"Hello"]).unwrap();
+            Ok(())
+        } else {
+            Err(PhpException::default("No `then`".into()))
+        }
     }
 
+    pub fn obj(&self) -> ClassObject<Test> {
+        let obj = ClassObject::new(Test {
+            test: "Hello world from class entry :)".into(),
+        });
+
+        obj
+    }
+
+    pub fn return_self(&self) -> ClassRef<PhpFuture> {
+        ClassRef::from_ref(self).unwrap()
+    }
+}
+
+#[php_impl]
+impl Test {
     pub fn set_str(&mut self, str: String) {
         self.test = str;
     }
@@ -136,8 +173,41 @@ impl Test {
     }
 }
 
+#[php_function]
+pub fn get_closure() -> Closure {
+    let mut x = 100;
+    Closure::wrap(Box::new(move || {
+        x += 5;
+        format!("x: {}", x)
+    }) as Box<dyn FnMut() -> String>)
+}
+
+#[php_function]
+pub fn fn_once() -> Closure {
+    let x = "Hello".to_string();
+    Closure::wrap_once(Box::new(move || {
+        println!("val here: {}", &x);
+        x
+    }) as Box<dyn FnOnce() -> String>)
+}
+
+#[php_function]
+pub fn closure_get_string() -> Closure {
+    // Return a closure which takes two integers and returns a string
+    Closure::wrap(Box::new(|a, b| format!("A: {} B: {}", a, b)) as Box<dyn Fn(i32, i32) -> String>)
+}
+
+#[php_function]
+pub fn closure_count() -> Closure {
+    let mut count = 0i32;
+
+    Closure::wrap(Box::new(move |a: i32| {
+        count += a;
+        count
+    }) as Box<dyn FnMut(i32) -> i32>)
+}
+
 #[php_module]
 pub fn module(module: ModuleBuilder) -> ModuleBuilder {
-    // module.info_function(php_module_info)
     module
 }

example/skel/test.php

@@ -1,15 +1,9 @@
 <?php
 
-include __DIR__.'/vendor/autoload.php';
+$x = fn_once();
+$x();
+$x();
 
-var_dump('program starting');
-$x = new Test();
-$x->set_str('Hello World');
-var_dump($x->get_str());
-var_dump($x->get());
-# $x->test = 'hello world';
-var_dump($x->get());
-var_dump($x->get_str());
-// var_dump($x);
-var_dump('program done');
-// var_dump($x->get_str());
+// $x = get_closure();
+
+// var_dump($x(5));

ext-php-rs-derive/src/class.rs

@@ -67,38 +67,16 @@ pub fn parser(args: AttributeArgs, mut input: ItemStruct) -> Result<TokenStream>
 
     let ItemStruct { ident, .. } = &input;
     let class_name = args.name.unwrap_or_else(|| ident.to_string());
-    let handlers = Ident::new(
-        &format!("_{}_OBJECT_HANDLERS", ident.to_string()),
-        Span::call_site(),
-    );
-    let class_entry = Ident::new(
-        &format!("_{}_CLASS_ENTRY", ident.to_string()),
-        Span::call_site(),
-    );
+    let meta = Ident::new(&format!("_{}_META", ident.to_string()), Span::call_site());
 
     let output = quote! {
         #input
 
-        static #handlers: ::ext_php_rs::php::types::object::Handlers<#ident> = ::ext_php_rs::php::types::object::Handlers::new();
-        static mut #class_entry: ::std::option::Option<&'static ::ext_php_rs::php::class::ClassEntry> = None;
+        static #meta: ::ext_php_rs::php::types::object::ClassMetadata<#ident> = ::ext_php_rs::php::types::object::ClassMetadata::new();
 
-        impl ::ext_php_rs::php::types::object::ZendObjectOverride for #ident {
-            unsafe extern "C" fn create_object(
-                ce: *mut ::ext_php_rs::php::class::ClassEntry,
-            ) -> *mut ::ext_php_rs::php::types::object::ZendObject {
-                ::ext_php_rs::php::types::object::ZendClassObject::<#ident>::new_ptr(ce, #handlers.get())
-                    .expect("Failed to allocate memory for new Zend object.")
-            }
-
-            fn get_class() -> &'static ::ext_php_rs::php::class::ClassEntry {
-                unsafe {
-                    #class_entry
-                        .expect(concat!("Class `", #class_name, "` has not been initialized yet."))
-                }
-            }
-
-            fn set_class(ce: &'static ::ext_php_rs::php::class::ClassEntry) {
-                unsafe { #class_entry.replace(ce) };
+        impl ::ext_php_rs::php::types::object::RegisteredClass for #ident {
+            fn get_metadata() -> &'static ::ext_php_rs::php::types::object::ClassMetadata<Self> {
+                &#meta
             }
         }
     };

ext-php-rs-derive/src/method.rs

@@ -142,7 +142,8 @@ fn build_arg_definitions(args: &[Arg]) -> (Vec<TokenStream>, bool) {
                 _static = false;
 
                 quote! {
-                    let #mutability this = match ::ext_php_rs::php::types::object::ZendClassObject::<Self>::get(ex) {
+                    // SAFETY: We are calling this on an execution data from a class method.
+                    let #mutability this = match unsafe { ex.get_object::<Self>() } {
                         Some(this) => this,
                         None => return ::ext_php_rs::php::exceptions::throw(
                             ::ext_php_rs::php::class::ClassEntry::exception(),

ext-php-rs-derive/src/startup_function.rs

@@ -28,6 +28,8 @@ pub fn parser(input: ItemFn) -> Result<TokenStream> {
                 #(#stmts)*
             }
 
+            ::ext_php_rs::php::module::ext_php_rs_startup();
+
             #(#classes)*
             #(#constants)*
 
@@ -48,7 +50,7 @@ fn build_classes(classes: &HashMap<String, Class>) -> Result<Vec<TokenStream>> {
         .map(|(name, class)| {
             let Class { class_name, .. } = &class;
             let ident = Ident::new(name, Span::call_site());
-            let class_entry = Ident::new(&format!("_{}_CLASS_ENTRY", name), Span::call_site());
+            let meta = Ident::new(&format!("_{}_META", name), Span::call_site());
             let methods = class.methods.iter().map(|method| {
                 let builder = method.get_builder(&ident);
                 let flags = method.get_flags();
@@ -122,7 +124,8 @@ fn build_classes(classes: &HashMap<String, Class>) -> Result<Vec<TokenStream>> {
                     .object_override::<#ident>()
                     .build()
                     .expect(concat!("Unable to build class `", #class_name, "`"));
-                unsafe { #class_entry.replace(class) };
+
+                #meta.set_ce(class);
             }})
         })
         .collect::<Result<Vec<_>>>()

guide/src/SUMMARY.md

@@ -12,6 +12,8 @@
   - [`HashMap`](./types/hashmap.md)
   - [`Binary`](./types/binary.md)
   - [`Option`](./types/option.md)
+  - [`Object`](./types/object.md)
+  - [`Closure`](./types/closure.md)
 - [Macros](./macros/index.md)
   - [Module](./macros/module.md)
   - [Module Startup Function](./macros/module_startup.md)