Return primitive types by value from getters

Cargo.toml

@@ -22,5 +22,7 @@ appveyor = { repository = "https://github.com/Hoverbear/getset", service = "gith
 proc-macro = true
 
 [dependencies]
-quote = "0.3.15"
-syn = "0.11.11"
+quote = "0.5.2"
+syn = "0.13.10"
+proc-macro2 = { version = "0.3", default-features = false }
+lazy_static = "1.0.0"

src/generate.rs

@@ -0,0 +1,186 @@
+use proc_macro2::{Span, Term};
+use quote::Tokens;
+use std::collections::HashSet;
+use syn::{Attribute, Field, Ident, Lit, Meta, MetaNameValue, PathSegment, Type, TypePath};
+
+pub struct GenParams {
+    pub attribute_name: &'static str,
+    pub fn_name_prefix: &'static str,
+    pub fn_name_suffix: &'static str,
+}
+
+pub enum GenMode {
+    Get,
+    Set,
+    GetMut,
+}
+
+fn attr_name(attr: &Attribute) -> Option<Ident> {
+    attr.interpret_meta().map(|v| v.name())
+}
+
+lazy_static! {
+    static ref PRIMITIVE_TYPENAMES: HashSet<&'static str> = {
+        let mut m = HashSet::new();
+        macro_rules! add_types {
+                ($m:ident, types: [$( $Type:ident ),*]) => {
+                    $(
+                        $m.insert(stringify!($Type));
+                        )*
+                }
+        }
+        add_types!(m, types: [i8, u8, i16, u16, i32, u32, i64, u64, usize, isize, bool, f32, f64]);
+        m
+    };
+}
+
+fn is_type_primitive(ty: &Type) -> bool {
+    if let Type::Path(TypePath {
+        qself: ref _qself,
+        path,
+    }) = ty
+    {
+        if path.segments.len() == 1 {
+            let seg: &PathSegment = path.segments.first().unwrap().value();
+            if PRIMITIVE_TYPENAMES.contains(seg.ident.as_ref()) {
+                true
+            } else {
+                false
+            }
+        } else {
+            false
+        }
+    } else {
+        false
+    }
+}
+
+pub fn implement(field: &Field, mode: GenMode, params: GenParams) -> Tokens {
+    let field_name = field
+        .clone()
+        .ident
+        .expect("Expected the field to have a name");
+    let type_primitive = is_type_primitive(&field.ty);
+    let fn_name = Term::new(
+        &format!(
+            "{}{}{}",
+            params.fn_name_prefix, field_name, params.fn_name_suffix
+        ),
+        Span::call_site(),
+    );
+    let ty = field.ty.clone();
+
+    let attr = field
+        .attrs
+        .iter()
+        .filter(|v| attr_name(v).expect("attribute") == params.attribute_name)
+        .last();
+
+    let doc = field
+        .attrs
+        .iter()
+        .filter(|v| attr_name(v).expect("attribute") == "doc")
+        .collect::<Vec<_>>();
+
+    match attr {
+        Some(attr) => {
+            match attr.interpret_meta() {
+                // `#[get]` or `#[set]`
+                Some(Meta::Word(_)) => match mode {
+                    GenMode::Get => {
+                        quote! {
+                            #(#doc)*
+                            #[inline(always)]
+                            fn #fn_name(&self) -> &#ty {
+                                &self.#field_name
+                            }
+                        }
+                    }
+                    GenMode::Set => {
+                        quote! {
+                            #(#doc)*
+                            #[inline(always)]
+                            fn #fn_name(&mut self, val: #ty) -> &mut Self {
+                                self.#field_name = val;
+                                self
+                            }
+                        }
+                    }
+                    GenMode::GetMut => {
+                        quote! {
+                            #(#doc)*
+                            fn #fn_name(&mut self) -> &mut #ty {
+                                &mut self.#field_name
+                            }
+                        }
+                    }
+                },
+                // `#[get = "pub"]` or `#[set = "pub"]`
+                Some(Meta::NameValue(MetaNameValue {
+                    lit: Lit::Str(ref s),
+                    ..
+                })) => {
+                    let visibility = Term::new(&s.value(), s.span());
+                    match mode {
+                        GenMode::Get => {
+                            if type_primitive {
+                                quote! {
+                                    #(#doc)*
+                                    #[inline(always)]
+                                    #visibility fn #fn_name(&self) -> #ty {
+                                        self.#field_name
+                                    }
+                                }
+                            } else {
+                                quote! {
+                                    #(#doc)*
+                                    #[inline(always)]
+                                    #visibility fn #fn_name(&self) -> &#ty {
+                                        &self.#field_name
+                                    }
+                                }
+                            }
+                        }
+                        GenMode::Set => {
+                            quote! {
+                                #(#doc)*
+                                #[inline(always)]
+                                #visibility fn #fn_name(&mut self, val: #ty) -> &mut Self {
+                                    self.#field_name = val;
+                                    self
+                                }
+                            }
+                        }
+                        GenMode::GetMut => {
+                            quote! {
+                                #(#doc)*
+                                #visibility fn #fn_name(&mut self) -> &mut #ty {
+                                    &mut self.#field_name
+                                }
+                            }
+                        }
+                    }
+                }
+                // This currently doesn't work, but it might in the future.
+                //
+                // // `#[get(pub)]`
+                // MetaItem::List(_, ref vec) => {
+                //     let s = vec.iter().last().expect("No item found in attribute list.");
+                //     let visibility = match s {
+                //         &NestedMetaItem::MetaItem(MetaItem::Word(ref i)) => Ident::new(format!("{}", i)),
+                //         &NestedMetaItem::Literal(Lit::Str(ref l, _)) => Ident::from(l.clone()),
+                //         _ => panic!("Unexpected attribute parameters."),
+                //     };
+                //     quote! {
+                //         #visibility fn #fn_name(&self) -> &#ty {
+                //             &self.#field_name
+                //         }
+                //     }
+                // },
+                _ => panic!("Unexpected attribute parameters."),
+            }
+        }
+        // Don't need to do anything.
+        None => quote!{},
+    }
+}

src/lib.rs

@@ -33,63 +33,83 @@ fn main() {
 ```
 */
 
-
 extern crate proc_macro;
 extern crate syn;
 #[macro_use]
 extern crate quote;
+extern crate proc_macro2;
+#[macro_use]
+extern crate lazy_static;
 
 use proc_macro::TokenStream;
-use syn::{Field, DeriveInput};
 use quote::Tokens;
+use syn::{DataStruct, DeriveInput, Field};
 
-mod mut_getters;
-mod getters;
-mod setters;
+mod generate;
+use generate::{GenMode, GenParams};
 
 #[proc_macro_derive(Getters, attributes(get))]
 pub fn getters(input: TokenStream) -> TokenStream {
-    // Construct a string representation of the type definition
-    let s = input.to_string();
-
     // Parse the string representation
-    let ast = syn::parse_derive_input(&s).expect("Couldn't parse for getters");
+    let ast = syn::parse(input).expect("Couldn't parse for getters");
 
     // Build the impl
-    let gen = produce(&ast, getters::implement);
+    let gen = produce(&ast, |f| {
+        generate::implement(
+            f,
+            GenMode::Get,
+            GenParams {
+                attribute_name: "get",
+                fn_name_prefix: "",
+                fn_name_suffix: "",
+            },
+        )
+    });
 
     // Return the generated impl
-    gen.parse().unwrap()
+    gen.into()
 }
 
 #[proc_macro_derive(MutGetters, attributes(get_mut))]
 pub fn mut_getters(input: TokenStream) -> TokenStream {
-    // Construct a string representation of the type definition
-    let s = input.to_string();
-
     // Parse the string representation
-    let ast = syn::parse_derive_input(&s).expect("Couldn't parse for getters");
-
+    let ast = syn::parse(input).expect("Couldn't parse for getters");
     // Build the impl
-    let gen = produce(&ast, mut_getters::implement);
-
+    let gen = produce(&ast, |f| {
+        generate::implement(
+            f,
+            GenMode::GetMut,
+            GenParams {
+                attribute_name: "get_mut",
+                fn_name_prefix: "",
+                fn_name_suffix: "_mut",
+            },
+        )
+    });
     // Return the generated impl
-    gen.parse().unwrap()
+    gen.into()
 }
 
 #[proc_macro_derive(Setters, attributes(set))]
 pub fn setters(input: TokenStream) -> TokenStream {
-    // Construct a string representation of the type definition
-    let s = input.to_string();
-
     // Parse the string representation
-    let ast = syn::parse_derive_input(&s).expect("Couldn't parse for setters");
+    let ast = syn::parse(input).expect("Couldn't parse for setters");
 
     // Build the impl
-    let gen = produce(&ast, setters::implement);
-
+    let gen = produce(&ast, |f| {
+        generate::implement(
+            f,
+            GenMode::Set,
+            GenParams {
+                attribute_name: "set",
+                fn_name_prefix: "set_",
+                fn_name_suffix: "",
+            },
+        )
+    });
+
     // Return the generated impl
-    gen.parse().unwrap()
+    gen.into()
 }
 
 fn produce(ast: &DeriveInput, worker: fn(&Field) -> Tokens) -> Tokens {
@@ -98,8 +118,7 @@ fn produce(ast: &DeriveInput, worker: fn(&Field) -> Tokens) -> Tokens {
     let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
 
     // Is it a struct?
-    if let syn::Body::Struct(syn::VariantData::Struct(ref fields)) = ast.body {
-
+    if let syn::Data::Struct(DataStruct { ref fields, .. }) = ast.data {
         let generated = fields.iter().map(worker).collect::<Vec<_>>();
 
         quote! {
@@ -111,4 +130,4 @@ fn produce(ast: &DeriveInput, worker: fn(&Field) -> Tokens) -> Tokens {
         // Nope. This is an Enum. We cannot handle these!
         panic!("#[derive(Getters)] is only defined for structs, not for enums!");
     }
-}
+}