remove panic via helper trait

Author: ModProg

macro/src/lib.rs

@@ -52,12 +52,21 @@ pub fn attribute_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStre
             }
         }
     }
-    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 attribute_ident = attribute_ident
+        .map(|attribute_ident| {
+            quote! {
+                # use attribute_derive::AttributeIdent;
+
+                impl #impl_generics AttributeIdent for #ident #ty_generics #where_clause {
+                    const ATTRIBUTE_IDENT: &'static str = #attribute_ident;
+                }
+            }
+        })
+        .unwrap_or_default();
+
     let mut options_ty: Punctuated<TokenStream, Token!(,)> = Punctuated::new();
     let mut parsing: Punctuated<TokenStream, Token!(,)> = Punctuated::new();
     let mut option_assignments: Punctuated<TokenStream, Token!(;)> = Punctuated::new();
@@ -246,9 +255,10 @@ pub fn attribute_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStre
             }
         }
 
+        #attribute_ident
+
         #[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> {

src/lib.rs

@@ -104,6 +104,18 @@ pub mod __private {
     pub use syn;
 }
 
+/// Helper trait providing the path for an attribute.
+///
+/// Automatically derived with [`Attribute`], if `#[attribute(ident =
+/// "some_ident")]` is provided.
+/// ```
+pub trait AttributeIdent: Sized {
+    const ATTRIBUTE_IDENT: &'static str;
+    fn get_attribute_ident() -> &'static str {
+        Self::ATTRIBUTE_IDENT
+    }
+}
+
 /// The trait you actually derive on your attribute struct.
 ///
 /// Basic gist is a struct like this:
@@ -132,7 +144,6 @@ pub mod __private {
 /// #[collection(authority="Some String", name = r#"Another string"#, views = [Option, ()], some_flag)]
 /// ```
 pub trait Attribute: Sized {
-    const IDENT: Option<&'static str>;
     type Parser: TryExtendOne + Parse + Default;
 
     #[doc(hidden)]
@@ -162,12 +173,15 @@ pub trait Attribute: Sized {
     /// - Invalid input is given for a parameter
     /// - A non aggregating parameter is specified multiple times
     /// - An attribute called [`IDENT`](Self::IDENT) has invalid syntax (e.g. `#attr(a: "a")`)
-    fn from_attributes<'a>(attrs: impl IntoIterator<Item = &'a syn::Attribute>) -> Result<Self> {
+    fn from_attributes<'a>(attrs: impl IntoIterator<Item = &'a syn::Attribute>) -> Result<Self>
+    where
+        Self: AttributeIdent,
+    {
         attrs
             .into_iter()
             .filter_map(|attr| {
                 attr.path
-                    .is_ident(Self::IDENT.expect(r#"To use `from_attributes` you need to pass the attribute name while deriving with `#[attribute(ident="some_ident")]"#))
+                    .is_ident(Self::ATTRIBUTE_IDENT)
                     .then(|| attr.parse_args::<Self::Parser>())
             })
             .try_fold(Self::Parser::default(), |mut acc, item| {
@@ -201,11 +215,14 @@ pub trait Attribute: Sized {
     /// - Invalid input is given for a parameter
     /// - A non aggregating parameter is specified multiple times
     /// - An attribute called [`IDENT`](Self::IDENT) has invalid syntax (e.g. `#attr(a: "a")`)
-    fn remove_attributes(attrs: &mut Vec<syn::Attribute>) -> Result<Self> {
+    fn remove_attributes(attrs: &mut Vec<syn::Attribute>) -> Result<Self>
+    where
+        Self: AttributeIdent,
+    {
         let mut parser: Self::Parser = Default::default();
         let mut i = 0;
         while i < attrs.len() {
-            if attrs[i].path.is_ident(Self::IDENT.expect(r#"To use `remove_attributes` you need to pass the attribute name while deriving with `#[attribute(ident="some_ident")]"#)) {
+            if attrs[i].path.is_ident(Self::ATTRIBUTE_IDENT) {
                 parser.try_extend_one(attrs.remove(i).parse_args()?)?;
             } else {
                 i += 1;