Macro syn::parse_quote
source · [−]macro_rules! parse_quote {
($($tt:tt)*) => { ... };
}
Expand description
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 moreT
separated by punctuationP
with optional trailing punctuationVec<Stmt>
— parses the same asBlock::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.