Provide manual implementation of Debug for Private<T>

format!("{:?}", Private(42)) will print "42" instead of "Private(42)"
google · Dec 22, 2023 · 55fb24e · 55fb24e
1 parent 06da5ed
commit 55fb24e
Show file tree

Hide file tree

Showing 78 changed files with 469 additions and 78 deletions.
diff --git a/pdl-compiler/src/backends/rust/preamble.rs b/pdl-compiler/src/backends/rust/preamble.rs
@@ -62,7 +62,7 @@ pub fn generate(path: &Path) -> proc_macro2::TokenStream {
         /// in situations where the value needs to be validated.
         /// Users can freely deref the value, but only the backend
         /// may create it.
-        #[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)]
+        #[derive(Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)]
         pub struct Private<T>(T);
 
         impl<T> std::ops::Deref for Private<T> {
@@ -71,6 +71,12 @@ pub fn generate(path: &Path) -> proc_macro2::TokenStream {
                 &self.0
             }
         }
+
+        impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
+            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+                T::fmt(&self.0, f)
+            }
+        }
     }
 }
 

diff --git a/pdl-compiler/tests/generated/custom_field_declaration_big_endian.rs b/pdl-compiler/tests/generated/custom_field_declaration_big_endian.rs
@@ -10,14 +10,19 @@ use pdl_runtime::{DecodeError, EncodeError, Packet};
 /// in situations where the value needs to be validated.
 /// Users can freely deref the value, but only the backend
 /// may create it.
-#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)]
+#[derive(Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)]
 pub struct Private<T>(T);
 impl<T> std::ops::Deref for Private<T> {
     type Target = T;
     fn deref(&self) -> &Self::Target {
         &self.0
     }
 }
+impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        T::fmt(&self.0, f)
+    }
+}
 #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[cfg_attr(feature = "serde", serde(from = "u32", into = "u32"))]

diff --git a/pdl-compiler/tests/generated/custom_field_declaration_little_endian.rs b/pdl-compiler/tests/generated/custom_field_declaration_little_endian.rs
@@ -10,14 +10,19 @@ use pdl_runtime::{DecodeError, EncodeError, Packet};
 /// in situations where the value needs to be validated.
 /// Users can freely deref the value, but only the backend
 /// may create it.
-#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)]
+#[derive(Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)]
 pub struct Private<T>(T);
 impl<T> std::ops::Deref for Private<T> {
     type Target = T;
     fn deref(&self) -> &Self::Target {
         &self.0
     }
 }
+impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        T::fmt(&self.0, f)
+    }
+}
 #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[cfg_attr(feature = "serde", serde(from = "u32", into = "u32"))]

diff --git a/pdl-compiler/tests/generated/enum_declaration_big_endian.rs b/pdl-compiler/tests/generated/enum_declaration_big_endian.rs
@@ -10,14 +10,19 @@ use pdl_runtime::{DecodeError, EncodeError, Packet};
 /// in situations where the value needs to be validated.
 /// Users can freely deref the value, but only the backend
 /// may create it.
-#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)]
+#[derive(Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)]
 pub struct Private<T>(T);
 impl<T> std::ops::Deref for Private<T> {
     type Target = T;
     fn deref(&self) -> &Self::Target {
         &self.0
     }
 }
+impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        T::fmt(&self.0, f)
+    }
+}
 #[repr(u64)]
 #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]

diff --git a/pdl-compiler/tests/generated/enum_declaration_little_endian.rs b/pdl-compiler/tests/generated/enum_declaration_little_endian.rs
@@ -10,14 +10,19 @@ use pdl_runtime::{DecodeError, EncodeError, Packet};
 /// in situations where the value needs to be validated.
 /// Users can freely deref the value, but only the backend
 /// may create it.
-#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)]
+#[derive(Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)]
 pub struct Private<T>(T);
 impl<T> std::ops::Deref for Private<T> {
     type Target = T;
     fn deref(&self) -> &Self::Target {
         &self.0
     }
 }
+impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        T::fmt(&self.0, f)
+    }
+}
 #[repr(u64)]
 #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]

diff --git a/pdl-compiler/tests/generated/packet_decl_24bit_enum_array_big_endian.rs b/pdl-compiler/tests/generated/packet_decl_24bit_enum_array_big_endian.rs
@@ -10,14 +10,19 @@ use pdl_runtime::{DecodeError, EncodeError, Packet};
 /// in situations where the value needs to be validated.
 /// Users can freely deref the value, but only the backend
 /// may create it.
-#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)]
+#[derive(Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)]
 pub struct Private<T>(T);
 impl<T> std::ops::Deref for Private<T> {
     type Target = T;
     fn deref(&self) -> &Self::Target {
         &self.0
     }
 }
+impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        T::fmt(&self.0, f)
+    }
+}
 #[repr(u64)]
 #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]

diff --git a/pdl-compiler/tests/generated/packet_decl_24bit_enum_array_little_endian.rs b/pdl-compiler/tests/generated/packet_decl_24bit_enum_array_little_endian.rs
@@ -10,14 +10,19 @@ use pdl_runtime::{DecodeError, EncodeError, Packet};
 /// in situations where the value needs to be validated.
 /// Users can freely deref the value, but only the backend
 /// may create it.
-#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)]
+#[derive(Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)]
 pub struct Private<T>(T);
 impl<T> std::ops::Deref for Private<T> {
     type Target = T;
     fn deref(&self) -> &Self::Target {
         &self.0
     }
 }
+impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        T::fmt(&self.0, f)
+    }
+}
 #[repr(u64)]
 #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]

diff --git a/pdl-compiler/tests/generated/packet_decl_24bit_enum_big_endian.rs b/pdl-compiler/tests/generated/packet_decl_24bit_enum_big_endian.rs
@@ -10,14 +10,19 @@ use pdl_runtime::{DecodeError, EncodeError, Packet};
 /// in situations where the value needs to be validated.
 /// Users can freely deref the value, but only the backend
 /// may create it.
-#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)]
+#[derive(Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)]
 pub struct Private<T>(T);
 impl<T> std::ops::Deref for Private<T> {
     type Target = T;
     fn deref(&self) -> &Self::Target {
         &self.0
     }
 }
+impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        T::fmt(&self.0, f)
+    }
+}
 #[repr(u64)]
 #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]

diff --git a/pdl-compiler/tests/generated/packet_decl_24bit_enum_little_endian.rs b/pdl-compiler/tests/generated/packet_decl_24bit_enum_little_endian.rs
@@ -10,14 +10,19 @@ use pdl_runtime::{DecodeError, EncodeError, Packet};
 /// in situations where the value needs to be validated.
 /// Users can freely deref the value, but only the backend
 /// may create it.
-#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)]
+#[derive(Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)]
 pub struct Private<T>(T);
 impl<T> std::ops::Deref for Private<T> {
     type Target = T;
     fn deref(&self) -> &Self::Target {
         &self.0
     }
 }
+impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        T::fmt(&self.0, f)
+    }
+}
 #[repr(u64)]
 #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]

diff --git a/pdl-compiler/tests/generated/packet_decl_24bit_scalar_array_big_endian.rs b/pdl-compiler/tests/generated/packet_decl_24bit_scalar_array_big_endian.rs
@@ -10,14 +10,19 @@ use pdl_runtime::{DecodeError, EncodeError, Packet};
 /// in situations where the value needs to be validated.
 /// Users can freely deref the value, but only the backend
 /// may create it.
-#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)]
+#[derive(Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)]
 pub struct Private<T>(T);
 impl<T> std::ops::Deref for Private<T> {
     type Target = T;
     fn deref(&self) -> &Self::Target {
         &self.0
     }
 }
+impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        T::fmt(&self.0, f)
+    }
+}
 #[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct FooData {

diff --git a/pdl-compiler/tests/generated/packet_decl_24bit_scalar_array_little_endian.rs b/pdl-compiler/tests/generated/packet_decl_24bit_scalar_array_little_endian.rs
@@ -10,14 +10,19 @@ use pdl_runtime::{DecodeError, EncodeError, Packet};
 /// in situations where the value needs to be validated.
 /// Users can freely deref the value, but only the backend
 /// may create it.
-#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)]
+#[derive(Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)]
 pub struct Private<T>(T);
 impl<T> std::ops::Deref for Private<T> {
     type Target = T;
     fn deref(&self) -> &Self::Target {
         &self.0
     }
 }
+impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        T::fmt(&self.0, f)
+    }
+}
 #[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct FooData {

diff --git a/pdl-compiler/tests/generated/packet_decl_24bit_scalar_big_endian.rs b/pdl-compiler/tests/generated/packet_decl_24bit_scalar_big_endian.rs
@@ -10,14 +10,19 @@ use pdl_runtime::{DecodeError, EncodeError, Packet};
 /// in situations where the value needs to be validated.
 /// Users can freely deref the value, but only the backend
 /// may create it.
-#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)]
+#[derive(Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)]
 pub struct Private<T>(T);
 impl<T> std::ops::Deref for Private<T> {
     type Target = T;
     fn deref(&self) -> &Self::Target {
         &self.0
     }
 }
+impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        T::fmt(&self.0, f)
+    }
+}
 #[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct FooData {

diff --git a/pdl-compiler/tests/generated/packet_decl_24bit_scalar_little_endian.rs b/pdl-compiler/tests/generated/packet_decl_24bit_scalar_little_endian.rs
@@ -10,14 +10,19 @@ use pdl_runtime::{DecodeError, EncodeError, Packet};
 /// in situations where the value needs to be validated.
 /// Users can freely deref the value, but only the backend
 /// may create it.
-#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)]
+#[derive(Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)]
 pub struct Private<T>(T);
 impl<T> std::ops::Deref for Private<T> {
     type Target = T;
     fn deref(&self) -> &Self::Target {
         &self.0
     }
 }
+impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        T::fmt(&self.0, f)
+    }
+}
 #[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct FooData {

diff --git a/pdl-compiler/tests/generated/packet_decl_64bit_enum_array_big_endian.rs b/pdl-compiler/tests/generated/packet_decl_64bit_enum_array_big_endian.rs
@@ -10,14 +10,19 @@ use pdl_runtime::{DecodeError, EncodeError, Packet};
 /// in situations where the value needs to be validated.
 /// Users can freely deref the value, but only the backend
 /// may create it.
-#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)]
+#[derive(Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)]
 pub struct Private<T>(T);
 impl<T> std::ops::Deref for Private<T> {
     type Target = T;
     fn deref(&self) -> &Self::Target {
         &self.0
     }
 }
+impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        T::fmt(&self.0, f)
+    }
+}
 #[repr(u64)]
 #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]

diff --git a/pdl-compiler/tests/generated/packet_decl_64bit_enum_array_little_endian.rs b/pdl-compiler/tests/generated/packet_decl_64bit_enum_array_little_endian.rs
@@ -10,14 +10,19 @@ use pdl_runtime::{DecodeError, EncodeError, Packet};
 /// in situations where the value needs to be validated.
 /// Users can freely deref the value, but only the backend
 /// may create it.
-#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)]
+#[derive(Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)]
 pub struct Private<T>(T);
 impl<T> std::ops::Deref for Private<T> {
     type Target = T;
     fn deref(&self) -> &Self::Target {
         &self.0
     }
 }
+impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        T::fmt(&self.0, f)
+    }
+}
 #[repr(u64)]
 #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]

diff --git a/pdl-compiler/tests/generated/packet_decl_64bit_enum_big_endian.rs b/pdl-compiler/tests/generated/packet_decl_64bit_enum_big_endian.rs
@@ -10,14 +10,19 @@ use pdl_runtime::{DecodeError, EncodeError, Packet};
 /// in situations where the value needs to be validated.
 /// Users can freely deref the value, but only the backend
 /// may create it.
-#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)]
+#[derive(Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)]
 pub struct Private<T>(T);
 impl<T> std::ops::Deref for Private<T> {
     type Target = T;
     fn deref(&self) -> &Self::Target {
         &self.0
     }
 }
+impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        T::fmt(&self.0, f)
+    }
+}
 #[repr(u64)]
 #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]

diff --git a/pdl-compiler/tests/generated/packet_decl_64bit_enum_little_endian.rs b/pdl-compiler/tests/generated/packet_decl_64bit_enum_little_endian.rs
@@ -10,14 +10,19 @@ use pdl_runtime::{DecodeError, EncodeError, Packet};
 /// in situations where the value needs to be validated.
 /// Users can freely deref the value, but only the backend
 /// may create it.
-#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)]
+#[derive(Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)]
 pub struct Private<T>(T);
 impl<T> std::ops::Deref for Private<T> {
     type Target = T;
     fn deref(&self) -> &Self::Target {
         &self.0
     }
 }
+impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        T::fmt(&self.0, f)
+    }
+}
 #[repr(u64)]
 #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]

diff --git a/pdl-compiler/tests/generated/packet_decl_64bit_scalar_array_big_endian.rs b/pdl-compiler/tests/generated/packet_decl_64bit_scalar_array_big_endian.rs
@@ -10,14 +10,19 @@ use pdl_runtime::{DecodeError, EncodeError, Packet};
 /// in situations where the value needs to be validated.
 /// Users can freely deref the value, but only the backend
 /// may create it.
-#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)]
+#[derive(Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)]
 pub struct Private<T>(T);
 impl<T> std::ops::Deref for Private<T> {
     type Target = T;
     fn deref(&self) -> &Self::Target {
         &self.0
     }
 }
+impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        T::fmt(&self.0, f)
+    }
+}
 #[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct FooData {

diff --git a/pdl-compiler/tests/generated/packet_decl_64bit_scalar_array_little_endian.rs b/pdl-compiler/tests/generated/packet_decl_64bit_scalar_array_little_endian.rs
@@ -10,14 +10,19 @@ use pdl_runtime::{DecodeError, EncodeError, Packet};
 /// in situations where the value needs to be validated.
 /// Users can freely deref the value, but only the backend
 /// may create it.
-#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)]
+#[derive(Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)]
 pub struct Private<T>(T);
 impl<T> std::ops::Deref for Private<T> {
     type Target = T;
     fn deref(&self) -> &Self::Target {
         &self.0
     }
 }
+impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        T::fmt(&self.0, f)
+    }
+}
 #[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct FooData {