[][src]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 Parse trait.

#[macro_use]
extern crate quote;
#[macro_use]
extern crate syn;

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 the "parsing" feature, although interpolation of syntax tree nodes into the quoted tokens is only supported if Syn is built with the "printing" feature as well.

Example

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

#[macro_use]
extern crate quote;
#[macro_use]
extern crate syn;

use syn::{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(ref mut 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 #![...]
  • Punctuated<T, P> — parses zero or more T separated by punctuation P with optional trailing punctuation

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.