Proc macros - using third party crate

Hello! I am trying to use a macro from an external crate (izip from itertools). After some trial and error, I found that I need to use external crate itertools inside the quote! {} macro to satisfy the cargo expand command (running the command on the program that uses the macro I have created). I can even see the macro is used in the output.
But when I try to run the program that uses the macro I have created, I get the error that says that the itertools crate is missing.

can't find crate for itertools

I am using quote and syn crates.
Any help?

itertools must be in the dependencies of the crate using your macro. Is it present there?

No, I had not added it there. I expected it to work without adding it. I don't remember adding any such extra dependency when I use third party macros.
Thanks! It worked when I added it

The Rust solution to this, more general than just to procedural macros, are public dependencies through public reexports:

//! Your ``

// 2018 edition
pub use ::itertools;
// old style
pub extern crate itertools;

and then within a macro_rules! macro, for instance, you expand to a path referring to your crate first, which must contain the itertools crate as the second element of the path / as if it were a top-level module:

macro_rules! my_izip {(
) => (
    $crate // self crate
    izip! { $($input) * }

This way users of your crate will not need to depend on itertools on their own.

This is all well and fine, but with procedural macros things get a bit more complicated. Indeed:

  • there is no $crate magic metavar for procedural macros.

    • You'll have to hardcode the name of your crate instead of $crate:

      ::name_of_my_crate::itertools::izip! { ... }
  • a proc-macro = true crate currently cannot export any items other than functions tagged with #[proc_macro], #[proc_macro_derive], or #[proc_macro_attribute]:

    Screenshot 2020-05-12 at 11.42.29

The solution to the second problem is easy, but a bit more cumbersome: a "normal" Rust crate that wants to define, among other things, procedural macros, needs, in practice, to be split in two crates:

  • the proc-macro / derive / internals / helper crate, which defines the procedural macros;

  • and the "frontend" crate, which reexports the proc-macro crate, while defining all the other stuff.

    • (The name of the crate to hardcode in the expanded paths is that of the frontend crate)

This means you need to:

Create your helper proc-macro = true crate

cargo new --lib src/proc_macros --name your_crate_name-proc_macros
(cd src/proc_macros && mv src/ && rmdir src)
Add to src/proc_macros/Cargo.toml
proc-macro = true
path = ""

proc-macro2.version = "1.0.x"
quote.version = "1.0.y"
syn.version = "1.0.z"
syn.features = []  # you may need "full" features
Edit src/proc_macros/ to your liking

Set up your frontend crate

Add to your Cargo.toml

path = "src/proc_macros"
version = "..."  # Same as main version

members = ["src/proc_macros"]
Add to your src/
pub use your_crate_name_proc_macros::{
    /* your procedural macros here */

#[doc(hidden)] pub /* hide from doc since it is just a tool for your macros */
use ::itertools;
// or
#[doc(hidden)] pub /* hide from doc since it is just a tool for your macros */
extern crate itertools;

What your procedural macro should expand to to refer to itertools' izip!:

use ::proc_macro::TokenStream;
use ::proc_macro2::{
    TokenStream as TokenStream2,
use ::quote::{
use ::syn::{*,
    parse::{Parse, Parser, ParseStream},
    Result, /* explicitly shadow `Result` */

#[proc_macro...] pub
fn your_proc_macro (/* args: TokenStream,*/ input: TokenStream)
  -> TokenStream
    let input = parse_macro_input!(input as /* ... */);
    // ...
    let izip = quote! {
    TokenStream::from(quote! {
        /* your expansion here */
        #izip! { /* ... */ }
  • You could even reexport izip directly (pub use ::itertools::izip) and have the proc-macro expand to ::your_crate_name::izip.

This topic was automatically closed 90 days after the last reply. New replies are no longer allowed.