Derive macros as a library crate

[Kestrer]

I'm writing a derive macro for a trait that requires Deserialize, and writing implementations by hand is very tedious. It would be useful if Serde could provide a non-proc macro crate with the same functionality as the proc macro crate, so I can simply invoke all of Serde's derive logic from a proc macro.

It could be called serde_derive2 or something, and it would expose the implementation of the derive functions as functions that use proc_macro2 types (maybe it could also support different names for the serde attribute). Like what currently goes on with serde_derive_internals it can be a module of serde_derive as well as an external crate.

If this is a good idea I'm happy to make a PR for it.

[dtolnay]

I wouldn't recommend starting with a PR for this — it seems like something that could be developed as an external crate, either using code forked from serde_derive, or rewriting just the parts of the logic that you feel other macros are going to want to use.

[Kestrer]

If anyone happens to encounter this in future, there was never actually any need for this. Derive macros can just expand to the same item but deriving the Serde macro, using a second attribute macro to not duplicate the type.

// Initial code:
#[derive(YourDeriveMacro)]
struct S;

// After your derive macro runs:
struct S;
impl YourTrait for S { /* ... */ }

#[derive(Deserialize)]
#[::your_crate::black_hole]
struct S; // second instance of the type, with added derives, emitted by your macro

// After Serde's derive macro runs:
struct S;
impl YourTrait for S { /* ... */ }
#[::your_crate::black_hole]
struct S;
impl<'de> Deserialize<'de> for S { /* ... */ }

// After your `black_hole` attribute macro runs (and emits nothing):
struct S;
impl YourTrait for S { /* ... */ }
impl<'de> Deserializer<'de> for S { /* ... */ }

It's a neat trick. black_hole can be implemented like so:

/// Not public API, do not use.
#[doc(hidden)]
pub fn black_hole(_: TokenStream, _: TokenStream) -> TokenStream {
    TokenStream::new()
}

Note that unfortunately #[cfg(any())] cannot be used in place of the black_hole macro, because it would run before the derives even if it's placed after.