Add a debug implementation for Address

examples/basic_wasm_bindgen/src/lib.rs

@@ -5,15 +5,19 @@ use xtra::spawn::WasmBindgen;
 
 struct Echoer;
 
-impl Actor for Echoer {}
+#[async_trait]
+impl Actor for Echoer {
+    type Stop = ();
 
-struct Echo(String);
-impl Message for Echo {
-    type Result = String;
+    async fn stopped(self) {}
 }
 
+struct Echo(String);
+
 #[async_trait]
 impl Handler<Echo> for Echoer {
+    type Return = String;
+
     async fn handle(&mut self, echo: Echo, _ctx: &mut Context<Self>) -> String {
         echo.0
     }

src/address.rs

@@ -1,7 +1,7 @@
 //! An address to an actor is a way to send it a message. An address allows an actor to be sent any
 //! kind of message that it can receive.
 
-use std::fmt::{self, Display, Formatter};
+use std::fmt::{self, Debug, Display, Formatter};
 use std::future::Future;
 use std::{cmp::Ordering, error::Error, hash::Hash};
 
@@ -44,6 +44,14 @@ pub struct Address<A, Rc: RefCounter = Strong> {
     pub(crate) ref_counter: Rc,
 }
 
+impl<A, Rc: RefCounter> Debug for Address<A, Rc> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        f.debug_struct(&format!("Address<{}>", std::any::type_name::<A>()))
+            .field("ref_counter", &self.ref_counter)
+            .finish()
+    }
+}
+
 /// A `WeakAddress` is a reference to an actor through which [`Message`s](../trait.Message.html) can be
 /// sent. It can be cloned. Unlike [`Address`](struct.Address.html), a `WeakAddress` will not inhibit
 /// the dropping of an actor. It is created by the [`Address::downgrade`](struct.Address.html#method.downgrade)

src/message_channel.rs

@@ -2,6 +2,8 @@
 //! any actor that can handle it. It is like [`Address`](../address/struct.Address.html), but associated with
 //! the message type rather than the actor type.
 
+use std::fmt::Debug;
+
 use futures_core::future::BoxFuture;
 use futures_core::stream::BoxStream;
 
@@ -77,10 +79,9 @@ use crate::{Handler, KeepRunning};
 ///     })
 /// }
 /// ```
-pub trait MessageChannel<M>: Sealed + Unpin + Send + Sync {
+pub trait MessageChannel<M>: Sealed + Unpin + Debug + Send + Sync {
     /// The return value of the handler for `M`.
     type Return: Send + 'static;
-
     /// Returns whether the actor referred to by this address is running and accepting messages.
     fn is_connected(&self) -> bool;
 

src/refcount.rs

@@ -1,8 +1,7 @@
-use crate::drop_notice;
-use crate::drop_notice::DropNotice;
+use std::fmt::{Debug, Formatter};
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::{Arc, RwLock, Weak as ArcWeak};
-
+use crate::drop_notice::{self, DropNotice};
 use crate::private::Sealed;
 
 /// The reference count of a strong address. Strong addresses will prevent the actor from being
@@ -18,6 +17,16 @@ pub struct Strong {
     lock: Arc<RwLock<()>>,
 }
 
+impl Debug for Strong {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("Strong")
+            .field("connected", &self.is_connected())
+            .field("strong_count", &self.strong_count())
+            .field("weak_count", &self.weak_count())
+            .finish()
+    }
+}
+
 #[doc(hidden)]
 pub struct Shared {
     connected: AtomicBool,
@@ -35,6 +44,11 @@ impl Strong {
         }
     }
 
+    fn weak_count(&self) -> usize {
+        let _lock = self.lock.read().unwrap();
+        Arc::weak_count(&self.shared)
+    }
+
     pub(crate) fn downgrade(&self) -> Weak {
         Weak {
             shared: Arc::downgrade(&self.shared),
@@ -55,17 +69,32 @@ pub struct Weak {
     lock: Arc<RwLock<()>>,
 }
 
+impl Debug for Weak {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("Weak")
+            .field("connected", &self.is_connected())
+            .field("strong_count", &self.strong_count())
+            .field("weak_count", &self.weak_count())
+            .finish()
+    }
+}
+
 impl Weak {
     pub(crate) fn upgrade(&self) -> Option<Strong> {
         ArcWeak::upgrade(&self.shared).map(|shared| Strong {
             shared,
             lock: self.lock.clone(),
         })
     }
+
+    fn weak_count(&self) -> usize {
+        let _lock = self.lock.read().unwrap();
+        ArcWeak::weak_count(&self.shared)
+    }
 }
 
 /// A reference counter that can be dynamically either strong or weak.
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub enum Either {
     /// A strong reference counter.
     Strong(Strong),
@@ -87,7 +116,7 @@ impl Either {
 /// [`Strong`](struct.Weak.html). These can be provided as the second type argument to
 /// [`Address`](../address/struct.Address.html) in order to change how the address affects the actor's
 /// dropping. Read the docs of [`Address`](../address/struct.Address.html) to find out more.
-pub trait RefCounter: Sealed + Clone + Unpin + Send + Sync + 'static {
+pub trait RefCounter: Sealed + Clone + Unpin + Debug + Send + Sync + 'static {
     #[doc(hidden)]
     fn is_connected(&self) -> bool;
     #[doc(hidden)]

tests/basic.rs

@@ -273,3 +273,25 @@ async fn address_send_exercises_backpressure() {
         .now_or_never()
         .expect("be able to queue another message because the mailbox is empty again");
 }
+
+#[test]
+fn address_debug() {
+    let (addr1, _ctx): (Address<_>, Context<Greeter>) = Context::new(None);
+
+    let addr2 = addr1.clone();
+    let weak_addr = addr2.downgrade();
+
+    assert_eq!(
+        format!("{:?}", addr1),
+        "Address<basic::Greeter> { \
+        ref_counter: Strong { connected: true, strong_count: 2, weak_count: 2 } }"
+    );
+
+    assert_eq!(format!("{:?}", addr1), format!("{:?}", addr2));
+
+    assert_eq!(
+        format!("{:?}", weak_addr),
+        "Address<basic::Greeter> { \
+        ref_counter: Weak { connected: true, strong_count: 2, weak_count: 2 } }"
+    );
+}