Support aggregating array type attributes

This makes it a lot easier to use with additive feature flags.

Bumping Version, as this is technically a breaking change.

Author: ModProg

.gitignore

@@ -1 +1,2 @@
 /target
+Cargo.lock

Cargo.lock

@@ -8,7 +8,7 @@ license = "MIT"
 readme = "README.md"
 repository = "https://github.com/ModProg/attribute-derive"
 name = "attribute-derive"
-version = "0.1.1"
+version = "0.2.1"
 edition = "2021"
 
 [lib]

Cargo.toml

@@ -7,7 +7,7 @@ keywords = ["derive", "macro"]
 license = "MIT"
 readme = "README.md"
 repository = "https://github.com/ModProg/attribute-derive"
-version = "0.1.0"
+version = "0.2.0"
 edition = "2021"
 name = "attribute-derive-macro"
 

macro/Cargo.toml

@@ -13,7 +13,6 @@ use syn::{
 pub fn attribute_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
     let syn: Path = parse_quote!(::attribute_derive::__private::syn);
     let pm2: Path = parse_quote!(::attribute_derive::__private::proc_macro2);
-    let none: Path = parse_quote!(::core::option::Option::None);
     let some: Path = parse_quote!(::core::option::Option::Some);
     let ok: Path = parse_quote!(::core::result::Result::Ok);
     let err: Path = parse_quote!(::core::result::Result::Err);
@@ -130,18 +129,7 @@ pub fn attribute_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStre
                 let error1 = format!("`{ident}` is specified multiple times");
                 let error2 = format!("`{ident}` was already specified");
                 option_assignments.push(quote! {
-                    match (&self.#ident, __other.#ident) {
-                        (#none, __value @ #some(_)) => self.#ident = __value,
-                        (#some(__first), #some(__second)) => {
-                            let mut __error = <<#ty as ::attribute_derive::ConvertParsed>::Type as ::attribute_derive::Error>::error(__first, #error1);
-                            #syn::Error::combine(&mut __error, <<#ty as ::attribute_derive::ConvertParsed>::Type as ::attribute_derive::Error>::error(
-                                &__second,
-                                #error2,
-                            ));
-                            return #err(__error);
-                        }
-                        _ => {}
-                    }
+                    self.#ident = <#ty as ::attribute_derive::ConvertParsed>::aggregate(self.#ident.take(), __other.#ident, #error1, #error2)?;
                 });
 
                 let error = if let Some(expected) = expected {

macro/src/lib.rs

@@ -40,9 +40,9 @@
 //! - other syntaxes, maybe something like `key: value`
 use std::fmt::Display;
 
-use proc_macro2::{Literal, Span};
 #[doc(hidden)]
 pub use attribute_derive_macro::Attribute;
+use proc_macro2::{Literal, Span, TokenStream};
 use syn::{
     bracketed, parse::Parse, punctuated::Punctuated, Expr, Lit, LitBool, LitByteStr, LitChar,
     LitFloat, LitInt, LitStr, Path, Result, Token, Type, __private::ToTokens, parse_quote,
@@ -113,7 +113,7 @@ where
 pub trait ConvertParsed
 where
     Self: Sized,
-    Self::Type: Error,
+    Self::Type: Error + Clone,
 {
     /// The type this can be converted from
     type Type;
@@ -128,14 +128,52 @@ where
     }
     /// The default value, this is necessary to implement the implicit default behavior of
     /// [`Option`]
+    ///
+    /// This is necessary as the [`Default`] trait cannot be used in expanded code, but normally you
+    /// can easily implement it using it:
+    /// ```
+    /// # use attribute_derive::ConvertParsed;
+    /// # use syn::{Result, LitBool};
+    /// # #[derive(Default)]
+    /// # struct bool;
+    /// impl ConvertParsed for bool {
+    /// #   type Type = LitBool;
+    /// #   fn convert(value: Self::Type) -> Result<Self> {
+    /// #       unimplemented!()
+    /// #   }
+    ///     fn default() -> Self {
+    ///         Default::default()
+    ///     }
+    /// }
+    /// ```
     fn default() -> Self {
         unreachable!("default_by_default should only return true if this is overridden")
     }
-    /// Should values of this type be able to be defined as flag i.e. just `#[attr(default)]`
-    /// instead of `#[attr(default=true)]`
+    /// Returns the value when this type is specified as flag i.e. just `#[attr(default)]`
+    /// instead of `#[attr(default=true)]`. This relies on [`Self::default`].
     fn as_flag() -> Option<Self::Type> {
         None
     }
+    /// Should values of this type be aggregated instead of conflict if specified multiple times
+    ///
+    /// Currently this is only implemented for [`Arrays`](Array)
+    #[allow(unused)]
+    fn aggregate(
+        this: Option<Self::Type>,
+        other: Option<Self::Type>,
+        error1: &str,
+        error2: &str,
+    ) -> Result<Option<Self::Type>> {
+        match (this, other) {
+            (None, value) => Ok(value),
+            (value, None) => Ok(value),
+            (Some(this), Some(other)) => {
+                let mut error = this.error(error1);
+                syn::Error::combine(&mut error, other.error(error2));
+                Err(error)
+            }
+        }
+    }
 }
 
 /// Helper trait to generate sensible errors
@@ -156,7 +194,8 @@ where
 
 /// Macro to easily implement [`ConvertParsed`] for syn types
 macro_rules! convert_parsed {
-    ($type:path) => {
+    ($(#[$meta:meta])* $type:path) => {
+        $(#[$meta])*
         impl ConvertParsed for $type {
             type Type = $type;
             fn convert(s: Self) -> Result<Self> {
@@ -206,7 +245,7 @@ macro_rules! convert_parsed {
 impl<Output, Parsed> ConvertParsed for Option<Output>
 where
     Output: ConvertParsed<Type = Parsed>,
-    Parsed: Error,
+    Parsed: Error + Clone,
 {
     type Type = Parsed;
     fn convert(s: Parsed) -> Result<Self> {
@@ -225,11 +264,29 @@ where
 impl<Output, Parsed> ConvertParsed for Vec<Output>
 where
     Output: ConvertParsed<Type = Parsed>,
+    Parsed: Clone,
 {
     type Type = Array<Parsed>;
     fn convert(array: Array<Parsed>) -> Result<Self> {
         array.data.into_iter().map(ConvertParsed::convert).collect()
     }
+    fn aggregate(
+        this: Option<Self::Type>,
+        other: Option<Self::Type>,
+        _: &str,
+        _: &str,
+    ) -> Result<Option<Self::Type>> {
+        Ok(match (this, other) {
+            (None, None) => None,
+            (None, value) => value,
+            (value, None) => value,
+            (Some(mut this), Some(other)) => {
+                this.data.extend_from_slice(&other.data);
+                this.span = this.span.join(other.span).unwrap_or(this.span);
+                Some(this)
+            }
+        })
+    }
 }
 
 impl ConvertParsed for bool {
@@ -254,6 +311,7 @@ impl ConvertParsed for bool {
 
 /// Helper struct to parse array literals:
 /// `[a, b, c]`
+#[derive(Clone)]
 pub struct Array<T> {
     data: Vec<T>,
     span: Span,
@@ -286,6 +344,16 @@ convert_parsed!(Lit);
 convert_parsed![LitStr, LitByteStr, LitChar, LitInt, LitFloat, LitBool, Literal];
 convert_parsed!(Expr);
 
+// TODO make this warning better visable
+convert_parsed! {
+    /// Try to avoid using this, as it will consume everything behind, so it needs to be defined as the
+    /// last parameter.
+    ///
+    /// In the future there might be something to allow better handling of this (maybe by puttin it
+    /// into `()`)
+    TokenStream
+}
+
 convert_parsed!(LitStr => String: LitStr::value);
 // TODO convert_parsed!(LitByteStr => Vec<u8>: LitByteStr::value);
 convert_parsed!(LitChar => char: LitChar::value);

src/lib.rs

@@ -1,4 +1,5 @@
 use attribute_derive::Attribute;
+use proc_macro2::TokenStream;
 use syn::parse_quote;
 
 #[test]
@@ -17,10 +18,11 @@ fn test() {
         f: Vec<Type>,
         g: bool,
         h: bool,
+        i: TokenStream,
     }
 
     let parsed = Test::from_attributes([
-        parse_quote!(#[test(b="hi", c="ho", oc="xD", d=(), e=if true{ "a" } else { "b" }, f= [(), Debug], g)]),
+        parse_quote!(#[test(b="hi", c="ho", oc="xD", d=(), e=if true{ "a" } else { "b" }, f= [(), Debug], g, i = smth::hello + 24/3'a', b = c)]),
     ])
     .unwrap();
     assert_eq!(parsed.b.value(), "hi");
@@ -32,6 +34,7 @@ fn test() {
     assert!(parsed.f.len() == 2);
     assert!(parsed.g);
     assert!(!parsed.h);
+    assert_eq!(parsed.i.to_string(), "smth :: hello + 24 / 3 'a' , b = c");
 }
 
 #[test]
@@ -156,10 +159,28 @@ fn error_specified() {
 fn default() {
     #[derive(Attribute, Debug)]
     #[attribute(ident = "test")]
-    #[attribute(invalid_field = "error message")]
-    #[allow(dead_code)]
     struct Test {
         #[attribute(default)]
         hi: f32,
     }
+    assert_eq!(Test::from_attributes([]).unwrap().hi, 0.);
+}
+
+#[test]
+fn aggregate() {
+    #[derive(Attribute, Debug)]
+    #[attribute(ident = "test")]
+    struct Test {
+        strings: Vec<String>,
+    }
+
+    assert_eq!(
+        Test::from_attributes([
+            parse_quote!(#[test(strings=["a"])]),
+            parse_quote!(#[test(strings=["b"])])
+        ])
+        .unwrap()
+        .strings,
+        vec!["a".to_owned(), "b".to_owned()]
+    )
 }