config_type: add argument for skipping derives

Author: l4l

config_proc_macro/src/args.rs

@@ -0,0 +1,46 @@
+use syn::{
+    parenthesized,
+    parse::{Error as ParserError, Parse, ParseStream},
+    Ident, Token,
+};
+
+#[derive(Debug, Default)]
+pub struct Args {
+    pub skip_derive: Option<Vec<String>>,
+}
+
+impl Args {
+    pub fn skip_derives(&self) -> impl Iterator<Item = &str> + '_ {
+        self.skip_derive
+            .as_ref()
+            .into_iter()
+            .flatten()
+            .map(|s| s.as_ref())
+    }
+}
+
+impl Parse for Args {
+    fn parse(input: ParseStream<'_>) -> Result<Self, ParserError> {
+        let mut args = Self::default();
+
+        while !input.is_empty() {
+            let ident: Ident = input.parse()?;
+            match ident.to_string().as_str() {
+                "skip_derive" => {
+                    let content;
+                    parenthesized!(content in input);
+                    args.skip_derive = Some(
+                        content
+                            .parse_terminated::<_, Token![,]>(Ident::parse)?
+                            .into_iter()
+                            .map(|i| i.to_string())
+                            .collect(),
+                    );
+                }
+                a => panic!("unknown attribute: {}", a),
+            }
+        }
+
+        Ok(args)
+    }
+}

config_proc_macro/src/config_type.rs

@@ -1,14 +1,15 @@
 use proc_macro2::TokenStream;
 
+use crate::args::Args;
 use crate::item_enum::define_config_type_on_enum;
 use crate::item_struct::define_config_type_on_struct;
 
 /// Defines `config_type` on enum or struct.
 // FIXME: Implement this on struct.
-pub fn define_config_type(input: &syn::Item) -> TokenStream {
+pub fn define_config_type(args: &Args, input: &syn::Item) -> TokenStream {
     match input {
-        syn::Item::Struct(st) => define_config_type_on_struct(st),
-        syn::Item::Enum(en) => define_config_type_on_enum(en),
+        syn::Item::Struct(st) => define_config_type_on_struct(args, st),
+        syn::Item::Enum(en) => define_config_type_on_enum(args, en),
         _ => panic!("Expected enum or struct"),
     }
     .unwrap()

config_proc_macro/src/item_enum.rs

@@ -2,13 +2,14 @@ use proc_macro2::TokenStream;
 use quote::{quote, quote_spanned};
 use syn::spanned::Spanned;
 
+use crate::args::Args;
 use crate::attrs::*;
 use crate::utils::*;
 
 type Variants = syn::punctuated::Punctuated<syn::Variant, syn::Token![,]>;
 
 /// Defines and implements `config_type` enum.
-pub fn define_config_type_on_enum(em: &syn::ItemEnum) -> syn::Result<TokenStream> {
+pub fn define_config_type_on_enum(args: &Args, em: &syn::ItemEnum) -> syn::Result<TokenStream> {
     let syn::ItemEnum {
         vis,
         enum_token,
@@ -21,22 +22,46 @@ pub fn define_config_type_on_enum(em: &syn::ItemEnum) -> syn::Result<TokenStream
     let mod_name_str = format!("__define_config_type_on_enum_{}", ident);
     let mod_name = syn::Ident::new(&mod_name_str, ident.span());
     let variants = fold_quote(variants.iter().map(process_variant), |meta| quote!(#meta,));
+    let derives = [
+        "std::fmt::Debug",
+        "std::clone::Clone",
+        "std::marker::Copy",
+        "std::cmp::Eq",
+        "std::cmp::PartialEq",
+    ]
+    .iter()
+    .filter(|d| args.skip_derives().all(|s| !d.ends_with(s)))
+    .map(|d| syn::parse_str(d).unwrap())
+    .collect::<Vec<syn::Path>>();
+    let derives = if derives.is_empty() {
+        quote!()
+    } else {
+        quote! { #[derive( #( #derives ),* )] }
+    };
 
     let impl_doc_hint = impl_doc_hint(&em.ident, &em.variants);
     let impl_from_str = impl_from_str(&em.ident, &em.variants);
     let impl_display = impl_display(&em.ident, &em.variants);
-    let impl_serde = impl_serde(&em.ident, &em.variants);
-    let impl_deserialize = impl_deserialize(&em.ident, &em.variants);
+    let impl_serialize = if args.skip_derives().any(|s| s == "Serialize") {
+        quote!()
+    } else {
+        impl_serialize(&em.ident, &em.variants)
+    };
+    let impl_deserialize = if args.skip_derives().any(|s| s == "Deserialize") {
+        quote!()
+    } else {
+        impl_deserialize(&em.ident, &em.variants)
+    };
 
     Ok(quote! {
         #[allow(non_snake_case)]
         mod #mod_name {
-            #[derive(Debug, Copy, Clone, Eq, PartialEq)]
+            #derives
             pub #enum_token #ident #generics { #variants }
             #impl_display
             #impl_doc_hint
             #impl_from_str
-            #impl_serde
+            #impl_serialize
             #impl_deserialize
         }
         #vis use #mod_name::#ident;
@@ -164,7 +189,7 @@ fn unstable_of_variant(variant: &syn::Variant) -> bool {
     any_unstable_variant(&variant.attrs)
 }
 
-fn impl_serde(ident: &syn::Ident, variants: &Variants) -> TokenStream {
+fn impl_serialize(ident: &syn::Ident, variants: &Variants) -> TokenStream {
     let arms = fold_quote(variants.iter(), |v| {
         let v_ident = &v.ident;
         let pattern = match v.fields {

config_proc_macro/src/item_struct.rs

@@ -1,5 +1,10 @@
 use proc_macro2::TokenStream;
 
-pub fn define_config_type_on_struct(_st: &syn::ItemStruct) -> syn::Result<TokenStream> {
+use crate::args::Args;
+
+pub fn define_config_type_on_struct(
+    _args: &Args,
+    _st: &syn::ItemStruct,
+) -> syn::Result<TokenStream> {
     unimplemented!()
 }

config_proc_macro/src/lib.rs

@@ -2,6 +2,7 @@
 
 #![recursion_limit = "256"]
 
+mod args;
 mod attrs;
 mod config_type;
 mod item_enum;
@@ -14,9 +15,10 @@ use proc_macro::TokenStream;
 use syn::parse_macro_input;
 
 #[proc_macro_attribute]
-pub fn config_type(_args: TokenStream, input: TokenStream) -> TokenStream {
+pub fn config_type(args: TokenStream, input: TokenStream) -> TokenStream {
+    let args = parse_macro_input!(args as args::Args);
     let input = parse_macro_input!(input as syn::Item);
-    let output = config_type::define_config_type(&input);
+    let output = config_type::define_config_type(&args, &input);
 
     #[cfg(feature = "debug-with-rustfmt")]
     {

config_proc_macro/src/utils.rs

@@ -1,12 +1,12 @@
 use proc_macro2::TokenStream;
 use quote::{quote, ToTokens};
 
-pub fn fold_quote<F, I, T>(input: impl Iterator<Item = I>, f: F) -> TokenStream
+pub fn fold_quote<F, I, T>(input: impl IntoIterator<Item = I>, f: F) -> TokenStream
 where
     F: Fn(I) -> T,
     T: ToTokens,
 {
-    input.fold(quote! {}, |acc, x| {
+    input.into_iter().fold(quote! {}, |acc, x| {
         let y = f(x);
         quote! { #acc #y }
     })

config_proc_macro/tests/smoke.rs

@@ -18,4 +18,9 @@ mod tests {
         FooBar,
         FooFoo(i32),
     }
+
+    #[config_type(skip_derive(Copy, Serialize))]
+    enum X {
+        Abc(String),
+    }
 }