Expose from_expr option when deriving FromMeta (#370)

* Add from_expr option for FromMeta

This rounds out the ability to make structs that accept custom short-forms without having to hand implement FromMeta.

Fixes #369

* Fix: Don't consider skipped variants for from_expr validation

Author: TedDriggs

CHANGELOG.md

@@ -4,6 +4,7 @@
 
 -  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`.
+-  Add `#[darling(from_expr = ...)]` when deriving `FromMeta` to support overriding the key-value form [#369](https://github.com/TedDriggs/darling/issues/369)
 
 
 ## v0.21.1 (August 4, 2025)

core/src/codegen/from_meta_impl.rs

@@ -12,6 +12,7 @@ pub struct FromMetaImpl<'a> {
     pub base: TraitImpl<'a>,
     pub from_word: Option<Cow<'a, Callable>>,
     pub from_none: Option<&'a Callable>,
+    pub from_expr: Option<&'a Callable>,
     pub derive_syn_parse: bool,
 }
 
@@ -35,6 +36,14 @@ impl ToTokens for FromMetaImpl<'_> {
             }
         });
 
+        let from_expr = self.from_expr.map(|body| {
+            quote_spanned! {body.span()=>
+                fn from_expr(expr: &::darling::export::syn::Expr) -> ::darling::Result<Self> {
+                    ::darling::export::identity::<fn(&::darling::export::syn::Expr) -> ::darling::Result<Self>>(#body)(expr)
+                }
+            }
+        });
+
         let impl_block = match base.data {
             // Unit structs allow empty bodies only.
             Data::Struct(ref vd) if vd.style.is_unit() => {
@@ -82,6 +91,8 @@ impl ToTokens for FromMetaImpl<'_> {
 
                     #from_none
 
+                    #from_expr
+
                     fn from_list(__items: &[::darling::export::NestedMeta]) -> ::darling::Result<Self> {
 
                         #decls
@@ -157,6 +168,8 @@ impl ToTokens for FromMetaImpl<'_> {
                     #from_word
 
                     #from_none
+
+                    #from_expr
                 )
             }
         };

core/src/options/from_meta.rs

@@ -17,6 +17,8 @@ pub struct FromMetaOptions {
     from_word: Option<Callable>,
     /// Override for the default [`FromMeta::from_none`] method.
     from_none: Option<Callable>,
+    /// Override for the default [`FromMeta::from_expr`] method.
+    from_expr: Option<Callable>,
     /// Whether or not to derive [`syn::parse::Parse`] in addition to deriving [`FromMeta`].
     derive_syn_parse: Option<bool>,
 }
@@ -27,6 +29,7 @@ impl FromMetaOptions {
             base: Core::start(di)?,
             from_word: None,
             from_none: None,
+            from_expr: None,
             derive_syn_parse: None,
         })
         .parse_attributes(&di.attrs)?
@@ -78,6 +81,12 @@ impl ParseAttribute for FromMetaOptions {
             }
 
             self.from_none = FromMeta::from_meta(mi).map(Some)?;
+        } else if path.is_ident("from_expr") {
+            if self.from_expr.is_some() {
+                return Err(Error::duplicate_field_path(path).with_span(path));
+            }
+
+            self.from_expr = FromMeta::from_meta(mi).map(Some)?;
         } else if path.is_ident("derive_syn_parse") {
             if self.derive_syn_parse.is_some() {
                 return Err(Error::duplicate_field_path(path).with_span(path));
@@ -113,6 +122,12 @@ impl ParseData for FromMetaOptions {
                         errors.push(Error::custom("`from_word` cannot be used on newtype structs because the implementation is entirely delegated to the inner type").with_span(from_word));
                     }
                 }
+
+                if let Some(from_expr) = &self.from_expr {
+                    if data.is_newtype() {
+                        errors.push(Error::custom("`from_expr` cannot be used on newtype structs because the implementation is entirely delegated to the inner type").with_span(from_expr));
+                    }
+                }
             }
             Data::Enum(ref data) => {
                 let word_variants: Vec<_> = data
@@ -140,6 +155,15 @@ impl ParseData for FromMetaOptions {
                         );
                     }
                 }
+
+                if let Some(from_expr) = &self.from_expr {
+                    if data.iter().any(|v| v.is_unit_variant() && !v.is_skipped()) {
+                        errors.push(
+                            Error::custom("`from_expr` cannot be used on enums with non-skipped unit variants because it conflicts with the generated impl")
+                                .with_span(from_expr),
+                        );
+                    }
+                }
             }
         }
     }
@@ -151,6 +175,7 @@ impl<'a> From<&'a FromMetaOptions> for FromMetaImpl<'a> {
             base: (&v.base).into(),
             from_word: v.from_word(),
             from_none: v.from_none.as_ref(),
+            from_expr: v.from_expr.as_ref(),
             derive_syn_parse: v.derive_syn_parse.unwrap_or_default(),
         }
     }

core/src/options/input_variant.rs

@@ -20,6 +20,14 @@ pub struct InputVariant {
 }
 
 impl InputVariant {
+    pub fn is_unit_variant(&self) -> bool {
+        self.data.is_unit()
+    }
+
+    pub fn is_skipped(&self) -> bool {
+        self.skip.unwrap_or_default()
+    }
+
     pub fn as_codegen_variant<'a>(&'a self, ty_ident: &'a syn::Ident) -> codegen::Variant<'a> {
         codegen::Variant {
             ty_ident,
@@ -29,7 +37,7 @@ impl InputVariant {
                 .as_deref()
                 .map_or_else(|| Cow::Owned(self.ident.to_string()), Cow::Borrowed),
             data: self.data.as_ref().map(InputField::as_codegen_field),
-            skip: self.skip.unwrap_or_default(),
+            skip: self.is_skipped(),
             allow_unknown_fields: self.allow_unknown_fields.unwrap_or_default(),
         }
     }

examples/from_word_and_expr.rs

@@ -0,0 +1,58 @@
+use darling::{ast::Data, util::Flag, FromDeriveInput, FromMeta};
+use darling_macro::FromField;
+
+#[derive(Default, FromMeta)]
+#[darling(from_word = || Ok(Default::default()), from_expr = |expr| Ok(ErrorPolicy::from(expr)))]
+struct ErrorPolicy {
+    warn: Flag,
+    value: Option<syn::Expr>,
+}
+
+impl From<&'_ syn::Expr> for ErrorPolicy {
+    fn from(expr: &'_ syn::Expr) -> Self {
+        ErrorPolicy {
+            warn: Flag::default(),
+            value: Some(expr.clone()),
+        }
+    }
+}
+
+#[derive(FromField)]
+#[darling(attributes(toml))]
+struct Field {
+    default: Option<ErrorPolicy>,
+    recover: Option<ErrorPolicy>,
+}
+
+#[derive(FromDeriveInput)]
+#[darling(attributes(toml))]
+struct TomlConfig {
+    data: Data<(), Field>,
+}
+
+fn main() {
+    let input = TomlConfig::from_derive_input(&syn::parse_quote! {
+        struct Config {
+            #[toml(default, recover(warn))]
+            field1: String,
+            #[toml(default = String::new())]
+            field2: String,
+        }
+    })
+    .unwrap();
+
+    assert!(input.data.is_struct());
+    let fields = input.data.take_struct().expect("input is struct").fields;
+    assert!(fields[0].default.is_some());
+    assert!(fields[0]
+        .recover
+        .as_ref()
+        .map(|r| r.warn.is_present())
+        .unwrap_or(false));
+    assert!(fields[1]
+        .default
+        .as_ref()
+        .map(|d| d.value.is_some())
+        .unwrap_or(false));
+    assert!(fields[1].recover.is_none());
+}

tests/compile-fail/from_expr.rs

@@ -0,0 +1,32 @@
+use darling::FromMeta;
+
+/// This usage of `from_expr` is VALID because there are no unit variants that should conflict with the
+/// implementation.
+#[derive(FromMeta)]
+#[darling(from_expr = |expr| Ok(HasNoUnits::Variant2 { other: format!("{:?}", expr) }))]
+enum HasNoUnits {
+    Variant1 { field: String },
+    Variant2 { other: String },
+}
+
+/// This usage of `from_expr` is invalid because unit variants already generate a from_expr
+/// method, and we don't allow using the from_expr override when it conflicts with the macro's
+/// "normal" operation.
+#[derive(FromMeta)]
+#[darling(from_expr = |expr| Ok(HasUnits::Variant2))]
+enum HasUnits {
+    Variant1 { field: String },
+    Variant2,
+}
+
+fn newtype_from_expr(_expr: &syn::Expr) -> darling::Result<Newtype> {
+    Ok(Newtype(true))
+}
+
+// This usage of `from_expr` is invalid because newtype structs call the inner type's `from_meta`
+// directly from their `from_meta`, so the custom `from_expr` will never be called in normal usage.
+#[derive(FromMeta)]
+#[darling(from_expr = newtype_from_expr)]
+struct Newtype(bool);
+
+fn main() {}

tests/compile-fail/from_expr.stderr

@@ -0,0 +1,11 @@
+error: `from_expr` cannot be used on enums with non-skipped unit variants because it conflicts with the generated impl
+  --> tests/compile-fail/from_expr.rs:16:23
+   |
+16 | #[darling(from_expr = |expr| Ok(HasUnits::Variant2))]
+   |                       ^
+
+error: `from_expr` cannot be used on newtype structs because the implementation is entirely delegated to the inner type
+  --> tests/compile-fail/from_expr.rs:29:23
+   |
+29 | #[darling(from_expr = newtype_from_expr)]
+   |                       ^^^^^^^^^^^^^^^^^