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(generics: &mut Generics) {
    for param in &mut generics.params {
        if let GenericParam::Type(type_param) = param {
            type_param.bounds.push(parse_quote!(::heapsize::HeapSize));
        }
    }
}

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
• Safety — parses the same as Safety::parse_safe_or_unsafe

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.