derive_pb 0.0.2

derive macro for proto
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
95
96
97
98
99

extern crate proc_macro;

mod a_enum;
mod a_struct;
mod field_attr;
mod field_meta_map;
mod utils;

use field_attr::{FieldAttr, VariantAttr};
use field_meta_map::FieldMetaMap;

use proc_macro::TokenStream;

// use proc_macro2::{Ident, Span};

use quote::quote;
use syn::{parse_macro_input, DeriveInput};

// HashMap<String, Vec<Seed>>
/*
{"name": "HashMap", "args": [
  {"name": "String", "args": []},
  {"name": "Vec", "args": [
      {"name": "Seed", "args": []}
  ]}
]}
*/
/*
fn get_path_args(segment: syn::PathSegment) -> (syn::Ident, syn::PathSegment) {
    //
    let mut r_name;
    let mut r_args;
    if segment.ident == "HashMap" {
        if let syn::PathArguments::AngleBracketed(args) = segment.arguments {
            // key
            if let syn::GenericArgument::Type(syn::Type::Path(bbb)) = &args.args[0] {
                let k = &bbb.path.segments[0].ident;
                eprintln!("key: {:?}", k);
                r_name = k;
            }
            // value
            if let syn::GenericArgument::Type(syn::Type::Path(bbb)) = &args.args[1] {
                let v = &bbb.path.segments[0].ident;
                let v_args = &bbb.path.segments[0].arguments;
                eprintln!("value: {:?}", v);
                eprintln!("value: {:?}", v_args);
            }


            /*
            for aaa in args.args.iter() {
                if let syn::GenericArgument::Type(syn::Type::Path(bbb)) = aaa {
                    // eprintln!("ddd: {:?}", bbb);
                    for segment in bbb.path.segments.iter() {
                        eprintln!("ddd: {:?}", segment);
                    }
                }
            }*/
        }
    }

    return r_name, r_args
}
*/

#[proc_macro_derive(Pb, attributes(pb))]
pub fn derive(input: TokenStream) -> TokenStream {
    let ast = parse_macro_input!(input as DeriveInput);

    if let syn::Data::Struct(syn::DataStruct {
        fields: syn::Fields::Named(syn::FieldsNamed { ref named, .. }),
        ..
    }) = &ast.data
    {
        println!("struct");
        let struct_info = a_struct::StructInfo::new(&ast);

        let a = quote! {
            #struct_info
        };

        // eprintln!("{}", a);

        return TokenStream::from(a);
    } else if let syn::Data::Enum(aaa) = &ast.data {
        println!("Enum");
        let enum_info = a_enum::EnumInfo::new(&ast);

        let a = quote! {
            #enum_info
        };

        // eprintln!("{}", a);

        return TokenStream::from(a);
    }

    return TokenStream::from(quote! {});
}