Add specialization for reference-to-type

The serde library implements `Serialize` for all `&T where T:
Serialize`.  This causes min_specialization to select the default
implementation of `Annotate` for `&T` when a specialized implementation
exists for `T`.

We supply a forwarding implementation for `&T` to `T` for every type
we derive `Annotate` on.

Signed-off-by: Chris Frantz <[email protected]>

Author: cfrantz

annotate_derive/src/expand.rs

@@ -140,6 +140,7 @@ fn impl_struct(input: Struct) -> TokenStream {
                 // We don't have to implement `thunk_serialize` because the default implementation
                 // already does what we need.
             }
+            serde_annotate::annotate_ref!(#name);
         };
     }
 }
@@ -171,6 +172,7 @@ fn impl_enum(input: Enum) -> TokenStream {
                 // We don't have to implement `thunk_serialize` because the default implementation
                 // already does what we need.
             }
+            serde_annotate::annotate_ref!(#name);
         };
     }
 }

src/annotate.rs

@@ -60,6 +60,36 @@ impl<T: ?Sized + serde::Serialize> Annotate for T {
     }
 }
 
+// Serde explicitly implements Serialize on &T where T: Serialize.  This
+// causes min_specialization to select the default implementation for &T
+// even though there is a specialized implementation available for T.
+//
+// The annotate_derive crate uses this macro to create the additional
+// specializations needed.
+#[macro_export]
+macro_rules! annotate_ref {
+    ($ty:ty) => {
+        $crate::__annotate_ref!(&$ty);
+    };
+}
+
+#[macro_export]
+macro_rules! __annotate_ref {
+    ($ty:ty) => {
+        impl Annotate for $ty {
+            fn format(&self, variant: Option<&str>, field: &MemberId) -> Option<Format> {
+                (**self).format(variant, field)
+            }
+            fn comment(&self, variant: Option<&str>, field: &MemberId) -> Option<String> {
+                (**self).comment(variant, field)
+            }
+            fn as_annotate(&self) -> Option<&dyn Annotate> {
+                (**self).as_annotate()
+            }
+        }
+    };
+}
+
 // We use a private trait to identify whether the Serializer passed to
 // various functions is our Serializer.
 pub(crate) unsafe trait IsSerializer {

tests/test_format.rs

@@ -275,8 +275,11 @@ struct Addresses {
     a: NesAddress,
     b: NesAddress,
     c: Option<NesAddress>,
-    d: CpuAddress,
-    e: NesAddress,
+    // Note: using a vec here causes the serializer to request
+    // serializing &CpuAddress rather than CpuAddress.  This tests
+    // that the specializations of Annotate for &T are working.
+    vectors: Vec<CpuAddress>,
+    inv: NesAddress,
 }
 
 #[test]
@@ -285,8 +288,8 @@ fn test_nes_addresses() -> Result<()> {
         a: NesAddress::File(0x4010),
         b: NesAddress::Prg(1, 0x8000),
         c: Some(NesAddress::Chr(2, 0x400)),
-        d: CpuAddress(0xFFFA),
-        e: NesAddress::Invalid,
+        vectors: vec![CpuAddress(0xFFFA), CpuAddress(0xFFFC), CpuAddress(0xFFFE)],
+        inv: NesAddress::Invalid,
     };
 
     tester!(
@@ -304,8 +307,12 @@ fn test_nes_addresses() -> Result<()> {
           "c": {
             "Chr": [2, 1024]
           },
-          "d": 65530,
-          "e": "Invalid"
+          "vectors": [
+            65530,
+            65532,
+            65534
+          ],
+          "inv": "Invalid"
         }"#
     );
 
@@ -327,8 +334,12 @@ fn test_nes_addresses() -> Result<()> {
             // NES CHR bank:address
             Chr: [0x2, 0x400]
           },
-          d: 0xFFFA,
-          e: "Invalid" // Bad Address
+          vectors: [
+            0xFFFA,
+            0xFFFC,
+            0xFFFE
+          ],
+          inv: "Invalid" // Bad Address
         }"#
     );
 
@@ -347,8 +358,11 @@ fn test_nes_addresses() -> Result<()> {
           c:
             # NES CHR bank:address
             Chr: [0x2, 0x400]
-          d: 0xFFFA
-          e: Invalid # Bad Address"#
+          vectors:
+            - 0xFFFA
+            - 0xFFFC
+            - 0xFFFE
+          inv: Invalid # Bad Address"#
     );
 
     Ok(())