//! A macro for optional arguments
//!
//! There are many builder crates for Rust. Thanks to Rust's powerful macro
//! system, it is easy to make a derive macro that creates a builder for a
//! struct. But none of them take the next step of adding a macro to allow
//! using literal syntax.
//! ```
//! use feluments::*;
//!
//! #[derive(Debug, PartialEq, Eq, Builder)]
//! #[builder(vis = pub)]
//! struct Foo {
//! #[builder(default = 45)]
//! x: i32,
//! #[builder(into)]
//! y: String,
//! #[builder(optional)]
//! z: ()
//! }
//!
//! # fn main() {
//! assert_eq!(
//! build!(Foo { x: 32, y: "baz" }),
//! Foo { x: 32, y: "baz".into(), z: () },
//! );
//! # }
//! ```
//!
//! The above call to the [`build`] macro expands to the following:
//!
//! ```
//! # use feluments::*;
//! # #[derive(Debug, PartialEq, Eq, Builder)]
//! # #[builder(vis = pub)]
//! # struct Foo {
//! # #[builder(default = 45)]
//! # x: i32,
//! # #[builder(into)]
//! # y: String,
//! # #[builder(optional)]
//! # z: ()
//! # }
//! # fn main() {
//! # assert_eq!(
//! Foo::builder().x(32).y("baz").build(),
//! # Foo { x: 32, y: "baz".into(), z: () },
//! # );
//! # }
//! ```
//!
//! Although this library provides a [`Builder`] derive macro to make the
//! [`build`] macro work, the `build!` macro is also compatible with other
//! builder crates, such as [bon](https://bon-rs.com/),
//! [buildstructor](https://crates.io/crates/buildstructor), or
//! [typed-builder](https://crates.io/crates/typed-builder).
use attribute_derive::FromAttr;
use proc_macro::TokenStream;
use proc_macro2::Span;
use quote::{format_ident, quote};
use syn::{
Expr, ExprStruct, Ident, ItemStruct, LitBool, Type, Visibility, parse_macro_input, token::Pub,
};
enum Default {
None,
Impl,
Value(Expr),
}
struct MaybeOptionalField {
visibility: Visibility,
name: Ident,
default: Default,
auto_into: bool,
ty: Type,
}
#[derive(FromAttr)]
#[from_attr(ident = builder)]
struct BuilderFieldOptions {
vis: Option<Visibility>,
optional: bool,
default: Option<Expr>,
into: bool,
}
#[derive(FromAttr)]
#[from_attr(ident = builder)]
struct BuilderOptions {
vis: Option<Visibility>,
}
/// Creates a builder implementation for struct that is compatible with the
/// build! macro.
///
/// When the `builder` attribute is applied to the struct, it may take a `vis`
/// argument, followed by the visibility of the `builder` method.
///
/// When the `builder` attribute is applied to a field of the struct, there are
/// several arguments it may take:
/// - `vis`: The visibility of the setter for this field. The default is the
/// visibility of the field.
/// - `optional`: Makes the field optional. If the `default` argument is
/// provided, then the default value will be the one provided. Otherwise, it
/// will be [`Default::default`].
/// - `default`: The default value of the field. Setting this parameter also
/// implies `optional`
/// - `into`: Arguments to the setter may be of any type that implements `Into`
/// for the type of the field.
///
/// # Examples
///
/// ```
/// use feluments::Builder;
///
/// #[derive(Debug, PartialEq, Eq, Builder)]
/// #[builder(vis = pub)]
/// struct Foo {
/// #[builder(default = 45)]
/// x: i32,
/// #[builder(into)]
/// y: String,
/// #[builder(optional)]
/// z: ()
/// }
///
/// # fn main() {
/// assert_eq!(
/// Foo::builder().y("bar").z(()).build(),
/// Foo { x: 45, y: "bar".into(), z: () },
/// );
/// # }
/// ```
///
/// [`Default::default`]: std::default::Default::default
#[proc_macro_derive(Builder, attributes(builder))]
pub fn derive_builder(input: TokenStream) -> TokenStream {
let structure = parse_macro_input!(input as ItemStruct);
let struct_name = &structure.ident;
let builder_name = format_ident!("{}Builder", structure.ident);
let fields = structure
.fields
.into_iter()
.map(|field| {
let attrs = BuilderFieldOptions::from_attributes(field.attrs).unwrap();
MaybeOptionalField {
visibility: attrs.vis.unwrap_or(field.vis),
name: field.ident.unwrap(),
default: match (attrs.optional, attrs.default) {
(true, None) => Default::Impl,
(_, Some(expr)) => Default::Value(expr),
(false, None) => Default::None,
},
auto_into: attrs.into,
ty: field.ty,
}
})
.collect::<Box<_>>();
let builder_visibility = BuilderOptions::from_attributes(structure.attrs)
.map(|options| options.vis)
.ok()
.flatten()
.or_else(|| {
// a normal struct can be constructed if all of the fields are public, so
// it makes sense to also allow a builder in this case.
fields
.iter()
.all(|field| matches!(field.visibility, Visibility::Public(_)))
.then_some(Visibility::Public(Pub {
span: Span::call_site(),
}))
});
let field_names = fields
.iter()
.map(|field| field.name.clone())
.collect::<Box<_>>();
let field_types = fields
.iter()
.map(|field| field.ty.clone())
.collect::<Box<_>>();
let const_generics = fields
.iter()
.filter(|field| matches!(field.default, Default::None))
.map(|field| Ident::new(&field.name.to_string().to_uppercase(), field.name.span()))
.collect::<Box<_>>();
let trues = (0..const_generics.len())
.map(|_| LitBool::new(true, Span::call_site()))
.collect::<Box<_>>();
let falses = (0..const_generics.len())
.map(|_| LitBool::new(false, Span::call_site()))
.collect::<Box<_>>();
let mut j = 0;
let setters = fields
.iter()
.enumerate()
.map(|(i, field)| {
let visibility = &field.visibility;
let setter_name = &field.name;
let ty = &field.ty;
let param_ty = if field.auto_into { quote! { impl ::core::convert::Into<#ty> } } else { quote! {#ty} };
let field_name = &field.name;
let fields_head = &field_names[0..i];
let fields_tail = &field_names[i+1..];
if matches!(field.default, Default::None) {
let generics_head = &const_generics[0..j];
let generics_tail = &const_generics[j+1..];
j += 1;
quote! {
#visibility fn #setter_name(self, value: #param_ty) -> #builder_name<#(#generics_head,)* true, #(#generics_tail),*> {
#builder_name {
#(#fields_head: self.#fields_head,)*
#field_name: Some(value.into()),
#(#fields_tail: self.#fields_tail,)*
}
}
}
} else {
let maybe_setter_name = format_ident!("maybe_{}", &field.name);
let clear_name = format_ident!("clear_{}", &field.name);
quote! {
#visibility fn #setter_name(self, value: #param_ty) -> #builder_name<#(#const_generics),*> {
#builder_name {
#(#fields_head: self.#fields_head,)*
#field_name: Some(value.into()),
#(#fields_tail: self.#fields_tail,)*
}
}
#visibility fn #maybe_setter_name(self, value: core::option::Option<#param_ty>) -> #builder_name<#(#const_generics),*> {
#builder_name {
#(#fields_head: self.#fields_head,)*
#field_name: value.map(Into::into),
#(#fields_tail: self.#fields_tail,)*
}
}
#visibility fn #clear_name(self) -> #builder_name<#(#const_generics),*> {
#builder_name {
#(#fields_head: self.#fields_head,)*
#field_name: None,
#(#fields_tail: self.#fields_tail,)*
}
}
}
}
})
.collect::<Box<_>>();
let build_fields = fields.iter().map(|field| {
let field_name = &field.name;
match &field.default {
Default::Value(default_value) => {
quote! { #field_name: self.#field_name.unwrap_or_else(|| #default_value) }
}
Default::Impl => quote! { #field_name: self.#field_name.unwrap_or_default() },
Default::None => quote! { #field_name: unsafe { self.#field_name.unwrap_unchecked() } },
}
});
quote! {
#[doc(hidden)]
#builder_visibility struct #builder_name<#(const #const_generics: bool),*> {
#(#field_names: Option<#field_types>,)*
}
// using impl instead of derive to improve compilation time
impl<#(const #const_generics: bool),*> core::default::Default for #builder_name<#(#const_generics),*> {
fn default() -> Self {
Self {
#(#field_names: None,)*
}
}
}
impl #struct_name {
#builder_visibility fn builder() -> #builder_name<#(#falses),*> {
#builder_name::default()
}
}
impl<#(const #const_generics: bool),*> #builder_name<#(#const_generics),*> {
#(#setters)*
}
impl #builder_name<#(#trues),*> {
#builder_visibility fn build(self) -> #struct_name {
#struct_name {
#(#build_fields,)*
}
}
}
}
.into()
}
/// Builds a value of a type that derives [`Builder`] using a constructor
/// literal syntax.
///
/// This is meant to be a convenience macro to using `Builder`, with a less
/// verbose syntax. Although this crate contains a `Builder` derive macro that
/// works well with this macro, this macro is also compatible with other crates
/// such as [bon](https://bon-rs.com/), [buildstructor](https://crates.io/crates/buildstructor),
/// or [typed-builder](https://crates.io/crates/typed-builder).
///
/// # Examples
///
/// ```
/// use feluments::*;
///
/// #[derive(Debug, PartialEq, Eq, Builder)]
/// #[builder(vis = pub)]
/// struct Foo {
/// #[builder(default = 45)]
/// x: i32,
/// #[builder(into)]
/// y: String,
/// #[builder(optional)]
/// z: ()
/// }
///
/// # fn main() {
/// assert_eq!(
/// build!(Foo { x: 32, y: "baz" }),
/// Foo { x: 32, y: "baz".into(), z: () },
/// );
/// # }
/// ```
#[proc_macro]
pub fn build(input: TokenStream) -> TokenStream {
let structure = parse_macro_input!(input as ExprStruct);
let struct_name = &structure.path;
let field_names = structure.fields.iter().map(|field| &field.member);
let field_values = structure.fields.iter().map(|field| &field.expr);
quote! {
#struct_name
::builder()
#(.#field_names(#field_values))*
.build()
}
.into()
}
|
