Struct syn::Macro [−][src]
pub struct Macro {
pub path: Path,
pub bang_token: Bang,
pub delimiter: MacroDelimiter,
pub tokens: TokenStream,
}
This is supported on crate features
full
or derive
only.Expand description
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
This is supported on crate feature parsing
only.
This is supported on crate feature
parsing
only.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(), "{:?}");
}
This is supported on crate feature parsing
only.
This is supported on crate feature
parsing
only.Parse the tokens within the macro invocation’s delimiters using the given parser.
Trait Implementations
Auto Trait Implementations
impl RefUnwindSafe for Macro
impl UnwindSafe for Macro
Blanket Implementations
Mutably borrows from an owned value. Read more