derive-docs 0.1.45

A tool for generating documentation from Rust derive macros
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

// Unbox a Vec<Box<T>> to Vec<T>.
// Unbox a Box<T> to T.
pub(crate) fn unbox(t: syn::Type) -> syn::Type {
    unbox_inner(unbox_vec(t))
}

// Unbox a syn::Type that is boxed to the inner object.
fn unbox_inner(t: syn::Type) -> syn::Type {
    match t {
        syn::Type::Path(syn::TypePath { ref path, .. }) => {
            let path = &path.segments;
            if path.len() == 1 {
                let seg = &path[0];
                if seg.ident == "Box" {
                    if let syn::PathArguments::AngleBracketed(syn::AngleBracketedGenericArguments { args, .. }) =
                        &seg.arguments
                    {
                        if args.len() == 1 {
                            let mut args = args.iter();
                            let ok = args.next().unwrap();
                            if let syn::GenericArgument::Type(ty) = ok {
                                return ty.clone();
                            }
                        }
                    }
                }
            }
        }
        _ => {
            return t;
        }
    }
    t
}

// For a Vec<Box<T>> return Vec<T>.
// For a Vec<T> return Vec<T>.
fn unbox_vec(t: syn::Type) -> syn::Type {
    match t {
        syn::Type::Path(syn::TypePath { ref path, .. }) => {
            let path = &path.segments;
            if path.len() == 1 {
                let seg = &path[0];
                if seg.ident == "Vec" {
                    if let syn::PathArguments::AngleBracketed(syn::AngleBracketedGenericArguments { args, .. }) =
                        &seg.arguments
                    {
                        if args.len() == 1 {
                            let mut args = args.iter();
                            let ok = args.next().unwrap();
                            if let syn::GenericArgument::Type(ty) = ok {
                                let unboxed = unbox(ty.clone());
                                // Wrap it back in a vec.
                                let wrapped = syn::Type::Path(syn::TypePath {
                                    qself: None,
                                    path: syn::Path {
                                        leading_colon: None,
                                        segments: {
                                            let mut segments = syn::punctuated::Punctuated::new();
                                            segments.push_value(syn::PathSegment {
                                                ident: syn::Ident::new("Vec", proc_macro2::Span::call_site()),
                                                arguments: syn::PathArguments::AngleBracketed(
                                                    syn::AngleBracketedGenericArguments {
                                                        colon2_token: None,
                                                        lt_token: syn::token::Lt::default(),
                                                        args: {
                                                            let mut args = syn::punctuated::Punctuated::new();
                                                            args.push_value(syn::GenericArgument::Type(unboxed));
                                                            args
                                                        },
                                                        gt_token: syn::token::Gt::default(),
                                                    },
                                                ),
                                            });
                                            segments
                                        },
                                    },
                                });
                                return wrapped;
                            }
                        }
                    }
                }
            }
        }
        _ => {
            return t;
        }
    }
    t
}