emit_macros 1.20.1

Internal proc macro crate for emit.
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
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155

use proc_macro2::TokenStream;
use syn::{FieldValue, parse::Parse, spanned::Spanned};

use crate::{
    args, capture,
    props::{Props, push_evt_props},
    template::{self, Template},
    util::{ToOptionTokens, ToRefTokens},
};

pub struct ExpandTokens {
    pub input: TokenStream,
}

struct StandaloneProps {
    fvs: Vec<FieldValue>,
}

impl Parse for StandaloneProps {
    fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
        Ok(StandaloneProps {
            fvs: input
                .parse_terminated(FieldValue::parse, Token![,])?
                .iter()
                .cloned()
                .collect(),
        })
    }
}

pub fn expand_tokens(opts: ExpandTokens) -> Result<TokenStream, syn::Error> {
    let (standalone, template, mut props) =
        template::parse2::<StandaloneProps>(opts.input, dbg_capture_fn, true)?;

    let template = match template {
        None => {
            for fv in standalone.fvs {
                props.push(&fv, dbg_capture_fn(&fv), false, true)?;
            }

            check_dbg_props(&props)?;

            compute_template(&props)?
        }
        Some(template) => {
            // If a template is supplied, ensure there are no properties before it
            if standalone.fvs.len() > 0 {
                return Err(syn::Error::new(
                    template.template_literal_tokens().span(),
                    "specify the template string literal before any properties",
                ));
            }

            check_dbg_props(&props)?;

            template
        }
    };

    push_loc_props(&mut props)?;
    push_evt_props(&mut props, Some(quote!(emit::Level::Debug)))?;

    let props_match_input_tokens = props.match_input_tokens();
    let props_match_binding_tokens = props.match_binding_tokens();
    let props_tokens = props.match_bound_tokens().to_ref_tokens();

    let rt_tokens = args::RtArg::default().to_tokens()?.to_ref_tokens();
    let when_tokens = None::<TokenStream>.to_option_tokens(quote!(&emit::Empty));

    let base_props_tokens = quote!(&emit::Empty);
    let extent_tokens = quote!(&emit::Empty);
    let mdl_tokens = args::MdlArg::default().to_tokens().to_ref_tokens();

    let template_tokens = template.template_tokens().to_ref_tokens();

    let emit_tokens = quote!(
        emit::__private::__private_emit(
            #rt_tokens,
            #mdl_tokens,
            #when_tokens,
            #extent_tokens,
            #template_tokens,
            #base_props_tokens,
            #props_tokens,
        );
    );

    Ok(quote!({
        match (#(#props_match_input_tokens),*) {
            (#(#props_match_binding_tokens),*) => {
                #emit_tokens
            }
        }
    }))
}

fn push_loc_props(props: &mut Props) -> Result<(), syn::Error> {
    let fv = syn::parse2::<FieldValue>(quote!(file: file!()))?;
    props.push(&fv, capture::default_fn_name(&fv), false, true)?;

    let fv = syn::parse2::<FieldValue>(quote!(line: line!()))?;
    props.push(&fv, capture::default_fn_name(&fv), false, true)?;

    Ok(())
}

fn compute_template(props: &Props) -> Result<Template, syn::Error> {
    let mut literal = String::new();

    let mut first = true;
    for (name, key_value) in props.iter() {
        if !first {
            literal.push_str(", ");
        }
        first = false;

        literal.push_str(name);
        literal.push_str(" = {");
        literal.push_str(&key_value.hole_tokens().to_string());
        literal.push_str("}");
    }

    if !first {
        literal.push_str(" ");
    }

    literal.push_str("at {file}:{line}");

    let (pre, template, _) =
        template::parse2::<StandaloneProps>(quote!(#literal), dbg_capture_fn, true)?;

    debug_assert_eq!(0, pre.fvs.len());

    Ok(template.expect("missing template"))
}

fn dbg_capture_fn(fv: &FieldValue) -> TokenStream {
    quote_spanned!(fv.span()=> __private_capture_anon_as_debug)
}

fn check_dbg_props(props: &Props) -> Result<(), syn::Error> {
    for (k, v) in props.iter() {
        match k {
            "line" | "file" => {
                return Err(syn::Error::new(
                    v.span(),
                    format!("`{k}` can't be used as a key in the `dbg` macro"),
                ));
            }
            _ => (),
        }
    }

    Ok(())
}