GODRIVER-2774 Refactor replaceErrors to use errors.Is/errors.As

Author: matthewdale

internal/codecutil/encoding.go

@@ -32,6 +32,8 @@ func (e MarshalError) Error() string {
 		reflect.TypeOf(e.Value), e.Err)
 }
 
+func (e MarshalError) Unwrap() error { return e.Err }
+
 // EncoderFn is used to functionally construct an encoder for marshaling values.
 type EncoderFn func(io.Writer) *bson.Encoder
 

mongo/errors.go

@@ -75,28 +75,35 @@ func replaceErrors(err error) error {
 	// ignored. For non-DDL write commands (insert, update, etc), acknowledgement
 	// should be be propagated at the result-level: e.g.,
 	// SingleResult.Acknowledged.
-	if errors.Is(err, driver.ErrUnacknowledgedWrite) {
+	// if errors.Is(err, driver.ErrUnacknowledgedWrite) {
+	// 	return nil
+	// }
+	if err == driver.ErrUnacknowledgedWrite {
 		return nil
 	}
 
 	if errors.Is(err, topology.ErrTopologyClosed) {
 		return ErrClientDisconnected
 	}
-	if de, ok := err.(driver.Error); ok {
+
+	var de driver.Error
+	if errors.As(err, &de) {
 		return CommandError{
 			Code:    de.Code,
 			Message: de.Message,
 			Labels:  de.Labels,
 			Name:    de.Name,
-			Wrapped: de.Wrapped,
+			Wrapped: err,
 			Raw:     bson.Raw(de.Raw),
 		}
 	}
-	if qe, ok := err.(driver.QueryFailureError); ok {
+
+	var qe driver.QueryFailureError
+	if errors.As(err, &qe) {
 		// qe.Message is "command failure"
 		ce := CommandError{
 			Name:    qe.Message,
-			Wrapped: qe.Wrapped,
+			Wrapped: err,
 			Raw:     bson.Raw(qe.Response),
 		}
 
@@ -111,18 +118,25 @@ func replaceErrors(err error) error {
 
 		return ce
 	}
-	if me, ok := err.(mongocrypt.Error); ok {
-		return MongocryptError{Code: me.Code, Message: me.Message}
+
+	var me mongocrypt.Error
+	if errors.As(err, &me) {
+		return MongocryptError{
+			Code:    me.Code,
+			Message: me.Message,
+			wrapped: err,
+		}
 	}
 
 	if errors.Is(err, codecutil.ErrNilValue) {
 		return ErrNilValue
 	}
 
-	if marshalErr, ok := err.(codecutil.MarshalError); ok {
+	var marshalErr codecutil.MarshalError
+	if errors.As(err, &marshalErr) {
 		return MarshalError{
 			Value: marshalErr.Value,
-			Err:   marshalErr.Err,
+			Err:   err,
 		}
 	}
 
@@ -199,13 +213,19 @@ func IsNetworkError(err error) bool {
 type MongocryptError struct {
 	Code    int32
 	Message string
+	wrapped error
 }
 
 // Error implements the error interface.
 func (m MongocryptError) Error() string {
 	return fmt.Sprintf("mongocrypt error %d: %v", m.Code, m.Message)
 }
 
+// Unwrap returns the underlying error.
+func (m MongocryptError) Unwrap() error {
+	return m.wrapped
+}
+
 // EncryptionKeyVaultError represents an error while communicating with the key vault collection during in-use
 // encryption.
 type EncryptionKeyVaultError struct {

mongo/mongo.go

@@ -43,6 +43,8 @@ func (me MarshalError) Error() string {
 	return fmt.Sprintf("cannot marshal type %s to a BSON Document: %v", reflect.TypeOf(me.Value), me.Err)
 }
 
+func (me MarshalError) Unwrap() error { return me.Err }
+
 // Pipeline is a type that makes creating aggregation pipelines easier. It is a
 // helper and is intended for serializing to BSON.
 //