pub struct Macro {
pub path: Path,
pub bang_token: Not,
pub delimiter: MacroDelimiter,
pub tokens: TokenStream,
}
Expand description
A macro invocation: println!("{}", mac)
.
Fields§
§path: Path
§bang_token: Not
§delimiter: MacroDelimiter
§tokens: TokenStream
Implementations§
source§impl Macro
impl Macro
sourcepub fn parse_body<T: Parse>(&self) -> Result<T>
pub fn parse_body<T: Parse>(&self) -> Result<T>
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(), "{:?}");
}
sourcepub fn parse_body_with<F: Parser>(&self, parser: F) -> Result<F::Output>
pub fn parse_body_with<F: Parser>(&self, parser: F) -> Result<F::Output>
Parse the tokens within the macro invocation’s delimiters using the given parser.
Trait Implementations§
source§impl PartialEq for Macro
impl PartialEq for Macro
source§impl ToTokens for Macro
impl ToTokens for Macro
source§fn to_tokens(&self, tokens: &mut TokenStream)
fn to_tokens(&self, tokens: &mut TokenStream)
source§fn to_token_stream(&self) -> TokenStream
fn to_token_stream(&self) -> TokenStream
source§fn into_token_stream(self) -> TokenStreamwhere
Self: Sized,
fn into_token_stream(self) -> TokenStreamwhere
Self: Sized,
impl Eq for Macro
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§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
source§impl<T> Spanned for Twhere
T: Spanned + ?Sized,
impl<T> Spanned for Twhere
T: Spanned + ?Sized,
source§fn span(&self) -> Span
fn span(&self) -> Span
Returns a
Span
covering the complete contents of this syntax tree
node, or Span::call_site()
if this node is empty.