Hygiene: enable errorlint.

There are no expected functional changes in this PR.

Made non-functional code changes to adhere to Golang error standards.

Context: #5899

See related style docs:
- https://pkg.go.dev/errors
- https://go.dev/blog/errors-are-values

/kind cleanup

- [N/A] Has [Docs](https://github.com/tektoncd/community/blob/main/standards.md#docs) included if any changes are user facing
- [N/A] Has [Tests](https://github.com/tektoncd/community/blob/main/standards.md#tests) included if any functionality added or changed
- [x] Follows the [commit message standard](https://github.com/tektoncd/community/blob/main/standards.md#commits)
- [x] Meets the [Tekton contributor standards](https://github.com/tektoncd/community/blob/main/standards.md) (including functionality, content, code)
- [x] Has a kind label. You can add one by adding a comment on this PR that contains `/kind <type>`. Valid types are bug, cleanup, design, documentation, feature, flake, misc, question, tep
- [N/A] Release notes block below has been updated with any user facing changes (API changes, bug fixes, changes requiring upgrade notices or deprecation warnings)
- [N/A] Release notes contains the string "action required" if the change requires additional action from users switching to the new release

```release-note
NONE
```

.golangci.yml

@@ -27,7 +27,7 @@ linters:
   - errcheck
   - errchkjson
   - errname
-  # errorlint TODO: cleanup the issues this linter uncovers https://github.com/tektoncd/pipeline/issues/5899
+  - errorlint
   - goconst
   - gocritic
   - gofmt

cmd/entrypoint/main.go

@@ -18,6 +18,7 @@ package main
 
 import (
 	"encoding/json"
+	"errors"
 	"flag"
 	"fmt"
 	"log"
@@ -97,12 +98,11 @@ func main() {
 	}
 	if err := subcommands.Process(flag.CommandLine.Args()); err != nil {
 		log.Println(err.Error())
-		switch err.(type) {
-		case subcommands.OK:
+		var ok *subcommands.OK
+		if errors.As(err, &ok) {
 			return
-		default:
-			os.Exit(1)
 		}
+		os.Exit(1)
 	}
 
 	// Copy credentials we're expecting from the legacy credentials helper (creds-init)
@@ -174,7 +174,7 @@ func main() {
 
 	if err := e.Go(); err != nil {
 		breakpointExitPostFile := e.PostFile + breakpointExitSuffix
-		switch t := err.(type) {
+		switch t := err.(type) { // nolint -- checking for multiple types with errors.As is ugly.
 		case skipError:
 			log.Print("Skipping step because a previous step failed")
 			os.Exit(1)

cmd/entrypoint/runner.go

@@ -20,6 +20,7 @@ package main
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"io"
 	"log"
@@ -118,7 +119,7 @@ func (rr *realRunner) Run(ctx context.Context, args ...string) error {
 
 	// Start defined command
 	if err := cmd.Start(); err != nil {
-		if ctx.Err() == context.DeadlineExceeded {
+		if errors.Is(ctx.Err(), context.DeadlineExceeded) {
 			return context.DeadlineExceeded
 		}
 		return err
@@ -152,7 +153,7 @@ func (rr *realRunner) Run(ctx context.Context, args ...string) error {
 
 	// Wait for command to exit
 	if err := cmd.Wait(); err != nil {
-		if ctx.Err() == context.DeadlineExceeded {
+		if errors.Is(ctx.Err(), context.DeadlineExceeded) {
 			return context.DeadlineExceeded
 		}
 		return err

cmd/entrypoint/runner_test.go

@@ -126,7 +126,7 @@ func TestRealRunnerTimeout(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), timeout)
 	defer cancel()
 	if err := rr.Run(ctx, "sleep", "0.01"); err != nil {
-		if err != context.DeadlineExceeded {
+		if errors.Is(err, context.DeadlineExceeded) {
 			t.Fatalf("unexpected error received: %v", err)
 		}
 	} else {

cmd/entrypoint/subcommands/subcommands_test.go

@@ -1,6 +1,7 @@
 package subcommands
 
 import (
+	"errors"
 	"os"
 	"path/filepath"
 	"testing"
@@ -24,6 +25,8 @@ func TestProcessSuccessfulSubcommands(t *testing.T) {
 		t.Fatalf("error writing source file: %v", err)
 	}
 
+	var ok OK
+
 	for _, tc := range []struct {
 		command string
 		args    []string
@@ -39,7 +42,7 @@ func TestProcessSuccessfulSubcommands(t *testing.T) {
 	} {
 		t.Run(tc.command, func(t *testing.T) {
 			returnValue := Process(append([]string{tc.command}, tc.args...))
-			if _, ok := returnValue.(OK); !ok {
+			if !errors.As(returnValue, &ok) {
 				t.Errorf("unexpected return value from command: %v", returnValue)
 			}
 		})
@@ -49,12 +52,12 @@ func TestProcessSuccessfulSubcommands(t *testing.T) {
 		tektonRoot = tmp
 
 		returnValue := Process([]string{StepInitCommand})
-		if _, ok := returnValue.(OK); !ok {
+		if !errors.As(returnValue, &ok) {
 			t.Errorf("unexpected return value from step-init command: %v", returnValue)
 		}
 
 		returnValue = Process([]string{StepInitCommand, "foo", "bar"})
-		if _, ok := returnValue.(OK); !ok {
+		if !errors.As(returnValue, &ok) {
 			t.Errorf("unexpected return value from step-init command w/ params: %v", returnValue)
 		}
 	})

cmd/entrypoint/waiter_test.go

@@ -17,6 +17,7 @@ limitations under the License.
 package main
 
 import (
+	"errors"
 	"os"
 	"strings"
 	"testing"
@@ -149,11 +150,11 @@ func TestRealWaiterWaitWithErrorWaitfile(t *testing.T) {
 		if err == nil {
 			t.Errorf("expected skipError upon encounter error waitfile")
 		}
-		switch typ := err.(type) {
-		case skipError:
+		var skipErr skipError
+		if errors.As(err, &skipErr) {
 			close(doneCh)
-		default:
-			t.Errorf("unexpected error type %T", typ)
+		} else {
+			t.Errorf("unexpected error type %T", err)
 		}
 	}()
 	delay := time.NewTimer(2 * testWaitPollingInterval)

internal/sidecarlogresults/sidecarlogresults_test.go

@@ -4,6 +4,7 @@ import (
 	"bytes"
 	"context"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"os"
 	"path/filepath"
@@ -181,7 +182,7 @@ func TestExtractResultsFromLogs_Failure(t *testing.T) {
 	logs := strings.NewReader(podLogs)
 
 	_, err := extractResultsFromLogs(logs, []v1beta1.PipelineResourceResult{}, 4096)
-	if err != ErrSizeExceeded {
+	if !errors.Is(err, ErrSizeExceeded) {
 		t.Fatalf("Expected error %v but got %v", ErrSizeExceeded, err)
 	}
 }

pkg/apis/config/feature_flags.go

@@ -151,7 +151,7 @@ func NewFeatureFlagsFromMap(cfgMap map[string]string) (*FeatureFlags, error) {
 		if cfg, ok := cfgMap[key]; ok {
 			value, err := strconv.ParseBool(cfg)
 			if err != nil {
-				return fmt.Errorf("failed parsing feature flags config %q: %v", cfg, err)
+				return fmt.Errorf("failed parsing feature flags config %q: %w", cfg, err)
 			}
 			*feature = value
 			return nil

pkg/apis/config/resolver/feature_flags.go

@@ -68,7 +68,7 @@ func NewFeatureFlagsFromMap(cfgMap map[string]string) (*FeatureFlags, error) {
 		if cfg, ok := cfgMap[key]; ok {
 			value, err := strconv.ParseBool(cfg)
 			if err != nil {
-				return fmt.Errorf("failed parsing feature flags config %q: %v", cfg, err)
+				return fmt.Errorf("failed parsing feature flags config %q: %w", cfg, err)
 			}
 			*feature = value
 			return nil

pkg/apis/pipeline/v1beta1/resource_types.go

@@ -63,7 +63,7 @@ func (r *ResultType) UnmarshalJSON(data []byte) error {
 	var asString string
 
 	if err := json.Unmarshal(data, &asString); err != nil {
-		return fmt.Errorf("unsupported value type, neither int nor string: %v", multierror.Append(intErr, err).ErrorOrNil())
+		return fmt.Errorf("unsupported value type, neither int nor string: %w", multierror.Append(intErr, err).ErrorOrNil())
 	}
 
 	switch asString {

pkg/apis/version/conversion.go

@@ -28,7 +28,7 @@ import (
 func SerializeToMetadata(meta *metav1.ObjectMeta, field interface{}, key string) error {
 	bytes, err := json.Marshal(field)
 	if err != nil {
-		return fmt.Errorf("error serializing field: %s", err)
+		return fmt.Errorf("error serializing field: %w", err)
 	}
 	if meta.Annotations == nil {
 		meta.Annotations = make(map[string]string)
@@ -46,7 +46,7 @@ func DeserializeFromMetadata(meta *metav1.ObjectMeta, to interface{}, key string
 	}
 	if str, ok := meta.Annotations[key]; ok {
 		if err := json.Unmarshal([]byte(str), to); err != nil {
-			return fmt.Errorf("error deserializing key %s from metadata: %s", key, err)
+			return fmt.Errorf("error deserializing key %s from metadata: %w", key, err)
 		}
 		delete(meta.Annotations, key)
 		if len(meta.Annotations) == 0 {

pkg/entrypoint/entrypointer.go

@@ -157,7 +157,7 @@ func (e Entrypointer) Go() error {
 			defer cancel()
 		}
 		err = e.Runner.Run(ctx, e.Command...)
-		if err == context.DeadlineExceeded {
+		if errors.Is(err, context.DeadlineExceeded) {
 			output = append(output, v1beta1.PipelineResourceResult{
 				Key:        "Reason",
 				Value:      "TimeoutExceeded",

pkg/git/git.go

@@ -154,7 +154,7 @@ func Fetch(logger *zap.SugaredLogger, spec FetchSpec) error {
 	fetchArgs = append(fetchArgs, "origin", "--update-head-ok", "--force")
 	fetchArgs = append(fetchArgs, fetchParam...)
 	if _, err := run(logger, spec.Path, fetchArgs...); err != nil {
-		return fmt.Errorf("failed to fetch %v: %v", fetchParam, err)
+		return fmt.Errorf("failed to fetch %v: %w", fetchParam, err)
 	}
 	// After performing a fetch, verify that the item to checkout is actually valid
 	if _, err := ShowCommit(logger, checkoutParam, spec.Path); err != nil {

pkg/pipelinerunmetrics/metrics.go

@@ -268,7 +268,7 @@ func (r *Recorder) RunningPipelineRuns(lister listers.PipelineRunLister) error {
 
 	prs, err := lister.List(labels.Everything())
 	if err != nil {
-		return fmt.Errorf("failed to list pipelineruns while generating metrics : %v", err)
+		return fmt.Errorf("failed to list pipelineruns while generating metrics : %w", err)
 	}
 
 	var runningPRs int

pkg/pod/entrypoint_lookup_impl.go

@@ -76,7 +76,7 @@ func (e *entrypointCache) get(ctx context.Context, ref name.Reference, namespace
 		ImagePullSecrets:   pullSecretsNames,
 	})
 	if err != nil {
-		return nil, fmt.Errorf("error creating k8schain: %v", err)
+		return nil, fmt.Errorf("error creating k8schain: %w", err)
 	}
 
 	desc, err := remote.Get(ref, remote.WithAuthFromKeychain(kc))

pkg/reconciler/events/k8sevent/events.go

@@ -30,7 +30,7 @@ func CheckEventsOrdered(t *testing.T, eventChan chan string, testName string, wa
 	t.Helper()
 	err := eventsFromChannel(eventChan, wantEvents)
 	if err != nil {
-		return fmt.Errorf("error in test %s: %v", testName, err)
+		return fmt.Errorf("error in test %s: %w", testName, err)
 	}
 	return nil
 }
@@ -60,7 +60,7 @@ func eventsFromChannel(c chan string, wantEvents []string) error {
 					return fmt.Errorf("expected event \"%s\" but got \"%s\" instead", wantEvent, event)
 				}
 			} else {
-				return fmt.Errorf("something went wrong matching the event: %s", err)
+				return fmt.Errorf("something went wrong matching the event: %w", err)
 			}
 		case <-timer:
 			return fmt.Errorf("received %d events but %d expected. Found events: %#v", len(foundEvents), len(wantEvents), foundEvents)

pkg/reconciler/pipelinerun/affinity_assistant.go

@@ -63,13 +63,13 @@ func (c *Reconciler) createAffinityAssistants(ctx context.Context, wb []v1beta1.
 				affinityAssistantStatefulSet := affinityAssistantStatefulSet(affinityAssistantName, pr, claimName, c.Images.NopImage, cfg.Defaults.DefaultAAPodTemplate)
 				_, err := c.KubeClientSet.AppsV1().StatefulSets(namespace).Create(ctx, affinityAssistantStatefulSet, metav1.CreateOptions{})
 				if err != nil {
-					errs = append(errs, fmt.Errorf("failed to create StatefulSet %s: %s", affinityAssistantName, err))
+					errs = append(errs, fmt.Errorf("failed to create StatefulSet %s: %w", affinityAssistantName, err))
 				}
 				if err == nil {
 					logger.Infof("Created StatefulSet %s in namespace %s", affinityAssistantName, namespace)
 				}
 			case err != nil:
-				errs = append(errs, fmt.Errorf("failed to retrieve StatefulSet %s: %s", affinityAssistantName, err))
+				errs = append(errs, fmt.Errorf("failed to retrieve StatefulSet %s: %w", affinityAssistantName, err))
 			}
 		}
 	}
@@ -97,7 +97,7 @@ func (c *Reconciler) cleanupAffinityAssistants(ctx context.Context, pr *v1beta1.
 		if w.PersistentVolumeClaim != nil || w.VolumeClaimTemplate != nil {
 			affinityAssistantStsName := getAffinityAssistantName(w.Name, pr.Name)
 			if err := c.KubeClientSet.AppsV1().StatefulSets(pr.Namespace).Delete(ctx, affinityAssistantStsName, metav1.DeleteOptions{}); err != nil && !apierrors.IsNotFound(err) {
-				errs = append(errs, fmt.Errorf("failed to delete StatefulSet %s: %s", affinityAssistantStsName, err))
+				errs = append(errs, fmt.Errorf("failed to delete StatefulSet %s: %w", affinityAssistantStsName, err))
 			}
 		}
 	}

pkg/reconciler/pipelinerun/cancel.go

@@ -163,7 +163,7 @@ func cancelPipelineTaskRunsForTaskNames(ctx context.Context, logger *zap.Sugared
 		logger.Infof("cancelling TaskRun %s", taskRunName)
 
 		if err := cancelTaskRun(ctx, taskRunName, pr.Namespace, clientSet); err != nil {
-			errs = append(errs, fmt.Errorf("Failed to patch TaskRun `%s` with cancellation: %s", taskRunName, err).Error())
+			errs = append(errs, fmt.Errorf("Failed to patch TaskRun `%s` with cancellation: %w", taskRunName, err).Error())
 			continue
 		}
 	}
@@ -172,7 +172,7 @@ func cancelPipelineTaskRunsForTaskNames(ctx context.Context, logger *zap.Sugared
 		logger.Infof("cancelling CustomRun %s", runName)
 
 		if err := cancelCustomRun(ctx, runName, pr.Namespace, clientSet); err != nil {
-			errs = append(errs, fmt.Errorf("Failed to patch CustomRun `%s` with cancellation: %s", runName, err).Error())
+			errs = append(errs, fmt.Errorf("Failed to patch CustomRun `%s` with cancellation: %w", runName, err).Error())
 			continue
 		}
 	}
@@ -181,7 +181,7 @@ func cancelPipelineTaskRunsForTaskNames(ctx context.Context, logger *zap.Sugared
 		logger.Infof("cancelling Run %s", runName)
 
 		if err := cancelRun(ctx, runName, pr.Namespace, clientSet); err != nil {
-			errs = append(errs, fmt.Errorf("Failed to patch Run `%s` with cancellation: %s", runName, err).Error())
+			errs = append(errs, fmt.Errorf("Failed to patch Run `%s` with cancellation: %w", runName, err).Error())
 			continue
 		}
 	}

pkg/reconciler/pipelinerun/pipelinerun.go

@@ -201,7 +201,7 @@ func (c *Reconciler) ReconcileKind(ctx context.Context, pr *v1beta1.PipelineRun)
 
 	vp, err := getVerificationPolicies(ctx, c.verificationPolicyLister, pr.Namespace)
 	if err != nil {
-		return fmt.Errorf("failed to list VerificationPolicies from namespace %s with error %v", pr.Namespace, err)
+		return fmt.Errorf("failed to list VerificationPolicies from namespace %s with error %w", pr.Namespace, err)
 	}
 	getPipelineFunc := resources.GetVerifiedPipelineFunc(ctx, c.KubeClientSet, c.PipelineClientSet, c.resolutionRequester, pr, vp)
 
@@ -311,7 +311,7 @@ func (c *Reconciler) resolvePipelineState(
 
 		vp, err := getVerificationPolicies(ctx, c.verificationPolicyLister, pr.Namespace)
 		if err != nil {
-			return nil, fmt.Errorf("failed to list VerificationPolicies from namespace %s with error %v", pr.Namespace, err)
+			return nil, fmt.Errorf("failed to list VerificationPolicies from namespace %s with error %w", pr.Namespace, err)
 		}
 
 		fn := tresources.GetVerifiedTaskFunc(ctx, c.KubeClientSet, c.PipelineClientSet, c.resolutionRequester, pr, task.TaskRef, trName, pr.Namespace, pr.Spec.ServiceAccountName, vp)
@@ -365,12 +365,12 @@ func (c *Reconciler) resolvePipelineState(
 				pr.Status.MarkFailed(ReasonResourceVerificationFailed, message)
 				return nil, controller.NewPermanentError(err)
 			}
-			switch err := err.(type) {
-			case *resources.TaskNotFoundError:
+			var nfErr *resources.TaskNotFoundError
+			if errors.As(err, &nfErr) {
 				pr.Status.MarkFailed(ReasonCouldntGetTask,
 					"Pipeline %s/%s can't be Run; it contains Tasks that don't exist: %s",
-					pipelineMeta.Namespace, pipelineMeta.Name, err)
-			default:
+					pipelineMeta.Namespace, pipelineMeta.Name, nfErr)
+			} else {
 				pr.Status.MarkFailed(ReasonFailedValidation,
 					"PipelineRun %s/%s can't be Run; couldn't resolve all references: %s",
 					pipelineMeta.Namespace, pr.Name, err)

pkg/reconciler/pipelinerun/resources/pipelineref_test.go

@@ -744,7 +744,7 @@ func TestGetVerifiedPipelineFunc_GetFuncError(t *testing.T) {
 			requester:                requesterUnsigned,
 			resourceVerificationMode: config.EnforceResourceVerificationMode,
 			pipelinerun:              *prResolutionError,
-			expectedErr:              fmt.Errorf("failed to get pipeline: error accessing data from remote resource: %v", resolvedUnsigned.DataErr),
+			expectedErr:              fmt.Errorf("failed to get pipeline: error accessing data from remote resource: %w", resolvedUnsigned.DataErr),
 		},
 	}
 	for _, tc := range testcases {

pkg/reconciler/pipelinerun/resources/pipelinerunresolution_test.go

@@ -1934,13 +1934,14 @@ func TestResolvePipelineRun_TaskDoesntExist(t *testing.T) {
 	}
 	for _, pt := range pts {
 		_, err := ResolvePipelineTask(context.Background(), pr, getTask, getTaskRun, nopGetRun, pt)
-		switch err := err.(type) {
-		case nil:
-			t.Fatalf("Expected error getting non-existent Tasks for Pipeline %s but got none", p.Name)
-		case *TaskNotFoundError:
+		var tnf *TaskNotFoundError
+		switch {
+		case err == nil:
+			t.Fatalf("Pipeline %s: want error, got nil", p.Name)
+		case errors.As(err, &tnf):
 			// expected error
 		default:
-			t.Fatalf("Expected specific error type returned by func for non-existent Task for Pipeline %s but got %s", p.Name, err)
+			t.Fatalf("Pipeline %s: Want %T, got %s of type %T", p.Name, tnf, err, err)
 		}
 	}
 }
@@ -1976,7 +1977,7 @@ func TestResolvePipelineRun_VerificationFailed(t *testing.T) {
 		if err == nil {
 			t.Errorf("expected to get err but got nil")
 		}
-		if err != trustedresources.ErrResourceVerificationFailed {
+		if !errors.Is(err, trustedresources.ErrResourceVerificationFailed) {
 			t.Errorf("expected to get %v but got %v", trustedresources.ErrResourceVerificationFailed, err)
 		}
 	}