macro_class_render/
lib.rs1extern crate proc_macro;
2extern crate syn;
3#[macro_use]
4extern crate quote;
5
6use proc_macro::TokenStream;
7use syn::{Field, DeriveInput};
8use quote::Tokens;
9
10mod mut_getters;
11mod getters;
12mod setters;
13mod constructor;
14
15#[proc_macro_derive(Constructor, attributes(__constructor))]
16pub fn constructor(input: TokenStream) -> TokenStream {
17 let s = input.to_string();
19
20 let ast = syn::parse_derive_input(&s).expect("Couldn't parse for getters");
22
23 let gen = produce_contructor(&ast, constructor::implement);
25
26 println!("String constructor : {}", gen);
27 gen.parse().unwrap()
29}
30
31#[proc_macro_derive(Getters, attributes(get))]
32pub fn getters(input: TokenStream) -> TokenStream {
33 let s = input.to_string();
35
36 let ast = syn::parse_derive_input(&s).expect("Couldn't parse for getters");
38
39 let gen = produce(&ast, getters::implement);
41
42 println!("String Getters : {}", gen);
43 gen.parse().unwrap()
45}
46
47#[proc_macro_derive(MutGetters, attributes(get_mut))]
48pub fn mut_getters(input: TokenStream) -> TokenStream {
49 let s = input.to_string();
51
52 let ast = syn::parse_derive_input(&s).expect("Couldn't parse for getters");
54
55 let gen = produce(&ast, mut_getters::implement);
57
58 println!("String MutGetters : {}", gen);
59 gen.parse().unwrap()
61}
62
63#[proc_macro_derive(Setters, attributes(set))]
64pub fn setters(input: TokenStream) -> TokenStream {
65 let s = input.to_string();
67
68 let ast = syn::parse_derive_input(&s).expect("Couldn't parse for setters");
70
71 let gen = produce(&ast, setters::implement);
73
74 println!("String Setters : {}", gen);
75 gen.parse().unwrap()
77}
78
79fn produce(ast: &DeriveInput, worker: fn(&Field) -> Tokens) -> Tokens {
80 let name = &ast.ident;
81 let generics = &ast.generics;
82 let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
83
84 if let syn::Body::Struct(syn::VariantData::Struct(ref fields)) = ast.body {
86
87 let generated = fields.iter().map(worker).collect::<Vec<_>>();
88
89 quote! {
90 impl #impl_generics #name #ty_generics #where_clause {
91 #(#generated)*
92 }
93 }
94 } else {
95 panic!("#[derive(Getters)] is only defined for structs, not for enums!");
97 }
98}
99
100fn produce_contructor(ast: &DeriveInput, worker: fn(&Field, &String) -> Tokens) -> Tokens {
101 let name = &ast.ident;
102 let generics = &ast.generics;
103 let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
104
105 if let syn::Body::Struct(syn::VariantData::Struct(ref fields)) = ast.body {
107 let classname = format!("{}", ast.ident);
108 let generated = fields.iter().map(|x| { (worker(x, &classname)) }).collect::<Vec<_>>();
109
110 quote! {
111 impl #impl_generics #name #ty_generics #where_clause {
112 #(#generated)*
113 }
114 }
115 } else {
116 panic!("#[derive(Getters)] is only defined for structs, not for enums!");
118 }
119}