Why do proc-macros have to be defined in proc-macro crate?

Question

I was trying to create a derive macro for my trait, to simplify some stuff.

I\'ve encountered some problems:

the `#[proc_macro_derive]` attribute is          


        

Answer 1

Procedural macros are fundamentally different from normal dependencies in your code. A normal library is just linked into your code, but a procedural macro is actually a compiler plugin.

Consider the case of cross-compiling: you are working on a Linux machine, but building a WASM project.

• A normal crate will be cross-compiled, generate WASM code and linked with the rest of the crates.
• A proc-macro crate must be compiled natively, in this case to Linux code, linked with the current compiler runtime (stable, beta, nightly) and be loaded by the compiler itself when compiling the crates where it is actually used. It will not be linked to the rest of the crates (different architecture!).

And since the compilation flow is different, the crate type must also be different, that is why the proc_macro=true is needed.

About this restriction:

proc-macro crate types cannot export any items other than functions tagged with #[proc_macro_derive]

Well, since the proc-macro crate is loaded by the compiler, not linked to the rest of your crates, any non-proc-macro code you export from this crate would be useless.

Note that the error message is inexact, as you can also export functions tagget with #[proc_macro].

And about this other restriction:

functions tagged with #[proc_macro_derive] must currently reside in the root of the crate

Adding proc_macro or proc_macro_derive items in nested modules is not currently supported, and does not seem to be particularly useful, IMHO.