proc_macro_roids 0.8.0

Traits and functions to make writing proc macros more ergonomic.
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

use proc_macro2::{Span, TokenStream};
use quote::quote;
use syn::{Fields, FieldsNamed, FieldsUnnamed, Ident};

/// Functions to make it ergonomic to work with `Fields`.
pub trait FieldsExt {
    /// Returns true if the `Fields` is for a unit struct.
    fn is_unit(&self) -> bool;

    /// Returns true if the `Fields` is for a struct with named fields.
    fn is_named(&self) -> bool;

    /// Returns true if the `Fields` is for a struct with unnamed fields.
    fn is_tuple(&self) -> bool;

    /// Returns a token stream of the construction form of the fields.
    ///
    /// For unit fields, this returns an empty token stream.
    ///
    /// * Tuple fields: `(_0, _1,)`
    /// * Named fields: `{ field_0, field_1 }`
    ///
    /// # Examples
    fn construction_form(&self) -> TokenStream;
}

impl FieldsExt for Fields {
    fn is_unit(&self) -> bool {
        matches!(self, Fields::Unit)
    }

    fn is_named(&self) -> bool {
        matches!(self, Fields::Named(..))
    }

    fn is_tuple(&self) -> bool {
        matches!(self, Fields::Unnamed(..))
    }

    fn construction_form(&self) -> TokenStream {
        match self {
            Fields::Unit => TokenStream::new(),
            Fields::Unnamed(FieldsUnnamed { unnamed, .. }) => {
                let token_stream =
                    (0..unnamed.len()).fold(TokenStream::new(), |mut token_stream, n| {
                        let tuple_field = Ident::new(format!("_{}", n).as_str(), Span::call_site());
                        token_stream.extend(quote!(#tuple_field, ));
                        token_stream
                    });

                quote! { (#token_stream) }
            }
            Fields::Named(FieldsNamed { named, .. }) => {
                let token_stream = named.iter().filter_map(|field| field.ident.as_ref()).fold(
                    TokenStream::new(),
                    |mut token_stream, field_name| {
                        token_stream.extend(quote!(#field_name, ));
                        token_stream
                    },
                );

                quote!({ #token_stream })
            }
        }
    }
}

#[cfg(test)]
mod tests {
    use quote::quote;
    use syn::{parse_quote, Fields, FieldsNamed, FieldsUnnamed};

    use super::FieldsExt;

    #[test]
    fn is_unit_returns_true_when_fields_unit() {
        assert!(Fields::Unit.is_unit());
    }

    #[test]
    fn is_unit_returns_false_when_fields_not_unit() {
        let fields_named: FieldsNamed = parse_quote! {{}};
        let fields = Fields::from(fields_named);

        assert!(!fields.is_unit());
    }

    #[test]
    fn is_named_returns_true_when_fields_named() {
        let fields_named: FieldsNamed = parse_quote! {{}};
        let fields = Fields::from(fields_named);

        assert!(fields.is_named());
    }

    #[test]
    fn is_named_returns_false_when_fields_not_named() {
        assert!(!Fields::Unit.is_named());
    }

    #[test]
    fn is_tuple_returns_true_when_fields_unnamed() {
        let fields_unnamed: FieldsUnnamed = parse_quote! {(u32,)};
        let fields = Fields::from(fields_unnamed);

        assert!(fields.is_tuple());
    }

    #[test]
    fn is_tuple_returns_false_when_fields_not_unnamed() {
        assert!(!Fields::Unit.is_tuple());
    }

    #[test]
    fn construction_form_fields_unit_is_empty_token_stream() {
        assert!(Fields::Unit.construction_form().is_empty());
    }

    #[test]
    fn construction_form_fields_named_is_brace_surrounding_comma_separated_variable_names() {
        let fields_named: FieldsNamed = parse_quote! {{
            pub field_0: u32,
            pub field_1: SomeType,
        }};
        let fields = Fields::from(fields_named);
        let construction_tokens = fields.construction_form();

        let expected_tokens = quote!({ field_0, field_1, });
        assert_eq!(expected_tokens.to_string(), construction_tokens.to_string());
    }

    #[test]
    fn construction_form_fields_unnamed_is_parentheses_surrounding_comma_separated_variable_ns() {
        let fields_unnamed: FieldsUnnamed = parse_quote! {(u32, u32)};
        let fields = Fields::from(fields_unnamed);
        let construction_tokens = fields.construction_form();

        let expected_tokens = quote!((_0, _1,));
        assert_eq!(expected_tokens.to_string(), construction_tokens.to_string());
    }

    #[test]
    fn construction_form_fields_unnamed_one_field_includes_trailing_comma() {
        let fields_unnamed: FieldsUnnamed = parse_quote! {(u32,)};
        let fields = Fields::from(fields_unnamed);
        let construction_tokens = fields.construction_form();

        let expected_tokens = quote!((_0,));
        assert_eq!(expected_tokens.to_string(), construction_tokens.to_string());
    }
}