use proc_macro::TokenStream;
use proc_macro2::TokenStream as TokenStream2;
use quote::quote;
use syn::{
parse::{Parse, ParseStream},
parse_macro_input,
punctuated::Punctuated,
Expr, Ident, ItemFn, LitStr, ReturnType, Token,
};
struct AttrArgs {
message: Option<String>,
per_try: bool,
log_args: Vec<Ident>,
}
impl Parse for AttrArgs {
fn parse(input: ParseStream) -> syn::Result<Self> {
let mut message = None;
let mut per_try = false;
let mut log_args = Vec::new();
let items = Punctuated::<AttrItem, Token![,]>::parse_terminated(input)?;
for item in items {
match item {
AttrItem::Message(s) => message = Some(s),
AttrItem::PerTry => per_try = true,
AttrItem::Args(idents) => log_args = idents,
}
}
Ok(Self {
message,
per_try,
log_args,
})
}
}
enum AttrItem {
Message(String),
PerTry,
Args(Vec<Ident>),
}
impl Parse for AttrItem {
fn parse(input: ParseStream) -> syn::Result<Self> {
if input.peek(LitStr) {
let lit: LitStr = input.parse()?;
return Ok(AttrItem::Message(lit.value()));
}
if input.peek(Ident) {
let ident: Ident = input.parse()?;
if ident == "per_try" {
return Ok(AttrItem::PerTry);
}
if ident == "args" {
let content;
syn::parenthesized!(content in input);
let idents = Punctuated::<Ident, Token![,]>::parse_terminated(&content)?;
return Ok(AttrItem::Args(idents.into_iter().collect()));
}
return Err(syn::Error::new(
ident.span(),
"expected `per_try`, `args(...)`, or a string literal",
));
}
Err(input.error("expected `per_try`, `args(...)`, or a string literal"))
}
}
#[proc_macro_attribute]
pub fn autocontext(attr: TokenStream, item: TokenStream) -> TokenStream {
let args = parse_macro_input!(attr as AttrArgs);
let input_fn = parse_macro_input!(item as ItemFn);
if !returns_result(&input_fn) {
return TokenStream::from(quote!(#input_fn));
}
let fn_name = input_fn.sig.ident.to_string();
let context_msg = args.message.unwrap_or(fn_name);
let output = if args.per_try {
expand_per_try(&input_fn, &context_msg, &args.log_args)
} else {
expand_wrap(&input_fn, &context_msg, &args.log_args)
};
TokenStream::from(output)
}
fn returns_result(f: &ItemFn) -> bool {
match &f.sig.output {
ReturnType::Default => false,
ReturnType::Type(_, ty) => {
let tokens = quote!(#ty).to_string();
tokens.starts_with("Result")
|| tokens.contains(":: Result")
|| tokens.contains("anyhow :: Result")
}
}
}
fn build_context_expr(msg: &str, log_args: &[Ident]) -> TokenStream2 {
if log_args.is_empty() {
quote! { ::anyhow::Context::context(__autocontext_result, #msg) }
} else {
let fmt_str = build_format_string(msg, log_args);
let args = log_args;
quote! {
::anyhow::Context::with_context(__autocontext_result, || {
format!(#fmt_str, #(#args),*)
})
}
}
}
fn build_format_string(msg: &str, log_args: &[Ident]) -> String {
if log_args.is_empty() {
return msg.to_string();
}
let args_part: Vec<String> = log_args
.iter()
.map(|id| format!("{}={{:?}}", id))
.collect();
format!("{}: {}", msg, args_part.join(" "))
}
fn expand_wrap(f: &ItemFn, msg: &str, log_args: &[Ident]) -> TokenStream2 {
let attrs = &f.attrs;
let vis = &f.vis;
let sig = &f.sig;
let body = &f.block;
let is_async = sig.asyncness.is_some();
let ret_ty = match &sig.output {
ReturnType::Type(_, ty) => ty,
ReturnType::Default => {
return quote! { #(#attrs)* #vis #sig #body };
}
};
let ctx_expr = build_context_expr(msg, log_args);
if is_async {
quote! {
#(#attrs)*
#vis #sig {
let __autocontext_result: #ret_ty = async #body.await;
#ctx_expr
}
}
} else {
quote! {
#(#attrs)*
#vis #sig {
let __autocontext_result = (|| -> #ret_ty #body)();
#ctx_expr
}
}
}
}
fn expand_per_try(f: &ItemFn, msg: &str, log_args: &[Ident]) -> TokenStream2 {
let attrs = &f.attrs;
let vis = &f.vis;
let sig = &f.sig;
let mut body = (*f.block).clone();
let mut folder = TryFolder {
msg: msg.to_string(),
counter: 0,
log_args: log_args.to_vec(),
};
syn::visit_mut::VisitMut::visit_block_mut(&mut folder, &mut body);
quote! {
#(#attrs)*
#vis #sig #body
}
}
struct TryFolder {
msg: String,
counter: u32,
log_args: Vec<Ident>,
}
impl syn::visit_mut::VisitMut for TryFolder {
fn visit_expr_mut(&mut self, expr: &mut Expr) {
syn::visit_mut::visit_expr_mut(self, expr);
if let Expr::Try(try_expr) = expr {
let inner = &try_expr.expr;
let ctx_label = format!("{} [try #{}]", self.msg, self.counter);
self.counter += 1;
let wrapped: Expr = if self.log_args.is_empty() {
syn::parse_quote! {
::anyhow::Context::with_context(#inner, || #ctx_label)
}
} else {
let fmt_str = build_format_string(&ctx_label, &self.log_args);
let args = &self.log_args;
syn::parse_quote! {
::anyhow::Context::with_context(#inner, || {
format!(#fmt_str, #(#args),*)
})
}
};
*try_expr.expr = wrapped;
}
}
}