pinenut-derive 0.0.1

The internal derive crate for `pinenut-log`, it implements some derive macros.
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

use proc_macro2::TokenStream;
use quote::{format_ident, quote};
use syn::{Data, DataStruct, DeriveInput, Fields};

use crate::misc::add_traits_bounds;

/// `Builder Pattern` derive macro implementation.
pub fn impl_builder(input: DeriveInput) -> TokenStream {
    // Destructures input data and extracts fields of struct.
    let Data::Struct(DataStruct { fields: Fields::Named(fields), .. }) = input.data else {
        let err_msg = "`#[derive(Builder)]` is only supported for structs with named fields";
        return syn::Error::new(input.ident.span(), err_msg).into_compile_error();
    };

    let (name, vis) = (input.ident, input.vis);
    let generics = add_traits_bounds(input.generics, [quote!(Default), quote!(Clone)]);
    let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();

    let builder_name = format_ident!("{name}Builder");
    let builder_doc = format!("Builder for [`{name}`].");

    // Generates setter code for all fields.
    let setters = fields.named.into_iter().map(|f| {
        let (field, ty) = (f.ident.unwrap(), f.ty);
        let doc = format!("Set [`{name}::{field}`].");
        quote! {
            #[doc = #doc]
            #[inline]
            #vis fn #field(&mut self, #field: #ty) -> &mut Self {
                self.0.#field = #field;
                self
            }
        }
    });

    quote! {
        #[doc = #builder_doc]
        #vis struct #builder_name #impl_generics(#name #ty_generics) #where_clause;

        impl #impl_generics #name #ty_generics #where_clause {
            /// Returns a new builder.
            #[inline]
            #vis fn builder() -> #builder_name #ty_generics {
                #builder_name::new()
            }
        }

        impl #impl_generics #builder_name #ty_generics #where_clause {
            /// Constructs a new `Builder`.
            #[inline]
            #vis fn new() -> Self {
                Self(Default::default())
            }

            /// Invokes the builder and returns the object.
            #[inline]
            #vis fn build(&self) -> #name #ty_generics {
                Clone::clone(&self.0)
            }

            #(#setters)*
        }
    }
}