# [−] [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.

    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 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.

    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 `#![...]`
- `Punctuated<T, P>` — parses zero or more `T` separated by punctuation `P` with optional trailing punctuation
- `Vec<Stmt>` — parses the same as `Block::parse_within`

# 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.