moretypes 0.1.3

Named tuples, records, and more!
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

// This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0. If a copy of the MPL was not distributed with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
//! Named tuples, or named structs with certain tuple-like functions

use proc_macro::TokenStream;
use quote::ToTokens;
use syn::{
    parse::{Parse, ParseStream},
    Result,
};

struct NamedTupleAttrs(syn::punctuated::Punctuated<NamedTupleAttr, syn::Token![,]>);

impl Parse for NamedTupleAttrs {
    fn parse(input: ParseStream) -> Result<Self> {
        input
            .parse_terminated::<NamedTupleAttr, syn::Token![,]>(NamedTupleAttr::parse)
            .map(NamedTupleAttrs)
    }
}

struct NamedTupleAttr {
    ident: syn::Ident,
    _eq_token: syn::Token![=],
    value: syn::Lit,
}

impl Parse for NamedTupleAttr {
    fn parse(input: ParseStream) -> Result<Self> {
        Ok(NamedTupleAttr {
            ident: input.parse()?,
            _eq_token: input.parse()?,
            value: input.parse()?,
        })
    }
}

struct NamedTupleConfig {
    constructor: bool,
    tuple_methods: bool,
}

impl Default for NamedTupleConfig {
    fn default() -> Self {
        Self {
            constructor: true,
            tuple_methods: true,
        }
    }
}

impl TryFrom<NamedTupleAttrs> for NamedTupleConfig {
    type Error = syn::Error;
    fn try_from(attrs: NamedTupleAttrs) -> syn::Result<Self> {
        attrs.0.iter().try_fold(Self::default(), |mut acc, attr| {
            match (attr.ident.to_string().as_str(), &attr.value) {
                ("constructor", syn::Lit::Bool(val)) => acc.constructor = val.value,
                ("tuple_methods", syn::Lit::Bool(val)) => acc.tuple_methods = val.value,
                _ => {
                    return Err(syn::Error::new(
                        attr.value.span(),
                        "invalid or unknown parameter",
                    ))
                }
            }
            Ok(acc)
        })
    }
}

pub fn named_tuple(attrs: TokenStream, item: TokenStream) -> TokenStream {
    let attrs = syn::parse_macro_input!(attrs as NamedTupleAttrs);
    let config = NamedTupleConfig::try_from(attrs)
        .map_err(syn::Error::into_compile_error)
        .unwrap();

    let strct = syn::parse_macro_input!(item as syn::ItemStruct);
    if let syn::Fields::Named(ref fields) = strct.fields {
        let name = &strct.ident;
        let (impl_generics, type_generics, where_clause) = &strct.generics.split_for_impl();
        let (names, types): (Vec<_>, Vec<_>) = fields
            .named
            .iter()
            .cloned()
            .map(|it| (it.ident.unwrap(), it.ty))
            .unzip();
        let mut stream = proc_macro2::TokenStream::new();
        strct.to_tokens(&mut stream);

        if config.constructor {
            quote::quote! {
                impl #impl_generics #name #type_generics #where_clause {
                    pub fn new(#(#names: #types),*) -> Self {
                        Self {
                            #(#names),*
                        }
                    }
                }
            }
            .to_tokens(&mut stream);
        }

        if config.tuple_methods {
            quote::quote! {
                impl #impl_generics From<(#(#types),*)> for #name #type_generics #where_clause {
                    fn from((#(#names),*): (#(#types),*)) -> Self {
                        Self { #(#names),* }
                    }
                }

                impl #impl_generics From<#name #type_generics> for (#(#types),*) #where_clause {
                    fn from(it: #name #type_generics) -> (#(#types),*) {
                        (#(it.#names),*)
                    }
                }

                impl #impl_generics #name #type_generics #where_clause {
                    pub fn as_tuple(self) -> (#(#types),*) {
                        <(#(#types),*)>::from(self)
                    }
                }
            }
            .to_tokens(&mut stream);
        }

        stream.into()
    } else {
        syn::Error::new(
            strct.struct_token.span,
            "Named tuples must have named fields!",
        )
        .into_compile_error();
        unreachable!();
    }
}