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

use proc_macro::TokenStream;
use syn_helpers::{
    derive_trait,
    proc_macro2::{Ident, Literal, Span},
    quote,
    syn::{parse_macro_input, parse_quote, DeriveInput},
    Constructable, FieldMut, Fields, Item, Trait, TraitItem, TypeOfSelf,
};

const PANIC_ON_SELF_TOKENIZE: &str = "panic_on_self_tokenize";
const SINGLE_FIELD: &str = "self_tokenize_field";

#[proc_macro_derive(
    SelfRustTokenize,
    attributes(panic_on_self_tokenize, self_tokenize_field)
)]
pub fn self_rust_tokenize(input: TokenStream) -> TokenStream {
    let input = parse_macro_input!(input as DeriveInput);

    let append_to_token_stream = TraitItem::new_method(
        Ident::new("append_to_token_stream", Span::call_site()),
        None,
        TypeOfSelf::Reference,
        vec![parse_quote!(
            token_stream: &mut ::self_rust_tokenize::proc_macro2::TokenStream
        )],
        None,
        |mut item: Item| {
            item.map_constructable(|mut constructable| {
                let attributes = &constructable
                    .get_fields()
                    .get_field_attributes();

                if attributes
                    .iter()
                    .any(|attr| attr.path.is_ident(PANIC_ON_SELF_TOKENIZE) )
                {
                    return Ok(vec![parse_quote!(panic!("Item not self-tokenize-able");)]);
                }

                if let Some(attribute) = attributes
                    .iter()
                    .find(|attr| attr.path.is_ident(SINGLE_FIELD))
                {
                    let member = attribute.parse_args::<syn::Member>()?;

                    let mut field = constructable.get_fields_mut().get_field_by_member_mut(member).ok_or_else(|| "could not find the field")?;

                    let reference = field.get_reference();

                    let call = parse_quote!(
                        ::self_rust_tokenize::SelfRustTokenize::append_to_token_stream(#reference, token_stream);
                    );

                    return Ok(vec![call]);
                }

                let segments =
                    constructable.get_constructor_path().segments.into_iter().map(|seg| Literal::string(&seg.ident.to_string()));

                let call = match constructable.get_fields_mut() {
                    Fields::Named(named, _) => {
                        let values = named.iter_mut().map(|named_field| {
                            let reference = named_field.get_reference();
                            let name = Literal::string(&named_field.name.to_string());
                            quote!((#name, ::self_rust_tokenize::SelfRustTokenize::to_tokens(#reference)))
                        });
                        parse_quote! {
                            ::self_rust_tokenize::_private::add_named_constructor_body(
                                token_stream,
                                &[#(#segments),*],
                                vec![#(#values),*],
                            );
                        }
                    }
                    Fields::Unnamed(unnamed, _) => {
                        let values = unnamed.iter_mut().map(|unnamed_field| {
                            let reference = unnamed_field.get_reference();
                            quote!(::self_rust_tokenize::SelfRustTokenize::to_tokens(#reference))
                        });
                        parse_quote! {
                            ::self_rust_tokenize::_private::add_unnamed_constructor_body(
                                token_stream,
                                &[#(#segments),*],
                                vec![#(#values),*],
                            );
                        }
                    }
                    Fields::Unit(_) => {
                        parse_quote! {
                            ::self_rust_tokenize::_private::add_unit_constructor_body(
                                token_stream,
                                &[#(#segments),*],
                            );
                        }
                    }
                };
                Ok(vec![call])
            })
        },
    );

    let self_rust_tokenize = Trait {
        name: parse_quote!(::self_rust_tokenize::SelfRustTokenize),
        generic_parameters: None,
        items: vec![append_to_token_stream],
    };

    let output = derive_trait(input, self_rust_tokenize);

    output.into()
}