Add support for field and method properties (#69)

* Rough implementation of struct properties

* Store properties hashtable once

* Tidy up handler functions with exceptions

* Add stub `get_properties` function for codegen structs

* Remove nightly features

* Revert storing properties

Technically, the zend object _could_ move in memory, leaving dangling
references in the properties hashtable. We will just build the hashtable
when required.

* Added `#[prop]` attribute

* Add pointer type to zval, tidy up zend string

* Add support for method properties

* Add `#[getter]` and `#[setter]` attributes

* Update documentation with method properties

* Tidy up macros code

* Remove string gc checks (done on PHP side)

* Move `RegisteredClass` implementation to module, update docs

* Fix read property `rv` segfault

* Fixed doctests

Author: davidcole1340

.github/workflows/build.yml

@@ -48,6 +48,9 @@ jobs:
           EXT_PHP_RS_TEST:
         run: cargo build --release --features alloc,closure
       - name: Test guide examples
+        env:
+          CARGO_PKG_NAME: mdbook-tests
+          CARGO_PKG_VERSION: 0.1.0
         run: |
           mdbook test guide -L target/release/deps
       - name: Test inline examples

build.rs

@@ -252,6 +252,7 @@ const ALLOWED_BINDINGS: &[&str] = &[
     "IS_TYPE_REFCOUNTED",
     "IS_UNDEF",
     "IS_VOID",
+    "IS_PTR",
     "MAY_BE_ANY",
     "MAY_BE_BOOL",
     "USING_ZTS",
@@ -316,4 +317,10 @@ const ALLOWED_BINDINGS: &[&str] = &[
     "_ZEND_TYPE_NAME_BIT",
     "zval_ptr_dtor",
     "zend_refcounted_h",
+    "zend_is_true",
+    "zend_object_std_dtor",
+    "zend_std_read_property",
+    "zend_std_write_property",
+    "zend_std_get_properties",
+    "zend_std_has_property",
 ];

docsrs_bindings.rs

@@ -760,6 +760,37 @@ pub struct _zend_object_handlers {
 extern "C" {
     pub static std_object_handlers: zend_object_handlers;
 }
+extern "C" {
+    pub fn zend_std_get_properties(object: *mut zend_object) -> *mut HashTable;
+}
+extern "C" {
+    pub fn zend_std_read_property(
+        object: *mut zend_object,
+        member: *mut zend_string,
+        type_: ::std::os::raw::c_int,
+        cache_slot: *mut *mut ::std::os::raw::c_void,
+        rv: *mut zval,
+    ) -> *mut zval;
+}
+extern "C" {
+    pub fn zend_std_write_property(
+        object: *mut zend_object,
+        member: *mut zend_string,
+        value: *mut zval,
+        cache_slot: *mut *mut ::std::os::raw::c_void,
+    ) -> *mut zval;
+}
+extern "C" {
+    pub fn zend_std_has_property(
+        object: *mut zend_object,
+        member: *mut zend_string,
+        has_set_exists: ::std::os::raw::c_int,
+        cache_slot: *mut *mut ::std::os::raw::c_void,
+    ) -> ::std::os::raw::c_int;
+}
+extern "C" {
+    pub fn zend_is_true(op: *mut zval) -> ::std::os::raw::c_int;
+}
 pub type zend_op_array = _zend_op_array;
 pub type zend_op = _zend_op;
 #[repr(C)]
@@ -946,6 +977,9 @@ extern "C" {
 extern "C" {
     pub fn zend_objects_clone_members(new_object: *mut zend_object, old_object: *mut zend_object);
 }
+extern "C" {
+    pub fn zend_object_std_dtor(object: *mut zend_object);
+}
 #[repr(C)]
 #[derive(Debug, Copy, Clone)]
 pub struct _zend_objects_store {

example/skel/src/lib.rs

@@ -1,121 +1,39 @@
-mod allocator;
-
-use ext_php_rs::{
-    parse_args,
-    php::{
-        args::Arg,
-        enums::DataType,
-        exceptions::PhpException,
-        execution_data::ExecutionData,
-        function::FunctionBuilder,
-        types::{
-            array::OwnedHashTable,
-            callable::Callable,
-            closure::Closure,
-            object::{ClassObject, ClassRef},
-            zval::{FromZval, IntoZval, Zval},
-        },
-    },
-    php_class,
-    prelude::*,
-};
-
-#[php_class]
-#[property(test = 0)]
-#[property(another = "Hello world")]
-#[derive(Default, Debug, Clone)]
-pub struct Test {
-    pub test: String,
-}
-
-#[php_function]
-pub fn take_test(test: &Test) -> String {
-    test.test.clone()
-}
+use ext_php_rs::prelude::*;
 
 #[php_class]
-#[derive(Default)]
-struct PhpFuture {
-    then: Option<Callable<'static>>,
-}
-
-#[php_impl]
-impl PhpFuture {
-    pub fn then(&mut self, then: Callable<'static>) {
-        self.then = Some(then);
-    }
-
-    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()))
+struct TestClass {
+    #[prop(rename = "Hello")]
+    a: i32,
+    #[prop]
+    b: i64,
+    #[prop]
+    c: String,
+}
+
+impl Default for TestClass {
+    fn default() -> Self {
+        Self {
+            a: 100,
+            b: 123,
+            c: "Hello, world!".into(),
         }
     }
-
-    pub fn obj(&self) -> ClassObject<Test> {
-        ClassObject::new(Test {
-            test: "Hello world from class entry :)".into(),
-        })
-    }
-
-    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;
+impl TestClass {
+    #[getter]
+    fn get_test_name(&self) -> String {
+        self.c.clone()
     }
 
-    pub fn get_str(&self) -> String {
-        self.test.clone()
+    #[setter]
+    fn set_test_name(&mut self, c: String) {
+        self.c = c;
     }
 }
 
-#[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.function(
-        FunctionBuilder::new("test_zval", test_zval)
-            .arg(Arg::new("test", DataType::Array))
-            .build()
-            .unwrap(),
-    )
+    module
 }

example/skel/test.php

@@ -1,28 +1,2 @@
 <?php
 
-<<<<<<< HEAD
-<<<<<<< HEAD
-<<<<<<< HEAD
-test_zval(['hello' => 'world']);
-=======
-test_zval();
->>>>>>> 712aded56 (Call zval destructor when changing zval type and dropping)
-=======
-test_zval(['hello' => 'world']);
->>>>>>> 3646da741 (Remove `ZendHashTable` wrapper)
-=======
-test_zval([]);
->>>>>>> 7ba9ee9bf (Refactor `ZendString` into a borrowed and owned variant)
-//include 'vendor/autoload.php';
-
-//$ext = new ReflectionExtension('skel');
-
-//dd($ext);
-
-//$x = fn_once();
-//$x();
-//$x();
-
-//// $x = get_closure();
-
-//// var_dump($x(5));