allow customizing fold and visit

Author: nikomatsakis

crates/formality-macros/src/custom.rs

@@ -5,6 +5,8 @@ pub(crate) struct Customize {
     pub parse: bool,
     pub debug: bool,
     pub constructors: bool,
+    pub fold: bool,
+    pub visit: bool,
 }
 
 impl syn::parse::Parse for Customize {
@@ -13,35 +15,36 @@ impl syn::parse::Parse for Customize {
 
         let token_stream: TokenStream = input.parse()?;
         let mut tokens = token_stream.into_iter();
-        while let Some(token) = tokens.next() {
-            match token {
-                proc_macro2::TokenTree::Ident(ident) if ident == "parse" => {
-                    if result.parse {
-                        return Err(syn::Error::new(ident.span(), "already customizing parse"));
-                    }
-                    result.parse = true;
-                }
 
-                proc_macro2::TokenTree::Ident(ident) if ident == "debug" => {
-                    if result.debug {
-                        return Err(syn::Error::new(ident.span(), "already customizing debug"));
-                    }
-                    result.debug = true;
-                }
+        while let Some(token) = tokens.next() {
+            macro_rules! match_customization_field_or_error {
+                ($($ident:ident,)*) => {
+                    match token {
+                        $(
+                            proc_macro2::TokenTree::Ident(ident) if ident == stringify!($ident) => {
+                                if result.$ident {
+                                    return Err(syn::Error::new(ident.span(), &format!("already customizing {}", stringify!($ident))));
+                                }
+                                result.$ident = true;
+                            }
+                        )*
 
-                proc_macro2::TokenTree::Ident(ident) if ident == "constructors" => {
-                    if result.constructors {
-                        return Err(syn::Error::new(ident.span(), "already customizing debug"));
+                        _ => {
+                            return Err(syn::Error::new(
+                                token.span(),
+                                "unexpected token in customization",
+                            ));
+                        }
                     }
-                    result.constructors = true;
-                }
+                };
+            }
 
-                _ => {
-                    return Err(syn::Error::new(
-                        token.span(),
-                        "unexpected token in customization",
-                    ));
-                }
+            match_customization_field_or_error! {
+                parse,
+                debug,
+                constructors,
+                fold,
+                visit,
             }
 
             if let Some(token) = tokens.next() {

crates/formality-macros/src/term.rs

@@ -15,31 +15,33 @@ use crate::{
 
 pub fn term(spec: Option<FormalitySpec>, mut input: DeriveInput) -> syn::Result<TokenStream> {
     let customize = attrs::customize(&input.attrs)?;
-    let fold_impl = derive_fold(synstructure::Structure::new(&input));
-    let visit_impl = derive_visit(synstructure::Structure::new(&input));
+    let fold_impl = if customize.fold {
+        Default::default()
+    } else {
+        derive_fold(synstructure::Structure::new(&input))
+    };
+    let visit_impl = if customize.visit {
+        Default::default()
+    } else {
+        derive_visit(synstructure::Structure::new(&input))
+    };
     let parse_impl = if customize.parse {
-        None
+        Default::default()
     } else {
-        Some(derive_parse_with_spec(
-            synstructure::Structure::new(&input),
-            spec.as_ref(),
-        )?)
+        derive_parse_with_spec(synstructure::Structure::new(&input), spec.as_ref())?
     };
     let debug_impl = if customize.debug {
-        None
+        Default::default()
     } else {
-        Some(derive_debug_with_spec(
-            synstructure::Structure::new(&input),
-            spec.as_ref(),
-        ))
+        derive_debug_with_spec(synstructure::Structure::new(&input), spec.as_ref())
     };
     let term_impl = derive_term(synstructure::Structure::new(&input));
     let downcast_impls = downcast_impls(synstructure::Structure::new(&input));
     let upcast_impls = upcast_impls(synstructure::Structure::new(&input));
     let constructors = if customize.constructors {
-        None
+        Default::default()
     } else {
-        Some(constructor_methods(synstructure::Structure::new(&input)))
+        constructor_methods(synstructure::Structure::new(&input))
     };
     remove_formality_attributes(&mut input);