Macro parse_quote

macro_rules! parse_quote {
    ($($tt:tt)*) => { ... };
}

Quasi-quotation macro that accepts input like the quote! macro but uses type inference to figure out a return type for those tokens.

The return type can be any syntax tree node that implements the Parse trait.

use quote::quote;
use syn::{parse_quote, Stmt};

fn main() {
    let name = quote!(v);
    let ty = quote!(u8);

    let stmt: Stmt = parse_quote! {
        let #name: #ty = Default::default();
    };

    println!("{:#?}", stmt);
}

This macro is available only if Syn is built with both the "parsing" and "printing" features.

Example

The following helper function adds a bound T: HeapSize to every type parameter T in the input generics.

use syn::{parse_quote, Generics, GenericParam};

// Add a bound `T: HeapSize` to every type parameter T.
fn add_trait_bounds(mut generics: Generics) -> Generics {
    for param in &mut generics.params {
        if let GenericParam::Type(type_param) = param {
            type_param.bounds.push(parse_quote!(HeapSize));
        }
    }
    generics
}

Special cases

This macro can parse the following additional types as a special case even though they do not implement the Parse trait.

• Attribute — parses one attribute, allowing either outer like #[...] or inner like #![...]
• Vec<Attribute> — parses multiple attributes, including mixed kinds in any order
• Punctuated<T, P> — parses zero or more T separated by punctuation P with optional trailing punctuation
• Vec<Arm> — parses arms separated by optional commas according to the same grammar as the inside of a match expression
• Vec<Stmt> — parses the same as Block::parse_within
• Pat, Box<Pat> — parses the same as Pat::parse_multi_with_leading_vert
• Field — parses a named or unnamed struct field

Panics

Panics if the tokens fail to parse as the expected syntax tree type. The caller is responsible for ensuring that the input tokens are syntactically valid.