Defer expansion of fmt shorthand

This will make it possible to distinguish between our expansion
heuristic for tuple vs struct variants, as well as local fields vs
statics.

impl/src/ast.rs

@@ -52,8 +52,12 @@ impl<'a> Input<'a> {
 
 impl<'a> Struct<'a> {
     fn from_syn(node: &'a DeriveInput, data: &'a DataStruct) -> Result<Self> {
+        let mut attrs = attr::get(&node.attrs)?;
+        if let Some(display) = &mut attrs.display {
+            display.expand_shorthand();
+        }
         Ok(Struct {
-            attrs: attr::get(&node.attrs)?,
+            attrs,
             ident: node.ident.clone(),
             generics: &node.generics,
             fields: Field::multiple_from_syn(&data.fields)?,
@@ -72,6 +76,9 @@ impl<'a> Enum<'a> {
                 if let display @ None = &mut variant.attrs.display {
                     *display = attrs.display.clone();
                 }
+                if let Some(display) = &mut variant.attrs.display {
+                    display.expand_shorthand();
+                }
                 Ok(variant)
             })
             .collect::<Result<_>>()?;

impl/src/attr.rs

@@ -70,15 +70,13 @@ pub fn get(input: &[Attribute]) -> Result<Attrs> {
 
 fn parse_display(attr: &Attribute) -> Result<Display> {
     attr.parse_args_with(|input: ParseStream| {
-        let mut display = Display {
+        Ok(Display {
             original: attr,
             fmt: input.parse()?,
             args: parse_token_expr(input, false)?,
             was_shorthand: false,
             has_bonus_display: false,
-        };
+        })
-        display.expand_shorthand();
-        Ok(display)
     })
 }