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
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153

use proc_macro2::TokenStream;
use proc_macro2::{Ident, Span};
use quote::quote;
use quote::{format_ident, ToTokens};
use syn::parse::ParseStream;
use syn::LitInt;
use syn::{Expr, Field, GenericArgument, PathArguments, Token, Type, WhereClause};
use syn::{ImplGenerics, Result};

pub fn type_is_option(ty: &Type) -> bool {
    type_of_option(ty).is_some()
}

pub fn type_of_option(ty: &Type) -> Option<&Type> {
    let path = match ty {
        Type::Path(ty) => &ty.path,
        _ => return None,
    };

    let last = path.segments.last().unwrap();
    if last.ident != "Option" {
        return None;
    }

    let bracketed = match &last.arguments {
        PathArguments::AngleBracketed(bracketed) => bracketed,
        _ => return None,
    };

    if bracketed.args.len() != 1 {
        return None;
    }

    match &bracketed.args[0] {
        GenericArgument::Type(arg) => Some(arg),
        _ => None,
    }
}

pub fn type_add_colon2(ret: &mut Type) {
    if let Type::Path(p) = ret {
        let path = &mut p.path;
        let segs = &mut path.segments;
        for seg in segs {
            if let PathArguments::AngleBracketed(ref mut ab) = &mut seg.arguments {
                if ab.colon2_token.is_none() {
                    ab.colon2_token = Some(<Token![::]>::default());
                }
            }
        }
    }
}

pub fn meta_list_to_fields(list: &syn::MetaList) -> Result<Vec<Field>> {
    list.parse_args_with(|stream: ParseStream| -> Result<Vec<Field>> {
        let mut fields: Vec<Field> = vec![];
        let named = stream.parse_terminated(Field::parse_named, Token![,])?;
        for field in named {
            fields.push(field);
        }
        Ok(fields)
    })
}

pub fn meta_list_to_expr(list: &syn::MetaList) -> Result<Vec<Expr>> {
    list.parse_args_with(|stream: ParseStream| -> Result<Vec<Expr>> {
        let mut exprs = vec![];
        while !stream.is_empty() {
            let field: Expr = stream.parse()?;
            exprs.push(field);
            if !stream.is_empty() {
                stream.parse::<Token![,]>()?;
            }
        }
        Ok(exprs)
    })
}

pub fn get_unname_field_ident(index: usize) -> Ident {
    format_ident!("unnamed_{}", index)
}

pub fn is_new_type(fields: &syn::Fields) -> bool {
    if let syn::Fields::Unnamed(fields) = fields {
        if fields.unnamed.len() == 1 {
            return true;
        }
    }
    false
}

pub fn get_index_lit(index: usize) -> LitInt {
    LitInt::new(&index.to_string(), Span::call_site())
}

pub fn impl_generics_join_trait(impl_generics: ImplGenerics, ty: &str) -> Result<TokenStream> {
    let mut generics_token = impl_generics.into_token_stream();
    if !generics_token.is_empty() {
        let generics_token_str = generics_token.to_string();
        let mut generics_token_str = generics_token_str.trim().to_string();
        generics_token_str.remove(0);
        generics_token_str.remove(generics_token_str.len() - 1);
        let mut split_generics: Vec<String> = generics_token_str
            .split(',')
            .map(|t| t.to_string())
            .collect();
        for item_ty in split_generics.iter_mut() {
            if item_ty.contains('\'') {
                continue;
            }
            if item_ty.contains(':') {
                item_ty.push_str(" + ");
                item_ty.push_str(ty);
            } else {
                item_ty.push_str(" : ");
                item_ty.push_str(ty);
            }
        }
        let mut generics_token_str = split_generics.join(",");
        generics_token_str.insert(0, '<');
        generics_token_str.push('>');
        generics_token = generics_token_str.parse()?;
    }
    Ok(generics_token)
}

pub fn where_generics_add_constraint(
    where_generics: Option<&WhereClause>,
    constraints: Vec<&str>,
) -> Result<TokenStream> {
    let mut generics_token = where_generics.into_token_stream();
    let mut exist_where = false;
    let mut generics_token_str = String::default();
    if !generics_token.is_empty() {
        generics_token_str = generics_token.to_string();
        generics_token_str = generics_token_str.trim().to_string();
        if !generics_token_str.is_empty() {
            let index = generics_token_str.find("where");
            exist_where = index.is_some();
        }
    }
    if !exist_where {
        generics_token_str.push_str("where ");
    } else if !generics_token_str.ends_with(',') {
        generics_token_str.push(',');
    }
    for constraint in constraints {
        generics_token_str.push_str(constraint);
        generics_token_str.push(',');
    }
    generics_token = generics_token_str.parse()?;
    Ok(quote! { #generics_token  })
}