error: Replace Never with std::convert::Infallible (#1158)

olix0r · web-flow · commit c8ba39f31392 · 2021-07-21T13:34:56.000-07:00
We define an `error::Never` type that is effectively identical to the
`std::convert::Infallible` type--and `Infallible` has a clearer name and
provides implementations for more common traits. Most importantly, it's
less surprising for new contributors.

This change removes our `Never` type and re-exports `Infallible` from
the `linkerd_error` crate.

There are no functional changes.
diff --git a/linkerd/app/core/src/lib.rs b/linkerd/app/core/src/lib.rs
@@ -17,7 +17,7 @@ pub use linkerd_cache as cache;
 pub use linkerd_conditional::Conditional;
 pub use linkerd_detect as detect;
 pub use linkerd_dns;
-pub use linkerd_error::{Error, Never, Recover};
+pub use linkerd_error::{Error, Infallible, Recover};
 pub use linkerd_exp_backoff as exp_backoff;
 pub use linkerd_http_metrics as http_metrics;
 pub use linkerd_identity as identity;
diff --git a/linkerd/app/gateway/src/lib.rs b/linkerd/app/gateway/src/lib.rs
@@ -19,7 +19,7 @@ use linkerd_app_core::{
     svc::{self, Param},
     tls,
     transport_header::SessionProtocol,
-    Error, NameAddr, NameMatch, Never,
+    Error, Infallible, NameAddr, NameMatch,
 };
 use linkerd_app_inbound::{
     direct::{ClientInfo, GatewayConnection, GatewayTransportHeader},
@@ -185,7 +185,7 @@ where
         .clone()
         .push_http_logical(resolve)
         .into_stack()
-        .push_switch(Ok::<_, Never>, endpoint.into_stack())
+        .push_switch(Ok::<_, Infallible>, endpoint.into_stack())
         .push(NewGateway::layer(local_id))
         .push(profiles::discover::layer(profiles, move |t: HttpTarget| {
             if allow_discovery.matches(t.target.name()) {
@@ -264,15 +264,15 @@ where
                         SessionProtocol::Http2 => http::Version::H2,
                     },
                 })),
-                None => Ok::<_, Never>(svc::Either::B(target)),
+                None => Ok::<_, Infallible>(svc::Either::B(target)),
             },
             tcp.push_on_response(svc::BoxService::layer())
                 .push(svc::BoxNewService::layer())
                 .into_inner(),
         )
         .push_switch(
             |gw| match gw {
-                GatewayConnection::TransportHeader(t) => Ok::<_, Never>(svc::Either::A(t)),
+                GatewayConnection::TransportHeader(t) => Ok::<_, Infallible>(svc::Either::A(t)),
                 GatewayConnection::Legacy(c) => Ok(svc::Either::B(c)),
             },
             legacy_http.into_inner(),
diff --git a/linkerd/app/inbound/src/direct.rs b/linkerd/app/inbound/src/direct.rs
@@ -6,7 +6,7 @@ use linkerd_app_core::{
     tls,
     transport::{self, metrics::SensorIo, ClientAddr, OrigDstAddr, Remote},
     transport_header::{self, NewTransportHeaderServer, SessionProtocol, TransportHeader},
-    Conditional, Error, NameAddr, Never,
+    Conditional, Error, Infallible, NameAddr,
 };
 use std::{convert::TryFrom, fmt::Debug, net::SocketAddr};
 use thiserror::Error;
@@ -135,7 +135,7 @@ impl<N> Inbound<N> {
                 .push_switch(
                     |client: ClientInfo| {
                         if client.header_negotiated() {
-                            Ok::<_, Never>(svc::Either::A(client))
+                            Ok::<_, Infallible>(svc::Either::A(client))
                         } else {
                             Ok(svc::Either::B(GatewayConnection::Legacy(client)))
                         }
diff --git a/linkerd/app/inbound/src/lib.rs b/linkerd/app/inbound/src/lib.rs
@@ -28,7 +28,7 @@ use linkerd_app_core::{
     proxy::tcp,
     serve, svc, tls,
     transport::{self, listen::Bind, ClientAddr, Local, OrigDstAddr, Remote, ServerAddr},
-    Error, NameMatch, Never, ProxyRuntime,
+    Error, Infallible, NameMatch, ProxyRuntime,
 };
 use std::{convert::TryFrom, fmt::Debug, future::Future, time::Duration};
 use tracing::{debug_span, info_span};
@@ -282,10 +282,10 @@ where
                 detect
                     .instrument(|_: &_| debug_span!("proxy"))
                     .push_switch(
-                        move |t: T| {
+                        move |t: T| -> Result<_, Infallible> {
                             let OrigDstAddr(addr) = t.param();
                             if !disable_detect.contains(&addr.port()) {
-                                Ok::<_, Never>(svc::Either::A(t))
+                                Ok(svc::Either::A(t))
                             } else {
                                 Ok(svc::Either::B(TcpAccept::port_skipped(t)))
                             }
diff --git a/linkerd/app/outbound/src/http/endpoint.rs b/linkerd/app/outbound/src/http/endpoint.rs
@@ -73,7 +73,7 @@ mod test {
         io,
         proxy::api_resolve::Metadata,
         svc::{NewService, ServiceExt},
-        Never,
+        Infallible,
     };
     use std::net::SocketAddr;
 
@@ -259,7 +259,7 @@ mod test {
                 .fold(rsp, |rsp, orig_proto| {
                     rsp.header(WAS_ORIG_PROTO, orig_proto)
                 });
-            future::ok::<_, Never>(rsp.body(hyper::Body::default()).unwrap())
+            future::ok::<_, Infallible>(rsp.body(hyper::Body::default()).unwrap())
         });
 
         let mut http = hyper::server::conn::Http::new();
diff --git a/linkerd/app/outbound/src/http/logical.rs b/linkerd/app/outbound/src/http/logical.rs
@@ -8,7 +8,7 @@ use linkerd_app_core::{
         http,
         resolve::map_endpoint,
     },
-    retry, svc, Error, Never,
+    retry, svc, Error, Infallible,
 };
 use tracing::debug_span;
 
@@ -43,7 +43,7 @@ impl<E> Outbound<E> {
             let identity_disabled = rt.identity.is_none();
             let resolve = svc::stack(resolve.into_service())
                 .check_service::<ConcreteAddr>()
-                .push_request_filter(|c: Concrete| Ok::<_, Never>(c.resolve))
+                .push_request_filter(|c: Concrete| Ok::<_, Infallible>(c.resolve))
                 .push(svc::layer::mk(move |inner| {
                     map_endpoint::Resolve::new(endpoint::FromMetadata { identity_disabled }, inner)
                 }))
diff --git a/linkerd/app/outbound/src/ingress.rs b/linkerd/app/outbound/src/ingress.rs
@@ -9,7 +9,7 @@ use linkerd_app_core::{
     svc::{self, stack::Param},
     tls,
     transport::{OrigDstAddr, Remote, ServerAddr},
-    AddrMatch, Error, NameAddr, Never,
+    AddrMatch, Error, Infallible, NameAddr,
 };
 use thiserror::Error;
 use tracing::{debug_span, info_span};
@@ -153,7 +153,7 @@ impl Outbound<svc::BoxNewHttp<http::Endpoint>> {
             .push_switch(
                 |Http { target, version }: Http<Target>| match target {
                     Target::Override(target) => {
-                        Ok::<_, Never>(svc::Either::A(Http { target, version }))
+                        Ok::<_, Infallible>(svc::Either::A(Http { target, version }))
                     }
                     Target::Forward(OrigDstAddr(addr)) => Ok(svc::Either::B(http::Endpoint {
                         addr: Remote(ServerAddr(addr)),
diff --git a/linkerd/app/outbound/src/switch_logical.rs b/linkerd/app/outbound/src/switch_logical.rs
@@ -1,5 +1,5 @@
 use crate::{endpoint::Endpoint, logical::Logical, tcp, transport::OrigDstAddr, Outbound};
-use linkerd_app_core::{io, profiles, svc, Error, Never};
+use linkerd_app_core::{io, profiles, svc, Error, Infallible};
 use std::fmt;
 
 impl<S> Outbound<S> {
@@ -29,7 +29,7 @@ impl<S> Outbound<S> {
         self.map_stack(|_, _, endpoint| {
             endpoint
                 .push_switch(
-                    move |(profile, target): (Option<profiles::Receiver>, T)| -> Result<_, Never> {
+                    move |(profile, target): (Option<profiles::Receiver>, T)| -> Result<_, Infallible> {
                         if let Some(rx) = profile {
                             // If the profile provides an endpoint, then the target is single endpoint and
                             // not a logical/load-balanced service.
diff --git a/linkerd/app/outbound/src/tcp/logical.rs b/linkerd/app/outbound/src/tcp/logical.rs
@@ -8,7 +8,7 @@ use linkerd_app_core::{
         resolve::map_endpoint,
         tcp,
     },
-    svc, Conditional, Error, Never,
+    svc, Conditional, Error, Infallible,
 };
 use tracing::debug_span;
 
@@ -51,7 +51,7 @@ where
             let identity_disabled = rt.identity.is_none();
             let resolve = svc::stack(resolve.into_service())
                 .check_service::<ConcreteAddr>()
-                .push_request_filter(|c: Concrete| Ok::<_, Never>(c.resolve))
+                .push_request_filter(|c: Concrete| Ok::<_, Infallible>(c.resolve))
                 .push(svc::layer::mk(move |inner| {
                     map_endpoint::Resolve::new(endpoint::FromMetadata { identity_disabled }, inner)
                 }))
diff --git a/linkerd/error/src/lib.rs b/linkerd/error/src/lib.rs
@@ -2,10 +2,9 @@
 #![forbid(unsafe_code)]
 #![allow(clippy::inconsistent_struct_constructor)]
 
-mod never;
 pub mod recover;
 
-pub use self::never::Never;
 pub use self::recover::Recover;
+pub use std::convert::Infallible;
 
 pub type Error = Box<dyn std::error::Error + Send + Sync>;
diff --git a/linkerd/error/src/never.rs b/linkerd/error/src/never.rs
diff --git a/linkerd/proxy/discover/src/buffer.rs b/linkerd/proxy/discover/src/buffer.rs
@@ -1,5 +1,5 @@
 use futures::{ready, Stream, TryFuture};
-use linkerd_error::{Error, Never};
+use linkerd_error::{Error, Infallible};
 use pin_project::pin_project;
 use std::future::Future;
 use std::pin::Pin;
@@ -24,7 +24,7 @@ pub struct Buffer<M> {
 pub struct Discover<K, S> {
     #[pin]
     rx: mpsc::Receiver<discover::Change<K, S>>,
-    _disconnect_tx: oneshot::Sender<Never>,
+    _disconnect_tx: oneshot::Sender<Infallible>,
 }
 
 #[pin_project]
@@ -41,7 +41,7 @@ pub struct Daemon<D: discover::Discover> {
     #[pin]
     discover: D,
     #[pin]
-    disconnect_rx: oneshot::Receiver<Never>,
+    disconnect_rx: oneshot::Receiver<Infallible>,
     tx: PollSender<discover::Change<D::Key, D::Service>>,
     #[pin]
     watchdog: Option<Sleep>,
diff --git a/linkerd/proxy/discover/src/from_resolve.rs b/linkerd/proxy/discover/src/from_resolve.rs
@@ -154,7 +154,7 @@ mod tests {
     use super::Discover;
     use async_stream::stream;
     use futures::prelude::*;
-    use linkerd_error::Never;
+    use linkerd_error::Infallible;
     use linkerd_proxy_core::resolve::Update;
     use std::net::SocketAddr;
     use tower::discover::Change;
@@ -168,7 +168,7 @@ mod tests {
     async fn reset() {
         tokio::pin! {
             let stream = stream! {
-                yield Ok::<_, Never>(Update::Add((1..=2).map(|n| (addr(n), n)).collect()));
+                yield Ok::<_, Infallible>(Update::Add((1..=2).map(|n| (addr(n), n)).collect()));
                 yield Ok(Update::Reset((2..=4).map(|n| (addr(n), n)).collect()));
             };
         }
diff --git a/linkerd/service-profiles/src/client.rs b/linkerd/service-profiles/src/client.rs
@@ -2,7 +2,7 @@ use crate::{proto, LookupAddr, Profile, Receiver};
 use futures::prelude::*;
 use http_body::Body;
 use linkerd2_proxy_api::destination::{self as api, destination_client::DestinationClient};
-use linkerd_error::{Never, Recover};
+use linkerd_error::{Infallible, Recover};
 use linkerd_stack::{Param, Service};
 use linkerd_tonic_watch::StreamWatch;
 use std::task::{Context, Poll};
@@ -55,8 +55,8 @@ where
     R::Backoff: Unpin + Send,
 {
     type Response = Option<Receiver>;
-    type Error = Never;
-    type Future = futures::future::BoxFuture<'static, Result<Option<Receiver>, Never>>;
+    type Error = Infallible;
+    type Future = futures::future::BoxFuture<'static, Result<Option<Receiver>, Infallible>>;
 
     #[inline]
     fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
@@ -76,7 +76,7 @@ where
                 }
                 Err(status) => {
                     debug!(%status, "Ignoring profile");
-                    Ok::<_, Never>(None)
+                    Ok::<_, Infallible>(None)
                 }
             }
         })
diff --git a/linkerd/stack/src/make_thunk.rs b/linkerd/stack/src/make_thunk.rs
@@ -1,5 +1,5 @@
 use futures::future;
-use linkerd_error::Never;
+use linkerd_error::Infallible;
 use std::task::{Context, Poll};
 
 /// Wraps a `Service<T>` as a `Service<()>`.
@@ -34,10 +34,10 @@ impl<S: Clone, T> super::NewService<T> for MakeThunk<S> {
 
 impl<S: Clone, T> tower::Service<T> for MakeThunk<S> {
     type Response = Thunk<S, T>;
-    type Error = Never;
-    type Future = future::Ready<Result<Thunk<S, T>, Never>>;
+    type Error = Infallible;
+    type Future = future::Ready<Result<Thunk<S, T>, Infallible>>;
 
-    fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Never>> {
+    fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Infallible>> {
         Poll::Ready(Ok(()))
     }
 
diff --git a/linkerd/tls/tests/tls_accept.rs b/linkerd/tls/tests/tls_accept.rs
@@ -7,7 +7,7 @@
 
 use futures::prelude::*;
 use linkerd_conditional::Conditional;
-use linkerd_error::Never;
+use linkerd_error::Infallible;
 use linkerd_identity as id;
 use linkerd_io::{self as io, AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt};
 use linkerd_proxy_transport::{
@@ -169,7 +169,7 @@ where
                             sender
                                 .send(Transported { tls, result })
                                 .expect("send result");
-                            Ok::<(), Never>(())
+                            Ok::<(), Infallible>(())
                         }
                         .instrument(tracing::info_span!("test_svc")),
                     )
