refactor(derive): reorganize the code a little bit

Author: aqrln

napi-derive/src/lib.rs

@@ -6,6 +6,8 @@ extern crate quote;
 extern crate syn;
 
 use proc_macro::TokenStream;
+use quote::Tokens;
+use syn::{Body, DeriveInput, VariantData};
 
 #[proc_macro_derive(NapiArgs)]
 pub fn napi_args(input: TokenStream) -> TokenStream {
@@ -16,63 +18,18 @@ pub fn napi_args(input: TokenStream) -> TokenStream {
     }
 }
 
-fn impl_napi_args(
-    ast: &syn::DeriveInput,
-) -> Result<quote::Tokens, &'static str> {
+fn impl_napi_args(ast: &DeriveInput) -> Result<Tokens, &'static str> {
     let name = &ast.ident;
 
     let variant_data = match ast.body {
-        syn::Body::Struct(ref data) => data,
+        Body::Struct(ref data) => data,
         _ => return Err("NapiArgs can only be derived for structs"),
     };
 
-    let (init_list, count, imports) = match *variant_data {
-        syn::VariantData::Struct(ref fields) => {
-            let inner = fields
-                .iter()
-                .enumerate()
-                .map(|(idx, field)| {
-                    let ident = field.clone().ident.unwrap();
-                    quote! {
-                        #ident: <_ as NapiValue>::from_sys_checked(
-                            env,
-                            argv[#idx],
-                        )?
-                    }
-                })
-                .collect::<Vec<_>>();
-
-            let outer = quote! {
-                { #(#inner),* }
-            };
-
-            let imports = quote! {
-                use ::napi::NapiValue;
-            };
+    let count = args_count(variant_data);
+    let (init_list, imports) = gen_args_code(variant_data);
 
-            (Some(outer), fields.len(), imports)
-        }
-
-        syn::VariantData::Tuple(ref fields) => {
-            let inner = (0..fields.len())
-                .map(|idx| {
-                    quote! {
-                        <_ as NapiValue>::from_sys_checked(env, argv[#idx])?
-                    }
-                })
-                .collect::<Vec<_>>();
-
-            let outer = quote! {
-                ( #(#inner),* )
-            };
-
-            (Some(outer), fields.len(), quote! {})
-        }
-
-        syn::VariantData::Unit => (None, 0, quote! {}),
-    };
-
-    let construct = if let Some(init_list) = init_list {
+    let initializer = if let Some(init_list) = init_list {
         quote! { #name #init_list }
     } else {
         quote! { #name }
@@ -81,7 +38,7 @@ fn impl_napi_args(
     let (gen_lifetime, ref_lifetime) = if count > 0 {
         (quote! { <'env> }, quote! { 'env })
     } else {
-        (quote! {}, quote! {})
+        (quote!{}, quote!{})
     };
 
     Ok(quote! {
@@ -120,8 +77,67 @@ fn impl_napi_args(
                     return Err(NapiError::type_error(env, &message));
                 }
 
-                Ok(#construct)
+                Ok(#initializer)
             }
         }
     })
 }
+
+fn args_count(variant_data: &VariantData) -> usize {
+    match *variant_data {
+        VariantData::Struct(ref fields) | VariantData::Tuple(ref fields) => {
+            fields.len()
+        }
+        VariantData::Unit => 0,
+    }
+}
+
+fn gen_args_code(
+    variant_data: &VariantData,
+) -> (Option<Tokens>, Option<Tokens>) {
+    match *variant_data {
+        VariantData::Struct(ref fields) => {
+            let inner = fields
+                .iter()
+                .enumerate()
+                .map(|(idx, field)| {
+                    let ident = field.clone().ident.unwrap();
+                    quote! {
+                        #ident: <_ as NapiValue>::from_sys_checked(
+                            env,
+                            argv[#idx],
+                        )?
+                    }
+                })
+                .collect::<Vec<_>>();
+
+            let outer = quote! {
+                { #(#inner),* }
+            };
+
+            let imports = quote! {
+                use ::napi::NapiValue;
+            };
+
+            (Some(outer), Some(imports))
+        }
+
+        VariantData::Tuple(ref fields) => {
+            let inner = (0..fields.len())
+                .map(|idx| {
+                    quote! {
+                        <_ as NapiValue>::from_sys_checked(env, argv[#idx])?
+                    }
+                })
+                .collect::<Vec<_>>();
+
+            let outer = quote! {
+                ( #(#inner),* )
+            };
+
+            (Some(outer), None)
+        }
+
+        VariantData::Unit => (None, None),
+    }
+}