Struct syn::Macro [−][src]
A macro invocation: println!("{}", mac)
.
This type is available only if Syn is built with the "derive"
or "full"
feature.
Fields
path: Path
bang_token: Bang
delimiter: MacroDelimiter
tokens: TokenStream
Implementations
impl Macro
[src]
pub fn parse_body<T: Parse>(&self) -> Result<T>
[src]
Parse the tokens within the macro invocation’s delimiters into a syntax tree.
This is equivalent to syn::parse2::<T>(mac.tokens)
except that it
produces a more useful span when tokens
is empty.
Example
use syn::{parse_quote, Expr, ExprLit, Ident, Lit, LitStr, Macro, Token}; use syn::ext::IdentExt; use syn::parse::{Error, Parse, ParseStream, Result}; use syn::punctuated::Punctuated; // The arguments expected by libcore's format_args macro, and as a // result most other formatting and printing macros like println. // // println!("{} is {number:.prec$}", "x", prec=5, number=0.01) struct FormatArgs { format_string: Expr, positional_args: Vec<Expr>, named_args: Vec<(Ident, Expr)>, } impl Parse for FormatArgs { fn parse(input: ParseStream) -> Result<Self> { let format_string: Expr; let mut positional_args = Vec::new(); let mut named_args = Vec::new(); format_string = input.parse()?; while !input.is_empty() { input.parse::<Token![,]>()?; if input.is_empty() { break; } if input.peek(Ident::peek_any) && input.peek2(Token![=]) { while !input.is_empty() { let name: Ident = input.call(Ident::parse_any)?; input.parse::<Token![=]>()?; let value: Expr = input.parse()?; named_args.push((name, value)); if input.is_empty() { break; } input.parse::<Token![,]>()?; } break; } positional_args.push(input.parse()?); } Ok(FormatArgs { format_string, positional_args, named_args, }) } } // Extract the first argument, the format string literal, from an // invocation of a formatting or printing macro. fn get_format_string(m: &Macro) -> Result<LitStr> { let args: FormatArgs = m.parse_body()?; match args.format_string { Expr::Lit(ExprLit { lit: Lit::Str(lit), .. }) => Ok(lit), other => { // First argument was not a string literal expression. // Maybe something like: println!(concat!(...), ...) Err(Error::new_spanned(other, "format string must be a string literal")) } } } fn main() { let invocation = parse_quote! { println!("{:?}", Instant::now()) }; let lit = get_format_string(&invocation).unwrap(); assert_eq!(lit.value(), "{:?}"); }
pub fn parse_body_with<F: Parser>(&self, parser: F) -> Result<F::Output>
[src]
Parse the tokens within the macro invocation’s delimiters using the given parser.
Trait Implementations
impl Clone for Macro
[src]
fn clone(&self) -> Self
[src]
pub fn clone_from(&mut self, source: &Self)
1.0.0[src]
impl Debug for Macro
[src]
impl Eq for Macro
[src]
impl Hash for Macro
[src]
fn hash<H>(&self, state: &mut H) where
H: Hasher,
[src]
H: Hasher,
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
impl Parse for Macro
[src]
fn parse(input: ParseStream<'_>) -> Result<Self>
[src]
impl PartialEq<Macro> for Macro
[src]
impl ToTokens for Macro
[src]
fn to_tokens(&self, tokens: &mut TokenStream)
[src]
pub fn to_token_stream(&self) -> TokenStream
[src]
pub fn into_token_stream(self) -> TokenStream
[src]
Auto Trait Implementations
impl RefUnwindSafe for Macro
impl !Send for Macro
impl !Sync for Macro
impl Unpin for Macro
impl UnwindSafe for Macro
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
pub fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T> Spanned for T where
T: Spanned + ?Sized,
[src]
T: Spanned + ?Sized,
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
pub fn to_owned(&self) -> T
[src]
pub fn clone_into(&self, target: &mut T)
[src]
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,