Macro syn::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 Synom trait.

#[macro_use]
extern crate syn;

#[macro_use]
extern crate quote;

use syn::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 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.

// 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(ref mut type_param) = *param {
            type_param.bounds.push(parse_quote!(HeapSize));
        }
    }
    generics
}

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.