df-derive-macros 0.3.0

Procedural derive macro implementation for df-derive.
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

use proc_macro2::TokenStream;
use quote::quote;
use syn::PathArguments;

use crate::ir::StringyBase;

use super::idents;

pub fn struct_type_tokens(ty: &syn::Type) -> TokenStream {
    if let syn::Type::Path(type_path) = ty
        && type_path.qself.is_none()
    {
        let mut path = type_path.path.clone();
        if let Some(segment) = path.segments.last_mut()
            && let PathArguments::AngleBracketed(args) = &mut segment.arguments
        {
            args.colon2_token.get_or_insert_with(Default::default);
        }
        return quote! { #path };
    }
    quote! { #ty }
}

pub(in crate::codegen) fn stringy_base_ty_path(base: &StringyBase) -> TokenStream {
    match base {
        StringyBase::String => quote! { ::std::string::String },
        StringyBase::BorrowedStr => quote! { &'_ str },
        StringyBase::CowStr => quote! { ::std::borrow::Cow<'_, str> },
        StringyBase::Struct(ty) => struct_type_tokens(ty),
        StringyBase::Generic(ident) => quote! { #ident },
    }
}

#[derive(Clone, Copy)]
pub(in crate::codegen) enum StringyExprKind {
    Bare,
    /// Uses closures so smart-pointer deref coercions fire below `Option`.
    OptionDeref,
    CollapsedOption,
    MbvaValue,
}

pub(in crate::codegen) fn stringy_value_expr(
    base: &StringyBase,
    binding: &TokenStream,
    kind: StringyExprKind,
) -> TokenStream {
    if matches!(base, StringyBase::BorrowedStr | StringyBase::CowStr) {
        let v = idents::leaf_value();
        return match kind {
            StringyExprKind::Bare => {
                quote! { ::core::convert::AsRef::<str>::as_ref(&(#binding)) }
            }
            StringyExprKind::OptionDeref => {
                quote! {
                    (#binding).as_ref().map(|#v| {
                        ::core::convert::AsRef::<str>::as_ref(#v)
                    })
                }
            }
            StringyExprKind::CollapsedOption => {
                quote! {
                    (#binding).map(|#v| {
                        ::core::convert::AsRef::<str>::as_ref(#v)
                    })
                }
            }
            StringyExprKind::MbvaValue => {
                quote! { ::core::convert::AsRef::<str>::as_ref(#binding) }
            }
        };
    }
    let is_string = base.is_string();
    match kind {
        StringyExprKind::Bare => {
            if is_string {
                quote! { &(#binding) }
            } else {
                let ty_path = stringy_base_ty_path(base);
                quote! { <#ty_path as ::core::convert::AsRef<str>>::as_ref(&(#binding)) }
            }
        }
        StringyExprKind::OptionDeref => {
            let v = idents::leaf_value();
            if is_string {
                quote! { (#binding).as_ref().map(|#v| #v.as_str()) }
            } else {
                let ty_path = stringy_base_ty_path(base);
                quote! {
                    (#binding).as_ref().map(|#v| {
                        <#ty_path as ::core::convert::AsRef<str>>::as_ref(#v)
                    })
                }
            }
        }
        StringyExprKind::CollapsedOption => {
            let v = idents::leaf_value();
            if is_string {
                quote! { (#binding).map(|#v| #v.as_str()) }
            } else {
                let ty_path = stringy_base_ty_path(base);
                quote! {
                    (#binding).map(|#v| {
                        <#ty_path as ::core::convert::AsRef<str>>::as_ref(#v)
                    })
                }
            }
        }
        StringyExprKind::MbvaValue => {
            if is_string {
                quote! { #binding.as_str() }
            } else {
                let ty_path = stringy_base_ty_path(base);
                quote! { <#ty_path as ::core::convert::AsRef<str>>::as_ref(#binding) }
            }
        }
    }
}