Enable #[darling(with = ...)] for generics field

Author: TedDriggs

CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## Unreleased
+
+-  Keep parsing the body and type params even if there are errors from parsing attributes. [#7](https://github.com/TedDriggs/darling/issues/325)
+-  Support `#[darling(with = ...)]` on the `generics` field when deriving `FromDeriveInput`.
+
+
 ## v0.21.1 (August 4, 2025)
 
 -  Track all alternate field names, and show them in error message if there aren't too many. [#325](https://github.com/TedDriggs/darling/issues/325)

core/src/codegen/from_derive_impl.rs

@@ -13,7 +13,7 @@ use super::ForwardAttrs;
 
 pub struct FromDeriveInputImpl<'a> {
     pub ident: Option<&'a Ident>,
-    pub generics: Option<&'a Ident>,
+    pub generics: Option<&'a ForwardedField>,
     pub vis: Option<&'a Ident>,
     pub data: Option<&'a ForwardedField>,
     pub base: TraitImpl<'a>,
@@ -53,17 +53,17 @@ impl ToTokens for FromDeriveInputImpl<'_> {
         let passed_vis = self.vis.as_ref().map(|i| quote!(#i: #input.vis.clone(),));
         let passed_attrs = self.forward_attrs.as_initializer();
 
-        let read_generics = self.generics.map(|_| {
+        let read_generics = self.generics.map(|generics| {
+            let ident = &generics.ident;
+            let with = generics.with.as_ref().map(|p| quote!(#p)).unwrap_or_else(
+                || quote_spanned!(ident.span()=>::darling::FromGenerics::from_generics),
+            );
             quote! {
-                let __generics = __errors.handle(::darling::FromGenerics::from_generics(&#input.generics));
+                let #ident = __errors.handle(#with(&#input.generics));
             }
         });
 
-        let pass_generics_to_receiver = self.generics.map(|generics| {
-            quote! {
-                #generics: __generics.expect("Parsing succeeded"),
-            }
-        });
+        let pass_generics_to_receiver = self.generics.map(|g| g.as_initializer());
 
         let check_shape = self
             .supports
@@ -80,17 +80,20 @@ impl ToTokens for FromDeriveInputImpl<'_> {
             .unwrap_or_else(|| quote!(::darling::export::Ok));
 
         let supports = self.supports;
-        let validate_and_read_data = quote! {
-            #supports
-            let __data = __errors.handle(#check_shape(&#input.data).and_then(#read_data));
-        };
-
-        let pass_data_to_receiver = self.data.map(|data| {
-            let data_ident = &data.ident;
+        let validate_and_read_data = {
+            // If the caller wants `data` read into a field, we can use `data` as the local variable name
+            // because we know there are no other fields of that name.
+            let let_binding = self.data.map(|d| {
+                let ident = &d.ident;
+                quote!(let #ident = )
+            });
             quote! {
-                #data_ident: __data.expect("Data parsed successfully"),
+                #supports
+                #let_binding __errors.handle(#check_shape(&#input.data).and_then(#read_data));
             }
-        });
+        };
+
+        let pass_data_to_receiver = self.data.map(|f| f.as_initializer());
 
         let inits = self.base.initializers();
         let default = if self.from_ident {

core/src/options/from_derive.rs

@@ -16,7 +16,7 @@ pub struct FdiOptions {
     pub vis: Option<Ident>,
 
     /// The field on the target struct which should receive the type generics, if any.
-    pub generics: Option<Ident>,
+    pub generics: Option<ForwardedField>,
 
     /// The field on the target struct which should receive the derive input body, if any.
     pub data: Option<ForwardedField>,
@@ -65,7 +65,7 @@ impl ParseData for FdiOptions {
                 Ok(())
             }
             Some("generics") => {
-                self.generics.clone_from(&field.ident);
+                self.generics = ForwardedField::from_field(field).map(Some)?;
                 Ok(())
             }
             _ => self.base.parse_field(field),

tests/generics_with.rs

@@ -0,0 +1,77 @@
+use std::collections::BTreeSet;
+
+use darling::{Error, FromDeriveInput, Result};
+use syn::{parse_quote, Ident};
+
+fn check_ident(ident: &Ident) -> Result<String> {
+    let s = ident.to_string();
+    if s.len() < 2 {
+        Err(Error::custom("generics must be at least 2 characters").with_span(ident))
+    } else {
+        Ok(s)
+    }
+}
+
+fn long_generic_names(generics: &syn::Generics) -> Result<BTreeSet<String>> {
+    let mut errors = Error::accumulator();
+    let valid = generics
+        .type_params()
+        .filter_map(|c| errors.handle(check_ident(&c.ident)))
+        .collect();
+    errors.finish_with(valid)
+}
+
+#[derive(Debug, FromDeriveInput)]
+#[darling(attributes(a))]
+struct Receiver {
+    #[darling(with = long_generic_names)]
+    generics: BTreeSet<String>,
+    surname: String,
+}
+
+#[test]
+fn succeeds_on_no_generics() {
+    let di = Receiver::from_derive_input(&parse_quote! {
+        #[a(surname = "Smith")]
+        struct Demo;
+    })
+    .unwrap();
+
+    assert!(di.generics.is_empty());
+}
+
+#[test]
+fn succeeds_on_valid_generics() {
+    let di = Receiver::from_derive_input(&parse_quote! {
+        #[a(surname = "Smith")]
+        struct Demo<Greeting> {
+            hello: Greeting,
+            world: String,
+        }
+    })
+    .unwrap();
+
+    assert_eq!(di.generics.len(), 1);
+    assert!(di.generics.contains("Greeting"));
+    assert_eq!(di.surname, "Smith");
+}
+
+#[test]
+fn rejects_invalid_input() {
+    let err = Receiver::from_derive_input(&parse_quote! {
+        struct Demo<G, S> {
+            hello: G,
+            world: S,
+        }
+    })
+    .unwrap_err();
+
+    assert_eq!(
+        err.len(),
+        // 2 errors from short type param names
+        2 +
+        // error for missing field `surname`
+        1,
+        "errors should have accumulated, and body checking should have occurred"
+    );
+}