refactor(common): replace Never with Infallible (hyperium#3335)

Signed-off-by: Sven Pfennig <[email protected]>

src/common/mod.rs

@@ -13,14 +13,11 @@ pub(crate) mod date;
 #[cfg(not(feature = "http2"))]
 pub(crate) mod exec;
 pub(crate) mod io;
-mod never;
 pub(crate) mod task;
 #[cfg(any(feature = "http1", feature = "http2", feature = "server"))]
 pub(crate) mod time;
 pub(crate) mod watch;
 
-#[cfg(any(feature = "http1", feature = "http2"))]
-pub(crate) use self::never::Never;
 pub(crate) use self::task::Poll;
 
 // group up types normally needed for `Future`

src/common/task.rs

@@ -1,12 +1,12 @@
 #[cfg(feature = "http1")]
-use super::Never;
+use std::convert::Infallible;
 pub(crate) use std::task::{Context, Poll};
 
 /// A function to help "yield" a future, such that it is re-scheduled immediately.
 ///
 /// Useful for spin counts, so a future doesn't hog too much time.
 #[cfg(feature = "http1")]
-pub(crate) fn yield_now(cx: &mut Context<'_>) -> Poll<Never> {
+pub(crate) fn yield_now(cx: &mut Context<'_>) -> Poll<Infallible> {
     cx.waker().wake_by_ref();
     Poll::Pending
 }

src/proto/h1/dispatch.rs

@@ -549,6 +549,8 @@ cfg_server! {
 // ===== impl Client =====
 
 cfg_client! {
+    use std::convert::Infallible;
+
     impl<B> Client<B> {
         pub(crate) fn new(rx: ClientRx<B>) -> Client<B> {
             Client {
@@ -565,13 +567,13 @@ cfg_client! {
     {
         type PollItem = RequestHead;
         type PollBody = B;
-        type PollError = crate::common::Never;
+        type PollError = Infallible;
         type RecvItem = crate::proto::ResponseHead;
 
         fn poll_msg(
             mut self: Pin<&mut Self>,
             cx: &mut task::Context<'_>,
-        ) -> Poll<Option<Result<(Self::PollItem, Self::PollBody), crate::common::Never>>> {
+        ) -> Poll<Option<Result<(Self::PollItem, Self::PollBody), Infallible>>> {
             let mut this = self.as_mut();
             debug_assert!(!this.rx_closed);
             match this.rx.poll_recv(cx) {

src/proto/h2/client.rs

@@ -1,6 +1,4 @@
-use std::marker::PhantomData;
-
-use std::time::Duration;
+use std::{convert::Infallible, marker::PhantomData, time::Duration};
 
 use crate::rt::{Read, Write};
 use bytes::Bytes;
@@ -19,7 +17,7 @@ use crate::body::{Body, Incoming as IncomingBody};
 use crate::client::dispatch::{Callback, SendWhen};
 use crate::common::io::Compat;
 use crate::common::time::Time;
-use crate::common::{task, Future, Never, Pin, Poll};
+use crate::common::{task, Future, Pin, Poll};
 use crate::ext::Protocol;
 use crate::headers;
 use crate::proto::h2::UpgradedSendStream;
@@ -33,11 +31,11 @@ type ClientRx<B> = crate::client::dispatch::Receiver<Request<B>, Response<Incomi
 
 ///// An mpsc channel is used to help notify the `Connection` task when *all*
 ///// other handles to it have been dropped, so that it can shutdown.
-type ConnDropRef = mpsc::Sender<Never>;
+type ConnDropRef = mpsc::Sender<Infallible>;
 
 ///// A oneshot channel watches the `Connection` task, and when it completes,
 ///// the "dispatch" task will be notified and can shutdown sooner.
-type ConnEof = oneshot::Receiver<Never>;
+type ConnEof = oneshot::Receiver<Infallible>;
 
 // Our defaults are chosen for the "majority" case, which usually are not
 // resource constrained, and so the spec default of 64kb can be too limiting
@@ -267,9 +265,9 @@ pin_project! {
         T: Unpin,
     {
         #[pin]
-        drop_rx: StreamFuture<Receiver<Never>>,
+        drop_rx: StreamFuture<Receiver<Infallible>>,
         #[pin]
-        cancel_tx: Option<oneshot::Sender<Never>>,
+        cancel_tx: Option<oneshot::Sender<Infallible>>,
         #[pin]
         conn: ConnMapErr<T, B>,
     }
@@ -282,8 +280,8 @@ where
 {
     fn new(
         conn: ConnMapErr<T, B>,
-        drop_rx: StreamFuture<Receiver<Never>>,
-        cancel_tx: oneshot::Sender<Never>,
+        drop_rx: StreamFuture<Receiver<Infallible>>,
+        cancel_tx: oneshot::Sender<Infallible>,
     ) -> Self {
         Self {
             drop_rx,
@@ -421,7 +419,7 @@ pin_project! {
         #[pin]
         pipe: PipeToSendStream<S>,
         #[pin]
-        conn_drop_ref: Option<Sender<Never>>,
+        conn_drop_ref: Option<Sender<Infallible>>,
         #[pin]
         ping: Option<Recorder>,
     }