butcher_proc_macro 0.4.1

Procedural macros for butcher
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

use std::fmt::{Formatter, Result as FmtResult};

use syn::Ident;

use quote::{format_ident, quote, IdentFragment, ToTokens, TokenStreamExt};

use proc_macro2::{Literal, TokenStream};

#[cfg(test)]
macro_rules! assert_eq_tt {
    ($left: ident, $right: ident) => {
        let left = format!("{}", $left);
        let right = format!("{}", $right);

        assert_eq!(left, right);
    };
}

#[derive(Clone, Debug, PartialEq)]
pub(crate) enum FieldName {
    Named(Ident),
    Unnamed(usize),
}

impl FieldName {
    pub fn expand_main_struct_field(&self) -> TokenStream {
        match self {
            FieldName::Named(name) => quote! { #name: },
            FieldName::Unnamed(_) => quote! {},
        }
    }

    pub(crate) fn expand_as_pattern_identifier(&self) -> TokenStream {
        match self {
            FieldName::Named(name) => quote! { #name },
            FieldName::Unnamed(id) => {
                // Creating an identifier from a field index
                let id = format_ident!("field_{}", id);
                quote! { #id }
            }
        }
    }
}

impl From<Ident> for FieldName {
    fn from(i: Ident) -> FieldName {
        FieldName::Named(i)
    }
}

impl From<usize> for FieldName {
    fn from(i: usize) -> FieldName {
        FieldName::Unnamed(i)
    }
}

impl IdentFragment for FieldName {
    fn fmt(&self, f: &mut Formatter) -> FmtResult {
        match self {
            FieldName::Named(name) => name.fmt(f),
            FieldName::Unnamed(id) => id.fmt(f),
        }
    }
}

impl ToTokens for FieldName {
    fn to_tokens(&self, tokens: &mut TokenStream) {
        match self {
            FieldName::Named(name) => tokens.append(name.clone()),
            FieldName::Unnamed(id) => tokens.append(Literal::usize_unsuffixed(*id)),
        }
    }
}

impl PartialEq<&str> for FieldName {
    fn eq(&self, other: &&str) -> bool {
        matches!(self, FieldName::Named(id) if id == other)
    }
}

impl PartialEq<usize> for FieldName {
    fn eq(&self, other: &usize) -> bool {
        matches!(self, FieldName::Unnamed(id) if id == other)
    }
}

impl PartialEq<usize> for &FieldName {
    fn eq(&self, other: &usize) -> bool {
        *self == other
    }
}

pub(crate) fn associated_struct_name(main_struct: &Ident, field: &FieldName) -> Ident {
    format_ident!("Butcher{}{}", main_struct, field)
}

pub(crate) fn global_associated_struct_name(initial_struct: &Ident) -> Ident {
    format_ident!("Butchered{}", initial_struct)
}

#[cfg(test)]
mod associated_struct_name {
    use super::*;

    use syn::parse_quote;

    #[test]
    fn test() {
        let main: Ident = parse_quote! { Foo };
        let field: Ident = parse_quote! { bar };

        assert_eq!(
            associated_struct_name(&main, &field.into()),
            "ButcherFoobar"
        );
    }
}