Allow using enum-level attributes for non-Display formatting traits as default (#495, #142)

## Synopsis

Allow using enum level attributes for non-`Display` formatting traits as default.

This behavior was already [documented](https://docs.rs/derive_more/latest/derive_more/derive.Display.html#shared-enum-format), but did not compile yet due to a too eager validation.

## Solution

Remove overly zealous validation of input.

```rust
#[derive(LowerHex)]
#[lower_hex("default")]
enum Enum {
   UsesDefault, // will format as `default`
   #[lower_hex("custom")]
   Custom, // will format as `custom`
}
```

Author: ModProg

CHANGELOG.md

@@ -60,6 +60,9 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 - Dependency on unstable `feature(error_generic_member_access)` in `Error` derive when
   using `Backtrace` on a non-nightly toolchain.
   ([#513](https://github.com/JelteF/derive_more/pull/513))
+- Broken support for `#[<display-trait>("default formatting")]` attribute without `{_variant}`
+  being used as default for enum variants without explicit formatting.
+  ([#495](https://github.com/JelteF/derive_more/pull/495))
 
 ## 2.0.1 - 2025-02-03
 

impl/src/fmt/display.rs

@@ -260,15 +260,27 @@ fn expand_enum(
 
             if attrs.common.fmt.is_none()
                 && variant.fields.is_empty()
-                && attr_name != "display"
-            {
-                return Err(syn::Error::new(
-                    e.variants.span(),
-                    format!(
-                        "implicit formatting of unit enum variant is supported only for `Display` \
-                         macro, use `#[{attr_name}(\"...\")]` to explicitly specify the formatting",
-                    ),
-                ));
+                && attr_name != "display" {
+                let container_fmt = container_attrs.common.fmt.as_ref();
+                if container_fmt.is_none() {
+                    return Err(syn::Error::new(
+                        e.variants.span(),
+                        format!(
+                            "implicit formatting of unit enum variant is supported only for \
+                             `Display` macro, use `#[{attr_name}(\"...\")]` to explicitly specify \
+                             the formatting on every variant or the enum",
+                        ),
+                    ));
+                } else if container_fmt.is_some_and(|fmt| fmt.contains_arg("_variant")) {
+                    return Err(syn::Error::new_spanned(
+                        variant,
+                        format!(
+                            "implicit formatting of unit enum variant is supported only for \
+                             `Display` macro, use `#[{attr_name}(\"...\")]` to explicitly specify \
+                             the formatting on every variant when using `{{_variant}}`",
+                        ),
+                    ));
+                }
             }
 
             if let Some(rename_all) = container_attrs.rename_all {

tests/compile_fail/display/non_display_implicit_enum_unit_variant.rs

@@ -3,4 +3,10 @@ enum Enum {
     UnitVariant,
 }
 
+#[derive(derive_more::Display, derive_more::UpperHex)]
+#[upper_hex("default with {_variant}")]
+enum EnumWithVariantInFmt {
+    UnitVariant,
+}
+
 fn main() {}

tests/compile_fail/display/non_display_implicit_enum_unit_variant.stderr

@@ -1,5 +1,11 @@
-error: implicit formatting of unit enum variant is supported only for `Display` macro, use `#[upper_hex("...")]` to explicitly specify the formatting
+error: implicit formatting of unit enum variant is supported only for `Display` macro, use `#[upper_hex("...")]` to explicitly specify the formatting on every variant or the enum
  --> tests/compile_fail/display/non_display_implicit_enum_unit_variant.rs:3:5
   |
 3 |     UnitVariant,
   |     ^^^^^^^^^^^
+
+error: implicit formatting of unit enum variant is supported only for `Display` macro, use `#[upper_hex("...")]` to explicitly specify the formatting on every variant when using `{_variant}`
+ --> tests/compile_fail/display/non_display_implicit_enum_unit_variant.rs:9:5
+  |
+9 |     UnitVariant,
+  |     ^^^^^^^^^^^

tests/display.rs

@@ -992,6 +992,54 @@ mod enums {
                 }
             }
         }
+
+        mod default {
+            use super::*;
+
+            #[derive(
+                Binary, Display, LowerExp, LowerHex, Octal, Pointer, UpperExp, UpperHex
+            )]
+            #[binary("Binary")]
+            #[display("Display")]
+            #[lower_exp("LowerExp")]
+            #[lower_hex("LowerHex")]
+            #[octal("Octal")]
+            #[pointer("Pointer")]
+            #[upper_exp("UpperExp")]
+            #[upper_hex("UpperHex")]
+            enum Unit {
+                A,
+                #[binary("Binary Custom")]
+                #[display("Display Custom")]
+                #[lower_exp("LowerExp Custom")]
+                #[lower_hex("LowerHex Custom")]
+                #[octal("Octal Custom")]
+                #[pointer("Pointer Custom")]
+                #[upper_exp("UpperExp Custom")]
+                #[upper_hex("UpperHex Custom")]
+                B,
+            }
+
+            #[test]
+            fn assert() {
+                assert_eq!(format!("{:b}", Unit::A), "Binary");
+                assert_eq!(format!("{:b}", Unit::B), "Binary Custom");
+                assert_eq!(Unit::A.to_string(), "Display");
+                assert_eq!(Unit::B.to_string(), "Display Custom");
+                assert_eq!(format!("{:e}", Unit::A), "LowerExp");
+                assert_eq!(format!("{:e}", Unit::B), "LowerExp Custom");
+                assert_eq!(format!("{:x}", Unit::A), "LowerHex");
+                assert_eq!(format!("{:x}", Unit::B), "LowerHex Custom");
+                assert_eq!(format!("{:o}", Unit::A), "Octal");
+                assert_eq!(format!("{:o}", Unit::B), "Octal Custom");
+                assert_eq!(format!("{:p}", Unit::A), "Pointer");
+                assert_eq!(format!("{:p}", Unit::B), "Pointer Custom");
+                assert_eq!(format!("{:E}", Unit::A), "UpperExp");
+                assert_eq!(format!("{:E}", Unit::B), "UpperExp Custom");
+                assert_eq!(format!("{:X}", Unit::A), "UpperHex");
+                assert_eq!(format!("{:X}", Unit::B), "UpperHex Custom");
+            }
+        }
     }
 
     mod single_field_variant {