RUST-738 Implement Clone on error types (#252)

This commit also updates a few of the error cases to include more information and more accurate names, and it also removes some redundant cases.

Author: patrickfreed

src/de/error.rs

@@ -1,15 +1,15 @@
-use std::{error, fmt, fmt::Display, io, string};
+use std::{error, fmt, fmt::Display, io, string, sync::Arc};
 
 use serde::de::{self, Unexpected};
 
 use crate::Bson;
 
 /// Possible errors that can arise during decoding.
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 #[non_exhaustive]
 pub enum Error {
     /// A [`std::io::Error`](https://doc.rust-lang.org/std/io/struct.Error.html) encountered while deserializing.
-    IoError(io::Error),
+    IoError(Arc<io::Error>),
 
     /// A [`std::string::FromUtf8Error`](https://doc.rust-lang.org/std/string/struct.FromUtf8Error.html) encountered
     /// while decoding a UTF-8 String from the input data.
@@ -31,11 +31,14 @@ pub enum Error {
     /// The end of the BSON input was reached too soon.
     EndOfStream,
 
-    /// An invalid timestamp was encountered while decoding.
-    InvalidTimestamp(i64),
+    /// An invalid datetime was encountered while decoding.
+    InvalidDateTime {
+        /// The key at which an unexpected/unsupported datetime was encountered.
+        key: String,
 
-    /// An ambiguous timestamp was encountered while decoding.
-    AmbiguousTimestamp(i64),
+        /// The value of the invalid datetime.
+        datetime: i64,
+    },
 
     /// A general error encountered during deserialization.
     /// See: https://docs.serde.rs/serde/de/trait.Error.html
@@ -47,7 +50,7 @@ pub enum Error {
 
 impl From<io::Error> for Error {
     fn from(err: io::Error) -> Error {
-        Error::IoError(err)
+        Error::IoError(Arc::new(err))
     }
 }
 
@@ -73,16 +76,17 @@ impl fmt::Display for Error {
             Error::SyntaxError { ref message } => message.fmt(fmt),
             Error::EndOfStream => fmt.write_str("end of stream"),
             Error::DeserializationError { ref message } => message.fmt(fmt),
-            Error::InvalidTimestamp(ref i) => write!(fmt, "no such local time {}", i),
-            Error::AmbiguousTimestamp(ref i) => write!(fmt, "ambiguous local time {}", i),
+            Error::InvalidDateTime { ref key, datetime } => {
+                write!(fmt, "invalid datetime for key \"{}\": {}", key, datetime)
+            }
         }
     }
 }
 
 impl error::Error for Error {
-    fn cause(&self) -> Option<&dyn error::Error> {
+    fn source(&self) -> Option<&(dyn error::Error + 'static)> {
         match *self {
-            Error::IoError(ref inner) => Some(inner),
+            Error::IoError(ref inner) => Some(inner.as_ref()),
             Error::FromUtf8Error(ref inner) => Some(inner),
             _ => None,
         }

src/de/mod.rs

@@ -326,19 +326,14 @@ pub(crate) fn deserialize_bson_kvp<R: Read + ?Sized>(
             // The int64 is UTC milliseconds since the Unix epoch.
             let time = read_i64(reader)?;
 
-            let mut sec = time / 1000;
-            let tmp_msec = time % 1000;
-            let msec = if tmp_msec < 0 {
-                sec -= 1;
-                1000 + tmp_msec
-            } else {
-                tmp_msec
-            };
-
-            match Utc.timestamp_opt(sec, (msec as u32) * 1_000_000) {
-                LocalResult::None => return Err(Error::InvalidTimestamp(time)),
-                LocalResult::Ambiguous(..) => return Err(Error::AmbiguousTimestamp(time)),
+            match Utc.timestamp_millis_opt(time) {
                 LocalResult::Single(t) => Bson::DateTime(t),
+                _ => {
+                    return Err(Error::InvalidDateTime {
+                        key,
+                        datetime: time,
+                    })
+                }
             }
         }
         Some(ElementType::Symbol) => read_string(reader, utf8_lossy).map(Bson::Symbol)?,

src/document.rs

@@ -26,7 +26,7 @@ use crate::{
 
 /// Error to indicate that either a value was empty or it contained an unexpected
 /// type, for use with the direct getters.
-#[derive(PartialEq)]
+#[derive(PartialEq, Clone)]
 #[non_exhaustive]
 pub enum ValueAccessError {
     /// Cannot find the expected field with the specified key

src/extjson/de.rs

@@ -27,7 +27,7 @@ use serde::de::{Error as _, Unexpected};
 
 use crate::{extjson::models, oid, Bson, Document};
 
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 #[non_exhaustive]
 /// Error cases that can occur during deserialization from [extended JSON](https://docs.mongodb.com/manual/reference/mongodb-extended-json/).
 pub enum Error {

src/oid.rs

@@ -31,7 +31,7 @@ lazy_static! {
 }
 
 /// Errors that can occur during OID construction and generation.
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 #[non_exhaustive]
 pub enum Error {
     /// An invalid argument was passed in.

src/ser/error.rs

@@ -1,15 +1,15 @@
-use std::{error, fmt, fmt::Display, io};
+use std::{error, fmt, fmt::Display, io, sync::Arc};
 
 use serde::ser;
 
 use crate::bson::Bson;
 
 /// Possible errors that can arise during encoding.
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 #[non_exhaustive]
 pub enum Error {
     /// A [`std::io::Error`](https://doc.rust-lang.org/std/io/struct.Error.html) encountered while serializing.
-    IoError(io::Error),
+    IoError(Arc<io::Error>),
 
     /// A key could not be serialized to a BSON string.
     InvalidMapKeyType {
@@ -28,18 +28,18 @@ pub enum Error {
     /// Returned when serialization of an unsigned integer was attempted. BSON only supports
     /// 32-bit and 64-bit signed integers.
     ///
-    /// To allow serialization of unsigned integers as signed integers, enable the "u2i" feature
-    /// flag.
-    UnsupportedUnsignedType,
+    /// To serialize unsigned integers to BSON, use an appropriate helper from
+    /// [`crate::serde_helpers`] or enable the "u2i" feature flag.
+    UnsupportedUnsignedInteger(u64),
 
     #[cfg(feature = "u2i")]
     /// An unsigned integer type could not fit into a signed integer type.
-    UnsignedTypesValueExceedsRange(u64),
+    UnsignedIntegerExceededRange(u64),
 }
 
 impl From<io::Error> for Error {
     fn from(err: io::Error) -> Error {
-        Error::IoError(err)
+        Error::IoError(Arc::new(err))
     }
 }
 
@@ -50,11 +50,17 @@ impl fmt::Display for Error {
             Error::InvalidMapKeyType { ref key } => write!(fmt, "Invalid map key type: {}", key),
             Error::SerializationError { ref message } => message.fmt(fmt),
             #[cfg(not(feature = "u2i"))]
-            Error::UnsupportedUnsignedType => fmt.write_str("BSON does not support unsigned type"),
+            Error::UnsupportedUnsignedInteger(value) => write!(
+                fmt,
+                "BSON does not support unsigned integers, cannot serialize value: {}. To \
+                 serialize unsigned integers to BSON, use an appropriate serde helper or enable \
+                 the u2i feature.",
+                value
+            ),
             #[cfg(feature = "u2i")]
-            Error::UnsignedTypesValueExceedsRange(value) => write!(
+            Error::UnsignedIntegerExceededRange(value) => write!(
                 fmt,
-                "BSON does not support unsigned types.
+                "BSON does not support unsigned integers.
                  An attempt to serialize the value: {} in a signed type failed due to the value's \
                  size.",
                 value
@@ -66,7 +72,7 @@ impl fmt::Display for Error {
 impl error::Error for Error {
     fn cause(&self) -> Option<&dyn error::Error> {
         match *self {
-            Error::IoError(ref inner) => Some(inner),
+            Error::IoError(ref inner) => Some(inner.as_ref()),
             _ => None,
         }
     }

src/ser/serde.rs

@@ -117,14 +117,14 @@ impl ser::Serializer for Serializer {
     }
 
     #[inline]
-    fn serialize_u8(self, _value: u8) -> crate::ser::Result<Bson> {
+    fn serialize_u8(self, value: u8) -> crate::ser::Result<Bson> {
         #[cfg(feature = "u2i")]
         {
-            Ok(Bson::Int32(_value as i32))
+            Ok(Bson::Int32(value as i32))
         }
 
         #[cfg(not(feature = "u2i"))]
-        Err(Error::UnsupportedUnsignedType)
+        Err(Error::UnsupportedUnsignedInteger(value as u64))
     }
 
     #[inline]
@@ -133,14 +133,14 @@ impl ser::Serializer for Serializer {
     }
 
     #[inline]
-    fn serialize_u16(self, _value: u16) -> crate::ser::Result<Bson> {
+    fn serialize_u16(self, value: u16) -> crate::ser::Result<Bson> {
         #[cfg(feature = "u2i")]
         {
-            Ok(Bson::Int32(_value as i32))
+            Ok(Bson::Int32(value as i32))
         }
 
         #[cfg(not(feature = "u2i"))]
-        Err(Error::UnsupportedUnsignedType)
+        Err(Error::UnsupportedUnsignedInteger(value as u64))
     }
 
     #[inline]
@@ -149,14 +149,14 @@ impl ser::Serializer for Serializer {
     }
 
     #[inline]
-    fn serialize_u32(self, _value: u32) -> crate::ser::Result<Bson> {
+    fn serialize_u32(self, value: u32) -> crate::ser::Result<Bson> {
         #[cfg(feature = "u2i")]
         {
-            Ok(Bson::Int64(_value as i64))
+            Ok(Bson::Int64(value as i64))
         }
 
         #[cfg(not(feature = "u2i"))]
-        Err(Error::UnsupportedUnsignedType)
+        Err(Error::UnsupportedUnsignedInteger(value as u64))
     }
 
     #[inline]
@@ -165,19 +165,19 @@ impl ser::Serializer for Serializer {
     }
 
     #[inline]
-    fn serialize_u64(self, _value: u64) -> crate::ser::Result<Bson> {
+    fn serialize_u64(self, value: u64) -> crate::ser::Result<Bson> {
         #[cfg(feature = "u2i")]
         {
             use std::convert::TryFrom;
 
-            match i64::try_from(_value) {
+            match i64::try_from(value) {
                 Ok(ivalue) => Ok(Bson::Int64(ivalue)),
-                Err(_) => Err(Error::UnsignedTypesValueExceedsRange(_value)),
+                Err(_) => Err(Error::UnsignedIntegerExceededRange(value)),
             }
         }
 
         #[cfg(not(feature = "u2i"))]
-        Err(Error::UnsupportedUnsignedType)
+        Err(Error::UnsupportedUnsignedInteger(value))
     }
 
     #[inline]

src/tests/modules/ser.rs

@@ -86,7 +86,7 @@ fn dec128() {
 fn uint8() {
     let _guard = LOCK.run_concurrently();
     let obj_min: ser::Result<Bson> = to_bson(&u8::MIN);
-    assert_matches!(obj_min, Err(ser::Error::UnsupportedUnsignedType));
+    assert_matches!(obj_min, Err(ser::Error::UnsupportedUnsignedInteger(_)));
 }
 
 #[test]
@@ -107,7 +107,7 @@ fn uint8_u2i() {
 fn uint16() {
     let _guard = LOCK.run_concurrently();
     let obj_min: ser::Result<Bson> = to_bson(&u16::MIN);
-    assert_matches!(obj_min, Err(ser::Error::UnsupportedUnsignedType));
+    assert_matches!(obj_min, Err(ser::Error::UnsupportedUnsignedInteger(_)));
 }
 
 #[test]
@@ -128,7 +128,7 @@ fn uint16_u2i() {
 fn uint32() {
     let _guard = LOCK.run_concurrently();
     let obj_min: ser::Result<Bson> = to_bson(&u32::MIN);
-    assert_matches!(obj_min, Err(ser::Error::UnsupportedUnsignedType));
+    assert_matches!(obj_min, Err(ser::Error::UnsupportedUnsignedInteger(_)));
 }
 
 #[test]
@@ -149,7 +149,7 @@ fn uint32_u2i() {
 fn uint64() {
     let _guard = LOCK.run_concurrently();
     let obj_min: ser::Result<Bson> = to_bson(&u64::MIN);
-    assert_matches!(obj_min, Err(ser::Error::UnsupportedUnsignedType));
+    assert_matches!(obj_min, Err(ser::Error::UnsupportedUnsignedInteger(_)));
 }
 
 #[test]
@@ -163,7 +163,7 @@ fn uint64_u2i() {
     let obj_max: ser::Result<Bson> = to_bson(&u64::MAX);
     assert_matches!(
         obj_max,
-        Err(ser::Error::UnsignedTypesValueExceedsRange(u64::MAX))
+        Err(ser::Error::UnsignedIntegerExceededRange(u64::MAX))
     );
 }