superstruct 0.10.1

Versioned data types with minimal boilerplate
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
156
157
158
159
160
161
162
163
164

use crate::attributes::IdentList;
use crate::naming::generate_map_macro_name;
use crate::utils::underscore_generics;
use crate::{StructOpts, TokenStream, TokenStream2};
use quote::quote;
use syn::Ident;

pub struct MacroFromType<'a> {
    /// The name of the superstruct type being matched on.
    pub name: &'a Ident,
    /// The number of generic type parameters.
    pub num_generics: usize,
    /// The names of the variant structs.
    pub struct_names: &'a [Ident],
}

/// Generate all the map macros for the top-level enum, Ref and RefMut.
#[allow(clippy::too_many_arguments)]
pub(crate) fn generate_all_map_macros(
    type_name: &Ident,
    ref_type_name: &Ident,
    ref_mut_type_name: &Ident,
    num_generics: usize,
    struct_names: &[Ident],
    variant_names: &[Ident],
    opts: &StructOpts,
    output_items: &mut Vec<TokenStream>,
) {
    generate_all_map_macros_for_type(
        type_name,
        num_generics,
        struct_names,
        &opts.map_into,
        |from_type, to_type| generate_owned_map_macro(from_type, to_type, variant_names),
        output_items,
    );

    generate_all_map_macros_for_type(
        ref_type_name,
        num_generics,
        struct_names,
        &opts.map_ref_into,
        |from_type, to_type| generate_ref_map_macro(from_type, to_type, variant_names, false),
        output_items,
    );

    generate_all_map_macros_for_type(
        ref_mut_type_name,
        num_generics,
        struct_names,
        &opts.map_ref_mut_into,
        |from_type, to_type| generate_ref_map_macro(from_type, to_type, variant_names, true),
        output_items,
    );
}

fn generate_all_map_macros_for_type(
    type_name: &Ident,
    num_generics: usize,
    struct_names: &[Ident],
    map_into: &Option<IdentList>,
    generator: impl Fn(&MacroFromType, Option<&Ident>) -> TokenStream2,
    output_items: &mut Vec<TokenStream>,
) {
    let from_type = MacroFromType {
        name: type_name,
        num_generics,
        struct_names,
    };
    let map_macro_self = generator(&from_type, None);
    output_items.push(map_macro_self.into());

    if let Some(map_into) = map_into {
        for to_type in &map_into.idents {
            let map_macro_to = generator(&from_type, Some(to_type));
            output_items.push(map_macro_to.into());
        }
    }
}

fn generate_owned_map_macro(
    from_type: &MacroFromType,
    to_type_name: Option<&Ident>,
    variant_names: &[Ident],
) -> TokenStream2 {
    assert_eq!(
        from_type.struct_names.len(),
        variant_names.len(),
        "there must be one struct per variant"
    );

    let from_type_name = &from_type.name;
    let from_type_struct_names = from_type.struct_names;
    let to_type_name = to_type_name.unwrap_or(from_type_name);
    let map_macro_name = generate_map_macro_name(from_type_name, to_type_name);

    // Generics we want the compiler to infer.
    let from_type_generics = underscore_generics(from_type.num_generics);

    quote! {
        #[macro_export]
        macro_rules! #map_macro_name {
            ($value:expr, $f:expr) => {
                match $value {
                    #(
                        #from_type_name::#variant_names(inner) => {
                            let f: fn(
                                #from_type_struct_names #from_type_generics,
                                fn(_) -> _,
                            ) -> _ = $f;
                            f(inner, #to_type_name::#variant_names)
                        }
                    )*
                }
            }
        }
    }
}

fn generate_ref_map_macro(
    from_type: &MacroFromType,
    to_type_name: Option<&Ident>,
    variant_names: &[Ident],
    mutable: bool,
) -> TokenStream2 {
    assert_eq!(
        from_type.struct_names.len(),
        variant_names.len(),
        "there must be one struct per variant"
    );

    let from_type_name = &from_type.name;
    let from_type_struct_names = from_type.struct_names;
    let to_type_name = to_type_name.unwrap_or(from_type_name);
    let map_macro_name = generate_map_macro_name(from_type_name, to_type_name);

    // Generics we want the compiler to infer.
    let from_type_generics = underscore_generics(from_type.num_generics);

    let mutability = if mutable {
        quote! { mut }
    } else {
        quote! {}
    };

    quote! {
        #[macro_export]
        macro_rules! #map_macro_name {
            (&$lifetime:tt _, $value:expr, $f:expr) => {
                match $value {
                    #(
                        #from_type_name::#variant_names(inner) => {
                            let f: fn(
                                &$lifetime #mutability #from_type_struct_names #from_type_generics,
                                fn(_) -> _,
                            ) -> _ = $f;
                            f(inner, #to_type_name::#variant_names)
                        }
                    )*
                }
            }
        }
    }
}