chore(lib): add dyn keyword to trait objects (#1820)

Requires Rust 1.27.
hyperium · Jun 3, 2019 · 01c03db · 01c03db
1 parent e0f5a9c
commit 01c03db
Show file tree

Hide file tree

Showing 28 changed files with 107 additions and 94 deletions.
diff --git a/.travis.yml b/.travis.yml
@@ -13,7 +13,7 @@ matrix:
         - rust: stable
           env: FEATURES="--no-default-features"
         # Minimum Supported Rust Version
-        - rust: 1.26.0
+        - rust: 1.27.0
           env: FEATURES="--no-default-features --features runtime" BUILD_ONLY="1"
 
 before_script:

diff --git a/examples/echo.rs b/examples/echo.rs
@@ -1,3 +1,4 @@
+#![deny(warnings)]
 extern crate futures;
 extern crate hyper;
 
@@ -12,7 +13,7 @@ use hyper::{Body, Method, Request, Response, Server, StatusCode};
 ///
 /// A boxed Future (trait object) is used as it is easier to understand
 /// and extend with more types. Advanced users could switch to `Either`.
-type BoxFut = Box<Future<Item = Response<Body>, Error = hyper::Error> + Send>;
+type BoxFut = Box<dyn Future<Item = Response<Body>, Error = hyper::Error> + Send>;
 
 /// This is our service handler. It receives a Request, routes on its
 /// path, and returns a Future of a Response.

diff --git a/examples/params.rs b/examples/params.rs
@@ -17,7 +17,7 @@ static MISSING: &[u8] = b"Missing field";
 static NOTNUMERIC: &[u8] = b"Number field is not numeric";
 
 // Using service_fn, we can turn this function into a `Service`.
-fn param_example(req: Request<Body>) -> Box<Future<Item=Response<Body>, Error=hyper::Error> + Send> {
+fn param_example(req: Request<Body>) -> Box<dyn Future<Item=Response<Body>, Error=hyper::Error> + Send> {
     match (req.method(), req.uri().path()) {
         (&Method::GET, "/") | (&Method::GET, "/post") => {
             Box::new(future::ok(Response::new(INDEX.into())))

diff --git a/examples/send_file.rs b/examples/send_file.rs
@@ -30,7 +30,7 @@ fn main() {
     hyper::rt::run(server);
 }
 
-type ResponseFuture = Box<Future<Item=Response<Body>, Error=io::Error> + Send>;
+type ResponseFuture = Box<dyn Future<Item=Response<Body>, Error=io::Error> + Send>;
 
 fn response_examples(req: Request<Body>) -> ResponseFuture {
     match (req.method(), req.uri().path()) {

diff --git a/examples/web_api.rs b/examples/web_api.rs
@@ -16,7 +16,7 @@ static INDEX: &[u8] = b"<a href=\"test.html\">test.html</a>";
 static POST_DATA: &str = r#"{"original": "data"}"#;
 
 type GenericError = Box<dyn std::error::Error + Send + Sync>;
-type ResponseFuture = Box<Future<Item=Response<Body>, Error=GenericError> + Send>;
+type ResponseFuture = Box<dyn Future<Item=Response<Body>, Error=GenericError> + Send>;
 
 fn client_request_response(client: &Client<HttpConnector>) -> ResponseFuture {
      let req = Request::builder()

diff --git a/src/body/body.rs b/src/body/body.rs
@@ -1,4 +1,5 @@
 use std::borrow::Cow;
+use std::error::Error as StdError;
 use std::fmt;
 
 use bytes::Bytes;
@@ -39,7 +40,7 @@ enum Kind {
         content_length: Option<u64>,
         recv: h2::RecvStream,
     },
-    Wrapped(Box<Stream<Item = Chunk, Error = Box<::std::error::Error + Send + Sync>> + Send>),
+    Wrapped(Box<dyn Stream<Item = Chunk, Error = Box<dyn StdError + Send + Sync>> + Send>),
 }
 
 struct Extra {
@@ -141,7 +142,7 @@ impl Body {
     pub fn wrap_stream<S>(stream: S) -> Body
     where
         S: Stream + Send + 'static,
-        S::Error: Into<Box<::std::error::Error + Send + Sync>>,
+        S::Error: Into<Box<dyn StdError + Send + Sync>>,
         Chunk: From<S::Item>,
     {
         let mapped = stream.map(Chunk::from).map_err(Into::into);
@@ -457,13 +458,13 @@ impl From<Chunk> for Body {
 }
 
 impl
-    From<Box<Stream<Item = Chunk, Error = Box<::std::error::Error + Send + Sync>> + Send + 'static>>
+    From<Box<dyn Stream<Item = Chunk, Error = Box<dyn StdError + Send + Sync>> + Send + 'static>>
     for Body
 {
     #[inline]
     fn from(
         stream: Box<
-            Stream<Item = Chunk, Error = Box<::std::error::Error + Send + Sync>> + Send + 'static,
+            dyn Stream<Item = Chunk, Error = Box<dyn StdError + Send + Sync>> + Send + 'static,
         >,
     ) -> Body {
         Body::new(Kind::Wrapped(stream))

diff --git a/src/body/payload.rs b/src/body/payload.rs
@@ -1,3 +1,5 @@
+use std::error::Error as StdError;
+
 use bytes::Buf;
 use futures::{Async, Poll};
 use http::HeaderMap;
@@ -13,7 +15,7 @@ pub trait Payload: Send + 'static {
     type Data: Buf + Send;
 
     /// The error type of this stream.
-    type Error: Into<Box<::std::error::Error + Send + Sync>>;
+    type Error: Into<Box<dyn StdError + Send + Sync>>;
 
     /// Poll for a `Data` buffer.
     ///

diff --git a/src/client/conn.rs b/src/client/conn.rs
@@ -98,7 +98,7 @@ pub struct Handshake<T, B> {
 pub struct ResponseFuture {
     // for now, a Box is used to hide away the internal `B`
     // that can be returned if canceled
-    inner: Box<Future<Item=Response<Body>, Error=::Error> + Send>,
+    inner: Box<dyn Future<Item=Response<Body>, Error=::Error> + Send>,
 }
 
 /// Deconstructed parts of a `Connection`.
@@ -464,7 +464,7 @@ impl Builder {
     /// Provide an executor to execute background HTTP2 tasks.
     pub fn executor<E>(&mut self, exec: E) -> &mut Builder
     where
-        E: Executor<Box<Future<Item=(), Error=()> + Send>> + Send + Sync + 'static,
+        E: Executor<Box<dyn Future<Item=(), Error=()> + Send>> + Send + Sync + 'static,
     {
         self.exec = Exec::Executor(Arc::new(exec));
         self

diff --git a/src/client/connect/dns.rs b/src/client/connect/dns.rs
@@ -184,7 +184,7 @@ impl fmt::Debug for GaiAddrs {
 }
 
 #[derive(Clone)]
-struct GaiExecutor(Arc<Executor<GaiTask> + Send + Sync>);
+struct GaiExecutor(Arc<dyn Executor<GaiTask> + Send + Sync>);
 
 impl Executor<oneshot::Execute<GaiBlocking>> for GaiExecutor {
     fn execute(&self, future: oneshot::Execute<GaiBlocking>) -> Result<(), ExecuteError<oneshot::Execute<GaiBlocking>>> {

diff --git a/src/client/connect/mod.rs b/src/client/connect/mod.rs
@@ -27,7 +27,7 @@ pub trait Connect: Send + Sync {
     /// The connected IO Stream.
     type Transport: AsyncRead + AsyncWrite + Send + 'static;
     /// An error occured when trying to connect.
-    type Error: Into<Box<StdError + Send + Sync>>;
+    type Error: Into<Box<dyn StdError + Send + Sync>>;
     /// A Future that will resolve to the connected Transport.
     type Future: Future<Item=(Self::Transport, Connected), Error=Self::Error> + Send;
     /// Connect to a destination.
@@ -53,7 +53,7 @@ pub struct Connected {
     pub(super) extra: Option<Extra>,
 }
 
-pub(super) struct Extra(Box<ExtraInner>);
+pub(super) struct Extra(Box<dyn ExtraInner>);
 
 #[derive(Clone, Copy, Debug, PartialEq)]
 pub(super) enum Alpn {
@@ -344,7 +344,7 @@ impl fmt::Debug for Extra {
 }
 
 trait ExtraInner: Send + Sync {
-    fn clone_box(&self) -> Box<ExtraInner>;
+    fn clone_box(&self) -> Box<dyn ExtraInner>;
     fn set(&self, res: &mut Response<::Body>);
 }
 
@@ -358,7 +358,7 @@ impl<T> ExtraInner for ExtraEnvelope<T>
 where
     T: Clone + Send + Sync + 'static
 {
-    fn clone_box(&self) -> Box<ExtraInner> {
+    fn clone_box(&self) -> Box<dyn ExtraInner> {
         Box::new(self.clone())
     }
 
@@ -367,7 +367,7 @@ where
     }
 }
 
-struct ExtraChain<T>(Box<ExtraInner>, T);
+struct ExtraChain<T>(Box<dyn ExtraInner>, T);
 
 impl<T: Clone> Clone for ExtraChain<T> {
     fn clone(&self) -> Self {
@@ -379,7 +379,7 @@ impl<T> ExtraInner for ExtraChain<T>
 where
     T: Clone + Send + Sync + 'static
 {
-    fn clone_box(&self) -> Box<ExtraInner> {
+    fn clone_box(&self) -> Box<dyn ExtraInner> {
         Box::new(self.clone())
     }
 

diff --git a/src/client/mod.rs b/src/client/mod.rs
@@ -583,11 +583,11 @@ impl<C, B> fmt::Debug for Client<C, B> {
 /// This is returned by `Client::request` (and `Client::get`).
 #[must_use = "futures do nothing unless polled"]
 pub struct ResponseFuture {
-    inner: Box<Future<Item=Response<Body>, Error=::Error> + Send>,
+    inner: Box<dyn Future<Item=Response<Body>, Error=::Error> + Send>,
 }
 
 impl ResponseFuture {
-    fn new(fut: Box<Future<Item=Response<Body>, Error=::Error> + Send>) -> Self {
+    fn new(fut: Box<dyn Future<Item=Response<Body>, Error=::Error> + Send>) -> Self {
         Self {
             inner: fut,
         }
@@ -1030,7 +1030,7 @@ impl Builder {
     /// Provide an executor to execute background `Connection` tasks.
     pub fn executor<E>(&mut self, exec: E) -> &mut Self
     where
-        E: Executor<Box<Future<Item=(), Error=()> + Send>> + Send + Sync + 'static,
+        E: Executor<Box<dyn Future<Item=(), Error=()> + Send>> + Send + Sync + 'static,
     {
         self.conn_builder.executor(exec);
         self

diff --git a/src/common/exec.rs b/src/common/exec.rs
@@ -21,7 +21,7 @@ pub trait NewSvcExec<I, N, S: Service, E, W: Watcher<I, S, E>>: Clone {
 #[derive(Clone)]
 pub enum Exec {
     Default,
-    Executor(Arc<Executor<Box<Future<Item=(), Error=()> + Send>> + Send + Sync>),
+    Executor(Arc<dyn Executor<Box<dyn Future<Item=(), Error=()> + Send>> + Send + Sync>),
 }
 
 // ===== impl Exec =====

diff --git a/src/error.rs b/src/error.rs
@@ -10,7 +10,7 @@ use h2;
 /// Result type often returned from methods that can have hyper `Error`s.
 pub type Result<T> = ::std::result::Result<T, Error>;
 
-type Cause = Box<StdError + Send + Sync>;
+type Cause = Box<dyn StdError + Send + Sync>;
 
 /// Represents errors that can occur handling HTTP streams.
 pub struct Error {
@@ -135,12 +135,12 @@ impl Error {
 
     #[doc(hidden)]
     #[cfg_attr(error_source, deprecated(note = "use Error::source instead"))]
-    pub fn cause2(&self) -> Option<&(StdError + 'static + Sync + Send)> {
+    pub fn cause2(&self) -> Option<&(dyn StdError + 'static + Sync + Send)> {
         self.inner.cause.as_ref().map(|e| &**e)
     }
 
     /// Consumes the error, returning its cause.
-    pub fn into_cause(self) -> Option<Box<StdError + Sync + Send>> {
+    pub fn into_cause(self) -> Option<Box<dyn StdError + Sync + Send>> {
         self.inner.cause
     }
 
@@ -380,12 +380,12 @@ impl StdError for Error {
     }
 
     #[cfg(error_source)]
-    fn source(&self) -> Option<&(StdError + 'static)> {
+    fn source(&self) -> Option<&(dyn StdError + 'static)> {
         self
             .inner
             .cause
             .as_ref()
-            .map(|cause| &**cause as &(StdError + 'static))
+            .map(|cause| &**cause as &(dyn StdError + 'static))
     }
 }
 

diff --git a/src/mock.rs b/src/mock.rs
@@ -435,7 +435,7 @@ impl Drop for DuplexHandle {
 }
 
 #[cfg(feature = "runtime")]
-type BoxedConnectFut = Box<Future<Item=(Duplex, Connected), Error=io::Error> + Send>;
+type BoxedConnectFut = Box<dyn Future<Item=(Duplex, Connected), Error=io::Error> + Send>;
 
 #[cfg(feature = "runtime")]
 #[derive(Clone)]

diff --git a/src/proto/h1/decode.rs b/src/proto/h1/decode.rs
@@ -186,15 +186,15 @@ impl ChunkedState {
         trace!("Read chunk hex size");
         let radix = 16;
         match byte!(rdr) {
-            b @ b'0'...b'9' => {
+            b @ b'0'..=b'9' => {
                 *size *= radix;
                 *size += (b - b'0') as u64;
             }
-            b @ b'a'...b'f' => {
+            b @ b'a'..=b'f' => {
                 *size *= radix;
                 *size += (b + 10 - b'a') as u64;
             }
-            b @ b'A'...b'F' => {
+            b @ b'A'..=b'F' => {
                 *size *= radix;
                 *size += (b + 10 - b'A') as u64;
             }

diff --git a/src/proto/h1/dispatch.rs b/src/proto/h1/dispatch.rs
@@ -1,3 +1,5 @@
+use std::error::Error as StdError;
+
 use bytes::{Buf, Bytes};
 use futures::{Async, Future, Poll, Stream};
 use http::{Request, Response, StatusCode};
@@ -44,7 +46,7 @@ type ClientRx<B> = ::client::dispatch::Receiver<Request<B>, Response<Body>>;
 impl<D, Bs, I, T> Dispatcher<D, Bs, I, T>
 where
     D: Dispatch<PollItem=MessageHead<T::Outgoing>, PollBody=Bs, RecvItem=MessageHead<T::Incoming>>,
-    D::PollError: Into<Box<::std::error::Error + Send + Sync>>,
+    D::PollError: Into<Box<dyn StdError + Send + Sync>>,
     I: AsyncRead + AsyncWrite,
     T: Http1Transaction,
     Bs: Payload,
@@ -334,7 +336,7 @@ where
 impl<D, Bs, I, T> Future for Dispatcher<D, Bs, I, T>
 where
     D: Dispatch<PollItem=MessageHead<T::Outgoing>, PollBody=Bs, RecvItem=MessageHead<T::Incoming>>,
-    D::PollError: Into<Box<::std::error::Error + Send + Sync>>,
+    D::PollError: Into<Box<dyn StdError + Send + Sync>>,
     I: AsyncRead + AsyncWrite,
     T: Http1Transaction,
     Bs: Payload,
@@ -365,7 +367,7 @@ impl<S> Server<S> where S: Service {
 impl<S, Bs> Dispatch for Server<S>
 where
     S: Service<ReqBody=Body, ResBody=Bs>,
-    S::Error: Into<Box<::std::error::Error + Send + Sync>>,
+    S::Error: Into<Box<dyn StdError + Send + Sync>>,
     Bs: Payload,
 {
     type PollItem = MessageHead<StatusCode>;

diff --git a/src/proto/h1/role.rs b/src/proto/h1/role.rs
@@ -717,7 +717,7 @@ impl Client {
             101 => {
                 return Ok(Some((DecodedLength::ZERO, true)));
             },
-            100...199 => {
+            100..=199 => {
                 trace!("ignoring informational response: {}", inc.subject.as_u16());
                 return Ok(None);
             },
@@ -729,7 +729,7 @@ impl Client {
             Some(Method::HEAD) => {
                 return Ok(Some((DecodedLength::ZERO, false)));
             }
-            Some(Method::CONNECT) => if let 200...299 = inc.subject.as_u16() {
+            Some(Method::CONNECT) => if let 200..=299 = inc.subject.as_u16() {
                 return Ok(Some((DecodedLength::ZERO, true)));
             }
             Some(_) => {},

diff --git a/src/proto/h2/server.rs b/src/proto/h2/server.rs
@@ -1,3 +1,5 @@
+use std::error::Error as StdError;
+
 use futures::{Async, Future, Poll, Stream};
 use h2::Reason;
 use h2::server::{Builder, Connection, Handshake, SendResponse};
@@ -46,7 +48,7 @@ impl<T, S, B, E> Server<T, S, B, E>
 where
     T: AsyncRead + AsyncWrite,
     S: Service<ReqBody=Body, ResBody=B>,
-    S::Error: Into<Box<::std::error::Error + Send + Sync>>,
+    S::Error: Into<Box<dyn StdError + Send + Sync>>,
     B: Payload,
     E: H2Exec<S::Future, B>,
 {
@@ -83,7 +85,7 @@ impl<T, S, B, E> Future for Server<T, S, B, E>
 where
     T: AsyncRead + AsyncWrite,
     S: Service<ReqBody=Body, ResBody=B>,
-    S::Error: Into<Box<::std::error::Error + Send + Sync>>,
+    S::Error: Into<Box<dyn StdError + Send + Sync>>,
     B: Payload,
     E: H2Exec<S::Future, B>,
 {
@@ -126,7 +128,7 @@ where
             ReqBody=Body,
             ResBody=B,
         >,
-        S::Error: Into<Box<::std::error::Error + Send + Sync>>,
+        S::Error: Into<Box<dyn StdError + Send + Sync>>,
         E: H2Exec<S::Future, B>,
     {
         if self.closing.is_none() {
@@ -203,7 +205,7 @@ where
 impl<F, B> H2Stream<F, B>
 where
     F: Future<Item=Response<B>>,
-    F::Error: Into<Box<::std::error::Error + Send + Sync>>,
+    F::Error: Into<Box<dyn StdError + Send + Sync>>,
     B: Payload,
 {
     fn new(fut: F, respond: SendResponse<SendBuf<B::Data>>) -> H2Stream<F, B> {
@@ -296,7 +298,7 @@ where
 impl<F, B> Future for H2Stream<F, B>
 where
     F: Future<Item=Response<B>>,
-    F::Error: Into<Box<::std::error::Error + Send + Sync>>,
+    F::Error: Into<Box<dyn StdError + Send + Sync>>,
     B: Payload,
 {
     type Item = ();