Add impl_attrs feature.

Author: guzman-raphael

src/generate.rs

@@ -1,7 +1,8 @@
 use proc_macro2::{Ident, Span, TokenStream as TokenStream2};
 use proc_macro_error2::abort;
 use syn::{
-    self, ext::IdentExt, spanned::Spanned, Expr, Field, Lit, Meta, MetaNameValue, Visibility,
+    self, ext::IdentExt, spanned::Spanned, Attribute, Expr, Field, Lit, Meta, MetaNameValue,
+    Visibility,
 };
 
 use self::GenMode::{Get, GetClone, GetCopy, GetMut, Set, SetWith};
@@ -10,6 +11,7 @@ use super::parse_attr;
 pub struct GenParams {
     pub mode: GenMode,
     pub global_attr: Option<Meta>,
+    pub impl_attrs: Vec<Attribute>,
 }
 
 #[derive(PartialEq, Eq, Copy, Clone)]
@@ -58,7 +60,7 @@ impl GenMode {
 }
 
 // Helper function to extract string from Expr
-fn expr_to_string(expr: &Expr) -> Option<String> {
+pub(crate) fn expr_to_string(expr: &Expr) -> Option<String> {
     if let Expr::Lit(expr_lit) = expr {
         if let Lit::Str(s) = &expr_lit.lit {
             Some(s.value())
@@ -111,7 +113,7 @@ fn has_prefix_attr(f: &Field, params: &GenParams) -> bool {
     let field_attr_has_prefix = f
         .attrs
         .iter()
-        .filter_map(|attr| parse_attr(attr, params.mode))
+        .filter_map(|attr| parse_attr(attr, params.mode, false).0)
         .find(|meta| {
             meta.path().is_ident("get")
                 || meta.path().is_ident("get_clone")
@@ -161,7 +163,7 @@ pub fn implement(field: &Field, params: &GenParams) -> TokenStream2 {
     let attr = field
         .attrs
         .iter()
-        .filter_map(|v| parse_attr(v, params.mode))
+        .filter_map(|v| parse_attr(v, params.mode, false).0)
         .last()
         .or_else(|| params.global_attr.clone());
 
@@ -236,7 +238,7 @@ pub fn implement_for_unnamed(field: &Field, params: &GenParams) -> TokenStream2
     let attr = field
         .attrs
         .iter()
-        .filter_map(|v| parse_attr(v, params.mode))
+        .filter_map(|v| parse_attr(v, params.mode, false).0)
         .last()
         .or_else(|| params.global_attr.clone());
     let ty = field.ty.clone();

src/lib.rs

@@ -209,11 +209,11 @@ use proc_macro::TokenStream;
 use proc_macro2::TokenStream as TokenStream2;
 use proc_macro_error2::{abort, abort_call_site, proc_macro_error};
 use syn::{
-    parse_macro_input, punctuated::Punctuated, spanned::Spanned, Attribute, Data, DataStruct,
-    DeriveInput, Fields, Meta, Token,
+    parse_macro_input, parse_str, punctuated::Punctuated, spanned::Spanned, Attribute, Data,
+    DataStruct, DeriveInput, Fields, ItemImpl, Meta, Token,
 };
 
-use crate::generate::{GenMode, GenParams};
+use crate::generate::{expr_to_string, GenMode, GenParams};
 
 mod generate;
 
@@ -272,21 +272,47 @@ pub fn with_setters(input: TokenStream) -> TokenStream {
 }
 
 fn make_params(attrs: &[Attribute], mode: GenMode) -> GenParams {
+    let mut impl_attrs = vec![];
     GenParams {
         mode,
-        global_attr: attrs.iter().filter_map(|v| parse_attr(v, mode)).last(),
+        global_attr: attrs
+            .iter()
+            .filter_map(|v| {
+                let (attr, impl_attrs_exist) = parse_attr(v, mode, true);
+                if let Some(Meta::NameValue(code)) = &impl_attrs_exist {
+                    match expr_to_string(&code.value) {
+                        Some(code_str) => {
+                            match parse_str::<ItemImpl>(&format!("{} impl _ {{}}", code_str)) {
+                                Ok(parsed_impl) => impl_attrs.extend(parsed_impl.attrs),
+                                Err(_) => abort!(
+                                    code.value.span(),
+                                    "Syntax error, expected attributes like #[..]."
+                                ),
+                            }
+                        }
+                        None => abort!(code.value.span(), "Expected string."),
+                    }
+                }
+                attr
+            })
+            .last(),
+        impl_attrs,
     }
 }
 
-fn parse_attr(attr: &Attribute, mode: GenMode) -> Option<Meta> {
+fn parse_attr(
+    attr: &Attribute,
+    mode: GenMode,
+    globally_called: bool,
+) -> (Option<Meta>, Option<Meta>) {
     if attr.path().is_ident("getset") {
         let meta_list = match attr.parse_args_with(Punctuated::<Meta, Token![,]>::parse_terminated)
         {
             Ok(list) => list,
             Err(e) => abort!(attr.span(), "Failed to parse getset attribute: {}", e),
         };
 
-        let (last, skip, mut collected) = meta_list
+        let (last, skip, impl_attrs, mut collected) = meta_list
             .into_iter()
             .inspect(|meta| {
                 if !(meta.path().is_ident("get")
@@ -295,21 +321,24 @@ fn parse_attr(attr: &Attribute, mode: GenMode) -> Option<Meta> {
                     || meta.path().is_ident("get_mut")
                     || meta.path().is_ident("set")
                     || meta.path().is_ident("set_with")
-                    || meta.path().is_ident("skip"))
+                    || meta.path().is_ident("skip")
+                    || (meta.path().is_ident("impl_attrs") && globally_called))
                 {
                     abort!(meta.path().span(), "unknown setter or getter")
                 }
             })
             .fold(
-                (None, None, Vec::new()),
-                |(last, skip, mut collected), meta| {
+                (None, None, None, Vec::new()),
+                |(last, skip, impl_attrs, mut collected), meta| {
                     if meta.path().is_ident(mode.name()) {
-                        (Some(meta), skip, collected)
+                        (Some(meta), skip, impl_attrs, collected)
                     } else if meta.path().is_ident("skip") {
-                        (last, Some(meta), collected)
+                        (last, Some(meta), impl_attrs, collected)
+                    } else if meta.path().is_ident("impl_attrs") {
+                        (last, skip, Some(meta), collected)
                     } else {
                         collected.push(meta);
-                        (last, skip, collected)
+                        (last, skip, impl_attrs, collected)
                     }
                 },
             );
@@ -318,26 +347,27 @@ fn parse_attr(attr: &Attribute, mode: GenMode) -> Option<Meta> {
             // Check if there is any setter or getter used with skip, which is
             // forbidden.
             if last.is_none() && collected.is_empty() {
-                skip
+                (skip, impl_attrs)
             } else {
                 abort!(
                     last.or_else(|| collected.pop()).unwrap().path().span(),
                     "use of setters and getters with skip is invalid"
                 );
             }
         } else {
-            last
+            (last, impl_attrs)
         }
     } else if attr.path().is_ident(mode.name()) {
         // If skip is not used, return the last occurrence of matching
         // setter/getter, if there is any.
-        attr.meta.clone().into()
+        (attr.meta.clone().into(), None)
     } else {
-        None
+        (None, None)
     }
 }
 
 fn produce(ast: &DeriveInput, params: &GenParams) -> TokenStream2 {
+    let impl_attrs = &params.impl_attrs;
     let name = &ast.ident;
     let generics = &ast.generics;
     let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
@@ -354,6 +384,7 @@ fn produce(ast: &DeriveInput, params: &GenParams) -> TokenStream2 {
             let generated = generate::implement_for_unnamed(field, params);
 
             quote! {
+                #(#impl_attrs)*
                 impl #impl_generics #name #ty_generics #where_clause {
                     #generated
                 }
@@ -362,6 +393,7 @@ fn produce(ast: &DeriveInput, params: &GenParams) -> TokenStream2 {
             let generated = fields.iter().map(|f| generate::implement(f, params));
 
             quote! {
+                #(#impl_attrs)*
                 impl #impl_generics #name #ty_generics #where_clause {
                     #(#generated)*
                 }

tests/impl_attrs.rs

@@ -1,3 +1,4 @@
+use fixture::add_1_to_implementation;
 use getset::{CloneGetters, CopyGetters};
 
 #[derive(CopyGetters, CloneGetters)]