Merge pull request #18 from jmjoy/0.2.0-alpha.3-dev

jmjoy · web-flow · commit 8c5894ac8d34 · 2021-05-24T00:16:55.000+08:00
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
@@ -22,7 +22,7 @@ jobs:
         os:
           - ubuntu-latest
         php-version:
-#          - "7.0"
+          - "7.0"
           - "7.1"
           - "7.2"
           - "7.3"
diff --git a/README.md b/README.md
@@ -25,7 +25,7 @@ A library that allows us to write PHP extensions using pure Rust and using safe
 
 *version*
 
-- [ ] 7.0
+- [x] 7.0
 - [x] 7.1
 - [x] 7.2
 - [x] 7.3
diff --git a/examples/hello/src/lib.rs b/examples/hello/src/lib.rs
@@ -3,13 +3,13 @@ use phper::{
     classes::{DynamicClass, Visibility},
     functions::Argument,
     ini::{Ini, Policy},
-    modules::{Module, ModuleArgs},
+    modules::{Module, ModuleContext},
     objects::Object,
     php_get_module,
     values::Val,
 };
 
-fn module_init(_args: ModuleArgs) -> bool {
+fn module_init(_args: ModuleContext) -> bool {
     true
 }
 
diff --git a/phper-macros/src/derives.rs b/phper-macros/src/derives.rs
@@ -0,0 +1,143 @@
+use proc_macro::TokenStream;
+use proc_macro2::TokenStream as TokenStream2;
+use quote::quote;
+use syn::{Attribute, Data, DeriveInput, Fields, Meta};
+
+pub(crate) fn derive_throwable(input: DeriveInput) -> syn::Result<TokenStream> {
+    let crate_ident = parse_throwable_crate_ident(&input);
+    let exception = parse_throwable_attrs(&input)?;
+    parse_throwable_input(&input, crate_ident, exception)
+}
+
+fn parse_throwable_crate_ident(input: &DeriveInput) -> TokenStream2 {
+    let has_throwable_crate = attributes_find_ident(&input.attrs, "throwable_crate");
+    let crate_ident = if has_throwable_crate.is_some() {
+        quote! { crate }
+    } else {
+        quote! { phper }
+    };
+    crate_ident
+}
+
+fn parse_throwable_attrs(input: &DeriveInput) -> syn::Result<TokenStream2> {
+    let attr = attributes_find_ident(&input.attrs, "throwable");
+    attr.map(|attr| {
+        attr.parse_args::<Meta>().and_then(|meta| match meta {
+            Meta::NameValue(name_value) => {
+                if !name_value.path.is_ident("class") {
+                    Err(syn::Error::new_spanned(
+                        &attr,
+                        "now only support #[throwable(error = ?)] for enum",
+                    ))
+                } else {
+                    let lit = name_value.lit;
+                    Ok(quote! { #lit })
+                }
+            }
+            _ => Err(syn::Error::new_spanned(
+                &attr,
+                "now only support #[throwable(error = ?)] for enum",
+            )),
+        })
+    })
+    .unwrap_or_else(|| Ok(quote! { "Exception" }))
+}
+
+fn parse_throwable_input(
+    input: &DeriveInput,
+    crate_ident: TokenStream2,
+    exception: TokenStream2,
+) -> syn::Result<TokenStream> {
+    let input_ident = &input.ident;
+
+    match &input.data {
+        Data::Enum(e) => {
+            let mut transparent_idents = Vec::new();
+
+            for variant in &e.variants {
+                let attr = attributes_find_ident(&variant.attrs, "throwable");
+                match attr {
+                    Some(attr) => {
+                        if attr.tokens.to_string() != "(transparent)" {
+                            return Err(syn::Error::new_spanned(
+                                &attr,
+                                "now only support #[throwable(transparent)] for variant",
+                            ));
+                        }
+                        match &variant.fields {
+                            Fields::Unnamed(f) if f.unnamed.len() == 1 => {
+                                transparent_idents.push(variant.ident.clone());
+                            }
+                            _ => {
+                                return Err(syn::Error::new_spanned(
+                                    &variant,
+                                    "now only support unnamed field with one item mark attribute #[throwable]",
+                                ));
+                            }
+                        }
+                    }
+                    None => continue,
+                }
+            }
+
+            let mut class_entry_arms = transparent_idents
+                .iter()
+                .map(|i| {
+                    quote! { Self::#i(e) => #crate_ident::errors::Throwable::class_entry(e), }
+                })
+                .collect::<Vec<_>>();
+            class_entry_arms.push(quote! { _ => ClassEntry::from_globals(#exception).unwrap(), });
+
+            let mut code_arms = transparent_idents
+                .iter()
+                .map(|i| {
+                    quote! { Self::#i(e) => #crate_ident::errors::Throwable::code(e), }
+                })
+                .collect::<Vec<_>>();
+            code_arms.push(quote! { _ => 0, });
+
+            let mut message_arms = transparent_idents
+                .iter()
+                .map(|i| {
+                    quote! { Self::#i(e) => #crate_ident::errors::Throwable::message(e), }
+                })
+                .collect::<Vec<_>>();
+            message_arms.push(quote! { _ => std::string::ToString::to_string(&self), });
+
+            Ok((quote! {
+                impl #crate_ident::errors::Throwable for #input_ident {
+                    fn class_entry(&self) -> &#crate_ident::classes::StatelessClassEntry {
+                        match self {
+                            #(#class_entry_arms)*
+                        }
+                    }
+
+                    fn code(&self) -> u64 {
+                        match self {
+                            #(#code_arms)*
+                        }
+                    }
+
+                    fn message(&self) -> std::string::String {
+                        match self {
+                            #(#message_arms)*
+                        }
+                    }
+                }
+            })
+            .into())
+        }
+        Data::Struct(_) => Err(syn::Error::new_spanned(
+            &input,
+            "struct auto derive Throwable is not supported",
+        )),
+        Data::Union(_) => Err(syn::Error::new_spanned(
+            &input,
+            "union auto derive Throwable is not supported",
+        )),
+    }
+}
+
+fn attributes_find_ident<'a>(attrs: &'a [Attribute], ident: &'a str) -> Option<&'a Attribute> {
+    attrs.iter().find(|attr| attr.path.is_ident(ident))
+}
diff --git a/phper-macros/src/lib.rs b/phper-macros/src/lib.rs
@@ -11,11 +11,13 @@ The proc-macros for [phper](https://crates.io/crates/phper).
 // TODO Write a bridge macro for easy usage about register functions and classes, like `cxx`.
 
 mod alloc;
+mod derives;
 mod inner;
 mod log;
 mod utils;
 
 use proc_macro::TokenStream;
+use syn::{parse_macro_input, DeriveInput};
 
 /// C style string end with '\0'.
 ///
@@ -70,3 +72,27 @@ pub fn c_str_ptr(input: TokenStream) -> TokenStream {
 pub fn php_get_module(attr: TokenStream, input: TokenStream) -> TokenStream {
     inner::php_get_module(attr, input)
 }
+
+/// Auto derive for [phper::errors::Throwable].
+///
+/// # Examples
+///
+/// ```no_test
+/// #[derive(thiserror::Error, crate::Throwable, Debug)]
+/// #[throwable(class = "Exception")]
+/// pub enum Error {
+///     #[error(transparent)]
+///     Io(#[from] std::io::Error),
+///
+///     #[error(transparent)]
+///     #[throwable(transparent)]
+///     My(#[from] MyError),
+/// }
+/// ```
+///
+/// TODO Support struct, attbiute `throwable` with `code` and `message`.
+#[proc_macro_derive(Throwable, attributes(throwable, throwable_crate))]
+pub fn derive_throwable(input: TokenStream) -> TokenStream {
+    let input = parse_macro_input!(input as DeriveInput);
+    derives::derive_throwable(input).unwrap_or_else(|e| e.into_compile_error().into())
+}
diff --git a/phper/src/errors.rs b/phper/src/errors.rs
@@ -35,7 +35,9 @@ pub type Result<T> = std::result::Result<T, self::Error>;
 /// Crate level Error, which also can become an exception in php.
 ///
 /// As a php exception, will throw `ErrorException` when the item not implement [Throwable].
-#[derive(thiserror::Error, Debug)]
+#[derive(thiserror::Error, crate::Throwable, Debug)]
+#[throwable(class = "ErrorException")]
+#[throwable_crate]
 pub enum Error {
     #[error(transparent)]
     Io(#[from] io::Error),
@@ -47,19 +49,23 @@ pub enum Error {
     FromBytesWithNul(#[from] FromBytesWithNulError),
 
     #[error(transparent)]
+    Other(#[from] anyhow::Error),
+
+    #[error(transparent)]
+    #[throwable(transparent)]
     Type(#[from] TypeError),
 
     #[error(transparent)]
+    #[throwable(transparent)]
     ClassNotFound(#[from] ClassNotFoundError),
 
     #[error(transparent)]
+    #[throwable(transparent)]
     ArgumentCount(#[from] ArgumentCountError),
 
     #[error(transparent)]
+    #[throwable(transparent)]
     StateType(#[from] StateTypeError),
-
-    #[error(transparent)]
-    Other(#[from] anyhow::Error),
 }
 
 impl Error {
@@ -70,27 +76,6 @@ impl Error {
     }
 }
 
-// TODO Add message() implement.
-impl Throwable for Error {
-    fn class_entry(&self) -> &StatelessClassEntry {
-        match self {
-            Self::Type(e) => e.class_entry(),
-            Self::ClassNotFound(e) => e.class_entry(),
-            Self::ArgumentCount(e) => e.class_entry(),
-            _ => ClassEntry::from_globals("ErrorException").unwrap(),
-        }
-    }
-
-    fn code(&self) -> u64 {
-        match self {
-            Self::Type(e) => e.code(),
-            Self::ClassNotFound(e) => e.code(),
-            Self::ArgumentCount(e) => e.code(),
-            _ => 0,
-        }
-    }
-}
-
 #[derive(thiserror::Error, Debug)]
 #[error("type error: {message}")]
 pub struct TypeError {
diff --git a/phper/src/functions.rs b/phper/src/functions.rs
@@ -280,7 +280,7 @@ unsafe extern "C" fn invoke(execute_data: *mut zend_execute_data, return_value:
     handler.call(execute_data, &mut arguments, return_value);
 }
 
-pub const fn create_zend_arg_info(
+pub(crate) const fn create_zend_arg_info(
     name: *const c_char,
     _pass_by_ref: bool,
 ) -> zend_internal_arg_info {
diff --git a/phper/src/modules.rs b/phper/src/modules.rs
@@ -29,7 +29,7 @@ pub(crate) fn write_global_module<R>(f: impl FnOnce(&mut Module) -> R) -> R {
 }
 
 unsafe extern "C" fn module_startup(r#type: c_int, module_number: c_int) -> c_int {
-    let args = ModuleArgs::new(r#type, module_number);
+    let args = ModuleContext::new(r#type, module_number);
     write_global_module(|module| {
         args.register_ini_entries(Ini::entries());
         for class_entity in &mut module.class_entities {
@@ -44,7 +44,7 @@ unsafe extern "C" fn module_startup(r#type: c_int, module_number: c_int) -> c_in
 }
 
 unsafe extern "C" fn module_shutdown(r#type: c_int, module_number: c_int) -> c_int {
-    let args = ModuleArgs::new(r#type, module_number);
+    let args = ModuleContext::new(r#type, module_number);
     args.unregister_ini_entries();
     read_global_module(|module| match &module.module_shutdown {
         Some(f) => f(args) as c_int,
@@ -54,14 +54,14 @@ unsafe extern "C" fn module_shutdown(r#type: c_int, module_number: c_int) -> c_i
 
 unsafe extern "C" fn request_startup(r#type: c_int, request_number: c_int) -> c_int {
     read_global_module(|module| match &module.request_init {
-        Some(f) => f(ModuleArgs::new(r#type, request_number)) as c_int,
+        Some(f) => f(ModuleContext::new(r#type, request_number)) as c_int,
         None => 1,
     })
 }
 
 unsafe extern "C" fn request_shutdown(r#type: c_int, request_number: c_int) -> c_int {
     read_global_module(|module| match &module.request_shutdown {
-        Some(f) => f(ModuleArgs::new(r#type, request_number)) as c_int,
+        Some(f) => f(ModuleContext::new(r#type, request_number)) as c_int,
         None => 1,
     })
 }
@@ -84,10 +84,10 @@ pub struct Module {
     name: String,
     version: String,
     author: String,
-    module_init: Option<Box<dyn Fn(ModuleArgs) -> bool + Send + Sync>>,
-    module_shutdown: Option<Box<dyn Fn(ModuleArgs) -> bool + Send + Sync>>,
-    request_init: Option<Box<dyn Fn(ModuleArgs) -> bool + Send + Sync>>,
-    request_shutdown: Option<Box<dyn Fn(ModuleArgs) -> bool + Send + Sync>>,
+    module_init: Option<Box<dyn Fn(ModuleContext) -> bool + Send + Sync>>,
+    module_shutdown: Option<Box<dyn Fn(ModuleContext) -> bool + Send + Sync>>,
+    request_init: Option<Box<dyn Fn(ModuleContext) -> bool + Send + Sync>>,
+    request_shutdown: Option<Box<dyn Fn(ModuleContext) -> bool + Send + Sync>>,
     function_entities: Vec<FunctionEntity>,
     class_entities: Vec<ClassEntity>,
 }
@@ -107,24 +107,27 @@ impl Module {
         }
     }
 
-    pub fn on_module_init(&mut self, func: impl Fn(ModuleArgs) -> bool + Send + Sync + 'static) {
+    pub fn on_module_init(&mut self, func: impl Fn(ModuleContext) -> bool + Send + Sync + 'static) {
         self.module_init = Some(Box::new(func));
     }
 
     pub fn on_module_shutdown(
         &mut self,
-        func: impl Fn(ModuleArgs) -> bool + Send + Sync + 'static,
+        func: impl Fn(ModuleContext) -> bool + Send + Sync + 'static,
     ) {
         self.module_shutdown = Some(Box::new(func));
     }
 
-    pub fn on_request_init(&mut self, func: impl Fn(ModuleArgs) -> bool + Send + Sync + 'static) {
+    pub fn on_request_init(
+        &mut self,
+        func: impl Fn(ModuleContext) -> bool + Send + Sync + 'static,
+    ) {
         self.request_init = Some(Box::new(func));
     }
 
     pub fn on_request_shutdown(
         &mut self,
-        func: impl Fn(ModuleArgs) -> bool + Send + Sync + 'static,
+        func: impl Fn(ModuleContext) -> bool + Send + Sync + 'static,
     ) {
         self.request_shutdown = Some(Box::new(func));
     }
@@ -201,13 +204,13 @@ impl Module {
     }
 }
 
-pub struct ModuleArgs {
+pub struct ModuleContext {
     #[allow(dead_code)]
     r#type: c_int,
     module_number: c_int,
 }
 
-impl ModuleArgs {
+impl ModuleContext {
     pub const fn new(r#type: c_int, module_number: c_int) -> Self {
         Self {
             r#type,
diff --git a/phper/src/objects.rs b/phper/src/objects.rs
diff --git a/tests/integration/tests/php/classes.php b/tests/integration/tests/php/classes.php

-Original file line number
+Diff line change
 *version*
 -- [ ] 7.0
 +- [x] 7.0
 - [x] 7.1
 - [x] 7.2
 - [x] 7.3
Original file line number	Diff line number	Diff line change
`@@ -280,7 +280,7 @@ unsafe extern "C" fn invoke(execute_data: *mut zend_execute_data, return_value:`
`280`	`280`	`handler.call(execute_data, &mut arguments, return_value);`
`281`	`281`	`}`
`282`	`282`
`283`		`-pub const fn create_zend_arg_info(`
	`283`	`+pub(crate) const fn create_zend_arg_info(`
`284`	`284`	`name: *const c_char,`
`285`	`285`	`_pass_by_ref: bool,`
`286`	`286`	`) -> zend_internal_arg_info {`