Auto format attributes on their own line

rustfmt.toml

@@ -0,0 +1 @@
+same_line_attributes = false

serde/src/private/ser.rs

@@ -61,7 +61,8 @@ enum Unsupported {
     Sequence,
     Tuple,
     TupleStruct,
-    #[cfg(not(any(feature = "std", feature = "alloc")))] Enum,
+    #[cfg(not(any(feature = "std", feature = "alloc")))]
+    Enum,
 }
 
 impl Display for Unsupported {

test_suite/tests/test_annotations.rs

@@ -84,10 +84,14 @@ where
     E: MyDefault,
 {
     a1: A,
-    #[serde(default)] a2: B,
+    #[serde(default)]
-    #[serde(default = "MyDefault::my_default")] a3: C,
+    a2: B,
-    #[serde(skip_deserializing)] a4: D,
+    #[serde(default = "MyDefault::my_default")]
-    #[serde(skip_deserializing, default = "MyDefault::my_default")] a5: E,
+    a3: C,
+    #[serde(skip_deserializing)]
+    a4: D,
+    #[serde(skip_deserializing, default = "MyDefault::my_default")]
+    a5: E,
 }
 
 #[test]
@@ -147,10 +151,14 @@ where
 {
     Struct {
         a1: A,
-        #[serde(default)] a2: B,
+        #[serde(default)]
-        #[serde(default = "MyDefault::my_default")] a3: C,
+        a2: B,
-        #[serde(skip_deserializing)] a4: D,
+        #[serde(default = "MyDefault::my_default")]
-        #[serde(skip_deserializing, default = "MyDefault::my_default")] a5: E,
+        a3: C,
+        #[serde(skip_deserializing)]
+        a4: D,
+        #[serde(skip_deserializing, default = "MyDefault::my_default")]
+        a5: E,
     },
 }
 
@@ -217,7 +225,8 @@ impl MyDefault for NoStdDefault {
 
 #[derive(Debug, PartialEq, Deserialize)]
 struct ContainsNoStdDefault<A: MyDefault> {
-    #[serde(default = "MyDefault::my_default")] a: A,
+    #[serde(default = "MyDefault::my_default")]
+    a: A,
 }
 
 // Tests that a struct field does not need to implement std::default::Default if
@@ -287,10 +296,14 @@ impl MyDefault for NotDeserializeEnum {
 
 #[derive(Debug, PartialEq, Deserialize)]
 struct ContainsNotDeserialize<A, B, C: DeserializeWith, E: MyDefault> {
-    #[serde(skip_deserializing)] a: A,
+    #[serde(skip_deserializing)]
-    #[serde(skip_deserializing, default)] b: B,
+    a: A,
-    #[serde(deserialize_with = "DeserializeWith::deserialize_with", default)] c: C,
+    #[serde(skip_deserializing, default)]
-    #[serde(skip_deserializing, default = "MyDefault::my_default")] e: E,
+    b: B,
+    #[serde(deserialize_with = "DeserializeWith::deserialize_with", default)]
+    c: C,
+    #[serde(skip_deserializing, default = "MyDefault::my_default")]
+    e: E,
 }
 
 // Tests that a struct field does not need to implement Deserialize if it is
@@ -373,14 +386,16 @@ fn test_ignore_unknown() {
 #[serde(rename = "Superhero")]
 struct RenameStruct {
     a1: i32,
-    #[serde(rename = "a3")] a2: i32,
+    #[serde(rename = "a3")]
+    a2: i32,
 }
 
 #[derive(Debug, PartialEq, Serialize, Deserialize)]
 #[serde(rename(serialize = "SuperheroSer", deserialize = "SuperheroDe"))]
 struct RenameStructSerializeDeserialize {
     a1: i32,
-    #[serde(rename(serialize = "a4", deserialize = "a5"))] a2: i32,
+    #[serde(rename(serialize = "a4", deserialize = "a5"))]
+    a2: i32,
 }
 
 #[test]
@@ -434,10 +449,17 @@ fn test_rename_struct() {
 #[derive(Debug, PartialEq, Serialize, Deserialize)]
 #[serde(rename = "Superhero")]
 enum RenameEnum {
-    #[serde(rename = "bruce_wayne")] Batman,
+    #[serde(rename = "bruce_wayne")]
-    #[serde(rename = "clark_kent")] Superman(i8),
+    Batman,
-    #[serde(rename = "diana_prince")] WonderWoman(i8, i8),
+    #[serde(rename = "clark_kent")]
-    #[serde(rename = "barry_allan")] Flash { #[serde(rename = "b")] a: i32 },
+    Superman(i8),
+    #[serde(rename = "diana_prince")]
+    WonderWoman(i8, i8),
+    #[serde(rename = "barry_allan")]
+    Flash {
+        #[serde(rename = "b")]
+        a: i32,
+    },
 }
 
 #[derive(Debug, PartialEq, Deserialize, Serialize)]
@@ -548,8 +570,10 @@ where
     C: ShouldSkip,
 {
     a: &'a i8,
-    #[serde(skip_serializing)] b: B,
+    #[serde(skip_serializing)]
-    #[serde(skip_serializing_if = "ShouldSkip::should_skip")] c: C,
+    b: B,
+    #[serde(skip_serializing_if = "ShouldSkip::should_skip")]
+    c: C,
 }
 
 #[test]
@@ -591,7 +615,8 @@ fn test_skip_serializing_struct() {
 #[derive(Debug, PartialEq, Serialize, Deserialize)]
 struct SkipStruct<B> {
     a: i8,
-    #[serde(skip)] b: B,
+    #[serde(skip)]
+    b: B,
 }
 
 #[test]
@@ -630,8 +655,10 @@ where
 {
     Struct {
         a: &'a i8,
-        #[serde(skip_serializing)] _b: B,
+        #[serde(skip_serializing)]
-        #[serde(skip_serializing_if = "ShouldSkip::should_skip")] c: C,
+        _b: B,
+        #[serde(skip_serializing_if = "ShouldSkip::should_skip")]
+        c: C,
     },
 }
 
@@ -697,9 +724,12 @@ where
     D: SerializeWith,
 {
     a: &'a Option<i8>,
-    #[serde(skip_serializing)] b: &'a B,
+    #[serde(skip_serializing)]
-    #[serde(skip_serializing)] c: Option<C>,
+    b: &'a B,
-    #[serde(serialize_with = "SerializeWith::serialize_with")] d: D,
+    #[serde(skip_serializing)]
+    c: Option<C>,
+    #[serde(serialize_with = "SerializeWith::serialize_with")]
+    d: D,
 }
 
 #[test]
@@ -733,7 +763,8 @@ where
     B: SerializeWith,
 {
     a: &'a i8,
-    #[serde(serialize_with = "SerializeWith::serialize_with")] b: B,
+    #[serde(serialize_with = "SerializeWith::serialize_with")]
+    b: B,
 }
 
 #[test]
@@ -777,7 +808,8 @@ where
 {
     Struct {
         a: &'a i8,
-        #[serde(serialize_with = "SerializeWith::serialize_with")] b: B,
+        #[serde(serialize_with = "SerializeWith::serialize_with")]
+        b: B,
     },
 }
 
@@ -993,7 +1025,8 @@ where
     B: DeserializeWith,
 {
     a: i8,
-    #[serde(deserialize_with = "DeserializeWith::deserialize_with")] b: B,
+    #[serde(deserialize_with = "DeserializeWith::deserialize_with")]
+    b: B,
 }
 
 #[test]
@@ -1036,7 +1069,8 @@ where
 {
     Struct {
         a: i8,
-        #[serde(deserialize_with = "DeserializeWith::deserialize_with")] b: B,
+        #[serde(deserialize_with = "DeserializeWith::deserialize_with")]
+        b: B,
     },
 }
 
@@ -1136,7 +1170,12 @@ fn test_missing_renamed_field_enum() {
 #[derive(Debug, PartialEq, Deserialize)]
 enum InvalidLengthEnum {
     A(i32, i32, i32),
-    B(#[serde(skip_deserializing)] i32, i32, i32),
+    B(
+        #[serde(skip_deserializing)]
+        i32,
+        i32,
+        i32,
+    ),
 }
 
 #[test]

test_suite/tests/test_borrow.rs

@@ -110,7 +110,8 @@ fn test_cow() {
     struct Cows<'a, 'b> {
         copied: Cow<'a, str>,
 
-        #[serde(borrow)] borrowed: Cow<'b, str>,
+        #[serde(borrow)]
+        borrowed: Cow<'b, str>,
     }
 
     let tokens = &[
@@ -145,7 +146,8 @@ fn test_lifetimes() {
     struct Cows<'a, 'b> {
         _copied: Cow<'a, str>,
 
-        #[serde(borrow)] _borrowed: Cow<'b, str>,
+        #[serde(borrow)]
+        _borrowed: Cow<'b, str>,
     }
 
     // Tests that `'de: 'a` is not required by the Deserialize impl.
@@ -158,7 +160,8 @@ fn test_lifetimes() {
 
     #[derive(Deserialize)]
     struct Wrap<'a, 'b> {
-        #[serde(borrow = "'b")] _cows: Cows<'a, 'b>,
+        #[serde(borrow = "'b")]
+        _cows: Cows<'a, 'b>,
     }
 
     // Tests that `'de: 'a` is not required by the Deserialize impl.

test_suite/tests/test_de.rs

@@ -49,14 +49,16 @@ struct TupleStruct(i32, i32, i32);
 struct Struct {
     a: i32,
     b: i32,
-    #[serde(skip_deserializing)] c: i32,
+    #[serde(skip_deserializing)]
+    c: i32,
 }
 
 #[derive(PartialEq, Debug, Deserialize)]
 #[serde(deny_unknown_fields)]
 struct StructDenyUnknown {
     a: i32,
-    #[serde(skip_deserializing)] b: i32,
+    #[serde(skip_deserializing)]
+    b: i32,
 }
 
 #[derive(PartialEq, Debug, Deserialize)]
@@ -77,19 +79,22 @@ impl Default for StructDefault<String> {
 
 #[derive(PartialEq, Debug, Deserialize)]
 struct StructSkipAll {
-    #[serde(skip_deserializing)] a: i32,
+    #[serde(skip_deserializing)]
+    a: i32,
 }
 
 #[derive(PartialEq, Debug, Deserialize)]
 #[serde(default)]
 struct StructSkipDefault {
-    #[serde(skip_deserializing)] a: i32,
+    #[serde(skip_deserializing)]
+    a: i32,
 }
 
 #[derive(PartialEq, Debug, Deserialize)]
 #[serde(default)]
 struct StructSkipDefaultGeneric<T> {
-    #[serde(skip_deserializing)] t: T,
+    #[serde(skip_deserializing)]
+    t: T,
 }
 
 impl Default for StructSkipDefault {
@@ -101,7 +106,8 @@ impl Default for StructSkipDefault {
 #[derive(PartialEq, Debug, Deserialize)]
 #[serde(deny_unknown_fields)]
 struct StructSkipAllDenyUnknown {
-    #[serde(skip_deserializing)] a: i32,
+    #[serde(skip_deserializing)]
+    a: i32,
 }
 
 #[derive(PartialEq, Debug, Deserialize)]

test_suite/tests/test_gen.rs

@@ -46,21 +46,25 @@ fn test_gen() {
     #[derive(Serialize, Deserialize)]
     struct With<T> {
         t: T,
-        #[serde(serialize_with = "ser_x", deserialize_with = "de_x")] x: X,
+        #[serde(serialize_with = "ser_x", deserialize_with = "de_x")]
+        x: X,
     }
     assert::<With<i32>>();
 
     #[derive(Serialize, Deserialize)]
     struct WithTogether<T> {
         t: T,
-        #[serde(with = "both_x")] x: X,
+        #[serde(with = "both_x")]
+        x: X,
     }
     assert::<WithTogether<i32>>();
 
     #[derive(Serialize, Deserialize)]
     struct WithRef<'a, T: 'a> {
-        #[serde(skip_deserializing)] t: StdOption<&'a T>,
+        #[serde(skip_deserializing)]
-        #[serde(serialize_with = "ser_x", deserialize_with = "de_x")] x: X,
+        t: StdOption<&'a T>,
+        #[serde(serialize_with = "ser_x", deserialize_with = "de_x")]
+        x: X,
     }
     assert::<WithRef<i32>>();
 
@@ -88,14 +92,19 @@ fn test_gen() {
     #[derive(Serialize, Deserialize)]
     enum EnumWith<T> {
         Unit,
-        Newtype(#[serde(serialize_with = "ser_x", deserialize_with = "de_x")] X),
+        Newtype(
+            #[serde(serialize_with = "ser_x", deserialize_with = "de_x")]
+            X,
+        ),
         Tuple(
             T,
-            #[serde(serialize_with = "ser_x", deserialize_with = "de_x")] X,
+            #[serde(serialize_with = "ser_x", deserialize_with = "de_x")]
+            X,
         ),
         Struct {
             t: T,
-            #[serde(serialize_with = "ser_x", deserialize_with = "de_x")] x: X,
+            #[serde(serialize_with = "ser_x", deserialize_with = "de_x")]
+            x: X,
         },
     }
     assert::<EnumWith<i32>>();
@@ -113,13 +122,17 @@ fn test_gen() {
     assert_ser::<MultipleRef<i32>>();
 
     #[derive(Serialize, Deserialize)]
-    struct Newtype(#[serde(serialize_with = "ser_x", deserialize_with = "de_x")] X);
+    struct Newtype(
+        #[serde(serialize_with = "ser_x", deserialize_with = "de_x")]
+        X,
+    );
     assert::<Newtype>();
 
     #[derive(Serialize, Deserialize)]
     struct Tuple<T>(
         T,
-        #[serde(serialize_with = "ser_x", deserialize_with = "de_x")] X,
+        #[serde(serialize_with = "ser_x", deserialize_with = "de_x")]
+        X,
     );
     assert::<Tuple<i32>>();
 
@@ -236,13 +249,15 @@ fn test_gen() {
 
     #[derive(Serialize, Deserialize)]
     struct BracedSkipAll {
-        #[serde(skip_deserializing)] f: u8,
+        #[serde(skip_deserializing)]
+        f: u8,
     }
 
     #[derive(Serialize, Deserialize)]
     #[serde(deny_unknown_fields)]
     struct BracedSkipAllDenyUnknown {
-        #[serde(skip_deserializing)] f: u8,
+        #[serde(skip_deserializing)]
+        f: u8,
     }
 
     #[cfg(feature = "unstable")]
@@ -255,11 +270,17 @@ fn test_gen() {
     struct EmptyTupleDenyUnknown();
 
     #[derive(Serialize, Deserialize)]
-    struct TupleSkipAll(#[serde(skip_deserializing)] u8);
+    struct TupleSkipAll(
+        #[serde(skip_deserializing)]
+        u8,
+    );
 
     #[derive(Serialize, Deserialize)]
     #[serde(deny_unknown_fields)]
-    struct TupleSkipAllDenyUnknown(#[serde(skip_deserializing)] u8);
+    struct TupleSkipAllDenyUnknown(
+        #[serde(skip_deserializing)]
+        u8,
+    );
 
     #[derive(Serialize, Deserialize)]
     enum EmptyEnum {}
@@ -280,8 +301,14 @@ fn test_gen() {
     enum EmptyVariants {
         Braced {},
         Tuple(),
-        BracedSkip { #[serde(skip_deserializing)] f: u8 },
+        BracedSkip {
-        TupleSkip(#[serde(skip_deserializing)] u8),
+            #[serde(skip_deserializing)]
+            f: u8,
+        },
+        TupleSkip(
+            #[serde(skip_deserializing)]
+            u8,
+        ),
     }
 
     #[cfg(feature = "unstable")]
@@ -290,8 +317,14 @@ fn test_gen() {
     enum EmptyVariantsDenyUnknown {
         Braced {},
         Tuple(),
-        BracedSkip { #[serde(skip_deserializing)] f: u8 },
+        BracedSkip {
-        TupleSkip(#[serde(skip_deserializing)] u8),
+            #[serde(skip_deserializing)]
+            f: u8,
+        },
+        TupleSkip(
+            #[serde(skip_deserializing)]
+            u8,
+        ),
     }
 
     #[derive(Serialize, Deserialize)]
@@ -311,8 +344,10 @@ fn test_gen() {
     #[derive(Serialize, Deserialize)]
     #[serde(untagged, remote = "Or")]
     enum OrDef<A, B> {
-        #[allow(dead_code)] A(A),
+        #[allow(dead_code)]
-        #[allow(dead_code)] B(B),
+        A(A),
+        #[allow(dead_code)]
+        B(B),
     }
 
     struct Str<'a>(&'a str);
@@ -323,13 +358,16 @@ fn test_gen() {
 
     #[derive(Serialize, Deserialize)]
     struct Remote<'a> {
-        #[serde(with = "OrDef")] or: Or<u8, bool>,
+        #[serde(with = "OrDef")]
-        #[serde(borrow, with = "StrDef")] s: Str<'a>,
+        or: Or<u8, bool>,
+        #[serde(borrow, with = "StrDef")]
+        s: Str<'a>,
     }
 
     #[derive(Serialize, Deserialize)]
     enum BorrowVariant<'a> {
-        #[serde(borrow, with = "StrDef")] S(Str<'a>),
+        #[serde(borrow, with = "StrDef")]
+        S(Str<'a>),
     }
 
     mod vis {
@@ -343,14 +381,14 @@ fn test_gen() {
     // This would not work if SDef::serialize / deserialize are private.
     #[derive(Serialize, Deserialize)]
     struct RemoteVisibility {
-        #[serde(with = "vis::SDef")] s: vis::S,
+        #[serde(with = "vis::SDef")]
+        s: vis::S,
     }
 
     #[derive(Serialize, Deserialize)]
     enum ExternallyTaggedVariantWith {
-        #[allow(dead_code)] Normal {
+        #[allow(dead_code)]
-            f1: String,
+        Normal { f1: String },
-        },
 
         #[serde(serialize_with = "ser_x")]
         #[serde(deserialize_with = "de_x")]
@@ -365,10 +403,7 @@ fn test_gen() {
         #[serde(serialize_with = "serialize_some_other_variant")]
         #[serde(deserialize_with = "deserialize_some_other_variant")]
         #[allow(dead_code)]
-        Struct {
+        Struct { f1: String, f2: u8 },
-            f1: String,
-            f2: u8,
-        },
 
         #[serde(serialize_with = "serialize_some_unit_variant")]
         #[serde(deserialize_with = "deserialize_some_unit_variant")]
@@ -380,9 +415,8 @@ fn test_gen() {
     #[derive(Serialize, Deserialize)]
     #[serde(tag = "t")]
     enum InternallyTaggedVariantWith {
-        #[allow(dead_code)] Normal {
+        #[allow(dead_code)]
-            f1: String,
+        Normal { f1: String },
-        },
 
         #[serde(serialize_with = "ser_x")]
         #[serde(deserialize_with = "de_x")]
@@ -392,10 +426,7 @@ fn test_gen() {
         #[serde(serialize_with = "serialize_some_other_variant")]
         #[serde(deserialize_with = "deserialize_some_other_variant")]
         #[allow(dead_code)]
-        Struct {
+        Struct { f1: String, f2: u8 },
-            f1: String,
-            f2: u8,
-        },
 
         #[serde(serialize_with = "serialize_some_unit_variant")]
         #[serde(deserialize_with = "deserialize_some_unit_variant")]
@@ -407,9 +438,8 @@ fn test_gen() {
     #[derive(Serialize, Deserialize)]
     #[serde(tag = "t", content = "c")]
     enum AdjacentlyTaggedVariantWith {
-        #[allow(dead_code)] Normal {
+        #[allow(dead_code)]
-            f1: String,
+        Normal { f1: String },
-        },
 
         #[serde(serialize_with = "ser_x")]
         #[serde(deserialize_with = "de_x")]
@@ -424,10 +454,7 @@ fn test_gen() {
         #[serde(serialize_with = "serialize_some_other_variant")]
         #[serde(deserialize_with = "deserialize_some_other_variant")]
         #[allow(dead_code)]
-        Struct {
+        Struct { f1: String, f2: u8 },
-            f1: String,
-            f2: u8,
-        },
 
         #[serde(serialize_with = "serialize_some_unit_variant")]
         #[serde(deserialize_with = "deserialize_some_unit_variant")]
@@ -439,9 +466,8 @@ fn test_gen() {
     #[derive(Serialize, Deserialize)]
     #[serde(untagged)]
     enum UntaggedVariantWith {
-        #[allow(dead_code)] Normal {
+        #[allow(dead_code)]
-            f1: String,
+        Normal { f1: String },
-        },
 
         #[serde(serialize_with = "ser_x")]
         #[serde(deserialize_with = "de_x")]
@@ -456,10 +482,7 @@ fn test_gen() {
         #[serde(serialize_with = "serialize_some_other_variant")]
         #[serde(deserialize_with = "deserialize_some_other_variant")]
         #[allow(dead_code)]
-        Struct {
+        Struct { f1: String, f2: u8 },
-            f1: String,
-            f2: u8,
-        },
 
         #[serde(serialize_with = "serialize_some_unit_variant")]
         #[serde(deserialize_with = "deserialize_some_unit_variant")]
@@ -489,7 +512,8 @@ fn test_gen() {
 
     #[derive(Serialize, Deserialize)]
     struct SkippedStaticStr {
-        #[serde(skip_deserializing)] skipped: &'static str,
+        #[serde(skip_deserializing)]
+        skipped: &'static str,
         other: isize,
     }
     assert::<SkippedStaticStr>();

test_suite/tests/test_identifier.rs

@@ -49,7 +49,8 @@ fn test_unit_fallthrough() {
     enum F {
         Aaa,
         Bbb,
-        #[serde(other)] Other,
+        #[serde(other)]
+        Other,
     }
 
     assert_de_tokens(&F::Other, &[Token::Str("x")]);

test_suite/tests/test_remote.rs

@@ -85,23 +85,32 @@ mod remote {
 
 #[derive(Serialize, Deserialize)]
 struct Test {
-    #[serde(with = "UnitDef")] unit: remote::Unit,
+    #[serde(with = "UnitDef")]
+    unit: remote::Unit,
 
-    #[serde(with = "PrimitivePrivDef")] primitive_priv: remote::PrimitivePriv,
+    #[serde(with = "PrimitivePrivDef")]
+    primitive_priv: remote::PrimitivePriv,
 
-    #[serde(with = "PrimitivePubDef")] primitive_pub: remote::PrimitivePub,
+    #[serde(with = "PrimitivePubDef")]
+    primitive_pub: remote::PrimitivePub,
 
-    #[serde(with = "NewtypePrivDef")] newtype_priv: remote::NewtypePriv,
+    #[serde(with = "NewtypePrivDef")]
+    newtype_priv: remote::NewtypePriv,
 
-    #[serde(with = "NewtypePubDef")] newtype_pub: remote::NewtypePub,
+    #[serde(with = "NewtypePubDef")]
+    newtype_pub: remote::NewtypePub,
 
-    #[serde(with = "TuplePrivDef")] tuple_priv: remote::TuplePriv,
+    #[serde(with = "TuplePrivDef")]
+    tuple_priv: remote::TuplePriv,
 
-    #[serde(with = "TuplePubDef")] tuple_pub: remote::TuplePub,
+    #[serde(with = "TuplePubDef")]
+    tuple_pub: remote::TuplePub,
 
-    #[serde(with = "StructPrivDef")] struct_priv: remote::StructPriv,
+    #[serde(with = "StructPrivDef")]
+    struct_priv: remote::StructPriv,
 
-    #[serde(with = "StructPubDef")] struct_pub: remote::StructPub,
+    #[serde(with = "StructPubDef")]
+    struct_pub: remote::StructPub,
 }
 
 #[derive(Serialize, Deserialize)]
@@ -110,7 +119,10 @@ struct UnitDef;
 
 #[derive(Serialize, Deserialize)]
 #[serde(remote = "remote::PrimitivePriv")]
-struct PrimitivePrivDef(#[serde(getter = "remote::PrimitivePriv::get")] u8);
+struct PrimitivePrivDef(
+    #[serde(getter = "remote::PrimitivePriv::get")]
+    u8,
+);
 
 #[derive(Serialize, Deserialize)]
 #[serde(remote = "remote::PrimitivePub")]
@@ -118,27 +130,40 @@ struct PrimitivePubDef(u8);
 
 #[derive(Serialize, Deserialize)]
 #[serde(remote = "remote::NewtypePriv")]
-struct NewtypePrivDef(#[serde(getter = "remote::NewtypePriv::get", with = "UnitDef")] remote::Unit);
+struct NewtypePrivDef(
+    #[serde(getter = "remote::NewtypePriv::get", with = "UnitDef")]
+    remote::Unit,
+);
 
 #[derive(Serialize, Deserialize)]
 #[serde(remote = "remote::NewtypePub")]
-struct NewtypePubDef(#[serde(with = "UnitDef")] remote::Unit);
+struct NewtypePubDef(
+    #[serde(with = "UnitDef")]
+    remote::Unit,
+);
 
 #[derive(Serialize, Deserialize)]
 #[serde(remote = "remote::TuplePriv")]
 struct TuplePrivDef(
-    #[serde(getter = "remote::TuplePriv::first")] u8,
+    #[serde(getter = "remote::TuplePriv::first")]
-    #[serde(getter = "remote::TuplePriv::second", with = "UnitDef")] remote::Unit,
+    u8,
+    #[serde(getter = "remote::TuplePriv::second", with = "UnitDef")]
+    remote::Unit,
 );
 
 #[derive(Serialize, Deserialize)]
 #[serde(remote = "remote::TuplePub")]
-struct TuplePubDef(u8, #[serde(with = "UnitDef")] remote::Unit);
+struct TuplePubDef(
+    u8,
+    #[serde(with = "UnitDef")]
+    remote::Unit,
+);
 
 #[derive(Serialize, Deserialize)]
 #[serde(remote = "remote::StructPriv")]
 struct StructPrivDef {
-    #[serde(getter = "remote::StructPriv::a")] a: u8,
+    #[serde(getter = "remote::StructPriv::a")]
+    a: u8,
 
     #[serde(getter = "remote::StructPriv::b")]
     #[serde(with = "UnitDef")]
@@ -148,7 +173,8 @@ struct StructPrivDef {
 #[derive(Serialize, Deserialize)]
 #[serde(remote = "remote::StructPub")]
 struct StructPubDef {
-    #[allow(dead_code)] a: u8,
+    #[allow(dead_code)]
+    a: u8,
 
     #[allow(dead_code)]
     #[serde(with = "UnitDef")]

test_suite/tests/test_ser.rs

@@ -50,11 +50,21 @@ enum Enum {
     Unit,
     One(i32),
     Seq(i32, i32),
-    Map { a: i32, b: i32 },
+    Map {
-    #[serde(skip_serializing)] SkippedUnit,
+        a: i32,
-    #[serde(skip_serializing)] SkippedOne(i32),
+        b: i32,
-    #[serde(skip_serializing)] SkippedSeq(i32, i32),
+    },
-    #[serde(skip_serializing)] SkippedMap { _a: i32, _b: i32 },
+    #[serde(skip_serializing)]
+    SkippedUnit,
+    #[serde(skip_serializing)]
+    SkippedOne(i32),
+    #[serde(skip_serializing)]
+    SkippedSeq(i32, i32),
+    #[serde(skip_serializing)]
+    SkippedMap {
+        _a: i32,
+        _b: i32,
+    },
 }
 
 //////////////////////////////////////////////////////////////////////////