feat: support stable compiler and implement initial machinery for args

Author: aqrln

Cargo.toml

@@ -1,7 +1,7 @@
 [workspace]
 members = [
   "napi",
+  "napi-derive",
   "napi-sys",
-  "napi-codegen",
   "example",
 ]

example/Cargo.toml

@@ -8,4 +8,4 @@ crate-type = ["staticlib"]
 
 [dependencies]
 napi = { path = "../napi" }
-napi-codegen = { path = "../napi-codegen" }
+napi-derive = { path = "../napi-derive" }

example/src/binding.c

@@ -1,7 +1,7 @@
 #include <node_api.h>
 
 #define FUNCTIONS_MAP(V)                                                      \
-  V(initialize, napi_rs_cb_initialize)
+  V(initialize, example_initialize)
 
 #define V(name, func)                                                         \
   extern napi_value func(napi_env env, napi_callback_info info);

example/src/lib.rs

@@ -1,12 +1,19 @@
-#![feature(plugin)]
-#![plugin(napi_codegen)]
-
+#[macro_use]
 extern crate napi;
+#[macro_use]
+extern crate napi_derive;
+
+use napi::{NapiArgs, NapiEnv, NapiResult, NapiUndefined};
 
-use napi::{NapiEnv, NapiResult, NapiUndefined};
+#[derive(NapiArgs)]
+struct InitializeArgs();
 
-#[napi_callback("initialize")]
-fn initialize(env: &NapiEnv) -> NapiResult<NapiUndefined> {
+fn initialize(
+    env: &NapiEnv,
+    _args: InitializeArgs,
+) -> NapiResult<NapiUndefined> {
     println!("Hello from the Rust land!");
     NapiUndefined::new(env)
 }
+
+napi_callback!(example_initialize, initialize);

napi-codegen/src/lib.rs

@@ -1,10 +1,11 @@
 [package]
-name = "napi-codegen"
-version = "0.1.0"
 authors = ["Alexey Orlenko <[email protected]>"]
-
-[lib]
-plugin = true
+name = "napi-derive"
+version = "0.1.0"
 
 [dependencies]
-napi = { path = "../napi" }
+quote = "0.3.15"
+syn = "0.11.11"
+
+[lib]
+proc-macro = true

napi-codegen/Cargo.toml renamed to napi-derive/Cargo.toml

@@ -0,0 +1,73 @@
+#![recursion_limit = "128"]
+
+extern crate proc_macro;
+#[macro_use]
+extern crate quote;
+extern crate syn;
+
+use proc_macro::TokenStream;
+
+#[proc_macro_derive(NapiArgs)]
+pub fn napi_args(input: TokenStream) -> TokenStream {
+    let ast = syn::parse_derive_input(&input.to_string()).unwrap();
+    match impl_napi_args(&ast) {
+        Ok(generated) => generated.parse().unwrap(),
+        Err(message) => panic!(message),
+    }
+}
+
+fn impl_napi_args(
+    ast: &syn::DeriveInput,
+) -> Result<quote::Tokens, &'static str> {
+    let name = &ast.ident;
+
+    let variant_data = match ast.body {
+        syn::Body::Struct(ref data) => data,
+        _ => return Err("NapiArgs can only be derived for structs"),
+    };
+
+    let fields = match variant_data {
+        &syn::VariantData::Tuple(ref fields) => fields,
+        _ => return Err("NapiArgs can only be derived for tuple-structs"),
+    };
+    let count = fields.len();
+
+    Ok(quote! {
+        impl NapiArgs for #name {
+            fn from_cb_info(
+                env: &::napi::NapiEnv,
+                cb_info: ::napi::sys::napi_callback_info,
+            ) -> ::napi::NapiResult<Self> {
+                use ::napi::sys;
+                use ::napi::{NapiError, NapiString};
+
+                use ::std::ptr;
+
+                let mut argc = #count;
+                let mut argv = [ptr::null_mut(); #count];
+
+                env.handle_status(unsafe {
+                    sys::napi_get_cb_info(
+                        env.as_sys_env(),
+                        cb_info,
+                        &mut argc,
+                        argv.as_mut_ptr(),
+                        ptr::null_mut(),
+                        ptr::null_mut(),
+                    )
+                })?;
+
+                if argc != #count {
+                    let message = NapiString::from_str(env, &format!(
+                        "Expected {} arguments, but got {}",
+                        #count,
+                        argc,
+                    ))?;
+                    return Err(NapiError::type_error(env, &message));
+                }
+
+                Ok(#name())
+            }
+        }
+    })
+}

napi-derive/src/lib.rs

@@ -0,0 +1,10 @@
+use env::NapiEnv;
+use result::NapiResult;
+use sys;
+
+pub trait NapiArgs: Sized {
+    fn from_cb_info(
+        env: &NapiEnv,
+        cb_info: sys::napi_callback_info,
+    ) -> NapiResult<Self>;
+}

napi/src/args.rs

@@ -1,9 +1,11 @@
 extern crate napi_sys;
 
+mod args;
 mod env;
 mod result;
 mod value;
 
+pub use args::NapiArgs;
 pub use env::NapiEnv;
 pub use result::{NapiError, NapiErrorKind, NapiResult};
 pub use value::{AsNapiObject, NapiAny, NapiArray, NapiArrayBuffer,
@@ -13,3 +15,64 @@ pub use value::{AsNapiObject, NapiAny, NapiArray, NapiArrayBuffer,
 pub mod sys {
     pub use napi_sys::*;
 }
+
+#[macro_export]
+macro_rules! napi_callback {
+    ($wrapper:ident, $handler:expr) => {
+        #[no_mangle]
+        pub extern "C" fn $wrapper(
+            env: $crate::sys::napi_env,
+            cb_info: $crate::sys::napi_callback_info,
+        ) -> $crate::sys::napi_value {
+            use std::error::Error;
+            use std::ffi::CString;
+            use std::ptr;
+
+            use $crate::{NapiArgs, NapiEnv, NapiResult, NapiValue};
+            use $crate::sys::{napi_get_undefined, napi_throw,
+                              napi_throw_error, napi_value};
+
+            let env_wrapper = NapiEnv::from(env);
+
+            fn typecheck_result<'a, T: NapiValue<'a>>(_: &NapiResult<T>) {}
+
+            let result = <_ as NapiArgs>::from_cb_info(&env_wrapper, cb_info)
+                .and_then(|args| {
+                    let result = $handler(&env_wrapper, args);
+                    typecheck_result(&result);
+                    result
+                });
+
+            match result {
+                Ok(value) => value.as_sys_value(),
+                Err(error) => {
+                    if let Some(exception) = error.exception {
+                        unsafe {
+                            napi_throw(env, exception);
+                        }
+                    } else {
+                        let message = format!("{}", &error);
+                        let c_string =
+                            CString::new(message).unwrap_or_else(|_| {
+                                CString::new(error.description()).unwrap()
+                            });
+
+                        unsafe {
+                            napi_throw_error(
+                                env,
+                                ptr::null(),
+                                c_string.as_ptr(),
+                            );
+                        }
+                    }
+
+                    let mut result: napi_value = ptr::null_mut();
+                    unsafe {
+                        napi_get_undefined(env, &mut result);
+                    }
+                    result
+                }
+            }
+        }
+    };
+}