quote

Quote provides the quote! macro for turning Rust syntax-tree data structures into tokens of source code. It is the quasi-quoting half of the Rust procedural-macro toolchain: you write code that looks like Rust, treat it as data, interpolate runtime values into it with #var, and hand the resulting TokenStream back to the compiler.

Authored by David Tolnay and built on proc-macro2, quote is a foundational crate downloaded over a billion times and depended on by nearly every derive macro and code generator in the Rust ecosystem. Though motivated by procedural macros, it is a general-purpose quasi-quoting library usable in build scripts and ordinary code as well.

What You Get

• The quote! and quote_spanned! macros for building token streams from template code
• The ToTokens trait implemented for most primitives and syn types, so any value can be interpolated with #var
• Repetition syntax #(...)* and #(...),* for iterating collections directly inside a template
• The format_ident! macro for correctly constructing new identifiers from runtime values
• A no_std-compatible, single-dependency build that works in tests, build scripts, and non-macro code

Common Use Cases

• Generating the output token stream of a derive or attribute procedural macro
• Emitting Rust source from a build.rs code generator, optionally formatted through prettyplease
• Constructing impl blocks, struct definitions, and method calls programmatically from parsed input
• Building up a final token stream by combining smaller quoted fragments from helper functions

Under The Hood

Architecture

The crate centers on src/lib.rs, a large declarative-macro engine that expands quote!/quote_spanned! by recursively walking the template token-by-token and lowering #var interpolations and #(...)* repetitions into imperative append calls. Those calls target the runtime layer in src/runtime.rs, which supplies helpers like push_* token constructors, RepInterp, and ext::RepIteratorExt to drive repetition. The public trait surface lives in src/to_tokens.rs (ToTokens), src/ext.rs (the sealed TokenStreamExt with append/append_all), src/format.rs (format_ident!), src/ident_fragment.rs (IdentFragment), and src/spanned.rs, with everything ultimately emitting proc_macro2 token types.

Tech Stack

Written in Rust (edition 2021, MSRV 1.71) with a single runtime dependency on proc-macro2 (default-features off, no_std via alloc). A proc-macro cargo feature toggles the dynamic dependency on libproc_macro so the crate can be used outside macro contexts. Dev dependencies are trybuild and rustversion for compile-fail testing; benchmarks live in a separate workspace member.

Code Quality

Quality is exemplary: tests/test.rs holds ~575 lines of behavioral tests, tests/ui/ contains trybuild compile-fail fixtures driven by tests/compiletest.rs, and benches/ tracks expansion performance. The code is idiomatic dtolnay — sealed traits to prevent unsound external impls, careful span propagation for hygiene, and thorough rustdoc with runnable examples on every public item.

API Design

The developer experience is a benchmark for the ecosystem. A single quote! { ... } invocation reads like the code it produces, #var interpolation and #(...),* repetition mirror macro_rules! intuitions, and format_ident! removes the footguns of manual identifier construction. Getting started requires almost no boilerplate, and the extensive documentation covers hygiene, spans, and non-macro code generation.