Merge pull request #59 from knz/20201212-errors

markers: delegate to an Is() method if present

Author: knz

markers/markers.go

@@ -28,12 +28,22 @@ import (
 // Is determines whether one of the causes of the given error or any
 // of its causes is equivalent to some reference error.
 //
+// As in the Go standard library, an error is considered to match a
+// reference error if it is equal to that target or if it implements a
+// method Is(error) bool such that Is(reference) returns true.
+//
+// Note: the inverse is not true - making an Is(reference) method
+// return false does not imply that errors.Is() also returns
+// false. Errors can be equal because their network equality marker is
+// the same. To force errors to appear different to Is(), use
+// errors.Mark().
+//
 // Note: if any of the error types has been migrated from a previous
 // package location or a different type, ensure that
 // RegisterTypeMigration() was called prior to Is().
 func Is(err, reference error) bool {
 	if reference == nil {
-		return err == reference
+		return err == nil
 	}
 
 	// Direct reference comparison is the fastest, and most
@@ -42,6 +52,11 @@ func Is(err, reference error) bool {
 		if c == reference {
 			return true
 		}
+		// Compatibility with std go errors: if the error object itself
+		// implements Is(), try to use that.
+		if tryDelegateToIsMethod(c, reference) {
+			return true
+		}
 	}
 
 	if err == nil {
@@ -67,6 +82,13 @@ func Is(err, reference error) bool {
 	return false
 }
 
+func tryDelegateToIsMethod(err, reference error) bool {
+	if x, ok := err.(interface{ Is(error) bool }); ok && x.Is(reference) {
+		return true
+	}
+	return false
+}
+
 // HasType returns true iff err contains an error whose concrete type
 // matches that of referenceType.
 func HasType(err error, referenceType error) bool {
@@ -125,6 +147,11 @@ func IsAny(err error, references ...error) bool {
 			if c == refErr {
 				return true
 			}
+			// Compatibility with std go errors: if the error object itself
+			// implements Is(), try to use that.
+			if tryDelegateToIsMethod(c, refErr) {
+				return true
+			}
 		}
 		if c == nil {
 			// This special case is to support a comparison to a nil

markers/markers_test.go

@@ -569,3 +569,33 @@ type invalidError struct {
 
 func (e *invalidError) Error() string { return e.emptyRef.Error() }
 func (e *invalidError) Cause() error  { return e.emptyRef }
+
+func TestDelegateToIsMethod(t *testing.T) {
+	tt := testutils.T{T: t}
+
+	efoo := &errWithIs{msg: "foo", seecret: "foo"}
+	efoo2 := &errWithIs{msg: "foo", seecret: "bar"}
+	ebar := &errWithIs{msg: "bar", seecret: "foo"}
+
+	tt.Check(markers.Is(efoo, efoo2))  // equality based on message
+	tt.Check(markers.Is(efoo, ebar))   // equality based on method
+	tt.Check(!markers.Is(efoo2, ebar)) // neither msg nor method
+
+	tt.Check(markers.IsAny(efoo, efoo2, ebar))
+	tt.Check(markers.IsAny(efoo2, ebar, efoo))
+	tt.Check(!markers.IsAny(efoo2, ebar, errors.New("other")))
+}
+
+type errWithIs struct {
+	msg     string
+	seecret string
+}
+
+func (e *errWithIs) Error() string { return e.msg }
+
+func (e *errWithIs) Is(o error) bool {
+	if ex, ok := o.(*errWithIs); ok {
+		return e.seecret == ex.seecret
+	}
+	return false
+}

markers_api.go

@@ -19,6 +19,16 @@ import "github.com/cockroachdb/errors/markers"
 // Is determines whether one of the causes of the given error or any
 // of its causes is equivalent to some reference error.
 //
+// As in the Go standard library, an error is considered to match a
+// reference error if it is equal to that target or if it implements a
+// method Is(error) bool such that Is(reference) returns true.
+//
+// Note: the inverse is not true - making an Is(reference) method
+// return false does not imply that errors.Is() also returns
+// false. Errors can be equal because their network equality marker is
+// the same. To force errors to appear different to Is(), use
+// errors.Mark().
+//
 // Note: if any of the error types has been migrated from a previous
 // package location or a different type, ensure that
 // RegisterTypeMigration() was called prior to Is().