手続き型マクロ属性で呼び出し元のソースコードの場所を取得できますか？

Ayush Mishra 2020-03-15 10:56.

すべてのメソッドの呼び出し元のソースの場所を取得する必要があります。proc_macro_attribute場所をキャプチャして印刷するためのを作成しようとしています。

#[proc_macro_attribute]
pub fn get_location(attr: TokenStream, item: TokenStream) -> TokenStream {
    // Get and print file!(), line!() of source
    // Should print line no. 11
    item
}

#[get_location]
fn add(x: u32, y: u32) -> u32 {
    x + y
}

fn main() {
    add(1, 5); // Line No. 11
}

rust rust-macros rust-proc-macros

2 answers

Victor Deleau 2020-03-18 07:11.

すぐに使用できるソリューションが利用可能です（@timotreeのコメントを参照）。これを自分で行いたい場合、柔軟性を高めたい場合、または学習したい場合は、バックトレース（呼び出された関数内から取得）を解析して必要な情報を出力する手続き型マクロを作成できます。これがlib.rs：内の手続き型マクロです。

extern crate proc_macro;
use proc_macro::{TokenStream, TokenTree};

#[proc_macro_attribute]
pub fn get_location(_attr: TokenStream, item: TokenStream) -> TokenStream {

    // prefix code to be added to the function's body
    let mut prefix: TokenStream = "
        // find earliest symbol in source file using backtrace
        let ps = Backtrace::new().frames().iter()
            .flat_map(BacktraceFrame::symbols)
            .skip_while(|s| s.filename()
                .map(|p|!p.ends_with(file!())).unwrap_or(true))
            .nth(1 as usize).unwrap();

        println!(\"Called from {:?} at line {:?}\",
            ps.filename().unwrap(), ps.lineno().unwrap());
    ".parse().unwrap(); // parse string into TokenStream

    item.into_iter().map(|tt| { // edit input TokenStream
        match tt { 
            TokenTree::Group(ref g) // match the function's body
                if g.delimiter() == proc_macro::Delimiter::Brace => { 

                    prefix.extend(g.stream()); // add parsed string

                    TokenTree::Group(proc_macro::Group::new(
                        proc_macro::Delimiter::Brace, prefix.clone()))
            },
            other => other, // else just forward TokenTree
        }
    }).collect()
}

バックトレースが解析され、ソースファイル内の最も古いシンボルが検索されます（file!()別のマクロを使用して取得）。関数に追加する必要のあるコードは文字列で定義され、文字列はaとして解析されTokenStream、関数の本体の先頭に追加されます。このロジックを最後に追加することもできますが、セミコロンなしで値を返すことはできなくなります。次に、次のようにで手続き型マクロを使用できmain.rsます。

extern crate backtrace;
use backtrace::{Backtrace, BacktraceFrame};
use mylib::get_location;

#[get_location]
fn add(x: u32, y: u32) -> u32 { x + y }

fn main() { 
    add(1, 41);
    add(41, 1);
}

出力は次のとおりです。

> Called from "src/main.rs" at line 10
> Called from "src/main.rs" at line 11

lib次の2行を次の行に追加して、クレートが手続き型マクロを提供していることを指定することを忘れないでくださいCargo.toml。

[lib]
proc-macro = true

timotree 2020-03-18 08:20.

TL; DR

ここで使用している手続きのマクロであるsynとquoteあなたが説明してきた何をすべきかは：

// print_caller_location/src/lib.rs

use proc_macro::TokenStream;
use quote::quote;
use syn::spanned::Spanned;

// Create a procedural attribute macro
//
// Notably, this must be placed alone in its own crate
#[proc_macro_attribute]
pub fn print_caller_location(_attr: TokenStream, item: TokenStream) -> TokenStream {
    // Parse the passed item as a function
    let func = syn::parse_macro_input!(item as syn::ItemFn);

    // Break the function down into its parts
    let syn::ItemFn {
        attrs,
        vis,
        sig,
        block,
    } = func;

    // Ensure that it isn't an `async fn`
    if let Some(async_token) = sig.asyncness {
        // Error out if so
        let error = syn::Error::new(
            async_token.span(),
            "async functions do not support caller tracking functionality
    help: consider returning `impl Future` instead",
        );

        return TokenStream::from(error.to_compile_error());
    }

    // Wrap body in a closure only if function doesn't already have #[track_caller]
    let block = if attrs.iter().any(|attr| attr.path.is_ident("track_caller")) {
        quote! { #block }
    } else {
        quote! {
            (move || #block)()
        }
    };

    // Extract function name for prettier output
    let name = format!("{}", sig.ident);

    // Generate the output, adding `#[track_caller]` as well as a `println!`
    let output = quote! {
        #[track_caller]
        #(#attrs)*
        #vis #sig {
            println!(
                "entering `fn {}`: called from `{}`",
                #name,
                ::core::panic::Location::caller()
            );
            #block
        }
    };

    // Convert the output from a `proc_macro2::TokenStream` to a `proc_macro::TokenStream`
    TokenStream::from(output)
}

必ずそれを木枠に入れて、これらの行をその上に追加してくださいCargo.toml：

# print_caller_location/Cargo.toml

[lib]
proc-macro = true

[dependencies]
syn = {version = "1.0.16", features = ["full"]}
quote = "1.0.3"
proc-macro2 = "1.0.9"

詳細な説明

マクロは、最初から手作業で記述できるコードにのみ拡張できます。これを知っていると、ここに2つの質問があります。

呼び出し元の場所を追跡する関数を作成するにはどうすればよいですか？
- 関数が呼び出されるたびに、関数の呼び出し場所にアクセスするにはどうすればよいですか？を参照してください。
  
  簡単な答え：関数が呼び出される場所を取得するには、関数にマークを付けて本体で#[track_caller]使用std::panic::Location::callerします。
このような関数を作成する手続き型マクロを作成するにはどうすればよいですか？

最初の試み

手続き型マクロが必要です

機能を取り、
それをマークします#[track_caller]、
を印刷する行を追加しますLocation::caller。

たとえば、次のような関数を変換します。

fn foo() {
    // body of foo
}

に

#[track_caller]
fn foo() {
    println!("{}", std::panic::Location::caller());
    // body of foo
}

以下に、その変換を正確に実行する手続き型マクロを示します。ただし、後のバージョンで見られるように、おそらく別のものが必要になるでしょう。このコードを試すには、以前のTL; DRセクションのように、コードを独自のクレートに入れ、依存関係をに追加しCargo.tomlます。

// print_caller_location/src/lib.rs

use proc_macro::TokenStream;
use quote::quote;

// Create a procedural attribute macro
//
// Notably, this must be placed alone in its own crate
#[proc_macro_attribute]
pub fn print_caller_location(_attr: TokenStream, item: TokenStream) -> TokenStream {
    // Parse the passed item as a function
    let func = syn::parse_macro_input!(item as syn::ItemFn);

    // Break the function down into its parts
    let syn::ItemFn {
        attrs,
        vis,
        sig,
        block,
    } = func;

    // Extract function name for prettier output
    let name = format!("{}", sig.ident);

    // Generate the output, adding `#[track_caller]` as well as a `println!`
    let output = quote! {
        #[track_caller]
        #(#attrs)*
        #vis #sig {
            println!(
                "entering `fn {}`: called from `{}`",
                #name,
                ::core::panic::Location::caller()
            );
            #block
        }
    };

    // Convert the output from a `proc_macro2::TokenStream` to a `proc_macro::TokenStream`
    TokenStream::from(output)
}

使用例：

// example1/src/main.rs

#![feature(track_caller)]

#[print_caller_location::print_caller_location]
fn add(x: u32, y: u32) -> u32 {
    x + y
}

fn main() {
    add(1, 5); // entering `fn add`: called from `example1/src/main.rs:11:5`
    add(1, 5); // entering `fn add`: called from `example1/src/main.rs:12:5`
}

残念ながら、その単純なバージョンで逃げることはできません。そのバージョンには少なくとも2つの問題があります。

async fnsでどのように構成するか：

呼び出し元の場所を出力する代わりに、マクロ（#[print_caller_location]）が呼び出された場所を出力します。例えば：

// example2/src/main.rs

#![feature(track_caller)]

#[print_caller_location::print_caller_location]
async fn foo() {}

fn main() {
    let future = foo();
    // ^ oops! prints nothing
    futures::executor::block_on(future);
    // ^ oops! prints "entering `fn foo`: called from `example2/src/main.rs:5:1`"
    let future = foo();
    // ^ oops! prints nothing
    futures::executor::block_on(future);
    // ^ oops! prints "entering `fn foo`: called from `example2/src/main.rs:5:1`"
}

それ自体の他の呼び出し、または一般的には、どのように機能するか#[track_caller]：

ネストされた関数#[print_caller_location]は、特定の関数の直接の呼び出し元ではなく、ルート呼び出し元の場所を出力します。例えば：

// example3/src/main.rs

#![feature(track_caller)]

#[print_caller_location::print_caller_location]
fn add(x: u32, y: u32) -> u32 {
    x + y
}

#[print_caller_location::print_caller_location]
fn add_outer(x: u32, y: u32) -> u32 {
    add(x, y)
    // ^ we would expect "entering `fn add`: called from `example3/src/main.rs:12:5`"
}

fn main() {
    add(1, 5);
    // ^ "entering `fn add`: called from `example3/src/main.rs:17:5`"
    add(1, 5);
    // ^ "entering `fn add`: called from `example3/src/main.rs:19:5`"
    add_outer(1, 5);
    // ^ "entering `fn add_outer`: called from `example3/src/main.rs:21:5`"
    // ^ oops! "entering `fn add`: called from `example3/src/main.rs:21:5`"
    //
    // In reality, `add` was called on line 12, from within the body of `add_outer`
    add_outer(1, 5);
    // ^ "entering `fn add_outer`: called from `example3/src/main.rs:26:5`"
    // oops! ^ entering `fn add`: called from `example3/src/main.rs:26:5`
    //
    // In reality, `add` was called on line 12, from within the body of `add_outer`
}

アドレッシング`async fn`秒

async fnを使用してsの問題を回避することは可能-> impl Futureです。たとえば、async fn反例を正しく機能させたい場合は、代わりに次のように記述できます。

// example4/src/main.rs

#![feature(track_caller)]

use std::future::Future;

#[print_caller_location::print_caller_location]
fn foo() -> impl Future<Output = ()> {
    async move {
        // body of foo
    }
}

fn main() {
    let future = foo();
    // ^ prints "entering `fn foo`: called from `example4/src/main.rs:15:18`"
    futures::executor::block_on(future);
    // ^ prints nothing
    let future = foo();
    // ^ prints "entering `fn foo`: called from `example4/src/main.rs:19:18`"
    futures::executor::block_on(future);
    // ^ prints nothing
}

この変換をマクロに適用する特別なケースを追加できます。ただし、その変換により、関数のパブリックAPIがからに変更async fn foo()さfn foo() -> impl Future<Output = ()>れるだけでなく、返されるfutureが持つことができる自動特性にも影響します。

したがって、ユーザーが必要に応じてその回避策を使用できるようにし、マクロがで使用されている場合は単にエラーを発行することをお勧めしますasync fn。これを行うには、次の行をマクロコードに追加します。

// Ensure that it isn't an `async fn`
if let Some(async_token) = sig.asyncness {
    // Error out if so
    let error = syn::Error::new(
        async_token.span(),
        "async functions do not support caller tracking functionality
    help: consider returning `impl Future` instead",
    );

    return TokenStream::from(error.to_compile_error());
}

`#[print_caller_location]`関数のネストされた動作の修正

この事実にダウン問題行動の最小化：#[track_caller]機能、foo直接別に呼び出して#[track_caller]、機能bar、Location::callerにそれらのアクセスの両方与えるfooの発信者を。言い換えると、Location::callerネストされた#[track_caller]関数の場合、ルート呼び出し元へのアクセスを提供します。

#![feature(track_caller)]

fn main() {
    foo(); // prints `src/main.rs:4:5` instead of the line number in `foo`
}

#[track_caller]
fn foo() {
   bar();
}

#[track_caller]
fn bar() {
    println!("{}", std::panic::Location::caller());
}

遊び場リンク

これを改善するには、#[track_caller]呼び出しのチェーンを切断する必要があります。barクロージャ内にネストされた呼び出しを非表示にすることで、チェーンを切断できます。

#![feature(track_caller)]

fn main() {
    foo();
}

#[track_caller]
fn foo() {
    (move || {
        bar(); // prints `src/main.rs:10:9`
    })()
}

#[track_caller]
fn bar() {
    println!("{}", std::panic::Location::caller());
}

遊び場リンク

#[track_caller]関数のチェーンを壊す方法がわかったので、この問題に対処できます。ユーザーが実際#[track_caller]に意図的に関数にマークを付けた場合は、クロージャーを挿入したりチェーンを切断したりしないようにする必要があります。

これらの行をソリューションに追加できます。

// Wrap body in a closure only if function doesn't already have #[track_caller]
let block = if attrs.iter().any(|attr| attr.path.is_ident("track_caller")) {
    quote! { #block }
} else {
    quote! {
        (move || #block)()
    }
};

最終的解決

これらの2つの変更の後、次のコードになりました。

// print_caller_location/src/lib.rs

use proc_macro::TokenStream;
use quote::quote;
use syn::spanned::Spanned;

// Create a procedural attribute macro
//
// Notably, this must be placed alone in its own crate
#[proc_macro_attribute]
pub fn print_caller_location(_attr: TokenStream, item: TokenStream) -> TokenStream {
    // Parse the passed item as a function
    let func = syn::parse_macro_input!(item as syn::ItemFn);

    // Break the function down into its parts
    let syn::ItemFn {
        attrs,
        vis,
        sig,
        block,
    } = func;

    // Ensure that it isn't an `async fn`
    if let Some(async_token) = sig.asyncness {
        // Error out if so
        let error = syn::Error::new(
            async_token.span(),
            "async functions do not support caller tracking functionality
    help: consider returning `impl Future` instead",
        );

        return TokenStream::from(error.to_compile_error());
    }

    // Wrap body in a closure only if function doesn't already have #[track_caller]
    let block = if attrs.iter().any(|attr| attr.path.is_ident("track_caller")) {
        quote! { #block }
    } else {
        quote! {
            (move || #block)()
        }
    };

    // Extract function name for prettier output
    let name = format!("{}", sig.ident);

    // Generate the output, adding `#[track_caller]` as well as a `println!`
    let output = quote! {
        #[track_caller]
        #(#attrs)*
        #vis #sig {
            println!(
                "entering `fn {}`: called from `{}`",
                #name,
                ::core::panic::Location::caller()
            );
            #block
        }
    };

    // Convert the output from a `proc_macro2::TokenStream` to a `proc_macro::TokenStream`
    TokenStream::from(output)
}