Add missing impl Debug

Author: DanglingPointer

Cargo.toml

@@ -15,12 +15,12 @@ tokio = ["dep:tokio"]
 [dependencies]
 futures = "0.3"
 log = "0.4"
-tokio = { version = "1.48", optional = true, features = ["time"] }
+tokio = { version = "1.50", optional = true, features = ["time"] }
 
 [dev-dependencies]
 static_assertions = "1.1"
 tokio-test = "0.4"
-tokio = { version = "1.48", features = ["time", "io-util"] }
+tokio = { version = "1.50", features = ["time", "io-util"] }
 
 [profile.dev]
 opt-level = 3

src/shared/local_shared.rs

@@ -1,5 +1,6 @@
 use super::{Shared, UnsafeShared};
 use std::cell::{RefCell, UnsafeCell};
+use std::fmt;
 use std::rc::Rc;
 
 /// Non-Send wrapper that allows access to the underlying data only through the `Shared` interface.
@@ -23,6 +24,12 @@ impl<T> Shared for LocalShared<T> {
     }
 }
 
+impl<T: fmt::Debug> fmt::Debug for LocalShared<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_tuple("LocalShared").field(&self.0.borrow()).finish()
+    }
+}
+
 impl<T> Clone for LocalShared<T> {
     fn clone(&self) -> Self {
         Self(self.0.clone())
@@ -50,6 +57,13 @@ impl<T> UnsafeShared for LocalUnsafeShared<T> {
     }
 }
 
+impl<T: fmt::Debug> fmt::Debug for LocalUnsafeShared<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let value = unsafe { &*self.0.get() };
+        f.debug_tuple("LocalUnsafeShared").field(value).finish()
+    }
+}
+
 impl<T> Clone for LocalUnsafeShared<T> {
     fn clone(&self) -> Self {
         Self(self.0.clone())

src/split.rs

@@ -1,10 +1,10 @@
 //! Utilities for splitting `AsyncRead + AsyncWrite` types into separate read and write halves.
 
 use std::cell::RefCell;
-use std::io;
 use std::pin::Pin;
 use std::rc::Rc;
 use std::task::{Context, Poll};
+use std::{fmt, io};
 use tokio::io::{AsyncRead, AsyncWrite, ReadBuf};
 
 /// The readable half of a value returned from [`split`].
@@ -68,3 +68,15 @@ impl<T: AsyncWrite> AsyncWrite for WriteHalf<T> {
         self.0.borrow().is_write_vectored()
     }
 }
+
+impl<T: fmt::Debug + AsyncRead> fmt::Debug for ReadHalf<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_tuple("ReadHalf").finish()
+    }
+}
+
+impl<T: fmt::Debug + AsyncWrite> fmt::Debug for WriteHalf<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_tuple("WriteHalf").finish()
+    }
+}

src/sync/pipe.rs

@@ -3,14 +3,13 @@ use std::cell::UnsafeCell;
 use std::io::BufRead;
 use std::rc::Rc;
 use std::task::{Context, Poll, Waker};
-use std::{cmp, io};
+use std::{cmp, fmt, io};
 use std::{collections::VecDeque, pin::Pin};
 use tokio::io::{AsyncRead, AsyncWrite, ReadBuf};
 
 /// Unidirectional in-memory pipe implementing `AsyncRead` and `AsyncWrite`.
 /// A more efficient version of [`tokio::io::SimplexStream`](https://docs.rs/tokio/latest/tokio/io/struct.SimplexStream.html)
 /// optimized for single-threaded use cases.
-#[derive(Debug)]
 pub struct Pipe {
     buffer: VecDeque<u8>,
     is_closed: bool,
@@ -180,6 +179,15 @@ impl AsyncWrite for Pipe {
     }
 }
 
+impl fmt::Debug for Pipe {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Pipe")
+            .field("buffer_len", &self.buffer.len())
+            .field("is_closed", &self.is_closed)
+            .finish()
+    }
+}
+
 /// The readable end of a [`Pipe`]. Not thread-safe.
 pub struct ReadEnd(Rc<UnsafeCell<Pipe>>);
 
@@ -204,6 +212,12 @@ impl Drop for ReadEnd {
     }
 }
 
+impl fmt::Debug for ReadEnd {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_tuple("ReadEnd").finish()
+    }
+}
+
 impl AsyncWrite for WriteEnd {
     fn poll_write(
         mut self: Pin<&mut Self>,
@@ -248,6 +262,12 @@ impl Drop for WriteEnd {
     }
 }
 
+impl fmt::Debug for WriteEnd {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_tuple("WriteEnd").finish()
+    }
+}
+
 /// Create a bi-directional in-memory stream of bytes using two [`Pipe`]s in opposite directions.
 /// Non-thread-safe equivalent of [`tokio::io::duplex`](https://docs.rs/tokio/latest/tokio/io/fn.duplex.html).
 /// # Returns
@@ -322,6 +342,12 @@ impl AsyncWrite for DuplexEnd {
     }
 }
 
+impl fmt::Debug for DuplexEnd {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_tuple("DuplexEnd").finish()
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;