Add support for generic bounds

Author: dflemstr

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

@@ -20,7 +20,7 @@ impl<'a> GenericSettersCtx<'a> {
         for (index, param) in generics.iter().enumerate() {
             match param {
                 syn::GenericParam::Type(type_param) => {
-                    methods.push(self.generic_setter_method(index, &type_param.ident));
+                    methods.push(self.generic_setter_method(index, type_param));
                 }
                 syn::GenericParam::Const(const_param) => {
                     bail!(
@@ -40,11 +40,16 @@ impl<'a> GenericSettersCtx<'a> {
         })
     }
 
-    fn generic_setter_method(&self, param_index: usize, param_ident: &syn::Ident) -> TokenStream {
+    fn generic_setter_method(
+        &self,
+        param_index: usize,
+        type_param: &syn::TypeParam,
+    ) -> TokenStream {
         let builder_ident = &self.base.builder_type.ident;
         let state_var = &self.base.state_var;
         let where_clause = &self.base.generics.where_clause;
 
+        let param_ident = &type_param.ident;
         let method_name = self.method_name(param_ident);
 
         let vis = self
@@ -59,6 +64,15 @@ impl<'a> GenericSettersCtx<'a> {
         // Build the generic arguments for the output type, where the current parameter
         // is replaced with a new type variable
         let new_type_var = self.base.namespace.unique_ident(param_ident.to_string());
+
+        // Copy the bounds from the original type parameter to the new one
+        let bounds = &type_param.bounds;
+        let new_type_param = if bounds.is_empty() {
+            quote!(#new_type_var)
+        } else {
+            quote!(#new_type_var: #bounds)
+        };
+
         let output_generic_args = self
             .base
             .generics
@@ -117,7 +131,7 @@ impl<'a> GenericSettersCtx<'a> {
         quote! {
             #(#docs)*
             #[inline(always)]
-            #vis fn #method_name<#new_type_var>(
+            #vis fn #method_name<#new_type_param>(
                 self
             ) -> #builder_ident<#(#output_generic_args,)* #state_var>
             #where_clause
@@ -204,6 +218,20 @@ fn type_uses_generic_param(ty: &syn::Type, param_ident: &syn::Ident) -> bool {
                 return;
             }
 
+            // For qualified paths like T::Assoc or <T as Trait>::Assoc,
+            // check if the first segment (or qself) uses the generic parameter
+
+            if let Some(qself) = &type_path.qself {
+                // For <T as Trait>::Assoc syntax
+                self.visit_type(&qself.ty);
+            } else if let Some(segment) = type_path.path.segments.first() {
+                // For T::Assoc syntax
+                if segment.ident == *self.param_ident {
+                    self.found = true;
+                    return;
+                }
+            }
+
             // Continue visiting the rest of the type path
             syn::visit::visit_type_path(self, type_path);
         }

bon/tests/integration/builder/generics_setters.rs

@@ -88,3 +88,83 @@ fn test_complex_syntax_with_docs() {
     let result = Sut::<()>::builder().conv_t::<u32>().value(42).build();
     assert_eq!(result.value, 42);
 }
+
+#[test]
+fn test_with_trait_bounds() {
+    trait MyTrait {
+        type Assoc;
+    }
+
+    impl MyTrait for () {
+        type Assoc = u32;
+    }
+
+    impl MyTrait for bool {
+        type Assoc = u64;
+    }
+
+    #[derive(Builder)]
+    #[builder(generics(setters(name = "conv_{}")))]
+    struct AssocTypeField<T: MyTrait> {
+        value: T::Assoc,
+    }
+
+    #[derive(Builder)]
+    #[builder(generics(setters(name = "conv_{}")))]
+    struct QualifiedPathField<T: MyTrait> {
+        value: <T as MyTrait>::Assoc,
+    }
+
+    let result1 = AssocTypeField::<()>::builder()
+        .conv_t::<bool>()
+        .value(42u64)
+        .build();
+    assert_eq!(result1.value, 42u64);
+
+    let result2 = QualifiedPathField::<()>::builder()
+        .conv_t::<bool>()
+        .value(99u64)
+        .build();
+    assert_eq!(result2.value, 99u64);
+}
+
+#[test]
+fn test_with_trait_bounds_false_friend() {
+    // The associated type is also called T, but should not be replaced by the generic <T>
+
+    trait MyTrait {
+        type T;
+    }
+
+    impl MyTrait for () {
+        type T = u32;
+    }
+
+    impl MyTrait for bool {
+        type T = u64;
+    }
+
+    #[derive(Builder)]
+    #[builder(generics(setters(name = "conv_{}")))]
+    struct AssocTypeField<T: MyTrait> {
+        value: T::T,
+    }
+
+    #[derive(Builder)]
+    #[builder(generics(setters(name = "conv_{}")))]
+    struct QualifiedPathField<T: MyTrait> {
+        value: <T as MyTrait>::T,
+    }
+
+    let result1 = AssocTypeField::<()>::builder()
+        .conv_t::<bool>()
+        .value(42u64)
+        .build();
+    assert_eq!(result1.value, 42u64);
+
+    let result2 = QualifiedPathField::<()>::builder()
+        .conv_t::<bool>()
+        .value(99u64)
+        .build();
+    assert_eq!(result2.value, 99u64);
+}

bon/tests/integration/ui/compile_fail/generics_setters.stderr

@@ -1,35 +1,3 @@
-error[E0277]: the trait bound `T_: MyTrait` is not satisfied
-  --> tests/integration/ui/compile_fail/generics_setters.rs:42:10
-   |
-42 | #[derive(Builder)]
-   |          ^^^^^^^ the trait `MyTrait` is not implemented for `T_`
-   |
-note: required by a bound in `AssocTypeFieldBuilder`
-  --> tests/integration/ui/compile_fail/generics_setters.rs:44:26
-   |
-42 | #[derive(Builder)]
-   |          ------- required by a bound in this struct
-43 | #[builder(generics(setters(name = "conv_{}")))]
-44 | struct AssocTypeField<T: MyTrait> {
-   |                          ^^^^^^^ required by this bound in `AssocTypeFieldBuilder`
-   = note: this error originates in the derive macro `Builder` (in Nightly builds, run with -Z macro-backtrace for more info)
-
-error[E0277]: the trait bound `T_: MyTrait` is not satisfied
-  --> tests/integration/ui/compile_fail/generics_setters.rs:48:10
-   |
-48 | #[derive(Builder)]
-   |          ^^^^^^^ the trait `MyTrait` is not implemented for `T_`
-   |
-note: required by a bound in `QualifiedPathFieldBuilder`
-  --> tests/integration/ui/compile_fail/generics_setters.rs:50:30
-   |
-48 | #[derive(Builder)]
-   |          ------- required by a bound in this struct
-49 | #[builder(generics(setters(name = "conv_{}")))]
-50 | struct QualifiedPathField<T: MyTrait> {
-   |                              ^^^^^^^ required by this bound in `QualifiedPathFieldBuilder`
-   = note: this error originates in the derive macro `Builder` (in Nightly builds, run with -Z macro-backtrace for more info)
-
 error[E0308]: mismatched types
   --> tests/integration/ui/compile_fail/generics_setters.rs:63:16
    |