RUST-679 Remove inner Arc from Error

Author: saghm

src/client/executor.rs

@@ -108,7 +108,7 @@ impl Client {
 
                 // Retryable writes are only supported by storage engines with document-level
                 // locking, so users need to disable retryable writes if using mmapv1.
-                if let ErrorKind::CommandError(ref err) = err.kind.as_ref() {
+                if let ErrorKind::CommandError(ref err) = err.kind {
                     if err.code == 20 && err.message.starts_with("Transaction numbers") {
                         let mut err = err.clone();
                         err.message = "This MongoDB deployment does not support retryable writes. \

src/client/options/test.rs

@@ -317,7 +317,7 @@ async fn run_test(test_file: TestFile) {
             match ClientOptions::parse(&test_case.uri)
                 .await
                 .as_ref()
-                .map_err(|e| e.as_ref())
+                .map_err(|e| &e.kind)
             {
                 Ok(_) => panic!("expected {}", expected_type),
                 Err(ErrorKind::ArgumentError { .. }) => {}
@@ -342,7 +342,7 @@ async fn run_connection_string_spec_tests() {
 async fn parse_uri(option: &str, suggestion: Option<&str>) {
     match ClientOptionsParser::parse(&format!("mongodb://host:27017/?{}=test", option))
         .as_ref()
-        .map_err(|e| e.as_ref())
+        .map_err(|e| &e.kind)
     {
         Ok(_) => panic!("expected error for option {}", option),
         Err(ErrorKind::ArgumentError { message, .. }) => {

src/cmap/mod.rs

@@ -156,12 +156,11 @@ impl ConnectionPool {
                 });
             }
             Err(ref e) => {
-                let failure_reason =
-                    if let ErrorKind::WaitQueueTimeoutError { .. } = e.kind.as_ref() {
-                        ConnectionCheckoutFailedReason::Timeout
-                    } else {
-                        ConnectionCheckoutFailedReason::ConnectionError
-                    };
+                let failure_reason = if let ErrorKind::WaitQueueTimeoutError { .. } = e.kind {
+                    ConnectionCheckoutFailedReason::Timeout
+                } else {
+                    ConnectionCheckoutFailedReason::ConnectionError
+                };
 
                 self.emit_event(|handler| {
                     handler.handle_connection_checkout_failed_event(ConnectionCheckoutFailedEvent {

src/cmap/test/file.rs

@@ -97,7 +97,7 @@ pub struct Error {
 
 impl Error {
     pub fn assert_matches(&self, error: &crate::error::Error, description: &str) {
-        match error.kind.as_ref() {
+        match error.kind {
             ErrorKind::WaitQueueTimeoutError { .. } => {
                 assert_eq!(self.type_, "WaitQueueTimeoutError", "{}", description);
             }

src/coll/mod.rs

@@ -437,7 +437,7 @@ where
                         }
                     }
                 }
-                Err(e) => match e.kind.as_ref() {
+                Err(e) => match e.kind {
                     ErrorKind::BulkWriteError(failure) => {
                         let failure_ref =
                             cumulative_failure.get_or_insert_with(BulkWriteFailure::new);

src/concern/test.rs

@@ -107,10 +107,7 @@ async fn inconsistent_write_concern_rejected() {
         )
         .await
         .expect_err("insert should fail");
-    assert!(matches!(
-        error.kind.as_ref(),
-        ErrorKind::ArgumentError { .. }
-    ));
+    assert!(matches!(error.kind, ErrorKind::ArgumentError { .. }));
 
     let coll = db.collection(function_name!());
     let wc = WriteConcern {
@@ -123,10 +120,7 @@ async fn inconsistent_write_concern_rejected() {
         .insert_one(doc! {}, options)
         .await
         .expect_err("insert should fail");
-    assert!(matches!(
-        error.kind.as_ref(),
-        ErrorKind::ArgumentError { .. }
-    ));
+    assert!(matches!(error.kind, ErrorKind::ArgumentError { .. }));
 }
 
 #[cfg_attr(feature = "tokio-runtime", tokio::test)]
@@ -148,8 +142,5 @@ async fn unacknowledged_write_concern_rejected() {
         )
         .await
         .expect_err("insert should fail");
-    assert!(matches!(
-        error.kind.as_ref(),
-        ErrorKind::ArgumentError { .. }
-    ));
+    assert!(matches!(error.kind, ErrorKind::ArgumentError { .. }));
 }

src/cursor/common.rs

@@ -137,7 +137,7 @@ pub(super) trait GetMoreProviderResult {
         match self.as_ref() {
             Ok(res) => res.exhausted,
             Err(e) => {
-                matches!(e.kind.as_ref(), ErrorKind::CommandError(e) if e.code == 43 || e.code == 237)
+                matches!(e.kind, ErrorKind::CommandError(ref e) if e.code == 43 || e.code == 237)
             }
         }
     }

src/error.rs

@@ -27,7 +27,7 @@ pub type Result<T> = std::result::Result<T, Error>;
 #[non_exhaustive]
 pub struct Error {
     /// The type of error that occurred.
-    pub kind: Arc<ErrorKind>,
+    pub kind: ErrorKind,
     labels: Vec<String>,
 }
 
@@ -63,7 +63,7 @@ impl Error {
 
     /// Whether this error is an "ns not found" error or not.
     pub(crate) fn is_ns_not_found(&self) -> bool {
-        matches!(self.kind.as_ref(), ErrorKind::CommandError(err) if err.code == 26)
+        matches!(self.kind, ErrorKind::CommandError(ref err) if err.code == 26)
     }
 
     /// Whether a read operation should be retried if this error occurs.
@@ -109,7 +109,7 @@ impl Error {
     /// Whether an error originated from the server.
     pub(crate) fn is_server_error(&self) -> bool {
         matches!(
-            self.kind.as_ref(),
+            self.kind,
             ErrorKind::AuthenticationError { .. }
                 | ErrorKind::BulkWriteError(_)
                 | ErrorKind::CommandError(_)
@@ -119,13 +119,13 @@ impl Error {
 
     /// Returns the labels for this error.
     pub fn labels(&self) -> &[String] {
-        match self.kind.as_ref() {
-            ErrorKind::CommandError(err) => &err.labels,
-            ErrorKind::WriteError(err) => match err {
+        match self.kind {
+            ErrorKind::CommandError(ref err) => &err.labels,
+            ErrorKind::WriteError(ref err) => match err {
                 WriteFailure::WriteError(_) => &self.labels,
-                WriteFailure::WriteConcernError(err) => &err.labels,
+                WriteFailure::WriteConcernError(ref err) => &err.labels,
             },
-            ErrorKind::BulkWriteError(err) => match err.write_concern_error {
+            ErrorKind::BulkWriteError(ref err) => match err.write_concern_error {
                 Some(ref err) => &err.labels,
                 None => &self.labels,
             },
@@ -143,24 +143,24 @@ impl Error {
     /// Returns a copy of this Error with the specified label added.
     pub(crate) fn with_label<T: AsRef<str>>(mut self, label: T) -> Self {
         let label = label.as_ref().to_string();
-        match self.kind.as_ref() {
-            ErrorKind::CommandError(err) => {
+        match self.kind {
+            ErrorKind::CommandError(ref err) => {
                 let mut err = err.clone();
                 err.labels.push(label);
                 ErrorKind::CommandError(err).into()
             }
-            ErrorKind::WriteError(err) => match err {
+            ErrorKind::WriteError(ref err) => match err {
                 WriteFailure::WriteError(_) => {
                     self.labels.push(label);
                     self
                 }
-                WriteFailure::WriteConcernError(err) => {
+                WriteFailure::WriteConcernError(ref err) => {
                     let mut err = err.clone();
                     err.labels.push(label);
                     ErrorKind::WriteError(WriteFailure::WriteConcernError(err)).into()
                 }
             },
-            ErrorKind::BulkWriteError(err) => match err.write_concern_error {
+            ErrorKind::BulkWriteError(ref err) => match err.write_concern_error {
                 Some(ref write_concern_error) => {
                     let mut err = err.clone();
                     let mut write_concern_error = write_concern_error.clone();
@@ -187,14 +187,38 @@ where
 {
     fn from(err: E) -> Self {
         Self {
-            kind: Arc::new(err.into()),
+            kind: err.into(),
             labels: Vec::new(),
         }
     }
 }
 
+impl From<bson::de::Error> for ErrorKind {
+    fn from(err: bson::de::Error) -> Self {
+        Self::BsonDecode(Arc::new(err))
+    }
+}
+
+impl From<bson::ser::Error> for ErrorKind {
+    fn from(err: bson::ser::Error) -> Self {
+        Self::BsonEncode(Arc::new(err))
+    }
+}
+
+impl From<std::io::Error> for ErrorKind {
+    fn from(err: std::io::Error) -> Self {
+        Self::Io(Arc::new(err))
+    }
+}
+
+impl From<std::io::ErrorKind> for ErrorKind {
+    fn from(err: std::io::ErrorKind) -> Self {
+        Self::Io(Arc::new(err.into()))
+    }
+}
+
 impl std::ops::Deref for Error {
-    type Target = Arc<ErrorKind>;
+    type Target = ErrorKind;
 
     fn deref(&self) -> &Self::Target {
         &self.kind
@@ -203,7 +227,7 @@ impl std::ops::Deref for Error {
 
 /// The types of errors that can occur.
 #[allow(missing_docs)]
-#[derive(Debug, Error)]
+#[derive(Clone, Debug, Error)]
 #[non_exhaustive]
 pub enum ErrorKind {
     /// Wrapper around [`std::net::AddrParseError`](https://doc.rust-lang.org/std/net/struct.AddrParseError.html).
@@ -215,10 +239,6 @@ pub enum ErrorKind {
     #[non_exhaustive]
     ArgumentError { message: String },
 
-    #[cfg(feature = "async-std-runtime")]
-    #[error("{0}")]
-    AsyncStdTimeout(#[from] async_std::future::TimeoutError),
-
     /// An error occurred while the [`Client`](../struct.Client.html) attempted to authenticate a
     /// connection.
     #[error("{message}")]
@@ -227,11 +247,11 @@ pub enum ErrorKind {
 
     /// Wrapper around `bson::de::Error`.
     #[error("{0}")]
-    BsonDecode(#[from] crate::bson::de::Error),
+    BsonDecode(Arc<crate::bson::de::Error>),
 
     /// Wrapper around `bson::ser::Error`.
     #[error("{0}")]
-    BsonEncode(#[from] crate::bson::ser::Error),
+    BsonEncode(Arc<crate::bson::ser::Error>),
 
     /// An error occurred when trying to execute a write operation consisting of multiple writes.
     #[error("An error occurred when trying to execute a write operation: {0:?}")]
@@ -262,7 +282,7 @@ pub enum ErrorKind {
 
     /// Wrapper around [`std::io::Error`](https://doc.rust-lang.org/std/io/struct.Error.html).
     #[error("{0}")]
-    Io(#[from] std::io::Error),
+    Io(Arc<std::io::Error>),
 
     #[error("No DNS results for domain {0}")]
     NoDnsResults(StreamAddress),
@@ -301,11 +321,6 @@ pub enum ErrorKind {
     #[non_exhaustive]
     SrvLookupError { message: String },
 
-    /// A timeout occurred before a Tokio task could be completed.
-    #[cfg(feature = "tokio-runtime")]
-    #[error("{0}")]
-    TokioTimeoutElapsed(#[from] tokio::time::error::Elapsed),
-
     #[error("{0}")]
     RustlsConfig(#[from] rustls::TLSError),
 
@@ -561,7 +576,7 @@ impl WriteFailure {
 /// Translates ErrorKind::BulkWriteError cases to ErrorKind::WriteErrors, leaving all other errors
 /// untouched.
 pub(crate) fn convert_bulk_errors(error: Error) -> Error {
-    match *error.kind {
+    match error.kind {
         ErrorKind::BulkWriteError(ref bulk_failure) => {
             match WriteFailure::from_bulk_failure(bulk_failure.clone()) {
                 Ok(failure) => ErrorKind::WriteError(failure).into(),

src/operation/aggregate/test.rs

@@ -310,7 +310,7 @@ async fn handle_write_concern_error() {
     let error = aggregate
         .handle_response(response)
         .expect_err("should get wc error");
-    match *error.kind {
+    match error.kind {
         ErrorKind::WriteError(WriteFailure::WriteConcernError(_)) => {}
         ref e => panic!("should have gotten WriteConcernError, got {:?} instead", e),
     }

src/operation/count/test.rs

@@ -96,7 +96,7 @@ async fn handle_response_no_n() {
     let response = CommandResponse::with_document(doc! { "ok" : 1 });
 
     let result = count_op.handle_response(response);
-    match result.as_ref().map_err(|e| e.as_ref()) {
+    match result.as_ref().map_err(|e| &e.kind) {
         Err(ErrorKind::ResponseError { .. }) => {}
         other => panic!("expected response error, but got {:?}", other),
     }

src/operation/create/test.rs

@@ -102,7 +102,7 @@ async fn handle_write_concern_error() {
     let result = op.handle_response(response);
     assert!(result.is_err());
 
-    match *result.unwrap_err().kind {
+    match result.unwrap_err().kind {
         ErrorKind::WriteError(WriteFailure::WriteConcernError(ref wc_err)) => {
             assert_eq!(wc_err.code, 100);
             assert_eq!(wc_err.code_name, "hello world");

src/operation/delete/test.rs

@@ -143,7 +143,7 @@ async fn handle_write_failure() {
     });
     let write_error_result = op.handle_response(write_error_response);
     assert!(write_error_result.is_err());
-    match *write_error_result.unwrap_err().kind {
+    match write_error_result.unwrap_err().kind {
         ErrorKind::WriteError(WriteFailure::WriteError(ref error)) => {
             let expected_err = WriteError {
                 code: 1234,
@@ -181,7 +181,7 @@ async fn handle_write_concern_failure() {
     let wc_error_result = op.handle_response(wc_error_response);
     assert!(wc_error_result.is_err());
 
-    match *wc_error_result.unwrap_err().kind {
+    match wc_error_result.unwrap_err().kind {
         ErrorKind::WriteError(WriteFailure::WriteConcernError(ref wc_error)) => {
             let expected_wc_err = WriteConcernError {
                 code: 456,

src/operation/distinct/test.rs

@@ -144,7 +144,7 @@ async fn handle_response_no_values() {
     });
 
     let result = distinct_op.handle_response(response);
-    match result.as_ref().map_err(|e| e.as_ref()) {
+    match result.as_ref().map_err(|e| &e.kind) {
         Err(ErrorKind::ResponseError { .. }) => {}
         other => panic!("expected response error, but got {:?}", other),
     }

src/operation/drop_collection/test.rs

@@ -80,7 +80,7 @@ async fn handle_write_concern_error() {
     let result = op.handle_response(response);
     assert!(result.is_err());
 
-    match *result.unwrap_err().kind {
+    match result.unwrap_err().kind {
         ErrorKind::WriteError(WriteFailure::WriteConcernError(ref wc_err)) => {
             assert_eq!(wc_err.code, 100);
             assert_eq!(wc_err.code_name, "hello world");

src/operation/drop_database/test.rs

@@ -78,7 +78,7 @@ async fn handle_write_concern_error() {
     let result = op.handle_response(response);
     assert!(result.is_err());
 
-    match *result.unwrap_err().kind {
+    match result.unwrap_err().kind {
         ErrorKind::WriteError(WriteFailure::WriteConcernError(ref wc_err)) => {
             assert_eq!(wc_err.code, 100);
             assert_eq!(wc_err.code_name, "hello world");

src/operation/insert/test.rs

@@ -193,7 +193,7 @@ async fn handle_write_failure() {
     let write_error_result = fixtures.op.handle_response(write_error_response);
     assert!(write_error_result.is_err());
 
-    match *write_error_result.unwrap_err().kind {
+    match write_error_result.unwrap_err().kind {
         ErrorKind::BulkWriteError(ref error) => {
             let write_errors = error.write_errors.clone().unwrap();
             assert_eq!(write_errors.len(), 1);

src/operation/list_databases/test.rs

@@ -140,7 +140,7 @@ async fn handle_response_no_databases() {
     });
 
     let result = list_databases_op.handle_response(response);
-    match result.as_ref().map_err(|e| e.as_ref()) {
+    match result.as_ref().map_err(|e| &e.kind) {
         Err(ErrorKind::ResponseError { .. }) => {}
         other => panic!("expected response error, but got {:?}", other),
     }

src/operation/update/test.rs

@@ -227,7 +227,7 @@ async fn handle_write_failure() {
     });
     let write_error_result = op.handle_response(write_error_response);
     assert!(write_error_result.is_err());
-    match *write_error_result.unwrap_err().kind {
+    match write_error_result.unwrap_err().kind {
         ErrorKind::WriteError(WriteFailure::WriteError(ref error)) => {
             let expected_err = WriteError {
                 code: 1234,
@@ -266,7 +266,7 @@ async fn handle_write_concern_failure() {
     let wc_error_result = op.handle_response(wc_error_response);
     assert!(wc_error_result.is_err());
 
-    match *wc_error_result.unwrap_err().kind {
+    match wc_error_result.unwrap_err().kind {
         ErrorKind::WriteError(WriteFailure::WriteConcernError(ref wc_error)) => {
             let expected_wc_err = WriteConcernError {
                 code: 456,