Upgrade tokio-postgres to 2018 edition

Author: sfackler

tokio-postgres/Cargo.toml

@@ -2,6 +2,7 @@
 name = "tokio-postgres"
 version = "0.3.0"
 authors = ["Steven Fackler <[email protected]>"]
+edition = "2018"
 license = "MIT"
 description = "A native PostgreSQL driver using Tokio"
 repository = "https://github.com/sfackler/rust-postgres"

tokio-postgres/src/builder.rs

@@ -1,8 +1,8 @@
 use std::collections::HashMap;
 use tokio_io::{AsyncRead, AsyncWrite};
 
-use proto::ConnectFuture;
-use {Connect, TlsMode};
+use crate::proto::ConnectFuture;
+use crate::{Connect, TlsMode};
 
 #[derive(Clone)]
 pub struct Builder {

tokio-postgres/src/error/mod.rs

@@ -32,7 +32,7 @@ pub enum Severity {
 }
 
 impl fmt::Display for Severity {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         let s = match *self {
             Severity::Panic => "PANIC",
             Severity::Fatal => "FATAL",
@@ -85,7 +85,7 @@ pub struct DbError {
 }
 
 impl DbError {
-    pub(crate) fn new(fields: &mut ErrorFields) -> io::Result<DbError> {
+    pub(crate) fn new(fields: &mut ErrorFields<'_>) -> io::Result<DbError> {
         let mut severity = None;
         let mut parsed_severity = None;
         let mut code = None;
@@ -307,7 +307,7 @@ impl DbError {
 }
 
 impl fmt::Display for DbError {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(fmt, "{}: {}", self.severity, self.message)
     }
 }
@@ -348,14 +348,14 @@ enum Kind {
 
 struct ErrorInner {
     kind: Kind,
-    cause: Option<Box<error::Error + Sync + Send>>,
+    cause: Option<Box<dyn error::Error + Sync + Send>>,
 }
 
 /// An error communicating with the Postgres server.
 pub struct Error(Box<ErrorInner>);
 
 impl fmt::Debug for Error {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         fmt.debug_struct("Error")
             .field("kind", &self.0.kind)
             .field("cause", &self.0.cause)
@@ -364,7 +364,7 @@ impl fmt::Debug for Error {
 }
 
 impl fmt::Display for Error {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         let s = match self.0.kind {
             Kind::Io => "error communicating with the server",
             Kind::UnexpectedMessage => "unexpected message from server",
@@ -390,14 +390,14 @@ impl fmt::Display for Error {
 }
 
 impl error::Error for Error {
-    fn source(&self) -> Option<&(error::Error + 'static)> {
+    fn source(&self) -> Option<&(dyn error::Error + 'static)> {
         self.0.cause.as_ref().map(|e| &**e as _)
     }
 }
 
 impl Error {
     /// Consumes the error, returning its cause.
-    pub fn into_cause(self) -> Option<Box<error::Error + Sync + Send>> {
+    pub fn into_cause(self) -> Option<Box<dyn error::Error + Sync + Send>> {
         self.0.cause
     }
 
@@ -411,7 +411,7 @@ impl Error {
             .map(|e| e.code())
     }
 
-    fn new(kind: Kind, cause: Option<Box<error::Error + Sync + Send>>) -> Error {
+    fn new(kind: Kind, cause: Option<Box<dyn error::Error + Sync + Send>>) -> Error {
         Error(Box::new(ErrorInner { kind, cause }))
     }
 
@@ -438,17 +438,17 @@ impl Error {
         Error::new(Kind::Encode, Some(Box::new(e)))
     }
 
-    pub(crate) fn to_sql(e: Box<error::Error + Sync + Send>) -> Error {
+    pub(crate) fn to_sql(e: Box<dyn error::Error + Sync + Send>) -> Error {
         Error::new(Kind::ToSql, Some(e))
     }
 
-    pub(crate) fn from_sql(e: Box<error::Error + Sync + Send>) -> Error {
+    pub(crate) fn from_sql(e: Box<dyn error::Error + Sync + Send>) -> Error {
         Error::new(Kind::FromSql, Some(e))
     }
 
     pub(crate) fn copy_in_stream<E>(e: E) -> Error
     where
-        E: Into<Box<error::Error + Sync + Send>>,
+        E: Into<Box<dyn error::Error + Sync + Send>>,
     {
         Error::new(Kind::CopyInStream, Some(e.into()))
     }
@@ -465,7 +465,7 @@ impl Error {
         Error::new(Kind::UnsupportedAuthentication, None)
     }
 
-    pub(crate) fn tls(e: Box<error::Error + Sync + Send>) -> Error {
+    pub(crate) fn tls(e: Box<dyn error::Error + Sync + Send>) -> Error {
         Error::new(Kind::Tls, Some(e))
     }
 

tokio-postgres/src/lib.rs

@@ -1,34 +1,19 @@
-extern crate antidote;
-extern crate bytes;
-extern crate fallible_iterator;
-extern crate futures_cpupool;
-extern crate phf;
-extern crate postgres_protocol;
-extern crate tokio_codec;
-extern crate tokio_io;
-extern crate void;
-
-#[macro_use]
-extern crate futures;
-#[macro_use]
-extern crate log;
-#[macro_use]
-extern crate state_machine_future;
+#![warn(rust_2018_idioms)]
 
 use bytes::{Bytes, IntoBuf};
-use futures::{Async, Future, Poll, Stream};
+use futures::{try_ready, Async, Future, Poll, Stream};
 use std::error::Error as StdError;
 use std::fmt;
 use std::sync::atomic::{AtomicUsize, Ordering};
 use tokio_io::{AsyncRead, AsyncWrite};
 
-pub use builder::*;
-pub use error::*;
-use proto::CancelFuture;
-use rows::RowIndex;
-pub use stmt::Column;
-pub use tls::*;
-use types::{FromSql, ToSql, Type};
+pub use crate::builder::*;
+pub use crate::error::*;
+use crate::proto::CancelFuture;
+use crate::rows::RowIndex;
+pub use crate::stmt::Column;
+pub use crate::tls::*;
+use crate::types::{FromSql, ToSql, Type};
 
 mod builder;
 pub mod error;
@@ -67,34 +52,39 @@ impl Client {
         Prepare(self.0.prepare(next_statement(), query, param_types))
     }
 
-    pub fn execute(&mut self, statement: &Statement, params: &[&ToSql]) -> Execute {
+    pub fn execute(&mut self, statement: &Statement, params: &[&dyn ToSql]) -> Execute {
         Execute(self.0.execute(&statement.0, params))
     }
 
-    pub fn query(&mut self, statement: &Statement, params: &[&ToSql]) -> Query {
+    pub fn query(&mut self, statement: &Statement, params: &[&dyn ToSql]) -> Query {
         Query(self.0.query(&statement.0, params))
     }
 
-    pub fn bind(&mut self, statement: &Statement, params: &[&ToSql]) -> Bind {
+    pub fn bind(&mut self, statement: &Statement, params: &[&dyn ToSql]) -> Bind {
         Bind(self.0.bind(&statement.0, next_portal(), params))
     }
 
     pub fn query_portal(&mut self, portal: &Portal, max_rows: i32) -> QueryPortal {
         QueryPortal(self.0.query_portal(&portal.0, max_rows))
     }
 
-    pub fn copy_in<S>(&mut self, statement: &Statement, params: &[&ToSql], stream: S) -> CopyIn<S>
+    pub fn copy_in<S>(
+        &mut self,
+        statement: &Statement,
+        params: &[&dyn ToSql],
+        stream: S,
+    ) -> CopyIn<S>
     where
         S: Stream,
         S::Item: IntoBuf,
         <S::Item as IntoBuf>::Buf: Send,
         // FIXME error type?
-        S::Error: Into<Box<StdError + Sync + Send>>,
+        S::Error: Into<Box<dyn StdError + Sync + Send>>,
     {
         CopyIn(self.0.copy_in(&statement.0, params, stream))
     }
 
-    pub fn copy_out(&mut self, statement: &Statement, params: &[&ToSql]) -> CopyOut {
+    pub fn copy_out(&mut self, statement: &Statement, params: &[&dyn ToSql]) -> CopyOut {
         CopyOut(self.0.copy_out(&statement.0, params))
     }
 
@@ -282,14 +272,14 @@ where
     S: Stream,
     S::Item: IntoBuf,
     <S::Item as IntoBuf>::Buf: Send,
-    S::Error: Into<Box<StdError + Sync + Send>>;
+    S::Error: Into<Box<dyn StdError + Sync + Send>>;
 
 impl<S> Future for CopyIn<S>
 where
     S: Stream,
     S::Item: IntoBuf,
     <S::Item as IntoBuf>::Buf: Send,
-    S::Error: Into<Box<StdError + Sync + Send>>,
+    S::Error: Into<Box<dyn StdError + Sync + Send>>,
 {
     type Item = u64;
     type Error = Error;

tokio-postgres/src/proto/bind.rs

@@ -1,11 +1,12 @@
 use futures::sync::mpsc;
 use futures::{Poll, Stream};
 use postgres_protocol::message::backend::Message;
-use proto::client::{Client, PendingRequest};
-use proto::portal::Portal;
-use proto::statement::Statement;
-use state_machine_future::RentToOwn;
-use Error;
+use state_machine_future::{transition, RentToOwn, StateMachineFuture};
+
+use crate::proto::client::{Client, PendingRequest};
+use crate::proto::portal::Portal;
+use crate::proto::statement::Statement;
+use crate::Error;
 
 #[derive(StateMachineFuture)]
 pub enum Bind {

tokio-postgres/src/proto/cancel.rs

@@ -1,12 +1,12 @@
-use futures::{Future, Poll};
+use futures::{try_ready, Future, Poll};
 use postgres_protocol::message::frontend;
-use state_machine_future::RentToOwn;
+use state_machine_future::{transition, RentToOwn, StateMachineFuture};
 use tokio_io::io::{self, Flush, WriteAll};
 use tokio_io::{AsyncRead, AsyncWrite};
 
-use error::Error;
-use proto::TlsFuture;
-use {CancelData, TlsMode};
+use crate::error::Error;
+use crate::proto::TlsFuture;
+use crate::{CancelData, TlsMode};
 
 #[derive(StateMachineFuture)]
 pub enum Cancel<S, T>

tokio-postgres/src/proto/client.rs

@@ -9,18 +9,18 @@ use std::collections::HashMap;
 use std::error::Error as StdError;
 use std::sync::{Arc, Weak};
 
-use proto::bind::BindFuture;
-use proto::connection::{Request, RequestMessages};
-use proto::copy_in::{CopyInFuture, CopyInReceiver, CopyMessage};
-use proto::copy_out::CopyOutStream;
-use proto::execute::ExecuteFuture;
-use proto::portal::Portal;
-use proto::prepare::PrepareFuture;
-use proto::query::QueryStream;
-use proto::simple_query::SimpleQueryFuture;
-use proto::statement::Statement;
-use types::{IsNull, Oid, ToSql, Type};
-use Error;
+use crate::proto::bind::BindFuture;
+use crate::proto::connection::{Request, RequestMessages};
+use crate::proto::copy_in::{CopyInFuture, CopyInReceiver, CopyMessage};
+use crate::proto::copy_out::CopyOutStream;
+use crate::proto::execute::ExecuteFuture;
+use crate::proto::portal::Portal;
+use crate::proto::prepare::PrepareFuture;
+use crate::proto::query::QueryStream;
+use crate::proto::simple_query::SimpleQueryFuture;
+use crate::proto::statement::Statement;
+use crate::types::{IsNull, Oid, ToSql, Type};
+use crate::Error;
 
 pub struct PendingRequest(Result<RequestMessages, Error>);
 
@@ -127,23 +127,23 @@ impl Client {
         PrepareFuture::new(self.clone(), pending, name)
     }
 
-    pub fn execute(&self, statement: &Statement, params: &[&ToSql]) -> ExecuteFuture {
+    pub fn execute(&self, statement: &Statement, params: &[&dyn ToSql]) -> ExecuteFuture {
         let pending = PendingRequest(
             self.excecute_message(statement, params)
                 .map(RequestMessages::Single),
         );
         ExecuteFuture::new(self.clone(), pending, statement.clone())
     }
 
-    pub fn query(&self, statement: &Statement, params: &[&ToSql]) -> QueryStream<Statement> {
+    pub fn query(&self, statement: &Statement, params: &[&dyn ToSql]) -> QueryStream<Statement> {
         let pending = PendingRequest(
             self.excecute_message(statement, params)
                 .map(RequestMessages::Single),
         );
         QueryStream::new(self.clone(), pending, statement.clone())
     }
 
-    pub fn bind(&self, statement: &Statement, name: String, params: &[&ToSql]) -> BindFuture {
+    pub fn bind(&self, statement: &Statement, name: String, params: &[&dyn ToSql]) -> BindFuture {
         let mut buf = self.bind_message(statement, &name, params);
         if let Ok(ref mut buf) = buf {
             frontend::sync(buf);
@@ -161,12 +161,12 @@ impl Client {
         QueryStream::new(self.clone(), pending, portal.clone())
     }
 
-    pub fn copy_in<S>(&self, statement: &Statement, params: &[&ToSql], stream: S) -> CopyInFuture<S>
+    pub fn copy_in<S>(&self, statement: &Statement, params: &[&dyn ToSql], stream: S) -> CopyInFuture<S>
     where
         S: Stream,
         S::Item: IntoBuf,
         <S::Item as IntoBuf>::Buf: Send,
-        S::Error: Into<Box<StdError + Sync + Send>>,
+        S::Error: Into<Box<dyn StdError + Sync + Send>>,
     {
         let (mut sender, receiver) = mpsc::channel(0);
         let pending = PendingRequest(self.excecute_message(statement, params).map(|buf| {
@@ -182,7 +182,7 @@ impl Client {
         CopyInFuture::new(self.clone(), pending, statement.clone(), stream, sender)
     }
 
-    pub fn copy_out(&self, statement: &Statement, params: &[&ToSql]) -> CopyOutStream {
+    pub fn copy_out(&self, statement: &Statement, params: &[&dyn ToSql]) -> CopyOutStream {
         let pending = PendingRequest(
             self.excecute_message(statement, params)
                 .map(RequestMessages::Single),
@@ -213,7 +213,7 @@ impl Client {
         &self,
         statement: &Statement,
         name: &str,
-        params: &[&ToSql],
+        params: &[&dyn ToSql],
     ) -> Result<Vec<u8>, Error> {
         let mut buf = vec![];
         let r = frontend::bind(
@@ -236,7 +236,7 @@ impl Client {
         }
     }
 
-    fn excecute_message(&self, statement: &Statement, params: &[&ToSql]) -> Result<Vec<u8>, Error> {
+    fn excecute_message(&self, statement: &Statement, params: &[&dyn ToSql]) -> Result<Vec<u8>, Error> {
         let mut buf = self.bind_message(statement, "", params)?;
         frontend::execute("", 0, &mut buf).map_err(Error::parse)?;
         frontend::sync(&mut buf);