Support Go 1.13 error chains in Cause

Imagine module A imports module B and both use `pkg/errors`. A uses
`errors.Cause` to inspect wrapped errors returned from B. As-is, B
cannot migrate from `errors.Wrap` to `fmt.Errorf("%w", err)` because
that would break `errors.Cause` calls in A. With this change merged,
`errors.Cause` becomes forwards-compatible with Go 1.13 error chains.
Module B will be free to switch to `fmt.Errorf("%w", err)` and that will
not break module A (so long as the top-level project pulls in the newer
version of `pkg/errors`).

cause.go

@@ -0,0 +1,29 @@
+// +build !go1.13
+
+package errors
+
+// Cause returns the underlying cause of the error, if possible.
+// An error value has a cause if it implements the following
+// interface:
+//
+//     type causer interface {
+//            Cause() error
+//     }
+//
+// If the error does not implement Cause, the original error will
+// be returned. If the error is nil, nil will be returned without further
+// investigation.
+func Cause(err error) error {
+	type causer interface {
+		Cause() error
+	}
+
+	for err != nil {
+		cause, ok := err.(causer)
+		if !ok {
+			break
+		}
+		err = cause.Cause()
+	}
+	return err
+}

cause_go113.go

@@ -0,0 +1,37 @@
+// +build go1.13
+
+package errors
+
+import "errors"
+
+// Cause returns the underlying cause of the error, if possible.
+// An error value has a cause if it implements the following
+// interface:
+//
+//     type causer interface {
+//            Cause() error
+//     }
+//
+// If the error does not implement the Cause interface, the Cause
+// function will fallback to the standard library's errors.Unwrap
+// that was added in Go 1.13. This makes Cause forwards-compatible
+// with Go 1.13 error chains.
+//
+// If the error is nil, nil will be returned without further
+// investigation.
+func Cause(err error) error {
+	type causer interface {
+		Cause() error
+	}
+
+	for err != nil {
+		if cause, ok := err.(causer); ok {
+			err = cause.Cause()
+		} else if unwrapped := errors.Unwrap(err); unwrapped != nil {
+			err = unwrapped
+		} else {
+			break
+		}
+	}
+	return err
+}

errors.go

@@ -260,29 +260,3 @@ func (w *withMessage) Format(s fmt.State, verb rune) {
 		io.WriteString(s, w.Error())
 	}
 }
-
-// Cause returns the underlying cause of the error, if possible.
-// An error value has a cause if it implements the following
-// interface:
-//
-//     type causer interface {
-//            Cause() error
-//     }
-//
-// If the error does not implement Cause, the original error will
-// be returned. If the error is nil, nil will be returned without further
-// investigation.
-func Cause(err error) error {
-	type causer interface {
-		Cause() error
-	}
-
-	for err != nil {
-		cause, ok := err.(causer)
-		if !ok {
-			break
-		}
-		err = cause.Cause()
-	}
-	return err
-}

go113_test.go

@@ -4,10 +4,20 @@ package errors
 
 import (
 	stdlib_errors "errors"
+	"fmt"
 	"testing"
 )
 
-func TestErrorChainCompat(t *testing.T) {
+func TestCauseErrorChainCompat(t *testing.T) {
+	err := stdlib_errors.New("leaf error")
+	wrapped := fmt.Errorf("wrapped error: %w", err)
+	wrapped = fmt.Errorf("wrapped again: %w", err)
+	if Cause(wrapped) != err {
+		t.Errorf("Cause does not support Go 1.13 error chains")
+	}
+}
+
+func TestWrapErrorChainCompat(t *testing.T) {
 	err := stdlib_errors.New("error that gets wrapped")
 	wrapped := Wrap(err, "wrapped up")
 	if !stdlib_errors.Is(wrapped, err) {