Custom derive macro to create getters and setters

Question

To learn how custom derive macros work in Rust, I decided to create a simple derive macro to provide getters and setters for a given struct.

It would be used like this:

#[derive(GetSet)]
pub struct Example {
 #[get]
 #[set]
 field1: String,
 #[get]
 field2: i32,
}

However, there are some things that feel wrong to me about it:

1. The code uses both proc_macro and proc_macro2, is this necessary?
2. Currently, every getter / setter is in their own impl block. But the quote! macro requires code that is well-formed regarding braces, so I think I cannot create impl #name { first and fill in the methods afterwards. Is there a better way?
3. The function identifiers are created with format!, is this okay?
4. Would it be possible to adapt it so one could just write

#[get, set]
field: (),

instead of

#[get]
#[set]
field: (),

Apart from that, what else would you improve or change?

Here is the code:

use proc_macro::TokenStream;
use proc_macro2::{Ident, Span};
use quote::quote;
use syn::{Data, DeriveInput};
#[proc_macro_derive(GetSet, attributes(get, set))]
pub fn get_set_derive(input: TokenStream) -> TokenStream {
 let ast: DeriveInput = syn::parse(input).unwrap();
 let mut gen = proc_macro2::TokenStream::new();
 let name = &ast.ident;
 let data = &ast.data;
 if let Data::Struct(data_struct) = data {
 let fields = &data_struct.fields;
 for field in fields {
 let field_name = field
 .ident
 .as_ref()
 .expect("struct idents are required for this to work!");
 let field_type = &field.ty;
 for attr in &field.attrs {
 let path = attr.path();
 if path.is_ident("get") {
 let fn_ident = Ident::new(&format!("get_{field_name}"), Span::call_site());
 let getter = quote! {
 impl #name {
 pub fn #fn_ident(&self) -> &#field_type {
 &self.#field_name
 }
 }
 };
 gen.extend(getter);
 }
 if path.is_ident("set") {
 let fn_ident = Ident::new(&format!("set_{field_name}"), Span::call_site());
 let setter = quote! {
 impl #name {
 pub fn #fn_ident(&mut self, new: #field_type) {
 self.#field_name = new;
 }
 }
 };
 gen.extend(setter);
 }
 }
 }
 } else {
 panic!("no support for enums or unions!")
 }
 gen.into()
}

Answer 1

The code uses both proc_macro and proc_macro2, is this necessary?

This is normal. proc_macro is the compiler API stub, only available to proc-macro crates, and proc_macro2 is a plain library that doesn't depend on the compiler proc macro API. It's possible to write a proc-macro crate that doesn't depend on proc_macro2 at all, but then you'd also need to avoid using syn and quote, or any other proc-macro utility libraries — they all depend on proc_macro2, precisely because without it there's no way to manipulate tokens in library code (as opposed to proc-macro crate code).

Currently, every getter / setter is in their own impl block. But the quote! macro requires code that is well-formed regarding braces, so I think I cannot create impl #name { first and fill in the methods afterwards.

You can use an iterator or collection in quote! to assemble the complete structure at once.

let mut functions: Vec<proc_macro2::TokenStream> = Vec::new();
// ... gather functions into vector ...
// this is the entire output of the derive (no `gen` stream)
quote! {
 impl #name {
 #( #functions )*
 }
}

The function identifiers are created with format!, is this okay?

Yes.

Would it be possible to adapt it ...

No, the syntax of attributes does not allow #[foo, bar]. You have to pick one name for the attribute, but it can have parameters: #[getset(get, set)].

Apart from that, what else would you improve or change?

It looks pretty good. You asked the right questions and I can't think of more things to change.