Drop WrongType variant

Following the tradition of WasNull

Author: sfackler

src/error.rs

@@ -10,7 +10,6 @@ use std::result;
 use std::collections::HashMap;
 
 use {Result, DbErrorNew};
-use types::Type;
 
 include!(concat!(env!("OUT_DIR"), "/sqlstate.rs"));
 
@@ -275,9 +274,6 @@ pub enum Error {
     Db(Box<DbError>),
     /// An error communicating with the Postgres server.
     Io(io::Error),
-    /// An attempt was made to convert between incompatible Rust and Postgres
-    /// types.
-    WrongType(Type),
     /// An error converting between Postgres and Rust types.
     Conversion(Box<error::Error + Sync + Send>),
 }
@@ -288,7 +284,6 @@ impl fmt::Display for Error {
         match *self {
             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),
         }
     }
@@ -299,7 +294,6 @@ impl error::Error for Error {
         match *self {
             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",
         }
     }
@@ -309,7 +303,6 @@ impl error::Error for Error {
             Error::Db(ref err) => Some(&**err),
             Error::Io(ref err) => Some(err),
             Error::Conversion(ref err) => Some(&**err),
-            _ => None,
         }
     }
 }

src/lib.rs

@@ -78,8 +78,7 @@ use message::{WriteMessage, ReadMessage};
 use notification::{Notifications, Notification};
 use rows::{Rows, LazyRows};
 use stmt::{Statement, Column};
-use types::{IsNull, Kind, Type, SessionInfo, Oid, Other};
-use types::{ToSql, FromSql};
+use types::{IsNull, Kind, Type, SessionInfo, Oid, Other, WrongType, ToSql, FromSql};
 use url::Url;
 
 #[macro_use]
@@ -1485,3 +1484,7 @@ trait ColumnNew {
 trait NotificationsNew<'conn> {
     fn new(conn: &'conn Connection) -> Notifications<'conn>;
 }
+
+trait WrongTypeNew {
+    fn new(ty: Type) -> WrongType;
+}

src/rows.rs

@@ -8,8 +8,8 @@ use std::ops::Deref;
 use std::slice;
 
 use {Result, Transaction, read_rows, DbErrorNew, SessionInfoNew, RowsNew, LazyRowsNew,
-     StatementInternals};
-use types::{FromSql, SessionInfo};
+     StatementInternals, WrongTypeNew};
+use types::{FromSql, SessionInfo, WrongType};
 use stmt::{Statement, Column};
 use error::Error;
 use message::FrontendMessage::*;
@@ -222,7 +222,7 @@ impl<'a> Row<'a> {
 
         let ty = self.stmt.columns()[idx].type_();
         if !<T as FromSql>::accepts(ty) {
-            return Some(Err(Error::WrongType(ty.clone())));
+            return Some(Err(Error::Conversion(Box::new(WrongType::new(ty.clone())))));
         }
         let conn = self.stmt.conn().conn.borrow();
         let value = match self.data[idx] {

src/types/mod.rs

@@ -7,7 +7,7 @@ use std::io::prelude::*;
 use byteorder::{ReadBytesExt, WriteBytesExt, BigEndian};
 
 pub use self::slice::Slice;
-use {Result, SessionInfoNew, InnerConnection, OtherNew};
+use {Result, SessionInfoNew, InnerConnection, OtherNew, WrongTypeNew};
 use error::Error;
 use util;
 
@@ -31,17 +31,32 @@ macro_rules! accepts {
 #[macro_export]
 macro_rules! to_sql_checked {
     () => {
-        fn to_sql_checked(&self, ty: &$crate::types::Type, out: &mut ::std::io::Write,
+        fn to_sql_checked(&self,
+                          ty: &$crate::types::Type,
+                          out: &mut ::std::io::Write,
                           ctx: &$crate::types::SessionInfo)
                           -> $crate::Result<$crate::types::IsNull> {
-            if !<Self as $crate::types::ToSql>::accepts(ty) {
-                return Err($crate::error::Error::WrongType(ty.clone()));
-            }
-            $crate::types::ToSql::to_sql(self, ty, out, ctx)
+            $crate::types::__to_sql_checked(self, ty, out, ctx)
         }
     }
 }
 
+// WARNING: this function is not considered part of this crate's public API.
+// It is subject to change at any time.
+#[doc(hidden)]
+pub fn __to_sql_checked<T>(v: &T,
+                           ty: &Type,
+                           out: &mut Write,
+                           ctx: &SessionInfo)
+                           -> Result<IsNull>
+    where T: ToSql
+{
+    if !T::accepts(ty) {
+        return Err(Error::Conversion(Box::new(WrongType(ty.clone()))));
+    }
+    v.to_sql(ty, out, ctx)
+}
+
 #[cfg(feature = "bit-vec")]
 mod bit_vec;
 #[cfg(feature = "uuid")]
@@ -547,6 +562,29 @@ impl error::Error for WasNull {
     }
 }
 
+/// An error indicating that a conversion was attempted between incompatible
+/// Rust and Postgres types.
+#[derive(Debug)]
+pub struct WrongType(Type);
+
+impl fmt::Display for WrongType {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        write!(fmt, "cannot convert to or from a Postgres value of type {:?}", self.0)
+    }
+}
+
+impl error::Error for WrongType {
+    fn description(&self) -> &str {
+        "cannot convert to or from a Postgres value"
+    }
+}
+
+impl WrongTypeNew for WrongType {
+    fn new(ty: Type) -> WrongType {
+        WrongType(ty)
+    }
+}
+
 /// A trait for types that can be created from a Postgres value.
 ///
 /// # Types

tests/test.rs

@@ -19,7 +19,7 @@ use postgres::{HandleNotice,
                IntoConnectParams,
                IsolationLevel};
 use postgres::error::{Error, ConnectError, DbError};
-use postgres::types::{Oid, Type, Kind};
+use postgres::types::{Oid, Type, Kind, WrongType};
 use postgres::error::SqlState::{SyntaxError,
                                 QueryCanceled,
                                 UndefinedTable,
@@ -451,7 +451,7 @@ fn test_execute_counts() {
 fn test_wrong_param_type() {
     let conn = or_panic!(Connection::connect("postgres://postgres@localhost", SslMode::None));
     match conn.execute("SELECT $1::VARCHAR", &[&1i32]) {
-        Err(Error::WrongType(_)) => {}
+        Err(Error::Conversion(ref e)) if e.is::<WrongType>() => {}
         res => panic!("unexpected result {:?}", res)
     }
 }
@@ -937,7 +937,7 @@ fn test_get_opt_wrong_type() {
     let res = stmt.query(&[]).unwrap();
     match res.iter().next().unwrap().get_opt::<_, String>(0) {
         Some(Ok(_)) => panic!("unexpected success"),
-        Some(Err(Error::WrongType(Type::Int4))) => {}
+        Some(Err(Error::Conversion(ref e))) if e.is::<WrongType>() => {}
         Some(Err(e)) => panic!("unexpected error {}", e),
         None => panic!("unexpected None"),
     }

tests/types/mod.rs

@@ -5,7 +5,7 @@ use std::fmt;
 
 use postgres::{Connection, SslMode};
 use postgres::error::Error;
-use postgres::types::{ToSql, FromSql, Slice};
+use postgres::types::{ToSql, FromSql, Slice, WrongType};
 
 #[cfg(feature = "bit-vec")]
 mod bit_vec;
@@ -217,7 +217,7 @@ fn test_slice_wrong_type() {
     let stmt = conn.prepare("SELECT * FROM foo WHERE id = ANY($1)").unwrap();
     match stmt.query(&[&Slice(&["hi"])]) {
         Ok(_) => panic!("Unexpected success"),
-        Err(Error::WrongType(..)) => {}
+        Err(Error::Conversion(ref e)) if e.is::<WrongType>() => {}
         Err(e) => panic!("Unexpected error {:?}", e),
     };
 }
@@ -229,7 +229,7 @@ fn test_slice_range() {
     let stmt = conn.prepare("SELECT $1::INT8RANGE").unwrap();
     match stmt.query(&[&Slice(&[1i64])]) {
         Ok(_) => panic!("Unexpected success"),
-        Err(Error::WrongType(..)) => {}
+        Err(Error::Conversion(ref e)) if e.is::<WrongType>() => {}
         Err(e) => panic!("Unexpected error {:?}", e),
     };
 }