errors: Drop Cause in favor of Go 1.13 error handling

The only use cases in the code were in errors.IsFatal, backend/b2,
which needs a workaround, and backend.ParseLayout. The last of these
requires all backends to implement error unwrapping in IsNotExist.
All backends except gs already did that.

internal/errors/errors.go

@@ -1,9 +1,8 @@
 package errors
 
 import (
-	"net/url"
+	stderrors "errors"
 
-	"github.com/cenkalti/backoff/v4"
 	"github.com/pkg/errors"
 )
 
@@ -29,29 +28,10 @@ var WithMessage = errors.WithMessage
 
 var WithStack = errors.WithStack
 
-// Cause returns the cause of an error. It will also unwrap certain errors,
-// e.g. *url.Error returned by the net/http client.
-func Cause(err error) error {
-	type Causer interface {
-		Cause() error
-	}
-
-	for {
-		switch e := err.(type) {
-		case Causer: // github.com/pkg/errors
-			err = e.Cause()
-		case *backoff.PermanentError:
-			err = e.Err
-		case *url.Error:
-			err = e.Err
-		default:
-			return err
-		}
-	}
-}
-
 // Go 1.13-style error handling.
 
-func As(err error, tgt interface{}) bool { return errors.As(err, tgt) }
+func As(err error, tgt interface{}) bool { return stderrors.As(err, tgt) }
 
-func Is(x, y error) bool { return errors.Is(x, y) }
+func Is(x, y error) bool { return stderrors.Is(x, y) }
+
+func Unwrap(err error) error { return stderrors.Unwrap(err) }

internal/errors/fatal.go

@@ -1,6 +1,9 @@
 package errors
 
-import "fmt"
+import (
+	"errors"
+	"fmt"
+)
 
 // fatalError is an error that should be printed to the user, then the program
 // should exit with an error code.
@@ -10,31 +13,19 @@ func (e fatalError) Error() string {
 	return string(e)
 }
 
-func (e fatalError) Fatal() bool {
-	return true
-}
-
-// Fataler is an error which should be printed to the user directly.
-// Afterwards, the program should exit with an error.
-type Fataler interface {
-	Fatal() bool
-}
-
 // IsFatal returns true if err is a fatal message that should be printed to the
 // user. Then, the program should exit.
 func IsFatal(err error) bool {
-	// unwrap "Wrap" method
-	err = Cause(err)
-	e, ok := err.(Fataler)
-	return ok && e.Fatal()
+	var fatal fatalError
+	return errors.As(err, &fatal)
 }
 
-// Fatal returns a wrapped error which implements the Fataler interface.
+// Fatal returns an error that is marked fatal.
 func Fatal(s string) error {
 	return Wrap(fatalError(s), "Fatal")
 }
 
-// Fatalf returns an error which implements the Fataler interface.
+// Fatalf returns an error that is marked fatal.
 func Fatalf(s string, data ...interface{}) error {
 	return Wrap(fatalError(fmt.Sprintf(s, data...)), "Fatal")
 }