markers: delegate to an Is() method if present

The Go std `errors` package has this rule about `Is()`:

> An error is considered to match a target if it is equal to that
> target or if it implements a method Is(error) bool such that
> Is(target) returns true.

([source](https://golang.org/pkg/errors/?source=post_page---------------------------#Is))

This patch extends the errors library accordingly.

Caveat: the doc says "if a.Is(b) is true, then errors.Is(a, b) is
true". This is the behavior implemented here. The doc does not say "if
a.Is(b) is false, then errors.Is(a, b) is false".

The CockroachDB errors library uses error identity markers which
enable comparisons across the network. The identity marker includes
only the type and message. Therefore, it is not possible to "make two
errors unequal" by customizing an `Is()` method to return `false`, if
their network identity marker is otherwise equal. To change this
behavior, use the `errors.Mark()` API instead, or implement an
`ErrorTypeKey()` method.

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().