Adding support for build_from and build_from_clone builder methods.

bon-macros/Cargo.toml

@@ -66,6 +66,8 @@ default = []
 # See the docs on this feature in the `bon`'s crate `Cargo.toml`
 experimental-overwritable = []
 
+experimental-build-from = []
+
 # See the docs on this feature in the `bon`'s crate `Cargo.toml`
 implied-bounds = []
 

bon-macros/src/builder/builder_gen/build_from.rs

@@ -0,0 +1,158 @@
+use crate::builder::builder_gen::{BuilderGenCtx, member::Member};
+use crate::util::prelude::*;
+use proc_macro2::{Ident, Span};
+use quote::quote;
+use syn::{Type, spanned::Spanned};
+
+pub(super) fn emit(ctx: &BuilderGenCtx, target_ty: &Type) -> Result<TokenStream> {
+    let mut tokens = TokenStream::new();
+    let ctor_args: Vec<_> = ctx
+        .members
+        .iter()
+        .map(|m| {
+            let ident = m.orig_ident();
+            quote! { #ident }
+        })
+        .collect();
+
+    let base_name = ctx.finish_fn.ident.clone();
+
+    if ctx.build_from {
+        tokens.extend(emit_build_from_method(
+            false,
+            &base_name,
+            target_ty,
+            &ctx.members,
+            &ctor_args,
+        ));
+    }
+
+    if ctx.build_from_clone {
+        tokens.extend(emit_build_from_method(
+            true,
+            &base_name,
+            target_ty,
+            &ctx.members,
+            &ctor_args,
+        )?);
+    }
+
+    Ok(tokens)
+}
+
+fn emit_build_from_method(
+    clone: bool,
+    base_name: &Ident,
+    target_ty: &Type,
+    members: &[Member],
+    ctor_args: &[TokenStream],
+) -> Result<TokenStream> {
+    let doc = if clone {
+        "Fills unset builder fields from an owned value of the target type and builds it."
+    } else {
+        "Fills unset builder fields from a reference to the target type and builds it."
+    };
+
+    let method_name = if clone {
+        format_ident!("{}_from_clone", base_name)
+    } else {
+        format_ident!("{}_from", base_name)
+    };
+
+    let arg_type = if clone {
+        quote!(&#target_ty)
+    } else {
+        quote!(#target_ty)
+    };
+
+    let arg_pat = if clone {
+        quote!(mut from)
+    } else {
+        quote!(from)
+    };
+
+    let ctor_path = extract_ctor_ident_path(target_ty, target_ty.span())?;
+    let field_vars = field_vars_from_members(members, clone);
+
+    Ok(quote! {
+        #[inline(always)]
+        #[doc = #doc]
+        pub fn #method_name(self, #arg_pat: #arg_type) -> #target_ty {
+            #( #field_vars )*
+            #ctor_path {
+                #( #ctor_args, )*
+            }
+        }
+    })
+}
+
+fn field_vars_from_members(members: &[Member], clone: bool) -> Vec<TokenStream> {
+    members
+        .iter()
+        .map(|member| {
+            let ident = member.orig_ident();
+            let ty = member.norm_ty();
+            let default_expr = quote! { ::core::default::Default::default() };
+
+            match member {
+                Member::Field(_) | Member::StartFn(_) => quote! {
+                    let #ident: #ty = self.#ident;
+                },
+                Member::Named(member) => {
+                    let index = &member.index;
+                    if clone {
+                        quote! {
+                            let #ident: #ty = match self.__unsafe_private_named.#index {
+                                Some(value) => value,
+                                None => from.#ident.clone(),
+                            };
+                        }
+                    } else {
+                        quote! {
+                            let #ident: #ty = match self.__unsafe_private_named.#index {
+                                Some(value) => value,
+                                None => from.#ident,
+                            };
+                        }
+                    }
+                }
+                Member::FinishFn(_) => {
+                    if clone {
+                        quote! {
+                            let #ident: #ty = from.#ident.clone();
+                        }
+                    } else {
+                        quote! {
+                            let #ident: #ty = from.#ident;
+                        }
+                    }
+                }
+                Member::Skip(_) => quote! {
+                    let #ident: #ty = #default_expr;
+                },
+            }
+        })
+        .collect()
+}
+
+pub(crate) fn extract_ctor_ident_path(ty: &Type, span: Span) -> Result<TokenStream> {
+    use quote::quote_spanned;
+
+    let path = ty.as_path_no_qself().ok_or_else(|| {
+        err!(
+            &span,
+            "expected a concrete type path (like `MyStruct`) for constructor"
+        )
+    })?;
+
+    let mut ident = path
+        .segments
+        .last()
+        .ok_or_else(|| err!(&span, "expected a named type, but found an empty path"))?
+        .ident
+        .clone();
+
+    ident.set_span(span);
+
+    Ok(quote! { #ident })
+}

bon-macros/src/builder/builder_gen/input_fn/mod.rs

@@ -412,6 +412,10 @@
             state_mod: self.config.state_mod,
             start_fn: self.start_fn,
             finish_fn,
+            #[cfg(feature = "experimental-build-from")]
+            build_from: self.config.build_from,
+            #[cfg(feature = "experimental-build-from")]
+            build_from_clone: self.config.build_from_clone,
         })
     }
 }

bon-macros/src/builder/builder_gen/input_struct.rs

@@ -238,6 +238,10 @@
             state_mod: self.config.state_mod,
             start_fn,
             finish_fn,
+            #[cfg(feature = "experimental-build-from")]
+            build_from: self.config.build_from,
+            #[cfg(feature = "experimental-build-from")]
+            build_from_clone: self.config.build_from_clone,
         })
     }
 }

bon-macros/src/builder/builder_gen/member/config/mod.rs

@@ -61,6 +61,9 @@ pub(crate) struct MemberConfig {
     /// this option to see if it's worth it.
     pub(crate) overwritable: darling::util::Flag,
 
+    /// Allows the use of `build_from` and `build_from_clone` methods.
+    pub(crate) build_from: darling::util::Flag,
+
     /// Disables the special handling for a member of type `Option<T>`. The
     /// member no longer has the default of `None`. It also becomes a required
     /// member unless a separate `#[builder(default = ...)]` attribute is
@@ -98,6 +101,7 @@ enum ParamName {
     Into,
     Name,
     Overwritable,
+    BuildFrom,
     Required,
     Setters,
     Skip,
@@ -115,6 +119,7 @@ impl fmt::Display for ParamName {
             Self::Into => "into",
             Self::Name => "name",
             Self::Overwritable => "overwritable",
+            Self::BuildFrom => "build_from",
             Self::Required => "required",
             Self::Setters => "setters",
             Self::Skip => "skip",
@@ -180,6 +185,7 @@ impl MemberConfig {
             into,
             name,
             overwritable,
+            build_from,
             required,
             setters,
             skip,
@@ -195,6 +201,7 @@ impl MemberConfig {
             (into.is_present(), ParamName::Into),
             (name.is_some(), ParamName::Name),
             (overwritable.is_present(), ParamName::Overwritable),
+            (build_from.is_present(), ParamName::BuildFrom),
             (required.is_present(), ParamName::Required),
             (setters.is_some(), ParamName::Setters),
             (skip.is_some(), ParamName::Skip),
@@ -227,6 +234,14 @@ impl MemberConfig {
             );
         }
 
+        if !cfg!(feature = "experimental-build-from") && self.build_from.is_present() {
+            bail!(
+                &self.build_from.span(),
+                "🔬 `build_from` attribute is experimental and requires \
+                 \"experimental-build-from\" cargo feature to be enabled.",
+            );
+        }
+
         if let Some(getter) = &self.getter {
             self.validate_mutually_exclusive(
                 ParamName::Getter,

bon-macros/src/builder/builder_gen/mod.rs

@@ -1,3 +1,6 @@
+#[cfg(feature = "experimental-build-from")]
+mod build_from;
+
 mod builder_decl;
 mod builder_derives;
 mod finish_fn;
@@ -134,6 +137,21 @@ impl BuilderGenCtx {
 
         let allows = allow_warnings_on_member_types();
 
+        let build_froms = {
+            #[cfg(feature = "experimental-build-from")]
+            {
+                match &self.finish_fn.output {
+                    syn::ReturnType::Type(_, ty) => build_from::emit(self, ty)?,
+                    syn::ReturnType::Default => quote! {},
+                }
+            }
+
+            #[cfg(not(feature = "experimental-build-from"))]
+            {
+                quote! {}
+            }
+        };
+
         Ok(quote! {
             #allows
             #[automatically_derived]
@@ -145,6 +163,7 @@ impl BuilderGenCtx {
             #where_clause
             {
                 #finish_fn
+                #build_froms
                 #(#accessor_methods)*
             }
         })

bon-macros/src/builder/builder_gen/models.rs

@@ -173,6 +173,10 @@ pub(crate) struct BuilderGenCtx {
     pub(super) state_mod: StateMod,
     pub(super) start_fn: StartFn,
     pub(super) finish_fn: FinishFn,
+    #[cfg(feature = "experimental-build-from")]
+    pub(super) build_from: bool,
+    #[cfg(feature = "experimental-build-from")]
+    pub(super) build_from_clone: bool,
 }
 
 pub(super) struct BuilderGenCtxParams<'a> {
@@ -201,6 +205,10 @@ pub(super) struct BuilderGenCtxParams<'a> {
     pub(super) state_mod: ItemSigConfig,
     pub(super) start_fn: StartFnParams,
     pub(super) finish_fn: FinishFnParams,
+    #[cfg(feature = "experimental-build-from")]
+    pub(super) build_from: bool,
+    #[cfg(feature = "experimental-build-from")]
+    pub(super) build_from_clone: bool,
 }
 
 impl BuilderGenCtx {
@@ -219,7 +227,12 @@ impl BuilderGenCtx {
             state_mod,
             start_fn,
             finish_fn,
+            ..
         } = params;
+        #[cfg(feature = "experimental-build-from")]
+        let build_from = params.build_from;
+        #[cfg(feature = "experimental-build-from")]
+        let build_from_clone = params.build_from_clone;
 
         let builder_type = BuilderType {
             ident: builder_type.ident,
@@ -370,6 +383,10 @@ impl BuilderGenCtx {
             state_mod,
             start_fn,
             finish_fn,
+            #[cfg(feature = "experimental-build-from")]
+            build_from,
+            #[cfg(feature = "experimental-build-from")]
+            build_from_clone,
         })
     }
 }

bon-macros/src/builder/builder_gen/top_level_config/mod.rs

@@ -1,14 +1,14 @@
 mod on;
 
 pub(crate) use on::OnConfig;
 
 use crate::parsing::{BonCratePath, ItemSigConfig, ItemSigConfigParsing, SpannedKey};
 use crate::util::prelude::*;
-use darling::ast::NestedMeta;
 use darling::FromMeta;
+use darling::ast::NestedMeta;
+use syn::ItemFn;
 use syn::parse::Parser;
 use syn::punctuated::Punctuated;
-use syn::ItemFn;
 
 fn parse_finish_fn(meta: &syn::Meta) -> Result<ItemSigConfig> {
     ItemSigConfigParsing {
@@ -42,6 +42,24 @@
     .parse()
 }
 
+#[cfg(feature = "experimental-build-from")]
+fn parse_build_from(meta: &syn::Meta) -> Result<ItemSigConfig> {
+    ItemSigConfigParsing {
+        meta,
+        reject_self_mentions: Some("builder struct's impl block"),
+    }
+    .parse()
+}
+
+#[cfg(feature = "experimental-build-from")]
+fn parse_build_from_clone(meta: &syn::Meta) -> Result<ItemSigConfig> {
+    ItemSigConfigParsing {
+        meta,
+        reject_self_mentions: Some("builder struct's impl block"),
+    }
+    .parse()
+}
+
 #[derive(Debug, FromMeta)]
 pub(crate) struct TopLevelConfig {
     /// Specifies whether the generated functions should be `const`.
@@ -75,6 +93,14 @@
     /// Specifies the derives to apply to the builder.
     #[darling(default, with = crate::parsing::parse_non_empty_paren_meta_list)]
     pub(crate) derive: DerivesConfig,
+
+    #[cfg(feature = "experimental-build-from")]
+    #[darling(default, with = parse_build_from)]
+    pub(crate) build_from: ItemSigConfig,
+
+    #[cfg(feature = "experimental-build-from")]
+    #[darling(default, with = parse_build_from_clone)]
+    pub(crate) build_from_clone: ItemSigConfig,
 }
 
 impl TopLevelConfig {