Remove github.com/pkg/errors and replace with std library version

This is possible now that we no longer support go1.12 and brings
rclone into line with standard practices in the Go world.

This also removes errors.New and errors.Errorf from lib/errors and
prefers the stdlib errors package over lib/errors.

fs/fserrors/error.go

@@ -3,15 +3,21 @@ package fserrors
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"io"
 	"net/http"
 	"strings"
 	"time"
 
-	"github.com/rclone/rclone/lib/errors"
+	liberrors "github.com/rclone/rclone/lib/errors"
 )
 
+// Must be satisfied for errors.Is/errors.As/Errors.Unwrap
+type unwrapper interface {
+	Unwrap() error
+}
+
 // Retrier is an optional interface for error as to whether the
 // operation should be retried at a high level.
 //
@@ -34,7 +40,7 @@ func (r retryError) Retry() bool {
 	return true
 }
 
-// Check interface
+// Check interfaces
 var _ Retrier = retryError("")
 
 // RetryErrorf makes an error which indicates it would like to be retried
@@ -53,8 +59,9 @@ func (err wrappedRetryError) Retry() bool {
 	return true
 }
 
-// Check interface
+// Check interfaces
 var _ Retrier = wrappedRetryError{error(nil)}
+var _ unwrapper = wrappedRetryError{}
 
 // RetryError makes an error which indicates it would like to be retried
 func RetryError(err error) error {
@@ -64,14 +71,14 @@ func RetryError(err error) error {
 	return wrappedRetryError{err}
 }
 
-func (err wrappedRetryError) Cause() error {
+func (err wrappedRetryError) Unwrap() error {
 	return err.error
 }
 
 // IsRetryError returns true if err conforms to the Retry interface
 // and calling the Retry method returns true.
 func IsRetryError(err error) (isRetry bool) {
-	errors.Walk(err, func(err error) bool {
+	liberrors.Walk(err, func(err error) bool {
 		if r, ok := err.(Retrier); ok {
 			isRetry = r.Retry()
 			return true
@@ -101,8 +108,9 @@ func (err wrappedFatalError) Fatal() bool {
 	return true
 }
 
-// Check interface
+// Check interfaces
 var _ Fataler = wrappedFatalError{error(nil)}
+var _ unwrapper = wrappedFatalError{}
 
 // FatalError makes an error which indicates it is a fatal error and
 // the sync should stop.
@@ -113,14 +121,14 @@ func FatalError(err error) error {
 	return wrappedFatalError{err}
 }
 
-func (err wrappedFatalError) Cause() error {
+func (err wrappedFatalError) Unwrap() error {
 	return err.error
 }
 
 // IsFatalError returns true if err conforms to the Fatal interface
 // and calling the Fatal method returns true.
 func IsFatalError(err error) (isFatal bool) {
-	errors.Walk(err, func(err error) bool {
+	liberrors.Walk(err, func(err error) bool {
 		if r, ok := err.(Fataler); ok {
 			isFatal = r.Fatal()
 			return true
@@ -153,8 +161,9 @@ func (err wrappedNoRetryError) NoRetry() bool {
 	return true
 }
 
-// Check interface
+// Check interfaces
 var _ NoRetrier = wrappedNoRetryError{error(nil)}
+var _ unwrapper = wrappedNoRetryError{}
 
 // NoRetryError makes an error which indicates the sync shouldn't be
 // retried.
@@ -162,14 +171,14 @@ func NoRetryError(err error) error {
 	return wrappedNoRetryError{err}
 }
 
-func (err wrappedNoRetryError) Cause() error {
+func (err wrappedNoRetryError) Unwrap() error {
 	return err.error
 }
 
 // IsNoRetryError returns true if err conforms to the NoRetry
 // interface and calling the NoRetry method returns true.
 func IsNoRetryError(err error) (isNoRetry bool) {
-	errors.Walk(err, func(err error) bool {
+	liberrors.Walk(err, func(err error) bool {
 		if r, ok := err.(NoRetrier); ok {
 			isNoRetry = r.NoRetry()
 			return true
@@ -199,8 +208,9 @@ func (err wrappedNoLowLevelRetryError) NoLowLevelRetry() bool {
 	return true
 }
 
-// Check interface
+// Check interfaces
 var _ NoLowLevelRetrier = wrappedNoLowLevelRetryError{error(nil)}
+var _ unwrapper = wrappedNoLowLevelRetryError{}
 
 // NoLowLevelRetryError makes an error which indicates the sync
 // shouldn't be low level retried.
@@ -208,15 +218,15 @@ func NoLowLevelRetryError(err error) error {
 	return wrappedNoLowLevelRetryError{err}
 }
 
-// Cause returns the underlying error
-func (err wrappedNoLowLevelRetryError) Cause() error {
+// Unwrap returns the underlying error
+func (err wrappedNoLowLevelRetryError) Unwrap() error {
 	return err.error
 }
 
 // IsNoLowLevelRetryError returns true if err conforms to the NoLowLevelRetry
 // interface and calling the NoLowLevelRetry method returns true.
 func IsNoLowLevelRetryError(err error) (isNoLowLevelRetry bool) {
-	errors.Walk(err, func(err error) bool {
+	liberrors.Walk(err, func(err error) bool {
 		if r, ok := err.(NoLowLevelRetrier); ok {
 			isNoLowLevelRetry = r.NoLowLevelRetry()
 			return true
@@ -257,13 +267,13 @@ func (e ErrorRetryAfter) RetryAfter() time.Time {
 	return time.Time(e)
 }
 
-// Check interface
+// Check interfaces
 var _ RetryAfter = ErrorRetryAfter{}
 
 // RetryAfterErrorTime returns the time that the RetryAfter error
 // indicates or a Zero time.Time
 func RetryAfterErrorTime(err error) (retryAfter time.Time) {
-	errors.Walk(err, func(err error) bool {
+	liberrors.Walk(err, func(err error) bool {
 		if r, ok := err.(RetryAfter); ok {
 			retryAfter = r.RetryAfter()
 			return true
@@ -303,7 +313,7 @@ func (err *wrappedCountableError) IsCounted() bool {
 	return err.isCounted
 }
 
-func (err *wrappedCountableError) Cause() error {
+func (err wrappedCountableError) Unwrap() error {
 	return err.error
 }
 
@@ -326,6 +336,7 @@ func Count(err error) {
 
 // Check interface
 var _ CountableError = &wrappedCountableError{error: error(nil)}
+var _ unwrapper = wrappedCountableError{}
 
 // FsError makes an error which can keep a record that it is already counted
 // or not
@@ -340,7 +351,7 @@ func FsError(err error) error {
 // library errors too.  It returns true if any of the intermediate
 // errors had a Timeout() or Temporary() method which returned true.
 func Cause(cause error) (retriable bool, err error) {
-	errors.Walk(cause, func(c error) bool {
+	liberrors.Walk(cause, func(c error) bool {
 		// Check for net error Timeout()
 		if x, ok := c.(interface {
 			Timeout() bool
@@ -453,13 +464,3 @@ func ContextError(ctx context.Context, perr *error) bool {
 	}
 	return false
 }
-
-type causer interface {
-	Cause() error
-}
-
-var (
-	_ causer = wrappedRetryError{}
-	_ causer = wrappedFatalError{}
-	_ causer = wrappedNoRetryError{}
-)