Work around test suite dead code warnings in nightly-2024-07-07

    warning: struct `Cows` is never constructed
       --> test_suite/tests/test_borrow.rs:165:12
        |
    165 |     struct Cows<'a, 'b> {
        |            ^^^^

    warning: struct `Wrap` is never constructed
       --> test_suite/tests/test_borrow.rs:181:12
        |
    181 |     struct Wrap<'a, 'b> {
        |            ^^^^

    warning: struct `StructSkipDefaultGeneric` is never constructed
      --> test_suite/tests/test_de.rs:96:8
       |
    96 | struct StructSkipDefaultGeneric<T> {
       |        ^^^^^^^^^^^^^^^^^^^^^^^^

    warning: struct `NonAsciiIdents` is never constructed
       --> test_suite/tests/test_gen.rs:290:12
        |
    290 |     struct NonAsciiIdents {
        |            ^^^^^^^^^^^^^^
        |
    note: the lint level is defined here
       --> test_suite/tests/test_gen.rs:5:9
        |
    5   | #![deny(warnings)]
        |         ^^^^^^^^
        = note: `#[warn(dead_code)]` implied by `#[warn(warnings)]`

    warning: struct `EmptyBraced` is never constructed
       --> test_suite/tests/test_gen.rs:295:12
        |
    295 |     struct EmptyBraced {}
        |            ^^^^^^^^^^^

    warning: struct `EmptyBracedDenyUnknown` is never constructed
       --> test_suite/tests/test_gen.rs:299:12
        |
    299 |     struct EmptyBracedDenyUnknown {}
        |            ^^^^^^^^^^^^^^^^^^^^^^

    warning: struct `BracedSkipAll` is never constructed
       --> test_suite/tests/test_gen.rs:302:12
        |
    302 |     struct BracedSkipAll {
        |            ^^^^^^^^^^^^^

    warning: struct `BracedSkipAllDenyUnknown` is never constructed
       --> test_suite/tests/test_gen.rs:309:12
        |
    309 |     struct BracedSkipAllDenyUnknown {
        |            ^^^^^^^^^^^^^^^^^^^^^^^^

    warning: struct `EmptyTuple` is never constructed
       --> test_suite/tests/test_gen.rs:315:12
        |
    315 |     struct EmptyTuple();
        |            ^^^^^^^^^^

    warning: struct `EmptyTupleDenyUnknown` is never constructed
       --> test_suite/tests/test_gen.rs:319:12
        |
    319 |     struct EmptyTupleDenyUnknown();
        |            ^^^^^^^^^^^^^^^^^^^^^

    warning: struct `TupleSkipAll` is never constructed
       --> test_suite/tests/test_gen.rs:322:12
        |
    322 |     struct TupleSkipAll(#[serde(skip_deserializing)] u8);
        |            ^^^^^^^^^^^^

    warning: struct `TupleSkipAllDenyUnknown` is never constructed
       --> test_suite/tests/test_gen.rs:326:12
        |
    326 |     struct TupleSkipAllDenyUnknown(#[serde(skip_deserializing)] u8);
        |            ^^^^^^^^^^^^^^^^^^^^^^^

    warning: enum `EmptyEnum` is never used
       --> test_suite/tests/test_gen.rs:329:10
        |
    329 |     enum EmptyEnum {}
        |          ^^^^^^^^^

    warning: enum `EmptyEnumDenyUnknown` is never used
       --> test_suite/tests/test_gen.rs:333:10
        |
    333 |     enum EmptyEnumDenyUnknown {}
        |          ^^^^^^^^^^^^^^^^^^^^

    warning: enum `EnumSkipAll` is never used
       --> test_suite/tests/test_gen.rs:336:10
        |
    336 |     enum EnumSkipAll {
        |          ^^^^^^^^^^^

    warning: enum `EmptyVariants` is never used
       --> test_suite/tests/test_gen.rs:343:10
        |
    343 |     enum EmptyVariants {
        |          ^^^^^^^^^^^^^

    warning: enum `EmptyVariantsDenyUnknown` is never used
       --> test_suite/tests/test_gen.rs:355:10
        |
    355 |     enum EmptyVariantsDenyUnknown {
        |          ^^^^^^^^^^^^^^^^^^^^^^^^

    warning: struct `UnitDenyUnknown` is never constructed
       --> test_suite/tests/test_gen.rs:367:12
        |
    367 |     struct UnitDenyUnknown;
        |            ^^^^^^^^^^^^^^^

    warning: struct `EmptyArray` is never constructed
       --> test_suite/tests/test_gen.rs:370:12
        |
    370 |     struct EmptyArray {
        |            ^^^^^^^^^^

    warning: enum `Or` is never used
       --> test_suite/tests/test_gen.rs:374:10
        |
    374 |     enum Or<A, B> {
        |          ^^

    warning: enum `OrDef` is never used
       --> test_suite/tests/test_gen.rs:381:10
        |
    381 |     enum OrDef<A, B> {
        |          ^^^^^

    warning: struct `Str` is never constructed
       --> test_suite/tests/test_gen.rs:386:12
        |
    386 |     struct Str<'a>(&'a str);
        |            ^^^

    warning: struct `StrDef` is never constructed
       --> test_suite/tests/test_gen.rs:390:12
        |
    390 |     struct StrDef<'a>(&'a str);
        |            ^^^^^^

    warning: struct `Remote` is never constructed
       --> test_suite/tests/test_gen.rs:393:12
        |
    393 |     struct Remote<'a> {
        |            ^^^^^^

    warning: enum `BorrowVariant` is never used
       --> test_suite/tests/test_gen.rs:401:10
        |
    401 |     enum BorrowVariant<'a> {
        |          ^^^^^^^^^^^^^

    warning: struct `RemoteVisibility` is never constructed
       --> test_suite/tests/test_gen.rs:418:12
        |
    418 |     struct RemoteVisibility {
        |            ^^^^^^^^^^^^^^^^

    warning: struct `FlattenDenyUnknown` is never constructed
       --> test_suite/tests/test_gen.rs:551:12
        |
    551 |     struct FlattenDenyUnknown<T> {
        |            ^^^^^^^^^^^^^^^^^^

    warning: struct `StaticStrStruct` is never constructed
       --> test_suite/tests/test_gen.rs:557:12
        |
    557 |     struct StaticStrStruct<'a> {
        |            ^^^^^^^^^^^^^^^

    warning: struct `StaticStrTupleStruct` is never constructed
       --> test_suite/tests/test_gen.rs:563:12
        |
    563 |     struct StaticStrTupleStruct<'a>(&'a str, &'static str);
        |            ^^^^^^^^^^^^^^^^^^^^

    warning: struct `StaticStrNewtypeStruct` is never constructed
       --> test_suite/tests/test_gen.rs:566:12
        |
    566 |     struct StaticStrNewtypeStruct(&'static str);
        |            ^^^^^^^^^^^^^^^^^^^^^^

    warning: enum `StaticStrEnum` is never used
       --> test_suite/tests/test_gen.rs:569:10
        |
    569 |     enum StaticStrEnum<'a> {
        |          ^^^^^^^^^^^^^

    warning: enum `AdjacentlyTaggedVoid` is never used
       --> test_suite/tests/test_gen.rs:652:10
        |
    652 |     enum AdjacentlyTaggedVoid {}
        |          ^^^^^^^^^^^^^^^^^^^^

    warning: struct `ImplicitlyBorrowedOption` is never constructed
       --> test_suite/tests/test_gen.rs:665:12
        |
    665 |     struct ImplicitlyBorrowedOption<'a> {
        |            ^^^^^^^^^^^^^^^^^^^^^^^^

    warning: enum `UntaggedNewtypeVariantWith` is never used
       --> test_suite/tests/test_gen.rs:672:10
        |
    672 |     enum UntaggedNewtypeVariantWith {
        |          ^^^^^^^^^^^^^^^^^^^^^^^^^^

    warning: struct `TransparentWith` is never constructed
       --> test_suite/tests/test_gen.rs:682:12
        |
    682 |     struct TransparentWith {
        |            ^^^^^^^^^^^^^^^

    warning: struct `FlattenSkipSerializing` is never constructed
       --> test_suite/tests/test_gen.rs:712:12
        |
    712 |     struct FlattenSkipSerializing<T> {
        |            ^^^^^^^^^^^^^^^^^^^^^^

    warning: struct `FlattenSkipSerializingIf` is never constructed
       --> test_suite/tests/test_gen.rs:719:12
        |
    719 |     struct FlattenSkipSerializingIf<T> {
        |            ^^^^^^^^^^^^^^^^^^^^^^^^

    warning: struct `FlattenSkipDeserializing` is never constructed
       --> test_suite/tests/test_gen.rs:725:12
        |
    725 |     struct FlattenSkipDeserializing<T> {
        |            ^^^^^^^^^^^^^^^^^^^^^^^^

    warning: enum `Message` is never used
       --> test_suite/tests/test_gen.rs:732:10
        |
    732 |     enum Message {
        |          ^^^^^^^

    warning: struct `MacroRules` is never constructed
       --> test_suite/tests/test_gen.rs:751:20
        |
    751 |             struct MacroRules<'a> {
        |                    ^^^^^^^^^^
    ...
    758 |     deriving!(&'a str);
        |     ------------------ in this macro invocation
        |
        = note: this warning originates in the macro `deriving` (in Nightly builds, run with -Z macro-backtrace for more info)

    warning: struct `BorrowLifetimeInsideMacro` is never constructed
       --> test_suite/tests/test_gen.rs:767:12
        |
    767 |     struct BorrowLifetimeInsideMacro<'a> {
        |            ^^^^^^^^^^^^^^^^^^^^^^^^^

    warning: struct `GenericUnitStruct` is never constructed
       --> test_suite/tests/test_gen.rs:782:12
        |
    782 |     struct GenericUnitStruct<const N: usize>;
        |            ^^^^^^^^^^^^^^^^^

    warning: enum `InternallyTagged` is never used
       --> test_suite/tests/test_gen.rs:869:6
        |
    869 | enum InternallyTagged {
        |      ^^^^^^^^^^^^^^^^

    warning: function `deserialize_generic` is never used
       --> test_suite/tests/test_gen.rs:880:4
        |
    880 | fn deserialize_generic<'de, T, D>(deserializer: D) -> StdResult<T, D::Error>
        |    ^^^^^^^^^^^^^^^^^^^

    warning: struct `Restricted` is never constructed
       --> test_suite/tests/test_gen.rs:643:20
        |
    643 |             struct Restricted {
        |                    ^^^^^^^^^^

    warning: struct `Test` is never constructed
      --> test_suite/tests/test_remote.rs:95:8
       |
    95 | struct Test {
       |        ^^^^

    warning: struct `UnitDef` is never constructed
       --> test_suite/tests/test_remote.rs:135:8
        |
    135 | struct UnitDef;
        |        ^^^^^^^

    warning: struct `PrimitivePubDef` is never constructed
       --> test_suite/tests/test_remote.rs:143:8
        |
    143 | struct PrimitivePubDef(u8);
        |        ^^^^^^^^^^^^^^^

    warning: struct `NewtypePubDef` is never constructed
       --> test_suite/tests/test_remote.rs:151:8
        |
    151 | struct NewtypePubDef(#[serde(with = "UnitDef")] remote::Unit);
        |        ^^^^^^^^^^^^^

    warning: struct `TuplePubDef` is never constructed
       --> test_suite/tests/test_remote.rs:162:8
        |
    162 | struct TuplePubDef(u8, #[serde(with = "UnitDef")] remote::Unit);
        |        ^^^^^^^^^^^

    warning: struct `StructPubDef` is never constructed
       --> test_suite/tests/test_remote.rs:177:8
        |
    177 | struct StructPubDef {
        |        ^^^^^^^^^^^^

    warning: struct `StructConcrete` is never constructed
       --> test_suite/tests/test_remote.rs:193:8
        |
    193 | struct StructConcrete {
        |        ^^^^^^^^^^^^^^

    warning: enum `EnumConcrete` is never used
       --> test_suite/tests/test_remote.rs:199:6
        |
    199 | enum EnumConcrete {
        |      ^^^^^^^^^^^^

    warning: enum `ErrorKind` is never used
       --> test_suite/tests/test_remote.rs:204:6
        |
    204 | enum ErrorKind {
        |      ^^^^^^^^^

    warning: enum `ErrorKindDef` is never used
       --> test_suite/tests/test_remote.rs:214:6
        |
    214 | enum ErrorKindDef {
        |      ^^^^^^^^^^^^

    warning: struct `PrimitivePub` is never constructed
      --> test_suite/tests/test_remote.rs:10:16
       |
    10 |     pub struct PrimitivePub(pub u8);
       |                ^^^^^^^^^^^^

    warning: struct `NewtypePub` is never constructed
      --> test_suite/tests/test_remote.rs:14:16
       |
    14 |     pub struct NewtypePub(pub Unit);
       |                ^^^^^^^^^^

    warning: struct `TuplePub` is never constructed
      --> test_suite/tests/test_remote.rs:18:16
       |
    18 |     pub struct TuplePub(pub u8, pub Unit);
       |                ^^^^^^^^

    warning: struct `StructPub` is never constructed
      --> test_suite/tests/test_remote.rs:25:16
       |
    25 |     pub struct StructPub {
       |                ^^^^^^^^^

    warning: enum `EnumGeneric` is never used
      --> test_suite/tests/test_remote.rs:89:14
       |
    89 |     pub enum EnumGeneric<T> {
       |              ^^^^^^^^^^^

    warning: struct `Tuple` is never constructed
      --> test_suite/tests/test_self.rs:44:12
       |
    44 |     struct Tuple(
       |            ^^^^^

    warning: associated items `ASSOC` and `assoc` are never used
      --> test_suite/tests/test_self.rs:52:15
       |
    51 |     impl Tuple {
       |     ---------- associated items in this implementation
    52 |         const ASSOC: usize = 1;
       |               ^^^^^
    53 |         const fn assoc() -> usize {
       |                  ^^^^^

    warning: enum `Enum` is never used
      --> test_suite/tests/test_self.rs:63:10
       |
    63 |     enum Enum {
       |          ^^^^

    warning: associated items `ASSOC` and `assoc` are never used
      --> test_suite/tests/test_self.rs:79:15
       |
    78 |     impl Enum {
       |     --------- associated items in this implementation
    79 |         const ASSOC: usize = 1;
       |               ^^^^^
    80 |         const fn assoc() -> usize {
       |                  ^^^^^

    warning: struct `Unit` is never constructed
      --> test_suite/no_std/src/main.rs:26:8
       |
    26 | struct Unit;
       |        ^^^^

    warning: struct `Newtype` is never constructed
      --> test_suite/no_std/src/main.rs:29:8
       |
    29 | struct Newtype(u8);
       |        ^^^^^^^

    warning: struct `Tuple` is never constructed
      --> test_suite/no_std/src/main.rs:32:8
       |
    32 | struct Tuple(u8, u8);
       |        ^^^^^

    warning: struct `Struct` is never constructed
      --> test_suite/no_std/src/main.rs:35:8
       |
    35 | struct Struct {
       |        ^^^^^^

    warning: enum `Enum` is never used
      --> test_suite/no_std/src/main.rs:40:6
       |
    40 | enum Enum {
       |      ^^^^

test_suite/no_std/src/main.rs

@@ -23,21 +23,21 @@ fn panic(_info: &core::panic::PanicInfo) -> ! {
 use serde_derive::{Deserialize, Serialize};
 
 #[derive(Serialize, Deserialize)]
-struct Unit;
+pub struct Unit;
 
 #[derive(Serialize, Deserialize)]
-struct Newtype(u8);
+pub struct Newtype(u8);
 
 #[derive(Serialize, Deserialize)]
-struct Tuple(u8, u8);
+pub struct Tuple(u8, u8);
 
 #[derive(Serialize, Deserialize)]
-struct Struct {
+pub struct Struct {
     f: u8,
 }
 
 #[derive(Serialize, Deserialize)]
-enum Enum {
+pub enum Enum {
     Unit,
     Newtype(u8),
     Tuple(u8, u8),

test_suite/tests/test_borrow.rs

@@ -162,7 +162,7 @@ fn test_cow() {
 #[test]
 fn test_lifetimes() {
     #[derive(Deserialize)]
-    struct Cows<'a, 'b> {
+    pub struct Cows<'a, 'b> {
         _copied: Cow<'a, str>,
 
         #[serde(borrow)]
@@ -178,7 +178,7 @@ fn test_lifetimes() {
     }
 
     #[derive(Deserialize)]
-    struct Wrap<'a, 'b> {
+    pub struct Wrap<'a, 'b> {
         #[serde(borrow = "'b")]
         _cows: Cows<'a, 'b>,
     }

test_suite/tests/test_de.rs

@@ -93,7 +93,7 @@ struct StructSkipDefault {
 
 #[derive(PartialEq, Debug, Deserialize)]
 #[serde(default)]
-struct StructSkipDefaultGeneric<T> {
+pub struct StructSkipDefaultGeneric<T> {
     #[serde(skip_deserializing)]
     t: T,
 }

test_suite/tests/test_gen.rs

@@ -287,60 +287,60 @@ fn test_gen() {
     assert::<EmptyEnumVariant>();
 
     #[derive(Serialize, Deserialize)]
-    struct NonAsciiIdents {
+    pub struct NonAsciiIdents {
         σ: f64,
     }
 
     #[derive(Serialize, Deserialize)]
-    struct EmptyBraced {}
+    pub struct EmptyBraced {}
 
     #[derive(Serialize, Deserialize)]
     #[serde(deny_unknown_fields)]
-    struct EmptyBracedDenyUnknown {}
+    pub struct EmptyBracedDenyUnknown {}
 
     #[derive(Serialize, Deserialize)]
-    struct BracedSkipAll {
+    pub struct BracedSkipAll {
         #[serde(skip_deserializing)]
         f: u8,
     }
 
     #[derive(Serialize, Deserialize)]
     #[serde(deny_unknown_fields)]
-    struct BracedSkipAllDenyUnknown {
+    pub struct BracedSkipAllDenyUnknown {
         #[serde(skip_deserializing)]
         f: u8,
     }
 
     #[derive(Serialize, Deserialize)]
-    struct EmptyTuple();
+    pub struct EmptyTuple();
 
     #[derive(Serialize, Deserialize)]
     #[serde(deny_unknown_fields)]
-    struct EmptyTupleDenyUnknown();
+    pub struct EmptyTupleDenyUnknown();
 
     #[derive(Serialize, Deserialize)]
-    struct TupleSkipAll(#[serde(skip_deserializing)] u8);
+    pub struct TupleSkipAll(#[serde(skip_deserializing)] u8);
 
     #[derive(Serialize, Deserialize)]
     #[serde(deny_unknown_fields)]
-    struct TupleSkipAllDenyUnknown(#[serde(skip_deserializing)] u8);
+    pub struct TupleSkipAllDenyUnknown(#[serde(skip_deserializing)] u8);
 
     #[derive(Serialize, Deserialize)]
-    enum EmptyEnum {}
+    pub enum EmptyEnum {}
 
     #[derive(Serialize, Deserialize)]
     #[serde(deny_unknown_fields)]
-    enum EmptyEnumDenyUnknown {}
+    pub enum EmptyEnumDenyUnknown {}
 
     #[derive(Serialize, Deserialize)]
-    enum EnumSkipAll {
+    pub enum EnumSkipAll {
         #[serde(skip_deserializing)]
         #[allow(dead_code)]
         Variant,
     }
 
     #[derive(Serialize, Deserialize)]
-    enum EmptyVariants {
+    pub enum EmptyVariants {
         Braced {},
         Tuple(),
         BracedSkip {
@@ -352,7 +352,7 @@ fn test_gen() {
 
     #[derive(Serialize, Deserialize)]
     #[serde(deny_unknown_fields)]
-    enum EmptyVariantsDenyUnknown {
+    pub enum EmptyVariantsDenyUnknown {
         Braced {},
         Tuple(),
         BracedSkip {
@@ -364,21 +364,21 @@ fn test_gen() {
 
     #[derive(Serialize, Deserialize)]
     #[serde(deny_unknown_fields)]
-    struct UnitDenyUnknown;
+    pub struct UnitDenyUnknown;
 
     #[derive(Serialize, Deserialize)]
-    struct EmptyArray {
+    pub struct EmptyArray {
         empty: [X; 0],
     }
 
-    enum Or<A, B> {
+    pub enum Or<A, B> {
         A(A),
         B(B),
     }
 
     #[derive(Serialize, Deserialize)]
     #[serde(untagged, remote = "Or")]
-    enum OrDef<A, B> {
+    pub enum OrDef<A, B> {
         A(A),
         B(B),
     }
@@ -390,15 +390,15 @@ fn test_gen() {
     struct StrDef<'a>(&'a str);
 
     #[derive(Serialize, Deserialize)]
-    struct Remote<'a> {
+    pub struct Remote<'a> {
         #[serde(with = "OrDef")]
         or: Or<u8, bool>,
         #[serde(borrow, with = "StrDef")]
         s: Str<'a>,
     }
 
     #[derive(Serialize, Deserialize)]
-    enum BorrowVariant<'a> {
+    pub enum BorrowVariant<'a> {
         #[serde(borrow, with = "StrDef")]
         S(Str<'a>),
     }
@@ -415,15 +415,14 @@ fn test_gen() {
 
     // This would not work if SDef::serialize / deserialize are private.
     #[derive(Serialize, Deserialize)]
-    struct RemoteVisibility {
+    pub struct RemoteVisibility {
         #[serde(with = "vis::SDef")]
         s: vis::S,
     }
 
     #[derive(Serialize, Deserialize)]
     #[serde(remote = "Self")]
-    #[allow(dead_code)]
-    struct RemoteSelf;
+    pub struct RemoteSelf;
 
     #[derive(Serialize, Deserialize)]
     enum ExternallyTaggedVariantWith {
@@ -548,25 +547,25 @@ fn test_gen() {
 
     #[derive(Serialize, Deserialize)]
     #[serde(deny_unknown_fields)]
-    struct FlattenDenyUnknown<T> {
+    pub struct FlattenDenyUnknown<T> {
         #[serde(flatten)]
         t: T,
     }
 
     #[derive(Serialize, Deserialize)]
-    struct StaticStrStruct<'a> {
+    pub struct StaticStrStruct<'a> {
         a: &'a str,
         b: &'static str,
     }
 
     #[derive(Serialize, Deserialize)]
-    struct StaticStrTupleStruct<'a>(&'a str, &'static str);
+    pub struct StaticStrTupleStruct<'a>(&'a str, &'static str);
 
     #[derive(Serialize, Deserialize)]
-    struct StaticStrNewtypeStruct(&'static str);
+    pub struct StaticStrNewtypeStruct(&'static str);
 
     #[derive(Serialize, Deserialize)]
-    enum StaticStrEnum<'a> {
+    pub enum StaticStrEnum<'a> {
         Struct { a: &'a str, b: &'static str },
         Tuple(&'a str, &'static str),
         Newtype(&'static str),
@@ -640,6 +639,7 @@ fn test_gen() {
             use serde_derive::{Deserialize, Serialize};
 
             #[derive(Serialize, Deserialize)]
+            #[allow(dead_code)]
             struct Restricted {
                 pub(super) a: usize,
                 pub(in super::inner) b: usize,
@@ -649,7 +649,7 @@ fn test_gen() {
 
     #[derive(Deserialize)]
     #[serde(tag = "t", content = "c")]
-    enum AdjacentlyTaggedVoid {}
+    pub enum AdjacentlyTaggedVoid {}
 
     #[derive(Serialize, Deserialize)]
     enum SkippedVariant<T> {
@@ -662,14 +662,13 @@ fn test_gen() {
     assert::<SkippedVariant<X>>();
 
     #[derive(Deserialize)]
-    struct ImplicitlyBorrowedOption<'a> {
-        #[allow(dead_code)]
+    pub struct ImplicitlyBorrowedOption<'a> {
         option: std::option::Option<&'a str>,
     }
 
     #[derive(Serialize, Deserialize)]
     #[serde(untagged)]
-    enum UntaggedNewtypeVariantWith {
+    pub enum UntaggedNewtypeVariantWith {
         Newtype(
             #[serde(serialize_with = "ser_x")]
             #[serde(deserialize_with = "de_x")]
@@ -679,7 +678,7 @@ fn test_gen() {
 
     #[derive(Serialize, Deserialize)]
     #[serde(transparent)]
-    struct TransparentWith {
+    pub struct TransparentWith {
         #[serde(serialize_with = "ser_x")]
         #[serde(deserialize_with = "de_x")]
         x: X,
@@ -701,35 +700,33 @@ fn test_gen() {
     }
 
     #[derive(Deserialize)]
-    struct RelObject<'a> {
-        #[allow(dead_code)]
+    pub struct RelObject<'a> {
         ty: &'a str,
-        #[allow(dead_code)]
         id: String,
     }
 
     #[derive(Serialize, Deserialize)]
-    struct FlattenSkipSerializing<T> {
+    pub struct FlattenSkipSerializing<T> {
         #[serde(flatten, skip_serializing)]
         #[allow(dead_code)]
         flat: T,
     }
 
     #[derive(Serialize, Deserialize)]
-    struct FlattenSkipSerializingIf<T> {
+    pub struct FlattenSkipSerializingIf<T> {
         #[serde(flatten, skip_serializing_if = "StdOption::is_none")]
         flat: StdOption<T>,
     }
 
     #[derive(Serialize, Deserialize)]
-    struct FlattenSkipDeserializing<T> {
+    pub struct FlattenSkipDeserializing<T> {
         #[serde(flatten, skip_deserializing)]
         flat: T,
     }
 
     // https://github.com/serde-rs/serde/issues/1804
     #[derive(Serialize, Deserialize)]
-    enum Message {
+    pub enum Message {
         #[serde(skip)]
         #[allow(dead_code)]
         String(String),
@@ -748,8 +745,7 @@ fn test_gen() {
     macro_rules! deriving {
         ($field:ty) => {
             #[derive(Deserialize)]
-            struct MacroRules<'a> {
-                #[allow(dead_code)]
+            pub struct MacroRules<'a> {
                 field: $field,
             }
         };
@@ -764,22 +760,20 @@ fn test_gen() {
     }
 
     #[derive(Deserialize)]
-    struct BorrowLifetimeInsideMacro<'a> {
+    pub struct BorrowLifetimeInsideMacro<'a> {
         #[serde(borrow = "'a")]
-        #[allow(dead_code)]
-        f: mac!(Cow<'a, str>),
+        pub f: mac!(Cow<'a, str>),
     }
 
     #[derive(Serialize)]
-    #[allow(dead_code)]
-    struct Struct {
+    pub struct Struct {
         #[serde(serialize_with = "vec_first_element")]
-        vec: Vec<Self>,
+        pub vec: Vec<Self>,
     }
 
     #[derive(Deserialize)]
     #[serde(bound(deserialize = "[&'de str; N]: Copy"))]
-    struct GenericUnitStruct<const N: usize>;
+    pub struct GenericUnitStruct<const N: usize>;
 }
 
 //////////////////////////////////////////////////////////////////////////
@@ -866,7 +860,7 @@ where
 
 #[derive(Debug, PartialEq, Deserialize)]
 #[serde(tag = "tag")]
-enum InternallyTagged {
+pub enum InternallyTagged {
     #[serde(deserialize_with = "deserialize_generic")]
     Unit,