agdb_derive 0.12.10

Agnesoft Graph Database - 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

use super::generics;
use super::type_def;
use proc_macro2::TokenStream;
use quote::quote;
use syn::DeriveInput;
use syn::FieldsUnnamed;

pub(crate) fn parse_tuple(fields: Option<&FieldsUnnamed>, input: &DeriveInput) -> TokenStream {
    let name = &input.ident;
    let generic_names = generics::list_generics(&input.generics);
    let generics = generics::parse_generics(name, &input.generics);
    let fields = parse_unnamed_fields(fields, &generic_names);
    let (impl_generics, ty_generic, where_clause) = input.generics.split_for_impl();

    quote! {
        impl #impl_generics ::agdb::api_def::TypeDefinition for #name #ty_generic #where_clause {
            fn type_def() -> ::agdb::api_def::Type {
                ::agdb::api_def::Type::Tuple(::agdb::api_def::tuple_def::Tuple {
                    name: stringify!(#name),
                    generics: &[#(#generics),*],
                    fields: &[#(#fields),*],
                    functions: <#name #ty_generic as ::agdb::api_def::ImplDefinition>::functions(),
                })
            }
        }
    }
}

pub(crate) fn parse_unnamed_fields(
    fields: Option<&FieldsUnnamed>,
    generics: &[String],
) -> Vec<TokenStream> {
    if let Some(fields) = fields {
        fields
            .unnamed
            .iter()
            .map(|f| {
                let field_type = type_def::parse_type(&f.ty, generics);

                quote! {
                    #field_type
                }
            })
            .collect()
    } else {
        Vec::new()
    }
}