Honor parse_err_ty attribute when the enum has a default variant (#431)

scovich · web-flow · commit 0ccbbf823c16 · 2026-02-21T12:25:01.000-08:00
* Honor parse_err_ty attribute when the enum has a default variant

* fix confusing variable name
diff --git a/strum_macros/src/lib.rs b/strum_macros/src/lib.rs
@@ -58,11 +58,15 @@ fn debug_print_generated(ast: &DeriveInput, toks: &TokenStream) {
 /// can be very fast for enums with a surprisingly large number of enum variants.
 ///
 /// The default error type is `strum::ParseError`. This can be overriden by applying both the
-/// `parse_err_ty` and `parse_err_fn` attributes at the type level.  `parse_error_fn` should be a
-/// function that accepts an `&str` and returns the type `parse_error_ty`. See
-/// [this test case](https://github.com/Peternator7/strum/blob/9db3c4dc9b6f585aeb9f5f15f9cc18b6cf4fd780/strum_tests/tests/from_str.rs#L233)
+/// `parse_err_ty` and `parse_err_fn` attributes at the type level.  `parse_err_fn` should be a
+/// function that accepts an `&str` and returns the type `parse_err_ty`. See [this test
+/// case](https://github.com/Peternator7/strum/blob/9db3c4dc9b6f585aeb9f5f15f9cc18b6cf4fd780/strum_tests/tests/from_str.rs#L233)
 /// for an example.
 ///
+/// If the enum has a default variant (annotated with `#[strum(default)]`), then parsing is
+/// infallible. In that case, `parse_err_fn` need not exist (it will never be called) and
+/// `parse_err_ty` can be safely set to [`std::convert::Infallible`].
+///
 /// # Example how to use `EnumString`
 /// ```
 /// use std::str::FromStr;
diff --git a/strum_macros/src/macros/strings/from_string.rs b/strum_macros/src/macros/strings/from_string.rs
@@ -19,7 +19,7 @@ pub fn from_string_inner(ast: &DeriveInput) -> syn::Result<TokenStream> {
     let strum_module_path = type_properties.crate_module_path();
 
     let mut default_kw = None;
-    let (mut default_err_ty, mut default) = match (
+    let (default_err_ty, mut default_match_arm) = match (
         type_properties.parse_err_ty,
         type_properties.parse_err_fn,
     ) {
@@ -54,17 +54,16 @@ pub fn from_string_inner(ast: &DeriveInput) -> syn::Result<TokenStream> {
             }
 
             default_kw = Some(kw);
-            default_err_ty = quote! { #strum_module_path::ParseError };
 
             match &variant.fields {
                 Fields::Unnamed(fields) if fields.unnamed.len() == 1 => {
-                    default = quote! {
+                    default_match_arm = quote! {
                         ::core::result::Result::Ok(#name::#ident(s.into()))
                     };
                 }
                 Fields::Named(ref f) if f.named.len() == 1 => {
                     let field_name = f.named.last().unwrap().ident.as_ref().unwrap();
-                    default = quote! {
+                    default_match_arm = quote! {
                         ::core::result::Result::Ok(#name::#ident { #field_name : s.into() } )
                     };
                 }
@@ -159,12 +158,12 @@ pub fn from_string_inner(ast: &DeriveInput) -> syn::Result<TokenStream> {
     };
 
     let standard_match_body = if standard_match_arms.is_empty() {
-        default
+        default_match_arm
     } else {
         quote! {
             ::core::result::Result::Ok(match s {
                 #(#standard_match_arms)*
-                _ => return #default,
+                _ => return #default_match_arm,
             })
         }
     };
diff --git a/strum_tests/tests/from_str.rs b/strum_tests/tests/from_str.rs
@@ -274,3 +274,29 @@ fn case_custom_parse_error() {
         r.unwrap_err()
     );
 }
+
+#[derive(Debug, EnumString, Eq, PartialEq)]
+#[strum(
+    parse_err_fn = not_needed_parsing_is_infallible,
+    parse_err_ty = std::convert::Infallible
+)]
+enum CaseCustomInfallibleParsingWithDefaultEnum {
+    #[strum(serialize = "foo")]
+    Foo,
+    #[strum(serialize = "bar")]
+    Bar,
+    #[strum(default)]
+    Unknown(String),
+}
+
+#[test]
+fn case_custom_infallible_parsing_with_default() {
+    let r = match "yellow".parse::<CaseCustomInfallibleParsingWithDefaultEnum>() {
+        Ok(r) => r,
+        Err(never) => match never {},
+    };
+    assert_eq!(
+        CaseCustomInfallibleParsingWithDefaultEnum::Unknown("yellow".to_string()),
+        r
+    );
+}
