giftwrap 0.5.0

Wrap and unwrap your types the stylish way
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

use {
    crate::GetFieldError,
    proc_macro2::Span,
    quote::quote,
    syn::{self, GenericArgument, PathArguments, Type},
};

pub(crate) enum Error {
    For(Span, &'static str),
    Only(Span, &'static str),
    Special(Span, &'static str),
}

impl From<Error> for syn::Error {
    fn from(e: Error) -> Self {
        match e {
            Error::For(span, msg) => {
                syn::Error::new(span, format!("Wrap cannot be derived for {msg}"))
            }
            Error::Only(span, msg) => {
                syn::Error::new(span, format!("Wrap can only be derived for {msg}"))
            }
            Error::Special(span, msg) => syn::Error::new(span, msg),
        }
    }
}

impl From<GetFieldError> for Error {
    fn from(e: GetFieldError) -> Self {
        match e {
            GetFieldError::Unit(span) => Error::For(span, "Unit variant"),
            GetFieldError::NotSingle(span) => Error::Only(span, "variant with 1 field"),
        }
    }
}

pub(super) fn generate_inner_conversions(types: &[Type]) -> proc_macro2::TokenStream {
    types
        .iter()
        .rev()
        .fold(quote! {f}, |froms, s_ty| match s_ty {
            Type::Path(path) => {
                let gen = path.path.segments[0].ident.clone();
                quote! {
                    #gen::<_>::from(#froms)
                }
            }
            Type::Ptr(_) | Type::Reference(_) => {
                quote! {&#froms}
            }
            _ => froms,
        })
}

pub(super) fn subtypes_list(top: &syn::Type, depth: Option<u32>) -> Vec<syn::Type> {
    let mut vec = vec![];

    let mut current = top;
    loop {
        if depth.map_or(false, |d| vec.len() == d as usize) {
            break;
        }
        vec.push(current.clone());
        match current {
            Type::Path(path) => {
                if let PathArguments::AngleBracketed(brac) = &path.path.segments[0].arguments {
                    if let Some(next_ty) = brac.args.iter().find_map(|v| {
                        if let GenericArgument::Type(ty) = v {
                            Some(ty)
                        } else {
                            None
                        }
                    }) {
                        current = next_ty
                    } else {
                        break;
                    }
                } else {
                    break;
                }
            }
            Type::Ptr(ptr) => current = &*ptr.elem,
            Type::Reference(reference) => current = &*reference.elem,
            Type::Paren(p) => {
                vec.pop();
                current = &*p.elem
            }

            _ => break,
        }
    }

    vec
}