Added Custom derive macro (#15)

This allows using `#[custom(...)]` in macro_rules derive

#9

---------

Co-authored-by: Daniel Henry-Mantilla <daniel.henry.mantilla@gmail.com>

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "macro_rules_attribute"
-version = "0.1.3"  # Keep in sync
+version = "0.1.4"  # Keep in sync
 authors = ["Daniel Henry-Mantilla <daniel.henry.mantilla@gmail.com>"]
 edition = "2018"
 
@@ -19,7 +19,7 @@ readme = "README.md"
 paste.version = "1.0.7"
 
 [dependencies.macro_rules_attribute-proc_macro]
-version = "0.1.3"  # Keep in sync
+version = "0.1.4"  # Keep in sync
 path = "src/proc_macro"
 
 [features]

src/lib.rs

@@ -193,6 +193,9 @@ pub use ::macro_rules_attribute_proc_macro::macro_rules_attribute as apply;
 /// This, as with any `#[derive(...)]`, **does not consume** the item it
 /// decorates: instead, it only generates code on top of it.
 ///
+/// Also derives [`Custom`] to allow using `#[custom(...)]` and `#[derive_args(...)]`
+/// as derive helpers.
+///
 /// ## Examples
 ///
 /// ### Implementing `Into<Int>` for a given `#[repr(Int)]` `enum`:
@@ -516,8 +519,17 @@ fn main ()
 /// This is achieved thanks to **checking for the presence of a terminating `!`
 /// (or lack thereof)** to determine whether the given derive macro is a classic
 /// procedural macro one or a `macro_rules!` one.
+///
+/// Also derives [`Custom`] to allow using `#[custom(...)]` and `#[derive_args(...)]`
+/// as derive helpers.
 pub use ::macro_rules_attribute_proc_macro::derive;
 
+/// No-op macro that is automatically derived with [`derive`] or [`macro_rules_derive`]
+/// to allow using the `#[custom(...)]` and `#[derive_args(...)]` attribute.
+///
+/// See <https://github.com/danielhenrymantilla/macro_rules_attribute-rs/issues/9> for more info.
+pub use ::macro_rules_attribute_proc_macro::Custom;
+
 attribute_alias! {
     #[apply(this_macro_is_private!)] =
         #[doc(hidden)]

src/proc_macro/Cargo.toml

@@ -4,7 +4,7 @@ path = "mod.rs"
 
 [package]
 name = "macro_rules_attribute-proc_macro"
-version = "0.1.3"  # Keep in sync
+version = "0.1.4"  # Keep in sync
 authors = ["Daniel Henry-Mantilla <daniel.henry.mantilla@gmail.com>"]
 edition = "2018"
 

src/proc_macro/mod.rs

@@ -72,6 +72,7 @@ fn macro_rules_derive (
             })
             .flat_map(|attr| macro_rules_attribute_impl(attr, input.clone()))
     );
+    ret.extend(real_derive(ts!(::macro_rules_attribute::Custom)));
     ret.extend(input);
     #[cfg(feature = "verbose-expansions")]
     eprintln!("{}", ret);
@@ -87,29 +88,6 @@ fn derive (
 {
     let attrs = attrs.vec();
 
-    fn real_derive (
-        derives: TokenStream,
-    ) -> TokenStream
-    {
-        // `#[::core::prelude::v1::derive( #derives )]`
-        TokenStream::from_iter([
-            TT::Punct(Punct::new('#', Spacing::Alone)),
-            TT::Group(Group::new(
-                Delimiter::Bracket,
-                {
-                    let mut ts: TokenStream = ts!(
-                        ::core::prelude::v1::derive
-                    );
-                    ts.extend([TT::Group(Group::new(
-                        Delimiter::Parenthesis,
-                        derives,
-                    ))]);
-                    ts
-                },
-            ))
-        ])
-    }
-
     // any `path::to::Macro!` in the derive list?
     if attrs.iter().any(is_punct('!')).not() {
         // This is a good old derive.
@@ -164,21 +142,49 @@ fn derive (
     attrs_banged(true).for_each(|attr| {
         ret.extend(macro_rules_attribute_impl(attr, input.clone()))
     });
-    if attrs_banged(false).any(|_| true) {
-        ret.extend(real_derive(
-            attrs_banged(false)
-                .flat_map(|attr| attr.iter().cloned().chain(ts!(,)))
-                .collect()
-            ,
-        ));
-    }
+    ret.extend(real_derive(
+        attrs_banged(false)
+            .flat_map(|attr| attr.iter().cloned().chain(ts!(,)))
+            .chain(ts!(::macro_rules_attribute::Custom,))
+            .collect()
+        ,
+    ));
     ret.extend(input);
 
     #[cfg(feature = "verbose-expansions")]
     eprintln!("{}", ret);
     ret
 }
 
+#[proc_macro_derive(Custom, attributes(custom, derive_args))] pub
+fn custom(_:TokenStream) -> TokenStream {
+    TokenStream::new()
+}
+
+fn real_derive (
+    derives: TokenStream,
+) -> TokenStream
+{
+    // `#[::core::prelude::v1::derive( #derives )]`
+    TokenStream::from_iter([
+        TT::Punct(Punct::new('#', Spacing::Alone)),
+        TT::Group(Group::new(
+            Delimiter::Bracket,
+            {
+                let mut ts: TokenStream = ts!(
+                    ::core::prelude::v1::derive
+                );
+                ts.extend([TT::Group(Group::new(
+                    Delimiter::Parenthesis,
+                    derives,
+                ))]);
+                ts
+            },
+        ))
+    ])
+}
+
+
 #[::core::prelude::v1::derive(Clone, Copy)]
 struct PathIsBangTerminated(bool);
 

tests/custom_derive.rs

@@ -0,0 +1,20 @@
+#[macro_use]
+extern crate macro_rules_attribute;
+
+derive_alias! {
+    #[derive(Nothing!)] = #[derive()];
+}
+
+#[derive(Nothing!)]
+#[custom(hello)]
+struct Foo {
+    #[derive_args("test")]
+    x: i32,
+}
+
+#[macro_rules_derive(Nothing)]
+#[custom(hello)]
+struct Bar {
+    #[derive_args("test")]
+    x: i32,
+}