support customization

Author: nikomatsakis

crates/formality-macros/src/attrs.rs

@@ -1,6 +1,8 @@
 //! Functions to manipulate the custom attributes that guide our macros in various ways.
 
-use syn::{Attribute, DeriveInput};
+use syn::{spanned::Spanned, Attribute, DeriveInput};
+
+use crate::custom::Customize;
 
 /// Checks for any kind of attribute that indicates an "is-a" relationship,
 /// e.g. `#[cast]` and `#[variable]`.
@@ -37,6 +39,33 @@ pub(crate) fn has_variable_attr(attrs: &[Attribute]) -> bool {
     attrs.iter().any(|a| a.path().is_ident("variable"))
 }
 
+/// Extracts any customization attribute from a list of attributes.
+pub(crate) fn customize(attrs: &[Attribute]) -> syn::Result<Customize> {
+    let mut v: Vec<Customize> = attrs
+        .iter()
+        .filter(|a| a.path().is_ident("customize"))
+        .map(|a| a.parse_args())
+        .collect::<syn::Result<_>>()?;
+
+    if v.len() > 1 {
+        Err(syn::Error::new(
+            attrs
+                .iter()
+                .filter(|a| a.path().is_ident("customize"))
+                .skip(1)
+                .next()
+                .unwrap()
+                .path()
+                .span(),
+            "multiple customize attributes",
+        ))
+    } else if v.len() == 1 {
+        Ok(v.pop().unwrap())
+    } else {
+        Ok(Customize::default())
+    }
+}
+
 /// Removes all attributes from the input that are specific to formality.
 pub(crate) fn remove_formality_attributes(input: &mut DeriveInput) {
     remove_formality_attributes_from_vec(&mut input.attrs);

crates/formality-macros/src/custom.rs

@@ -0,0 +1,56 @@
+use proc_macro2::TokenStream;
+
+#[derive(Default, Debug)]
+pub(crate) struct Customize {
+    pub parse: bool,
+    pub debug: bool,
+}
+
+impl syn::parse::Parse for Customize {
+    fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
+        let mut result = Customize::default();
+
+        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;
+                }
+
+                _ => {
+                    return Err(syn::Error::new(
+                        token.span(),
+                        "unexpected token in customization",
+                    ));
+                }
+            }
+
+            if let Some(token) = tokens.next() {
+                match token {
+                    proc_macro2::TokenTree::Punct(p) if p.as_char() == ',' => (),
+                    _ => {
+                        return Err(syn::Error::new(
+                            token.span(),
+                            "unexpected token in customization",
+                        ));
+                    }
+                }
+            } else {
+                break;
+            }
+        }
+
+        Ok(result)
+    }
+}

crates/formality-macros/src/lib.rs

@@ -7,6 +7,7 @@ extern crate proc_macro;
 
 mod attrs;
 mod cast;
+mod custom;
 mod debug;
 mod fixed_point;
 mod fold;

crates/formality-macros/src/term.rs

@@ -3,7 +3,7 @@ use quote::quote;
 use syn::DeriveInput;
 
 use crate::{
-    attrs::remove_formality_attributes,
+    attrs::{self, remove_formality_attributes},
     cast::{downcast_impls, upcast_impls},
     debug::derive_debug_with_spec,
     fold::derive_fold,
@@ -13,10 +13,25 @@ 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 parse_impl = derive_parse_with_spec(synstructure::Structure::new(&input), spec.as_ref())?;
-    let debug_impl = derive_debug_with_spec(synstructure::Structure::new(&input), spec.as_ref());
+    let parse_impl = if customize.parse {
+        None
+    } else {
+        Some(derive_parse_with_spec(
+            synstructure::Structure::new(&input),
+            spec.as_ref(),
+        )?)
+    };
+    let debug_impl = if customize.debug {
+        None
+    } else {
+        Some(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));