Shorten error variant names

sfackler · sfackler · commit 4f37625cd66f · 2015-12-25T20:14:09.000-07:00
No reason to repeat Error
diff --git a/src/error.rs b/src/error.rs
@@ -124,15 +124,15 @@ impl DbErrorNew for DbError {
 
     fn new_connect<T>(fields: Vec<(u8, String)>) -> result::Result<T, ConnectError> {
         match DbError::new_raw(fields) {
-            Ok(err) => Err(ConnectError::DbError(Box::new(err))),
-            Err(()) => Err(ConnectError::IoError(::bad_response())),
+            Ok(err) => Err(ConnectError::Db(Box::new(err))),
+            Err(()) => Err(ConnectError::Io(::bad_response())),
         }
     }
 
     fn new<T>(fields: Vec<(u8, String)>) -> Result<T> {
         match DbError::new_raw(fields) {
-            Ok(err) => Err(Error::DbError(Box::new(err))),
-            Err(()) => Err(Error::IoError(::bad_response())),
+            Ok(err) => Err(Error::Db(Box::new(err))),
+            Err(()) => Err(Error::Io(::bad_response())),
         }
     }
 }
@@ -180,7 +180,7 @@ pub enum ConnectError {
     /// The `ConnectParams` was missing a user.
     MissingUser,
     /// An error from the Postgres server itself.
-    DbError(Box<DbError>),
+    Db(Box<DbError>),
     /// A password was required but not provided in the `ConnectParams`.
     MissingPassword,
     /// The Postgres server requested an authentication method not supported
@@ -189,19 +189,19 @@ pub enum ConnectError {
     /// The Postgres server does not support SSL encryption.
     NoSslSupport,
     /// An error initializing the SSL session.
-    SslError(Box<error::Error + Sync + Send>),
+    Ssl(Box<error::Error + Sync + Send>),
     /// An error communicating with the server.
-    IoError(io::Error),
+    Io(io::Error),
 }
 
 impl fmt::Display for ConnectError {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         try!(fmt.write_str(error::Error::description(self)));
         match *self {
             ConnectError::BadConnectParams(ref msg) => write!(fmt, ": {}", msg),
-            ConnectError::DbError(ref err) => write!(fmt, ": {}", err),
-            ConnectError::SslError(ref err) => write!(fmt, ": {}", err),
-            ConnectError::IoError(ref err) => write!(fmt, ": {}", err),
+            ConnectError::Db(ref err) => write!(fmt, ": {}", err),
+            ConnectError::Ssl(ref err) => write!(fmt, ": {}", err),
+            ConnectError::Io(ref err) => write!(fmt, ": {}", err),
             _ => Ok(()),
         }
     }
@@ -212,45 +212,45 @@ impl error::Error for ConnectError {
         match *self {
             ConnectError::BadConnectParams(_) => "Error creating `ConnectParams`",
             ConnectError::MissingUser => "User missing in `ConnectParams`",
-            ConnectError::DbError(_) => "Error reported by Postgres",
+            ConnectError::Db(_) => "Error reported by Postgres",
             ConnectError::MissingPassword => {
                 "The server requested a password but none was provided"
             }
             ConnectError::UnsupportedAuthentication => {
                 "The server requested an unsupported authentication method"
             }
             ConnectError::NoSslSupport => "The server does not support SSL",
-            ConnectError::SslError(_) => "Error initiating SSL session",
-            ConnectError::IoError(_) => "Error communicating with the server",
+            ConnectError::Ssl(_) => "Error initiating SSL session",
+            ConnectError::Io(_) => "Error communicating with the server",
         }
     }
 
     fn cause(&self) -> Option<&error::Error> {
         match *self {
             ConnectError::BadConnectParams(ref err) => Some(&**err),
-            ConnectError::DbError(ref err) => Some(&**err),
-            ConnectError::SslError(ref err) => Some(&**err),
-            ConnectError::IoError(ref err) => Some(err),
+            ConnectError::Db(ref err) => Some(&**err),
+            ConnectError::Ssl(ref err) => Some(&**err),
+            ConnectError::Io(ref err) => Some(err),
             _ => None,
         }
     }
 }
 
 impl From<io::Error> for ConnectError {
     fn from(err: io::Error) -> ConnectError {
-        ConnectError::IoError(err)
+        ConnectError::Io(err)
     }
 }
 
 impl From<DbError> for ConnectError {
     fn from(err: DbError) -> ConnectError {
-        ConnectError::DbError(Box::new(err))
+        ConnectError::Db(Box::new(err))
     }
 }
 
 impl From<byteorder::Error> for ConnectError {
     fn from(err: byteorder::Error) -> ConnectError {
-        ConnectError::IoError(From::from(err))
+        ConnectError::Io(From::from(err))
     }
 }
 
@@ -272,9 +272,9 @@ pub enum ErrorPosition {
 #[derive(Debug)]
 pub enum Error {
     /// An error reported by the Postgres server.
-    DbError(Box<DbError>),
+    Db(Box<DbError>),
     /// An error communicating with the Postgres server.
-    IoError(io::Error),
+    Io(io::Error),
     /// An attempt was made to convert between incompatible Rust and Postgres
     /// types.
     WrongType(Type),
@@ -286,8 +286,8 @@ impl fmt::Display for Error {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         try!(fmt.write_str(error::Error::description(self)));
         match *self {
-            Error::DbError(ref err) => write!(fmt, ": {}", err),
-            Error::IoError(ref err) => write!(fmt, ": {}", err),
+            Error::Db(ref err) => write!(fmt, ": {}", err),
+            Error::Io(ref err) => write!(fmt, ": {}", err),
             Error::WrongType(ref ty) => write!(fmt, ": saw type {:?}", ty),
             Error::Conversion(ref err) => write!(fmt, ": {}", err),
         }
@@ -297,17 +297,17 @@ impl fmt::Display for Error {
 impl error::Error for Error {
     fn description(&self) -> &str {
         match *self {
-            Error::DbError(_) => "Error reported by Postgres",
-            Error::IoError(_) => "Error communicating with the server",
+            Error::Db(_) => "Error reported by Postgres",
+            Error::Io(_) => "Error communicating with the server",
             Error::WrongType(_) => "Unexpected type",
             Error::Conversion(_) => "Error converting between Postgres and Rust types",
         }
     }
 
     fn cause(&self) -> Option<&error::Error> {
         match *self {
-            Error::DbError(ref err) => Some(&**err),
-            Error::IoError(ref err) => Some(err),
+            Error::Db(ref err) => Some(&**err),
+            Error::Io(ref err) => Some(err),
             Error::Conversion(ref err) => Some(&**err),
             _ => None,
         }
@@ -316,19 +316,19 @@ impl error::Error for Error {
 
 impl From<DbError> for Error {
     fn from(err: DbError) -> Error {
-        Error::DbError(Box::new(err))
+        Error::Db(Box::new(err))
     }
 }
 
 impl From<io::Error> for Error {
     fn from(err: io::Error) -> Error {
-        Error::IoError(err)
+        Error::Io(err)
     }
 }
 
 impl From<byteorder::Error> for Error {
     fn from(err: byteorder::Error) -> Error {
-        Error::IoError(From::from(err))
+        Error::Io(From::from(err))
     }
 }
 
diff --git a/src/lib.rs b/src/lib.rs
@@ -346,7 +346,7 @@ impl IsolationLevel {
         } else if raw.eq_ignore_ascii_case("SERIALIZABLE") {
             Ok(IsolationLevel::Serializable)
         } else {
-            Err(Error::IoError(bad_response()))
+            Err(Error::Io(bad_response()))
         }
     }
 }
@@ -444,7 +444,7 @@ impl InnerConnection {
                 }
                 ReadyForQuery { .. } => break,
                 ErrorResponse { fields } => return DbError::new_connect(fields),
-                _ => return Err(ConnectError::IoError(bad_response())),
+                _ => return Err(ConnectError::Io(bad_response())),
             }
         }
 
@@ -464,10 +464,10 @@ impl InnerConnection {
                                     t.typnamespace = n.oid \
                                 WHERE t.oid = $1") {
             Ok(..) => return Ok(()),
-            Err(Error::IoError(e)) => return Err(ConnectError::IoError(e)),
+            Err(Error::Io(e)) => return Err(ConnectError::Io(e)),
             // Range types weren't added until Postgres 9.2, so pg_range may not exist
-            Err(Error::DbError(ref e)) if e.code == SqlState::UndefinedTable => {}
-            Err(Error::DbError(e)) => return Err(ConnectError::DbError(e)),
+            Err(Error::Db(ref e)) if e.code == SqlState::UndefinedTable => {}
+            Err(Error::Db(e)) => return Err(ConnectError::Db(e)),
             _ => unreachable!(),
         }
 
@@ -478,8 +478,8 @@ impl InnerConnection {
                                     ON t.typnamespace = n.oid \
                                 WHERE t.oid = $1") {
             Ok(..) => Ok(()),
-            Err(Error::IoError(e)) => Err(ConnectError::IoError(e)),
-            Err(Error::DbError(e)) => Err(ConnectError::DbError(e)),
+            Err(Error::Io(e)) => Err(ConnectError::Io(e)),
+            Err(Error::Db(e)) => Err(ConnectError::Db(e)),
             _ => unreachable!(),
         }
     }
@@ -567,13 +567,13 @@ impl InnerConnection {
             AuthenticationGSS |
             AuthenticationSSPI => return Err(ConnectError::UnsupportedAuthentication),
             ErrorResponse { fields } => return DbError::new_connect(fields),
-            _ => return Err(ConnectError::IoError(bad_response())),
+            _ => return Err(ConnectError::Io(bad_response())),
         }
 
         match try!(self.read_message()) {
             AuthenticationOk => Ok(()),
             ErrorResponse { fields } => return DbError::new_connect(fields),
-            _ => return Err(ConnectError::IoError(bad_response())),
+            _ => return Err(ConnectError::Io(bad_response())),
         }
     }
 
@@ -1336,13 +1336,13 @@ fn read_rows(conn: &mut InnerConnection, buf: &mut VecDeque<Vec<Option<Vec<u8>>>
                         _ => {}
                     }
                 }
-                return Err(Error::IoError(std_io::Error::new(std_io::ErrorKind::InvalidInput,
+                return Err(Error::Io(std_io::Error::new(std_io::ErrorKind::InvalidInput,
                                                              "COPY queries cannot be directly \
                                                               executed")));
             }
             _ => {
                 conn.desynchronized = true;
-                return Err(Error::IoError(bad_response()));
+                return Err(Error::Io(bad_response()));
             }
         }
     }
diff --git a/src/macros.rs b/src/macros.rs
@@ -13,7 +13,7 @@ macro_rules! try_desync {
 macro_rules! check_desync {
     ($e:expr) => ({
         if $e.is_desynchronized() {
-            return Err(::error::Error::IoError(::desynchronized()));
+            return Err(::error::Error::Io(::desynchronized()));
         }
     })
 }
@@ -22,6 +22,6 @@ macro_rules! bad_response {
     ($s:expr) => ({
         debug!("Bad response at {}:{}", file!(), line!());
         $s.desynchronized = true;
-        return Err(::error::Error::IoError(::bad_response()));
+        return Err(::error::Error::Io(::bad_response()));
     })
 }
diff --git a/src/notification.rs b/src/notification.rs
@@ -115,7 +115,7 @@ impl<'a> Iterator for BlockingIter<'a> {
         }
 
         if conn.is_desynchronized() {
-            return Some(Err(Error::IoError(desynchronized())));
+            return Some(Err(Error::Io(desynchronized())));
         }
 
         match conn.read_message_with_notification() {
@@ -126,7 +126,7 @@ impl<'a> Iterator for BlockingIter<'a> {
                     payload: payload,
                 }))
             }
-            Err(err) => Some(Err(Error::IoError(err))),
+            Err(err) => Some(Err(Error::Io(err))),
             _ => unreachable!(),
         }
     }
@@ -150,7 +150,7 @@ impl<'a> Iterator for TimeoutIter<'a> {
         }
 
         if conn.is_desynchronized() {
-            return Some(Err(Error::IoError(desynchronized())));
+            return Some(Err(Error::Io(desynchronized())));
         }
 
         match conn.read_message_with_notification_timeout(self.timeout) {
@@ -162,7 +162,7 @@ impl<'a> Iterator for TimeoutIter<'a> {
                 }))
             }
             Ok(None) => None,
-            Err(err) => Some(Err(Error::IoError(err))),
+            Err(err) => Some(Err(Error::Io(err))),
             _ => unreachable!(),
         }
     }
diff --git a/src/priv_io.rs b/src/priv_io.rs
@@ -180,6 +180,6 @@ pub fn initialize_stream(params: &ConnectParams,
 
     match negotiator.negotiate_ssl(host, socket) {
         Ok(stream) => Ok(stream),
-        Err(err) => Err(ConnectError::SslError(err)),
+        Err(err) => Err(ConnectError::Ssl(err)),
     }
 }
diff --git a/src/stmt.rs b/src/stmt.rs
diff --git a/tests/test.rs b/tests/test.rs

Original file line number	Diff line number	Diff line change
`@@ -124,15 +124,15 @@ impl DbErrorNew for DbError {`
`124`	`124`
`125`	`125`	`fn new_connect<T>(fields: Vec<(u8, String)>) -> result::Result<T, ConnectError> {`
`126`	`126`	`match DbError::new_raw(fields) {`
`127`		`- Ok(err) => Err(ConnectError::DbError(Box::new(err))),`
`128`		`- Err(()) => Err(ConnectError::IoError(::bad_response())),`
	`127`	`+ Ok(err) => Err(ConnectError::Db(Box::new(err))),`
	`128`	`+ Err(()) => Err(ConnectError::Io(::bad_response())),`
`129`	`129`	`}`
`130`	`130`	`}`
`131`	`131`
`132`	`132`	`fn new<T>(fields: Vec<(u8, String)>) -> Result<T> {`
`133`	`133`	`match DbError::new_raw(fields) {`
`134`		`- Ok(err) => Err(Error::DbError(Box::new(err))),`
`135`		`- Err(()) => Err(Error::IoError(::bad_response())),`
	`134`	`+ Ok(err) => Err(Error::Db(Box::new(err))),`
	`135`	`+ Err(()) => Err(Error::Io(::bad_response())),`
`136`	`136`	`}`
`137`	`137`	`}`
`138`	`138`	`}`
`@@ -180,7 +180,7 @@ pub enum ConnectError {`
`180`	`180`	/// The `ConnectParams` was missing a user.
`181`	`181`	`MissingUser,`
`182`	`182`	`/// An error from the Postgres server itself.`
`183`		`- DbError(Box<DbError>),`
	`183`	`+ Db(Box<DbError>),`
`184`	`184`	/// A password was required but not provided in the `ConnectParams`.
`185`	`185`	`MissingPassword,`
`186`	`186`	`/// The Postgres server requested an authentication method not supported`
`@@ -189,19 +189,19 @@ pub enum ConnectError {`
`189`	`189`	`/// The Postgres server does not support SSL encryption.`
`190`	`190`	`NoSslSupport,`
`191`	`191`	`/// An error initializing the SSL session.`
`192`		`- SslError(Box<error::Error + Sync + Send>),`
	`192`	`+ Ssl(Box<error::Error + Sync + Send>),`
`193`	`193`	`/// An error communicating with the server.`
`194`		`- IoError(io::Error),`
	`194`	`+ Io(io::Error),`
`195`	`195`	`}`
`196`	`196`
`197`	`197`	`impl fmt::Display for ConnectError {`
`198`	`198`	`fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {`
`199`	`199`	`try!(fmt.write_str(error::Error::description(self)));`
`200`	`200`	`match *self {`
`201`	`201`	`ConnectError::BadConnectParams(ref msg) => write!(fmt, ": {}", msg),`
`202`		`- ConnectError::DbError(ref err) => write!(fmt, ": {}", err),`
`203`		`- ConnectError::SslError(ref err) => write!(fmt, ": {}", err),`
`204`		`- ConnectError::IoError(ref err) => write!(fmt, ": {}", err),`
	`202`	`+ ConnectError::Db(ref err) => write!(fmt, ": {}", err),`
	`203`	`+ ConnectError::Ssl(ref err) => write!(fmt, ": {}", err),`
	`204`	`+ ConnectError::Io(ref err) => write!(fmt, ": {}", err),`
`205`	`205`	`_ => Ok(()),`
`206`	`206`	`}`
`207`	`207`	`}`
`@@ -212,45 +212,45 @@ impl error::Error for ConnectError {`
`212`	`212`	`match *self {`
`213`	`213`	ConnectError::BadConnectParams(_) => "Error creating `ConnectParams`",
`214`	`214`	ConnectError::MissingUser => "User missing in `ConnectParams`",
`215`		`- ConnectError::DbError(_) => "Error reported by Postgres",`
	`215`	`+ ConnectError::Db(_) => "Error reported by Postgres",`
`216`	`216`	`ConnectError::MissingPassword => {`
`217`	`217`	`"The server requested a password but none was provided"`
`218`	`218`	`}`
`219`	`219`	`ConnectError::UnsupportedAuthentication => {`
`220`	`220`	`"The server requested an unsupported authentication method"`
`221`	`221`	`}`
`222`	`222`	`ConnectError::NoSslSupport => "The server does not support SSL",`
`223`		`- ConnectError::SslError(_) => "Error initiating SSL session",`
`224`		`- ConnectError::IoError(_) => "Error communicating with the server",`
	`223`	`+ ConnectError::Ssl(_) => "Error initiating SSL session",`
	`224`	`+ ConnectError::Io(_) => "Error communicating with the server",`
`225`	`225`	`}`
`226`	`226`	`}`
`227`	`227`
`228`	`228`	`fn cause(&self) -> Option<&error::Error> {`
`229`	`229`	`match *self {`
`230`	`230`	`ConnectError::BadConnectParams(ref err) => Some(&**err),`
`231`		`- ConnectError::DbError(ref err) => Some(&**err),`
`232`		`- ConnectError::SslError(ref err) => Some(&**err),`
`233`		`- ConnectError::IoError(ref err) => Some(err),`
	`231`	`+ ConnectError::Db(ref err) => Some(&**err),`
	`232`	`+ ConnectError::Ssl(ref err) => Some(&**err),`
	`233`	`+ ConnectError::Io(ref err) => Some(err),`
`234`	`234`	`_ => None,`
`235`	`235`	`}`
`236`	`236`	`}`
`237`	`237`	`}`
`238`	`238`
`239`	`239`	`impl From<io::Error> for ConnectError {`
`240`	`240`	`fn from(err: io::Error) -> ConnectError {`
`241`		`- ConnectError::IoError(err)`
	`241`	`+ ConnectError::Io(err)`
`242`	`242`	`}`
`243`	`243`	`}`
`244`	`244`
`245`	`245`	`impl From<DbError> for ConnectError {`
`246`	`246`	`fn from(err: DbError) -> ConnectError {`
`247`		`- ConnectError::DbError(Box::new(err))`
	`247`	`+ ConnectError::Db(Box::new(err))`
`248`	`248`	`}`
`249`	`249`	`}`
`250`	`250`
`251`	`251`	`impl From<byteorder::Error> for ConnectError {`
`252`	`252`	`fn from(err: byteorder::Error) -> ConnectError {`
`253`		`- ConnectError::IoError(From::from(err))`
	`253`	`+ ConnectError::Io(From::from(err))`
`254`	`254`	`}`
`255`	`255`	`}`
`256`	`256`
`@@ -272,9 +272,9 @@ pub enum ErrorPosition {`
`272`	`272`	`#[derive(Debug)]`
`273`	`273`	`pub enum Error {`
`274`	`274`	`/// An error reported by the Postgres server.`
`275`		`- DbError(Box<DbError>),`
	`275`	`+ Db(Box<DbError>),`
`276`	`276`	`/// An error communicating with the Postgres server.`
`277`		`- IoError(io::Error),`
	`277`	`+ Io(io::Error),`
`278`	`278`	`/// An attempt was made to convert between incompatible Rust and Postgres`
`279`	`279`	`/// types.`
`280`	`280`	`WrongType(Type),`
`@@ -286,8 +286,8 @@ impl fmt::Display for Error {`
`286`	`286`	`fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {`
`287`	`287`	`try!(fmt.write_str(error::Error::description(self)));`
`288`	`288`	`match *self {`
`289`		`- Error::DbError(ref err) => write!(fmt, ": {}", err),`
`290`		`- Error::IoError(ref err) => write!(fmt, ": {}", err),`
	`289`	`+ Error::Db(ref err) => write!(fmt, ": {}", err),`
	`290`	`+ Error::Io(ref err) => write!(fmt, ": {}", err),`
`291`	`291`	`Error::WrongType(ref ty) => write!(fmt, ": saw type {:?}", ty),`
`292`	`292`	`Error::Conversion(ref err) => write!(fmt, ": {}", err),`
`293`	`293`	`}`
`@@ -297,17 +297,17 @@ impl fmt::Display for Error {`
`297`	`297`	`impl error::Error for Error {`
`298`	`298`	`fn description(&self) -> &str {`
`299`	`299`	`match *self {`
`300`		`- Error::DbError(_) => "Error reported by Postgres",`
`301`		`- Error::IoError(_) => "Error communicating with the server",`
	`300`	`+ Error::Db(_) => "Error reported by Postgres",`
	`301`	`+ Error::Io(_) => "Error communicating with the server",`
`302`	`302`	`Error::WrongType(_) => "Unexpected type",`
`303`	`303`	`Error::Conversion(_) => "Error converting between Postgres and Rust types",`
`304`	`304`	`}`
`305`	`305`	`}`
`306`	`306`
`307`	`307`	`fn cause(&self) -> Option<&error::Error> {`
`308`	`308`	`match *self {`
`309`		`- Error::DbError(ref err) => Some(&**err),`
`310`		`- Error::IoError(ref err) => Some(err),`
	`309`	`+ Error::Db(ref err) => Some(&**err),`
	`310`	`+ Error::Io(ref err) => Some(err),`
`311`	`311`	`Error::Conversion(ref err) => Some(&**err),`
`312`	`312`	`_ => None,`
`313`	`313`	`}`
`@@ -316,19 +316,19 @@ impl error::Error for Error {`
`316`	`316`
`317`	`317`	`impl From<DbError> for Error {`
`318`	`318`	`fn from(err: DbError) -> Error {`
`319`		`- Error::DbError(Box::new(err))`
	`319`	`+ Error::Db(Box::new(err))`
`320`	`320`	`}`
`321`	`321`	`}`
`322`	`322`
`323`	`323`	`impl From<io::Error> for Error {`
`324`	`324`	`fn from(err: io::Error) -> Error {`
`325`		`- Error::IoError(err)`
	`325`	`+ Error::Io(err)`
`326`	`326`	`}`
`327`	`327`	`}`
`328`	`328`
`329`	`329`	`impl From<byteorder::Error> for Error {`
`330`	`330`	`fn from(err: byteorder::Error) -> Error {`
`331`		`- Error::IoError(From::from(err))`
	`331`	`+ Error::Io(From::from(err))`
`332`	`332`	`}`
`333`	`333`	`}`
`334`	`334`
Original file line number	Diff line number	Diff line change
`@@ -346,7 +346,7 @@ impl IsolationLevel {`
`346`	`346`	`} else if raw.eq_ignore_ascii_case("SERIALIZABLE") {`
`347`	`347`	`Ok(IsolationLevel::Serializable)`
`348`	`348`	`} else {`
`349`		`- Err(Error::IoError(bad_response()))`
	`349`	`+ Err(Error::Io(bad_response()))`
`350`	`350`	`}`
`351`	`351`	`}`
`352`	`352`	`}`
`@@ -444,7 +444,7 @@ impl InnerConnection {`
`444`	`444`	`}`
`445`	`445`	`ReadyForQuery { .. } => break,`
`446`	`446`	`ErrorResponse { fields } => return DbError::new_connect(fields),`
`447`		`- _ => return Err(ConnectError::IoError(bad_response())),`
	`447`	`+ _ => return Err(ConnectError::Io(bad_response())),`
`448`	`448`	`}`
`449`	`449`	`}`
`450`	`450`
`@@ -464,10 +464,10 @@ impl InnerConnection {`
`464`	`464`	`t.typnamespace = n.oid \`
`465`	`465`	`WHERE t.oid = $1") {`
`466`	`466`	`Ok(..) => return Ok(()),`
`467`		`- Err(Error::IoError(e)) => return Err(ConnectError::IoError(e)),`
	`467`	`+ Err(Error::Io(e)) => return Err(ConnectError::Io(e)),`
`468`	`468`	`// Range types weren't added until Postgres 9.2, so pg_range may not exist`
`469`		`- Err(Error::DbError(ref e)) if e.code == SqlState::UndefinedTable => {}`
`470`		`- Err(Error::DbError(e)) => return Err(ConnectError::DbError(e)),`
	`469`	`+ Err(Error::Db(ref e)) if e.code == SqlState::UndefinedTable => {}`
	`470`	`+ Err(Error::Db(e)) => return Err(ConnectError::Db(e)),`
`471`	`471`	`_ => unreachable!(),`
`472`	`472`	`}`
`473`	`473`
`@@ -478,8 +478,8 @@ impl InnerConnection {`
`478`	`478`	`ON t.typnamespace = n.oid \`
`479`	`479`	`WHERE t.oid = $1") {`
`480`	`480`	`Ok(..) => Ok(()),`
`481`		`- Err(Error::IoError(e)) => Err(ConnectError::IoError(e)),`
`482`		`- Err(Error::DbError(e)) => Err(ConnectError::DbError(e)),`
	`481`	`+ Err(Error::Io(e)) => Err(ConnectError::Io(e)),`
	`482`	`+ Err(Error::Db(e)) => Err(ConnectError::Db(e)),`
`483`	`483`	`_ => unreachable!(),`
`484`	`484`	`}`
`485`	`485`	`}`
`@@ -567,13 +567,13 @@ impl InnerConnection {`
`567`	`567`	`AuthenticationGSS \|`
`568`	`568`	`AuthenticationSSPI => return Err(ConnectError::UnsupportedAuthentication),`
`569`	`569`	`ErrorResponse { fields } => return DbError::new_connect(fields),`
`570`		`- _ => return Err(ConnectError::IoError(bad_response())),`
	`570`	`+ _ => return Err(ConnectError::Io(bad_response())),`
`571`	`571`	`}`
`572`	`572`
`573`	`573`	`match try!(self.read_message()) {`
`574`	`574`	`AuthenticationOk => Ok(()),`
`575`	`575`	`ErrorResponse { fields } => return DbError::new_connect(fields),`
`576`		`- _ => return Err(ConnectError::IoError(bad_response())),`
	`576`	`+ _ => return Err(ConnectError::Io(bad_response())),`
`577`	`577`	`}`
`578`	`578`	`}`
`579`	`579`
`@@ -1336,13 +1336,13 @@ fn read_rows(conn: &mut InnerConnection, buf: &mut VecDeque<Vec<Option<Vec<u8>>>`
`1336`	`1336`	`_ => {}`
`1337`	`1337`	`}`
`1338`	`1338`	`}`
`1339`		`- return Err(Error::IoError(std_io::Error::new(std_io::ErrorKind::InvalidInput,`
	`1339`	`+ return Err(Error::Io(std_io::Error::new(std_io::ErrorKind::InvalidInput,`
`1340`	`1340`	`"COPY queries cannot be directly \`
`1341`	`1341`	`executed")));`
`1342`	`1342`	`}`
`1343`	`1343`	`_ => {`
`1344`	`1344`	`conn.desynchronized = true;`
`1345`		`- return Err(Error::IoError(bad_response()));`
	`1345`	`+ return Err(Error::Io(bad_response()));`
`1346`	`1346`	`}`
`1347`	`1347`	`}`
`1348`	`1348`	`}`
Original file line number	Diff line number	Diff line change
`@@ -13,7 +13,7 @@ macro_rules! try_desync {`
`13`	`13`	`macro_rules! check_desync {`
`14`	`14`	`($e:expr) => ({`
`15`	`15`	`if $e.is_desynchronized() {`
`16`		`- return Err(::error::Error::IoError(::desynchronized()));`
	`16`	`+ return Err(::error::Error::Io(::desynchronized()));`
`17`	`17`	`}`
`18`	`18`	`})`
`19`	`19`	`}`
`@@ -22,6 +22,6 @@ macro_rules! bad_response {`
`22`	`22`	`($s:expr) => ({`
`23`	`23`	`debug!("Bad response at {}:{}", file!(), line!());`
`24`	`24`	`$s.desynchronized = true;`
`25`		`- return Err(::error::Error::IoError(::bad_response()));`
	`25`	`+ return Err(::error::Error::Io(::bad_response()));`
`26`	`26`	`})`
`27`	`27`	`}`
Original file line number	Diff line number	Diff line change
`@@ -115,7 +115,7 @@ impl<'a> Iterator for BlockingIter<'a> {`
`115`	`115`	`}`
`116`	`116`
`117`	`117`	`if conn.is_desynchronized() {`
`118`		`- return Some(Err(Error::IoError(desynchronized())));`
	`118`	`+ return Some(Err(Error::Io(desynchronized())));`
`119`	`119`	`}`
`120`	`120`
`121`	`121`	`match conn.read_message_with_notification() {`
`@@ -126,7 +126,7 @@ impl<'a> Iterator for BlockingIter<'a> {`
`126`	`126`	`payload: payload,`
`127`	`127`	`}))`
`128`	`128`	`}`
`129`		`- Err(err) => Some(Err(Error::IoError(err))),`
	`129`	`+ Err(err) => Some(Err(Error::Io(err))),`
`130`	`130`	`_ => unreachable!(),`
`131`	`131`	`}`
`132`	`132`	`}`
`@@ -150,7 +150,7 @@ impl<'a> Iterator for TimeoutIter<'a> {`
`150`	`150`	`}`
`151`	`151`
`152`	`152`	`if conn.is_desynchronized() {`
`153`		`- return Some(Err(Error::IoError(desynchronized())));`
	`153`	`+ return Some(Err(Error::Io(desynchronized())));`
`154`	`154`	`}`
`155`	`155`
`156`	`156`	`match conn.read_message_with_notification_timeout(self.timeout) {`
`@@ -162,7 +162,7 @@ impl<'a> Iterator for TimeoutIter<'a> {`
`162`	`162`	`}))`
`163`	`163`	`}`
`164`	`164`	`Ok(None) => None,`
`165`		`- Err(err) => Some(Err(Error::IoError(err))),`
	`165`	`+ Err(err) => Some(Err(Error::Io(err))),`
`166`	`166`	`_ => unreachable!(),`
`167`	`167`	`}`
`168`	`168`	`}`
Original file line number	Diff line number	Diff line change
`@@ -180,6 +180,6 @@ pub fn initialize_stream(params: &ConnectParams,`
`180`	`180`
`181`	`181`	`match negotiator.negotiate_ssl(host, socket) {`
`182`	`182`	`Ok(stream) => Ok(stream),`
`183`		`- Err(err) => Err(ConnectError::SslError(err)),`
	`183`	`+ Err(err) => Err(ConnectError::Ssl(err)),`
`184`	`184`	`}`
`185`	`185`	`}`