Add private fields to public types for forward compatibility

futures-channel/src/mpsc/mod.rs

@@ -166,7 +166,7 @@ enum SendErrorKind {
 
 /// The error type returned from [`try_next`](Receiver::try_next).
 pub struct TryRecvError {
-    _inner: (),
+    _priv: (),
 }
 
 impl fmt::Display for SendError {
@@ -834,7 +834,7 @@ impl<T> Receiver<T> {
             Poll::Ready(msg) => {
                 Ok(msg)
             },
-            Poll::Pending => Err(TryRecvError { _inner: () }),
+            Poll::Pending => Err(TryRecvError { _priv: () }),
         }
     }
 

futures-channel/src/oneshot.rs

@@ -249,7 +249,7 @@ impl<T> Inner<T> {
                     return Ok(Some(data));
                 }
             }
-            Err(Canceled)
+            Err(Canceled { _priv: () })
         } else {
             Ok(None)
         }
@@ -290,7 +290,7 @@ impl<T> Inner<T> {
                     return Poll::Ready(Ok(data));
                 }
             }
-            Poll::Ready(Err(Canceled))
+            Poll::Ready(Err(Canceled { _priv: () }))
         } else {
             Poll::Pending
         }
@@ -377,8 +377,16 @@ impl<T> Drop for Sender<T> {
 
 /// Error returned from a [`Receiver`](Receiver) when the corresponding
 /// [`Sender`](Sender) is dropped.
-#[derive(Clone, Copy, PartialEq, Eq, Debug)]
-pub struct Canceled;
+#[derive(Clone, PartialEq, Eq)]
+pub struct Canceled {
+    _priv: (),
+}
+
+impl fmt::Debug for Canceled {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Canceled").finish()
+    }
+}
 
 impl fmt::Display for Canceled {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

futures-core/src/task/spawn.rs

@@ -55,7 +55,7 @@ pub trait LocalSpawn {
 
 /// An error that occurred during spawning.
 pub struct SpawnError {
-    _hidden: (),
+    _priv: (),
 }
 
 impl fmt::Debug for SpawnError {
@@ -78,7 +78,7 @@ impl std::error::Error for SpawnError {}
 impl SpawnError {
     /// Spawning failed because the executor has been shut down.
     pub fn shutdown() -> Self {
-        Self { _hidden: () }
+        Self { _priv: () }
     }
 
     /// Check whether spawning failed to the executor being shut down.

futures-executor/src/enter.rs

@@ -7,16 +7,29 @@ thread_local!(static ENTERED: Cell<bool> = Cell::new(false));
 ///
 /// For more details, see [`enter` documentation](enter()).
 pub struct Enter {
-    _a: ()
+    _priv: (),
 }
 
 /// An error returned by `enter` if an execution scope has already been
 /// entered.
-#[derive(Debug)]
 pub struct EnterError {
-    _a: (),
+    _priv: (),
 }
 
+impl fmt::Debug for EnterError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("EnterError").finish()
+    }
+}
+
+impl fmt::Display for EnterError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "an execution scope has already been entered")
+    }
+}
+
+impl std::error::Error for EnterError {}
+
 /// Marks the current thread as being within the dynamic extent of an
 /// executor.
 ///
@@ -42,11 +55,11 @@ pub struct EnterError {
 pub fn enter() -> Result<Enter, EnterError> {
     ENTERED.with(|c| {
         if c.get() {
-            Err(EnterError { _a: () })
+            Err(EnterError { _priv: () })
         } else {
             c.set(true);
 
-            Ok(Enter { _a: () })
+            Ok(Enter { _priv: () })
         }
     })
 }
@@ -65,3 +78,4 @@ impl Drop for Enter {
         });
     }
 }
+

futures-util/src/future/abortable.rs

@@ -2,6 +2,7 @@ use crate::task::AtomicWaker;
 use futures_core::future::Future;
 use futures_core::task::{Context, Poll};
 use pin_utils::unsafe_pinned;
+use core::fmt;
 use core::pin::Pin;
 use core::sync::atomic::{AtomicBool, Ordering};
 use alloc::sync::Arc;
@@ -30,12 +31,12 @@ impl<Fut> Abortable<Fut> where Fut: Future {
     ///
     /// ```
     /// # futures::executor::block_on(async {
-    /// use futures::future::{Abortable, AbortHandle, Aborted};
+    /// use futures::future::{Abortable, AbortHandle};
     ///
     /// let (abort_handle, abort_registration) = AbortHandle::new_pair();
     /// let future = Abortable::new(async { 2 }, abort_registration);
     /// abort_handle.abort();
-    /// assert_eq!(future.await, Err(Aborted));
+    /// assert!(future.await.is_err());
     /// # });
     /// ```
     pub fn new(future: Fut, reg: AbortRegistration) -> Self {
@@ -70,12 +71,12 @@ impl AbortHandle {
     ///
     /// ```
     /// # futures::executor::block_on(async {
-    /// use futures::future::{Abortable, AbortHandle, Aborted};
+    /// use futures::future::{Abortable, AbortHandle};
     ///
     /// let (abort_handle, abort_registration) = AbortHandle::new_pair();
     /// let future = Abortable::new(async { 2 }, abort_registration);
     /// abort_handle.abort();
-    /// assert_eq!(future.await, Err(Aborted));
+    /// assert!(future.await.is_err());
     /// # });
     /// ```
     pub fn new_pair() -> (Self, AbortRegistration) {
@@ -121,16 +122,24 @@ pub fn abortable<Fut>(future: Fut) -> (Abortable<Fut>, AbortHandle)
 }
 
 /// Indicator that the `Abortable` future was aborted.
-#[derive(Copy, Clone, Debug, Eq, PartialEq)]
-pub struct Aborted;
+#[derive(Clone, Eq, PartialEq)]
+pub struct Aborted {
+    _priv: (),
+}
+
+impl fmt::Debug for Aborted {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_tuple("Aborted").finish()
+    }
+}
 
 impl<Fut> Future for Abortable<Fut> where Fut: Future {
     type Output = Result<Fut::Output, Aborted>;
 
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         // Check if the future has been aborted
         if self.inner.cancel.load(Ordering::Relaxed) {
-            return Poll::Ready(Err(Aborted))
+            return Poll::Ready(Err(Aborted { _priv: () }))
         }
 
         // attempt to complete the future
@@ -146,7 +155,7 @@ impl<Fut> Future for Abortable<Fut> where Fut: Future {
         // Checking with `Relaxed` is sufficient because `register` introduces an
         // `AcqRel` barrier.
         if self.inner.cancel.load(Ordering::Relaxed) {
-            return Poll::Ready(Err(Aborted))
+            return Poll::Ready(Err(Aborted { _priv: () }))
         }
 
         Poll::Pending

futures-util/src/try_stream/mod.rs

@@ -417,7 +417,7 @@ pub trait TryStreamExt: TryStream {
     ///
     /// // The final result is an error because the second future
     /// // resulted in an error.
-    /// assert_eq!(Err(oneshot::Canceled), fut.await);
+    /// assert!(fut.await.is_err());
     /// # })
     /// ```
     #[cfg_attr(

futures/tests/abortable.rs

@@ -1,6 +1,6 @@
 use futures::channel::oneshot;
 use futures::executor::block_on;
-use futures::future::{abortable, Aborted, FutureExt};
+use futures::future::{abortable, FutureExt};
 use futures::task::{Context, Poll};
 use futures_test::task::new_count_waker;
 
@@ -10,7 +10,7 @@ fn abortable_works() {
     let (abortable_rx, abort_handle) = abortable(a_rx);
 
     abort_handle.abort();
-    assert_eq!(Err(Aborted), block_on(abortable_rx));
+    assert!(block_on(abortable_rx).is_err());
 }
 
 #[test]
@@ -25,7 +25,10 @@ fn abortable_awakens() {
     assert_eq!(counter, 0);
     abort_handle.abort();
     assert_eq!(counter, 1);
-    assert_eq!(Poll::Ready(Err(Aborted)), abortable_rx.poll_unpin(&mut cx));
+    match abortable_rx.poll_unpin(&mut cx) {
+        Poll::Ready(Err(_)) => {}
+        _ => unreachable!()
+    }
 }
 
 #[test]

futures/tests/futures_unordered.rs

@@ -137,9 +137,9 @@ fn iter_mut_cancel() {
     assert!(b_tx.is_canceled());
     assert!(c_tx.is_canceled());
 
-    assert_eq!(iter.next(), Some(Err(futures::channel::oneshot::Canceled)));
-    assert_eq!(iter.next(), Some(Err(futures::channel::oneshot::Canceled)));
-    assert_eq!(iter.next(), Some(Err(futures::channel::oneshot::Canceled)));
+    assert!(iter.next().unwrap().is_err());
+    assert!(iter.next().unwrap().is_err());
+    assert!(iter.next().unwrap().is_err());
     assert_eq!(iter.next(), None);
 }
 

futures/tests/oneshot.rs

@@ -43,7 +43,7 @@ fn oneshot_drop_tx1() {
     drop(tx1);
     rx1.map(move |result| tx2.send(result).unwrap()).run_in_background();
 
-    assert_eq!(Err(oneshot::Canceled), rx2.recv().unwrap());
+    assert!(rx2.recv().unwrap().is_err());
 }
 
 #[test]
@@ -55,7 +55,7 @@ fn oneshot_drop_tx2() {
     rx1.map(move |result| tx2.send(result).unwrap()).run_in_background();
     t.join().unwrap();
 
-    assert_eq!(Err(oneshot::Canceled), rx2.recv().unwrap());
+    assert!(rx2.recv().unwrap().is_err());
 }
 
 #[test]

futures/tests/ready_queue.rs

@@ -55,13 +55,19 @@ fn resolving_errors() {
 
         drop(tx2);
 
-        assert_eq!(Poll::Ready(Some(Err(oneshot::Canceled))), queue.poll_next_unpin(cx));
+        match queue.poll_next_unpin(cx) {
+            Poll::Ready(Some(Err(_))) => {}
+            _ => unreachable!(),
+        }
         assert!(!queue.poll_next_unpin(cx).is_ready());
 
         drop(tx1);
         tx3.send("world2").unwrap();
 
-        assert_eq!(Poll::Ready(Some(Err(oneshot::Canceled))), queue.poll_next_unpin(cx));
+        match queue.poll_next_unpin(cx) {
+            Poll::Ready(Some(Err(_))) => {}
+            _ => unreachable!(),
+        }
         assert_eq!(Poll::Ready(Some(Ok("world2"))), queue.poll_next_unpin(cx));
         assert_eq!(Poll::Ready(None), queue.poll_next_unpin(cx));
     }));