feat: add more ways to parse

Author: ModProg

Cargo.toml

@@ -8,14 +8,15 @@ license = "MIT"
 readme = "README.md"
 repository = "https://github.com/ModProg/attribute-derive"
 name = "attribute-derive"
-version = "0.2.2"
+version = "0.3.0"
 edition = "2021"
 
 [lib]
 
 [dependencies]
 proc-macro2 = "1"
 syn = "1"
+quote = "1.0.18"
 
 [dependencies.attribute-derive-macro]
 version = "0.2.0"

README.md

@@ -37,3 +37,21 @@ There are some limitations in syntax parsing that will be lifted future releases
 - literals in top level (meaning something like `#[attr(42, 3.14, "hi")]`
 - function like arguments (something like `#[attr(view(a = "test"))]`
 - other syntaxes, maybe something like `key: value`
+
+## Parse methods
+
+There are multiple ways of parsing a struct deriving [`Attribute`](https://docs.rs/attribute-derive/latest/attribute_derive/trait.Attribute.html).
+
+For helper attributes there is:
+- [`Attribute::from_attributes`](https://docs.rs/attribute-derive/latest/attribute_derive/trait.Attribute.html#tymethod.from_attributes) which takes in an [`IntoIterator<Item = &'a
+syn::Attribute`](https://docs.rs/syn/latest/syn/struct.Attribute.html)
+(e.g. a [`&Vec<syn::Attribute>`](https://docs.rs/syn/latest/syn/struct.Attribute.html)). Most useful for derive macros.
+- [`Attribute::remove_attributes`](https://docs.rs/attribute-derive/latest/attribute_derive/trait.Attribute.html#tymethod.remove_attributes) which takes an [`&mut Vec<syn::Attribute>`](https://docs.rs/syn/latest/syn/struct.Attribute.html)
+and does not only parse the [`Attribute`](https://docs.rs/attribute-derive/latest/attribute_derive/trait.Attribute.html#tymethod.from_attributes) but also removes those matching. Useful for helper
+attributes for proc macros, where the helper attributes need to be removed.
+
+For parsing a single [`TokenStream`](https://docs.rs/proc-macro2/latest/proc_macro2/struct.TokenStream.html) e.g. for parsing the proc macro input there a two ways:
+
+- [`Attribute::from_args`](https://docs.rs/attribute-derive/latest/attribute_derive/trait.Attribute.html#tymethod.from_args) taking in a [`TokenStream`](https://docs.rs/proc-macro2/latest/proc_macro2/struct.TokenStream.html)
+- As `derive(Attribute)` also derives [`Parse`](https://docs.rs/syn/latest/syn/parse/trait.Parse.html) so you can use the [parse](https://docs.rs/syn/latest/syn/parse/index.html) API,
+e.g. with [`parse_macro_input!(tokens as Attribute)`](https://docs.rs/syn/latest/syn/macro.parse_macro_input.html).

macro/Cargo.toml

@@ -18,5 +18,6 @@ proc-macro = true
 [dependencies]
 proc-macro-error = "1.0.4"
 proc-macro2 = "1.0.36"
-quote = "1.0"
+quote = "1.0.18"
+quote-use = { version = "0.4.3", features = ["namespace_idents", "prelude_core", "prelude_2021"], default-features = false }
 syn = "1.0"

macro/src/lib.rs

@@ -1,22 +1,18 @@
 use proc_macro2::TokenStream;
 use proc_macro_error::{abort_call_site, proc_macro_error, ResultExt};
-use quote::quote;
+use quote::format_ident;
 use syn::{
-    parse_macro_input, parse_quote, punctuated::Punctuated, DataStruct, DeriveInput, Field, Fields,
-    FieldsNamed, Lit, Meta, MetaNameValue, NestedMeta, Path, Token,
+    parse_macro_input, punctuated::Punctuated, DataStruct, DeriveInput, Field, Fields, FieldsNamed,
+    Lit, Meta, MetaNameValue, NestedMeta, Token,
 };
 
+use quote_use::quote_use as quote;
+
 // TODO generally should use fully qualified names for trait function calls
 
 #[proc_macro_error]
 #[proc_macro_derive(Attribute, attributes(attribute))]
 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 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);
-
     let DeriveInput {
         attrs,
         ident,
@@ -25,6 +21,8 @@ pub fn attribute_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStre
         ..
     } = parse_macro_input!(input as DeriveInput);
 
+    let parser_ident = format_ident!("{ident}__Parser");
+
     let mut attribute_ident = None;
     let mut invalid_field = None;
 
@@ -54,16 +52,13 @@ pub fn attribute_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStre
             }
         }
     }
-    let attribute_ident: String = attribute_ident.unwrap_or_else(|| {
-        abort_call_site!(
-            r#"You need to specify the attribute path via `#[attribute(ident="name_of_your_attribute")]`"#
-        );
-    });
+    let attribute_ident = attribute_ident
+        .map(|attribute_ident| quote!(Some(#attribute_ident)))
+        .unwrap_or_else(|| quote!(None));
 
     let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
 
     let mut options_ty: Punctuated<TokenStream, Token!(,)> = Punctuated::new();
-    let mut options_creation: Punctuated<TokenStream, Token!(,)> = Punctuated::new();
     let mut parsing: Punctuated<TokenStream, Token!(,)> = Punctuated::new();
     let mut option_assignments: Punctuated<TokenStream, Token!(;)> = Punctuated::new();
     let mut assignments: Punctuated<TokenStream, Token!(,)> = Punctuated::new();
@@ -124,35 +119,35 @@ pub fn attribute_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStre
 
                 options_ty
                     .push(quote!(#ident: Option<<#ty as ::attribute_derive::ConvertParsed>::Type>));
-                options_creation.push(quote!(#ident: None));
 
                 let error1 = format!("`{ident}` is specified multiple times");
                 let error2 = format!("`{ident}` was already specified");
                 option_assignments.push(quote! {
-                    self.#ident = <#ty as ::attribute_derive::ConvertParsed>::aggregate(self.#ident.take(), __other.#ident, #error1, #error2)?;
+                    self.#ident = <#ty as ::attribute_derive::ConvertParsed>::aggregate(self.#ident.take(), $other.#ident, #error1, #error2)?;
                 });
 
                 let error = if let Some(expected) = expected {
-                    quote! {.map_err(|__error| #syn::Error::new(__error.span(), #expected)) }
+                    quote! {.map_err(|__error| ::attribute_derive::__private::syn::Error::new(__error.span(), #expected)) }
                 } else {
                     quote!()
                 };
 
                 parsing.push(quote! {
+                    # use ::attribute_derive::__private::{syn, proc_macro2};
                     #ident_str => {
-                        __options.#ident = #some(
-                            if let #some(#some(__value)) = __is_flag.then(|| <#ty as ::attribute_derive::ConvertParsed>::as_flag()) {
+                        $parser.#ident = Some(
+                            if let Some(Some(__value)) = $is_flag.then(|| <#ty as ::attribute_derive::ConvertParsed>::as_flag()) {
                                 __value
                             } else {
-                                __input.step(|__cursor| match __cursor.punct() {
-                                    #some((__punct, __rest))
-                                        if __punct.as_char() == '=' && __punct.spacing() == #pm2::Spacing::Alone =>
+                                $input.step(|__cursor| match __cursor.punct() {
+                                    Some((__punct, __rest))
+                                        if __punct.as_char() == '=' && __punct.spacing() == proc_macro2::Spacing::Alone =>
                                     {
-                                        #ok(((), __rest))
+                                        Ok(((), __rest))
                                     }
-                                    _ => #err(__cursor.error("Expected assignment `=`")),
+                                    _ => Err(__cursor.error("Expected assignment `=`")),
                                 })?;
-                                #syn::parse::Parse::parse(__input)#error?
+                                syn::parse::Parse::parse($input)#error?
                             }
                         );
                     }
@@ -163,14 +158,15 @@ pub fn attribute_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStre
                 });
                 assignments.push(if default {
                     quote! {
-                        #ident: __options.#ident.map(|t| ::attribute_derive::ConvertParsed::convert(t)).unwrap_or_else(|| #ok(<#ty as core::default::Default>::default()))?
+                        #ident: $parser.#ident.map(|t| ::attribute_derive::ConvertParsed::convert(t)).unwrap_or_else(|| Ok(<#ty as Default>::default()))?
                     }
                 } else {
                     quote! {
-                        #ident: match __options.#ident.map(|t| ::attribute_derive::ConvertParsed::convert(t)) {
+                        # use ::attribute_derive::__private::{syn, proc_macro2};
+                        #ident: match $parser.#ident.map(|t| ::attribute_derive::ConvertParsed::convert(t)) {
                                 Some(__option) => __option?,
                                 None if <#ty as ::attribute_derive::ConvertParsed>::default_by_default() => <#ty as ::attribute_derive::ConvertParsed>::default(),
-                                _ => #err(#syn::Error::new(#pm2::Span::call_site(), #error))?,
+                                _ => Err(syn::Error::new(proc_macro2::Span::call_site(), #error))?,
                             }
                     }
                 });
@@ -195,66 +191,74 @@ pub fn attribute_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStre
     });
 
     quote! {
-        #[allow(unreachable_code)]
-        impl #impl_generics ::attribute_derive::Attribute for #ident #ty_generics #where_clause {
-            fn from_attributes(__attrs: impl ::core::iter::IntoIterator<Item = #syn::Attribute>) -> #syn::Result<Self>{
-                struct __Options{
-                    #options_ty
-                }
-                impl __Options {
-                    fn extend_with(&mut self, __other:Self) -> #syn::Result<()>{
-                        #option_assignments
-                        #ok(())
-                    }
-                }
-                impl #syn::parse::Parse for __Options {
-                    fn parse(__input: #syn::parse::ParseStream<'_>) -> #syn::Result<Self> {
-                        let mut __options = __Options{
-                            #options_creation
-                        };
-                        loop {
-                            if __input.is_empty() {
-                                break;
-                            }
+        # use ::attribute_derive::__private::{syn::{self, Result, Ident, Token, parse::{Parse, ParseStream}}, proc_macro2};
+        # use ::attribute_derive::TryExtendOne;
 
-                            let __variable = #syn::Ident::parse(__input)?;
+        #[doc(hidden)]
+        #[allow(non_camel_case_types)]
+        #[derive(Default)]
+        struct #parser_ident {
+            #options_ty
+        }
 
-                            let __is_flag = !__input.peek(#syn::Token!(=));
+        #[allow(unreachable_code)]
+        impl Parse for #parser_ident {
+            fn parse($input: ParseStream<'_>) -> Result<Self> {
+                let mut $parser: Self = Default::default();
+                loop {
+                    if $input.is_empty() {
+                        break;
+                    }
 
-                            match __variable.to_string().as_str() {
-                                #parsing
-                                _ => {
-                                    return #err(#syn::Error::new(
-                                        __variable.span(),
-                                        #error_invalid_name
-                                    ))
-                                }
-                            }
+                    let $variable = Ident::parse($input)?;
 
-                            if __input.is_empty() {
-                                break;
-                            }
+                    let $is_flag = !$input.peek(Token!(=));
 
-                            // Parse `,`
-                            __input.step(|__cursor| match __cursor.punct() {
-                                #some((__punct, __rest)) if __punct.as_char() == ',' => #ok(((), __rest)),
-                                _ => #err(__cursor.error("Expected assignment `=`")),
-                            })?;
+                    match $variable.to_string().as_str() {
+                        #parsing
+                        _ => {
+                            return Err(syn::Error::new(
+                                $variable.span(),
+                                #error_invalid_name
+                            ))
                         }
-                        Ok(__options)
                     }
-                }
-                let mut __options = __Options{
-                    #options_creation
-                };
-                for __attribute in __attrs {
-                    if __attribute.path.is_ident(#attribute_ident) {
-                        __options.extend_with(__attribute.parse_args()?)?;
+
+                    if $input.is_empty() {
+                        break;
                     }
+
+                    // Parse `,`
+                    $input.step(|__cursor| match __cursor.punct() {
+                        Some((__punct, __rest)) if __punct.as_char() == ',' => Ok(((), __rest)),
+                        _ => Err(__cursor.error("Expected assignment `=`")),
+                    })?;
                 }
-                #ok(Self {
-                    #assignments
-                })
+                Ok($parser)
+            }
+        }
+
+        #[allow(unreachable_code)]
+        impl TryExtendOne for #parser_ident {
+            fn try_extend_one(&mut self, $other: Self) -> Result<()>{
+                #option_assignments
+                Ok(())
+            }
+        }
+
+        #[allow(unreachable_code)]
+        impl #impl_generics ::attribute_derive::Attribute for #ident #ty_generics #where_clause {
+            const IDENT: Option<&'static str> = #attribute_ident;
+            type Parser = #parser_ident;
+
+            fn from_parser($parser: Self::Parser) -> Result<Self> {
+                Ok(Self{#assignments})
+            }
+        }
+
+        impl #impl_generics Parse for #ident #ty_generics #where_clause {
+            fn parse($input: ParseStream<'_>) -> Result<Self> {
+                Parse::parse($input).and_then(Self::from_parser)
             }
         }
     }