RUST-742 Reduce the size of Error

Author: patrickfreed

src/client/executor.rs

@@ -110,7 +110,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 mut command_error) = err.kind {
+                if let ErrorKind::CommandError(ref mut command_error) = *err.kind {
                     if command_error.code == 20
                         && command_error.message.starts_with("Transaction numbers")
                     {

src/client/options/test.rs

@@ -316,8 +316,7 @@ async fn run_test(test_file: TestFile) {
 
             match ClientOptions::parse(&test_case.uri)
                 .await
-                .as_ref()
-                .map_err(|e| &e.kind)
+                .map_err(|e| *e.kind)
             {
                 Ok(_) => panic!("expected {}", expected_type),
                 Err(ErrorKind::ArgumentError { .. }) => {}
@@ -341,8 +340,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.kind)
+        .map_err(|e| *e.kind)
     {
         Ok(_) => panic!("expected error for option {}", option),
         Err(ErrorKind::ArgumentError { message, .. }) => {

src/cmap/mod.rs

@@ -156,7 +156,7 @@ impl ConnectionPool {
                 });
             }
             Err(ref e) => {
-                let failure_reason = if let ErrorKind::WaitQueueTimeoutError { .. } = e.kind {
+                let failure_reason = if let ErrorKind::WaitQueueTimeoutError { .. } = *e.kind {
                     ConnectionCheckoutFailedReason::Timeout
                 } else {
                     ConnectionCheckoutFailedReason::ConnectionError

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 {
+        match error.kind.as_ref() {
             ErrorKind::WaitQueueTimeoutError { .. } => {
                 assert_eq!(self.type_, "WaitQueueTimeoutError", "{}", description);
             }

src/coll/mod.rs

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

src/concern/test.rs

@@ -107,7 +107,7 @@ async fn inconsistent_write_concern_rejected() {
         )
         .await
         .expect_err("insert should fail");
-    assert!(matches!(error.kind, ErrorKind::ArgumentError { .. }));
+    assert!(matches!(*error.kind, ErrorKind::ArgumentError { .. }));
 
     let coll = db.collection(function_name!());
     let wc = WriteConcern {
@@ -120,7 +120,7 @@ async fn inconsistent_write_concern_rejected() {
         .insert_one(doc! {}, options)
         .await
         .expect_err("insert should fail");
-    assert!(matches!(error.kind, ErrorKind::ArgumentError { .. }));
+    assert!(matches!(*error.kind, ErrorKind::ArgumentError { .. }));
 }
 
 #[cfg_attr(feature = "tokio-runtime", tokio::test)]
@@ -142,5 +142,5 @@ async fn unacknowledged_write_concern_rejected() {
         )
         .await
         .expect_err("insert should fail");
-    assert!(matches!(error.kind, 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, ErrorKind::CommandError(ref 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

@@ -1,6 +1,6 @@
 //! Contains the `Error` and `Result` types that `mongodb` uses.
 
-use std::{fmt, sync::Arc};
+use std::{fmt::{self, Debug}, sync::Arc};
 
 use serde::Deserialize;
 use thiserror::Error;
@@ -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: ErrorKind,
+    pub kind: Box<ErrorKind>,
     labels: Vec<String>,
 }
 
@@ -66,20 +66,20 @@ impl Error {
     }
 
     pub(crate) fn is_auth_error(&self) -> bool {
-        matches!(self.kind, ErrorKind::AuthenticationError { .. })
+        matches!(self.kind.as_ref(), ErrorKind::AuthenticationError { .. })
     }
 
     pub(crate) fn is_command_error(&self) -> bool {
-        matches!(self.kind, ErrorKind::CommandError(_))
+        matches!(self.kind.as_ref(), ErrorKind::CommandError(_))
     }
 
     pub(crate) fn is_network_timeout(&self) -> bool {
-        matches!(self.kind, ErrorKind::Io(ref io_err) if io_err.kind() == std::io::ErrorKind::TimedOut)
+        matches!(self.kind.as_ref(), ErrorKind::Io(ref io_err) if io_err.kind() == std::io::ErrorKind::TimedOut)
     }
 
     /// Whether this error is an "ns not found" error or not.
     pub(crate) fn is_ns_not_found(&self) -> bool {
-        matches!(self.kind, ErrorKind::CommandError(ref err) if err.code == 26)
+        matches!(self.kind.as_ref(), ErrorKind::CommandError(ref err) if err.code == 26)
     }
 
     /// Whether a read operation should be retried if this error occurs.
@@ -119,7 +119,7 @@ impl Error {
     /// Whether an error originated from the server.
     pub(crate) fn is_server_error(&self) -> bool {
         matches!(
-            self.kind,
+            self.kind.as_ref(),
             ErrorKind::AuthenticationError { .. }
                 | ErrorKind::BulkWriteError(_)
                 | ErrorKind::CommandError(_)
@@ -129,7 +129,7 @@ impl Error {
 
     /// Returns the labels for this error.
     pub fn labels(&self) -> &[String] {
-        match self.kind {
+        match self.kind.as_ref() {
             ErrorKind::CommandError(ref err) => &err.labels,
             ErrorKind::WriteError(ref err) => match err {
                 WriteFailure::WriteError(_) => &self.labels,
@@ -153,7 +153,7 @@ 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 {
+        match self.kind.as_ref() {
             ErrorKind::CommandError(ref err) => {
                 let mut err = err.clone();
                 err.labels.push(label);
@@ -197,7 +197,7 @@ where
 {
     fn from(err: E) -> Self {
         Self {
-            kind: err.into(),
+            kind: Box::new(err.into()),
             labels: Vec::new(),
         }
     }
@@ -603,7 +603,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, &Default::default())
         .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

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