1extern 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;
14mod functions;
15
16#[proc_macro_derive(Functions, attributes(__function))]
17pub fn functions(input: TokenStream) -> TokenStream {
18 let s = input.to_string();
20
21 let ast = syn::parse_derive_input(&s).expect("Couldn't parse for Functions");
23
24 let gen = produce_contructor(&ast, functions::implement);
26
27 println!("String Function : {}", gen);
28 gen.parse().unwrap()
30}
31
32#[proc_macro_derive(Constructor, attributes(__constructor))]
33pub fn constructor(input: TokenStream) -> TokenStream {
34 let s = input.to_string();
36
37 let ast = syn::parse_derive_input(&s).expect("Couldn't parse for Contructor");
39
40 let gen = produce_contructor(&ast, constructor::implement);
42
43 println!("String constructor : {}", gen);
44 gen.parse().unwrap()
46}
47
48#[proc_macro_derive(Getters, attributes(get))]
49pub fn getters(input: TokenStream) -> TokenStream {
50 let s = input.to_string();
52
53 let ast = syn::parse_derive_input(&s).expect("Couldn't parse for getters");
55
56 let gen = produce(&ast, getters::implement);
58
59 println!("String Getters : {}", gen);
60 gen.parse().unwrap()
62}
63
64#[proc_macro_derive(MutGetters, attributes(get_mut))]
65pub fn mut_getters(input: TokenStream) -> TokenStream {
66 let s = input.to_string();
68
69 let ast = syn::parse_derive_input(&s).expect("Couldn't parse for getters");
71
72 let gen = produce(&ast, mut_getters::implement);
74
75 println!("String MutGetters : {}", gen);
76 gen.parse().unwrap()
78}
79
80#[proc_macro_derive(Setters, attributes(set))]
81pub fn setters(input: TokenStream) -> TokenStream {
82 let s = input.to_string();
84
85 let ast = syn::parse_derive_input(&s).expect("Couldn't parse for setters");
87
88 let gen = produce(&ast, setters::implement);
90
91 println!("String Setters : {}", gen);
92 gen.parse().unwrap()
94}
95
96fn produce(ast: &DeriveInput, worker: fn(&Field) -> Tokens) -> Tokens {
97 let name = &ast.ident;
98 let generics = &ast.generics;
99 let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
100
101 if let syn::Body::Struct(syn::VariantData::Struct(ref fields)) = ast.body {
103
104 let generated = fields.iter().map(worker).collect::<Vec<_>>();
105
106 quote! {
107 impl #impl_generics #name #ty_generics #where_clause {
108 #(#generated)*
109 }
110 }
111 } else {
112 panic!("#[derive(Getters)] is only defined for structs, not for enums!");
114 }
115}
116
117fn produce_contructor(ast: &DeriveInput, worker: fn(&Field, &String) -> Tokens) -> Tokens {
118 let name = &ast.ident;
119 let generics = &ast.generics;
120 let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
121
122 if let syn::Body::Struct(syn::VariantData::Struct(ref fields)) = ast.body {
124 let classname = format!("{}", ast.ident);
125 let generated = fields.iter().map(|x| { (
126 worker(x, &classname)
127 ) }).collect::<Vec<_>>();
128
129 quote! {
130 impl #impl_generics #name #ty_generics #where_clause {
131 #(#generated)*
132 }
133 }
134 } else {
135 panic!("#[derive(Getters)] is only defined for structs, not for enums!");
137 }
138}