Add method visibility and static access modifier.

Author: jmjoy

examples/hello/src/lib.rs

@@ -1,6 +1,6 @@
 use phper::{
     arrays::Array,
-    classes::DynamicClass,
+    classes::{DynamicClass, Visibility},
     functions::Argument,
     ini::Policy,
     modules::{Module, ModuleArgs},
@@ -66,6 +66,7 @@ pub fn get_module() -> Module {
     foo_class.add_property("foo", "100".to_string());
     foo_class.add_method(
         "getFoo",
+        Visibility::Public,
         |this: &mut Object<()>, _: &mut [Val]| -> phper::Result<Val> {
             let prop = this.get_property("foo");
             Ok(Val::new(prop.as_string_value()?))
@@ -74,6 +75,7 @@ pub fn get_module() -> Module {
     );
     foo_class.add_method(
         "setFoo",
+        Visibility::Public,
         |this: &mut Object<()>, arguments: &mut [Val]| -> phper::Result<()> {
             this.set_property("foo", Val::new(arguments[0].as_string_value()?));
             Ok(())

examples/http-client/src/client.rs

@@ -3,7 +3,11 @@ use crate::{
     response::{ReadiedResponse, RESPONSE_CLASS_NAME},
 };
 
-use phper::{classes::DynamicClass, functions::Argument, objects::Object};
+use phper::{
+    classes::{DynamicClass, Visibility},
+    functions::Argument,
+    objects::Object,
+};
 use reqwest::blocking::{Client, ClientBuilder};
 use std::time::Duration;
 
@@ -19,6 +23,7 @@ pub fn make_client_class() -> DynamicClass<Client> {
 
     class.add_method(
         "get",
+        Visibility::Public,
         |this, arguments| {
             let url = arguments[0].as_string()?;
             let client = this.as_state();

examples/http-client/src/lib.rs

@@ -5,6 +5,7 @@ use phper::{modules::Module, php_get_module};
 
 pub mod client;
 pub mod errors;
+pub mod request;
 pub mod response;
 
 #[php_get_module]

examples/http-client/src/request.rs

@@ -0,0 +1,10 @@
+use phper::classes::DynamicClass;
+use reqwest::blocking::{Request, RequestBuilder};
+
+pub const REQUEST_BUILDER_CLASS_NAME: &'static str = "HttpClient\\RequestBuilder";
+
+pub fn make_request_builder_class() -> DynamicClass<Option<RequestBuilder>> {
+    let mut class = DynamicClass::new_with_none(REQUEST_BUILDER_CLASS_NAME);
+
+    class
+}

examples/http-client/src/response.rs

@@ -1,6 +1,9 @@
 use bytes::Bytes;
 use indexmap::map::IndexMap;
-use phper::classes::DynamicClass;
+use phper::{
+    classes::{DynamicClass, Visibility},
+    objects::Object,
+};
 use reqwest::{header::HeaderMap, StatusCode};
 use std::{convert::Infallible, net::SocketAddr};
 
@@ -14,13 +17,12 @@ pub struct ReadiedResponse {
 }
 
 pub fn make_response_class() -> DynamicClass<Option<ReadiedResponse>> {
-    let mut class = DynamicClass::new_with_constructor(RESPONSE_CLASS_NAME, || {
-        Ok::<Option<ReadiedResponse>, Infallible>(None)
-    });
+    let mut class = DynamicClass::new_with_none(RESPONSE_CLASS_NAME);
 
     class.add_method(
         "body",
-        |this, _arguments| {
+        Visibility::Public,
+        |this: &mut Object<Option<ReadiedResponse>>, _arguments| {
             let readied_response = this.as_state().as_ref().unwrap();
             let body: &[u8] = readied_response.body.as_ref();
             body.to_vec()
@@ -30,6 +32,7 @@ pub fn make_response_class() -> DynamicClass<Option<ReadiedResponse>> {
 
     class.add_method(
         "status",
+        Visibility::Public,
         |this, _arguments| {
             let readied_response = this.as_state().as_ref().unwrap();
             readied_response.status.as_u16() as i64
@@ -39,6 +42,7 @@ pub fn make_response_class() -> DynamicClass<Option<ReadiedResponse>> {
 
     class.add_method(
         "headers",
+        Visibility::Public,
         |this, _arguments| {
             let readied_response = this.as_state().as_ref().unwrap();
             let headers_map =

phper/src/classes.rs

@@ -1,9 +1,18 @@
 //! Apis relate to [crate::sys::zend_class_entry].
 
-use crate::alloc::EBox;
+use crate::{
+    alloc::EBox,
+    errors::{ClassNotFoundError, StateTypeError, Throwable},
+    functions::{Argument, Function, FunctionEntity, FunctionEntry, Method},
+    objects::{ExtendObject, Object},
+    sys::*,
+    utils::ensure_end_with_zero,
+    values::{SetVal, Val},
+};
+use dashmap::DashMap;
 use once_cell::sync::OnceCell;
 use std::{
-    any::Any,
+    any::{Any, TypeId},
     convert::Infallible,
     marker::PhantomData,
     mem::{size_of, zeroed, ManuallyDrop},
@@ -15,17 +24,6 @@ use std::{
     },
 };
 
-use crate::{
-    errors::{ClassNotFoundError, StateTypeError, Throwable},
-    functions::{Argument, FunctionEntity, FunctionEntry, Method},
-    objects::{ExtendObject, Object},
-    sys::*,
-    utils::ensure_end_with_zero,
-    values::{SetVal, Val},
-};
-use dashmap::DashMap;
-use std::any::TypeId;
-
 pub trait Classifiable {
     fn state_constructor(&self) -> Box<StateConstructor<Box<dyn Any>>>;
     fn state_type_id(&self) -> TypeId;
@@ -37,7 +35,7 @@ pub trait Classifiable {
 
 pub type StateConstructor<T> = dyn Fn() -> Result<T, Box<dyn Throwable>> + Send + Sync;
 
-pub struct DynamicClass<T: Send + Sync + 'static> {
+pub struct DynamicClass<T: Send + 'static> {
     class_name: String,
     state_constructor: Arc<StateConstructor<T>>,
     pub(crate) method_entities: Vec<FunctionEntity>,
@@ -52,19 +50,19 @@ impl DynamicClass<()> {
     }
 }
 
-impl<T: Default + Send + Sync + 'static> DynamicClass<T> {
+impl<T: Default + Send + 'static> DynamicClass<T> {
     pub fn new_with_default(class_name: impl ToString) -> Self {
         Self::new_with_constructor(class_name, || Ok::<_, Infallible>(Default::default()))
     }
 }
 
-impl<T: Send + Sync + 'static> DynamicClass<Option<T>> {
+impl<T: Send + 'static> DynamicClass<Option<T>> {
     pub fn new_with_none(class_name: impl ToString) -> Self {
         Self::new_with_constructor(class_name, || Ok::<_, Infallible>(None))
     }
 }
 
-impl<T: Send + Sync + 'static> DynamicClass<T> {
+impl<T: Send + 'static> DynamicClass<T> {
     pub fn new_with_constructor<F, E>(class_name: impl ToString, state_constructor: F) -> Self
     where
         F: Fn() -> Result<T, E> + Send + Sync + 'static,
@@ -85,15 +83,41 @@ impl<T: Send + Sync + 'static> DynamicClass<T> {
         dyn_class
     }
 
-    pub fn add_method<F, R>(&mut self, name: impl ToString, handler: F, arguments: Vec<Argument>)
-    where
+    pub fn add_method<F, R>(
+        &mut self,
+        name: impl ToString,
+        vis: Visibility,
+        handler: F,
+        arguments: Vec<Argument>,
+    ) where
         F: Fn(&mut Object<T>, &mut [Val]) -> R + Send + Sync + 'static,
         R: SetVal + 'static,
     {
         self.method_entities.push(FunctionEntity::new(
             name,
             Box::new(Method::new(handler)),
             arguments,
+            Some(vis),
+            Some(false),
+        ));
+    }
+
+    pub fn add_static_method<F, R>(
+        &mut self,
+        name: impl ToString,
+        vis: Visibility,
+        handler: F,
+        arguments: Vec<Argument>,
+    ) where
+        F: Fn(&mut [Val]) -> R + Send + Sync + 'static,
+        R: SetVal + 'static,
+    {
+        self.method_entities.push(FunctionEntity::new(
+            name,
+            Box::new(Function::new(handler)),
+            arguments,
+            Some(vis),
+            Some(true),
         ));
     }
 
@@ -108,7 +132,7 @@ impl<T: Send + Sync + 'static> DynamicClass<T> {
     }
 }
 
-impl<T: Send + Sync> Classifiable for DynamicClass<T> {
+impl<T: Send> Classifiable for DynamicClass<T> {
     fn state_constructor(&self) -> Box<StateConstructor<Box<dyn Any>>> {
         let sc = self.state_constructor.clone();
         Box::new(move || sc().map(|x| Box::new(x) as _))

phper/src/functions.rs

@@ -3,6 +3,7 @@
 use std::{mem::zeroed, os::raw::c_char};
 
 use crate::{
+    classes::Visibility,
     errors::ArgumentCountError,
     objects::Object,
     strings::ZendString,
@@ -16,11 +17,21 @@ pub(crate) trait Callable {
     fn call(&self, execute_data: &mut ExecuteData, arguments: &mut [Val], return_value: &mut Val);
 }
 
-pub(crate) struct Function<F, R>(pub(crate) F)
+pub(crate) struct Function<F, R>(F)
 where
     F: Fn(&mut [Val]) -> R + Send + Sync,
     R: SetVal;
 
+impl<F, R> Function<F, R>
+where
+    F: Fn(&mut [Val]) -> R + Send + Sync,
+    R: SetVal,
+{
+    pub fn new(f: F) -> Self {
+        Self(f)
+    }
+}
+
 impl<F, R> Callable for Function<F, R>
 where
     F: Fn(&mut [Val]) -> R + Send + Sync,
@@ -84,23 +95,29 @@ pub struct FunctionEntity {
     pub(crate) name: String,
     pub(crate) handler: Box<dyn Callable>,
     pub(crate) arguments: Vec<Argument>,
+    pub(crate) visibility: Option<Visibility>,
+    pub(crate) r#static: Option<bool>,
 }
 
 impl FunctionEntity {
     pub(crate) fn new(
         name: impl ToString,
         handler: Box<dyn Callable>,
         arguments: Vec<Argument>,
+        visibility: Option<Visibility>,
+        r#static: Option<bool>,
     ) -> Self {
         let name = ensure_end_with_zero(name);
         FunctionEntity {
             name,
             handler,
             arguments,
+            visibility,
+            r#static,
         }
     }
 
-    // Leak memory
+    /// Will leak memory
     pub(crate) unsafe fn entry(&self) -> zend_function_entry {
         let mut infos = Vec::new();
 
@@ -125,12 +142,18 @@ impl FunctionEntity {
         let last_arg_info: zend_internal_arg_info = translator.internal_arg_info;
         infos.push(last_arg_info);
 
+        let flags = self.visibility.map(|v| v as u32).unwrap_or_default()
+            | self
+                .r#static
+                .and_then(|v| if v { Some(ZEND_ACC_STATIC) } else { None })
+                .unwrap_or_default();
+
         zend_function_entry {
             fname: self.name.as_ptr().cast(),
             handler: Some(invoke),
             arg_info: Box::into_raw(infos.into_boxed_slice()).cast(),
             num_args: self.arguments.len() as u32,
-            flags: 0,
+            flags,
         }
     }
 }

phper/src/modules.rs

@@ -211,8 +211,10 @@ impl Module {
     {
         self.function_entities.push(FunctionEntity::new(
             name,
-            Box::new(Function(handler)),
+            Box::new(Function::new(handler)),
             arguments,
+            None,
+            None,
         ));
     }
 

tests/integration/src/classes.rs

@@ -0,0 +1,9 @@
+use phper::{classes::DynamicClass, modules::Module};
+
+pub fn integrate(module: &mut Module) {
+    integrate_a(module);
+}
+
+fn integrate_a(module: &mut Module) {
+    // let class = DynamicClass::new_with_constructor("IntegrationTest\\A", ||);
+}

tests/integration/src/lib.rs

@@ -2,6 +2,7 @@
 
 mod arguments;
 mod arrays;
+mod classes;
 mod objects;
 mod strings;
 mod values;
@@ -18,6 +19,7 @@ pub fn get_module() -> Module {
 
     arguments::integrate(&mut module);
     arrays::integrate(&mut module);
+    classes::integrate(&mut module);
     objects::integrate(&mut module);
     values::integrate(&mut module);
     strings::integrate(&mut module);