lint: fix all golangci-lint issues and test failures

Fix gofmt formatting, simplify code patterns flagged by
gocritic/staticcheck/revive, update test path expectations
to not assume GOPATH layout.

Signed-off-by: Tonis Tiigi <tonistiigi@gmail.com>

Author: tonistiigi

.golangci.yml

@@ -12,7 +12,6 @@ linters:
   default: standard
   enable:
     - bodyclose
-    - errname
     - forbidigo
     - gocritic
     - gosec
@@ -25,3 +24,14 @@ linters:
     - unconvert
     - unparam
     - whitespace
+  settings:
+    errcheck:
+      exclude-functions:
+        - io.WriteString
+  exclusions:
+    presets:
+      - std-error-handling
+    rules:
+      - linters:
+          - gosec
+        text: "G104"

bench_test.go

@@ -1,3 +1,4 @@
+//go:build go1.7
 // +build go1.7
 
 package errors
@@ -97,7 +98,7 @@ func BenchmarkStackFormatting(b *testing.B) {
 		name := fmt.Sprintf("%s-stacktrace-%d", r.format, r.stack)
 		b.Run(name, func(b *testing.B) {
 			err := yesErrors(0, r.stack)
-			st := err.(*fundamental).stack.StackTrace()
+			st := err.(*fundamental).StackTrace()
 			b.ReportAllocs()
 			b.ResetTimer()
 			for i := 0; i < b.N; i++ {

errors.go

@@ -2,89 +2,89 @@
 //
 // The traditional error handling idiom in Go is roughly akin to
 //
-//     if err != nil {
-//             return err
-//     }
+//	if err != nil {
+//	        return err
+//	}
 //
 // which when applied recursively up the call stack results in error reports
 // without context or debugging information. The errors package allows
 // programmers to add context to the failure path in their code in a way
 // that does not destroy the original value of the error.
 //
-// Adding context to an error
+// # Adding context to an error
 //
 // The errors.Wrap function returns a new error that adds context to the
 // original error by recording a stack trace at the point Wrap is called,
 // together with the supplied message. For example
 //
-//     _, err := ioutil.ReadAll(r)
-//     if err != nil {
-//             return errors.Wrap(err, "read failed")
-//     }
+//	_, err := io.ReadAll(r)
+//	if err != nil {
+//	        return errors.Wrap(err, "read failed")
+//	}
 //
 // If additional control is required, the errors.WithStack and
 // errors.WithMessage functions destructure errors.Wrap into its component
 // operations: annotating an error with a stack trace and with a message,
 // respectively.
 //
-// Retrieving the cause of an error
+// # Retrieving the cause of an error
 //
 // Using errors.Wrap constructs a stack of errors, adding context to the
 // preceding error. Depending on the nature of the error it may be necessary
 // to reverse the operation of errors.Wrap to retrieve the original error
 // for inspection. Any error value which implements this interface
 //
-//     type causer interface {
-//             Cause() error
-//     }
+//	type causer interface {
+//	        Cause() error
+//	}
 //
 // can be inspected by errors.Cause. errors.Cause will recursively retrieve
 // the topmost error that does not implement causer, which is assumed to be
 // the original cause. For example:
 //
-//     switch err := errors.Cause(err).(type) {
-//     case *MyError:
-//             // handle specifically
-//     default:
-//             // unknown error
-//     }
+//	switch err := errors.Cause(err).(type) {
+//	case *MyError:
+//	        // handle specifically
+//	default:
+//	        // unknown error
+//	}
 //
 // Although the causer interface is not exported by this package, it is
 // considered a part of its stable public interface.
 //
-// Formatted printing of errors
+// # Formatted printing of errors
 //
 // All error values returned from this package implement fmt.Formatter and can
 // be formatted by the fmt package. The following verbs are supported:
 //
-//     %s    print the error. If the error has a Cause it will be
-//           printed recursively.
-//     %v    see %s
-//     %+v   extended format. Each Frame of the error's StackTrace will
-//           be printed in detail.
+//	%s    print the error. If the error has a Cause it will be
+//	      printed recursively.
+//	%v    see %s
+//	%+v   extended format. Each Frame of the error's StackTrace will
+//	      be printed in detail.
 //
-// Retrieving the stack trace of an error or wrapper
+// # Retrieving the stack trace of an error or wrapper
 //
 // New, Errorf, Wrap, and Wrapf record a stack trace at the point they are
 // invoked. This information can be retrieved with the following interface:
 //
-//     type stackTracer interface {
-//             StackTrace() errors.StackTrace
-//     }
+//	type stackTracer interface {
+//	        StackTrace() errors.StackTrace
+//	}
 //
 // The returned errors.StackTrace type is defined as
 //
-//     type StackTrace []Frame
+//	type StackTrace []Frame
 //
 // The Frame type represents a call site in the stack trace. Frame supports
 // the fmt.Formatter interface that can be used for printing information about
 // the stack trace of this error. For example:
 //
-//     if err, ok := err.(stackTracer); ok {
-//             for _, f := range err.StackTrace() {
-//                     fmt.Printf("%+s:%d\n", f, f)
-//             }
-//     }
+//	if err, ok := err.(stackTracer); ok {
+//	        for _, f := range err.StackTrace() {
+//	                fmt.Printf("%+s:%d\n", f, f)
+//	        }
+//	}
 //
 // Although the stackTracer interface is not exported by this package, it is
 // considered a part of its stable public interface.
@@ -265,13 +265,18 @@ func (w *withMessage) Format(s fmt.State, verb rune) {
 // An error value has a cause if it implements the following
 // interface:
 //
-//     type causer interface {
-//            Cause() error
-//     }
+//	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.
+//
+// Note: Cause only traverses errors implementing the causer interface.
+// It does not traverse errors wrapped with fmt.Errorf("%w", err) or
+// other standard library mechanisms. Prefer errors.Is or errors.As
+// for matching errors across mixed wrapping styles.
 func Cause(err error) error {
 	type causer interface {
 		Cause() error

errors_test.go

@@ -228,7 +228,7 @@ func TestWithMessagef(t *testing.T) {
 // but the change in errors#27 made them incomparable. Assert that
 // various kinds of errors have a functional equality operator, even
 // if the result of that equality is always false.
-func TestErrorEquality(t *testing.T) {
+func TestErrorEquality(_ *testing.T) {
 	vals := []error{
 		nil,
 		io.EOF,