agdb_derive 0.12.9

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
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

use proc_macro2::TokenStream;
use quote::quote;
use syn::ExprField;
use syn::ExprStruct;
use syn::FieldValue;
use syn::Member;

use crate::api_def::expression;
use crate::api_def::expression::path;
use crate::api_def::statement::ExpressionContext;

pub(crate) fn parse_field_access(e: &ExprField, context: ExpressionContext) -> TokenStream {
    let base_ts = expression::parse_expression(&e.base, context.inner());
    match &e.member {
        Member::Named(ident) => {
            quote! {
                ::agdb::api_def::Expression::FieldAccess {
                    base: &#base_ts,
                    field: stringify!(#ident),
                }
            }
        }
        Member::Unnamed(index) => {
            let index = index.index;
            quote! {
                ::agdb::api_def::Expression::TupleAccess {
                    base: &#base_ts,
                    index: #index,
                }
            }
        }
    }
}

pub(crate) fn parse_tuple(e: &syn::ExprTuple, context: ExpressionContext) -> TokenStream {
    let elements = e
        .elems
        .iter()
        .map(|elem| expression::parse_expression(elem, context.inner()));
    quote! {
        ::agdb::api_def::Expression::Tuple(&[#(#elements),*])
    }
}

pub(crate) fn parse_struct(e: &ExprStruct, context: ExpressionContext) -> TokenStream {
    let path = path::parse_path(&e.path, context.inner());
    let fields = e
        .fields
        .iter()
        .map(|field| parse_struct_field(field, &context));
    quote! {
        ::agdb::api_def::Expression::Struct {
            name: &#path,
            fields: &[#(#fields),*],
        }
    }
}

fn parse_struct_field(field: &FieldValue, context: &ExpressionContext) -> TokenStream {
    let field_name = match &field.member {
        Member::Named(ident) => ident,
        Member::Unnamed(_) => panic!("Unnamed fields are not supported in struct expressions"),
    };
    let field_value = expression::parse_expression(&field.expr, context.inner());

    quote! {
        (stringify!(#field_name), #field_value)
    }
}