rlst-proc-macro 0.6.0

Proc macros for a Rust native linear algebra library.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

//! Macro to trace execution times

use darling::{ast::NestedMeta, Error, FromMeta};
use proc_macro::TokenStream;
use quote::quote;
use syn::parse_macro_input;

#[derive(Default, FromMeta)]
#[darling(default)]
struct Identifier {
    id: String,
}

pub(crate) fn measure_duration_impl(args: TokenStream, item: TokenStream) -> TokenStream {
    let syn::ItemFn {
        vis,
        sig,
        attrs,
        block,
        ..
    } = parse_macro_input!(item);

    let attr_args = match NestedMeta::parse_meta_list(args.into()) {
        Ok(v) => v,
        Err(e) => {
            return TokenStream::from(Error::from(e).write_errors());
        }
    };

    let args = match Identifier::from_list(&attr_args) {
        Ok(v) => v,
        Err(e) => {
            return TokenStream::from(e.write_errors());
        }
    };

    let ident = args.id;

    let statements = block.stmts;

    if cfg!(feature = "enable_tracing") {
        quote! {


            # (# attrs)*
            #vis #sig
            {

                let now = std::time::Instant::now();

                let __result = {
                    #(#statements)*
                };

                let duration = now.elapsed();
                let duration_as_secs = duration.as_secs_f64();
                let ident = #ident;

                log::info!("Id: {ident} - {duration_as_secs}s");

                rlst::tracing::Tracing::add_duration(&#ident, duration);
                __result

            }



        }
        .into()
    } else {
        quote! {


        # (# attrs)*
        #vis #sig {
                #(#statements)*
        }


            }
        .into()
    }
}