chore(lint): enable errorlint

.golangci.yaml

@@ -19,7 +19,6 @@ linters:
     - errcheck
     - errchkjson
     - errname
-    - errorlint
     - exhaustive
     - exhaustruct
     - fatcontext

buildcontext/excludes_test.go

@@ -5,6 +5,8 @@ import (
 	"path/filepath"
 	"reflect"
 	"testing"
+
+	"errors"
 )
 
 func Test_readExcludes(t *testing.T) {
@@ -122,7 +124,7 @@ func Test_readExcludes(t *testing.T) {
 			}
 
 			excludes, err := readExcludes(dir, testcase.noImplicitIgnore, testcase.useDockerIgnore)
-			if err != testcase.expectedErr {
+			if !errors.Is(err, testcase.expectedErr) {
 				t.Logf("actual err: %v", err)
 				t.Logf("expected err: %v", testcase.expectedErr)
 				t.Error("unexpected error getting excludes")

buildcontext/gitlookup.go

@@ -335,12 +335,11 @@ func (gl *GitLookup) getHostKeyAlgorithms(hostname string) ([]string, []string,
 	} {
 		for _, keyScan := range keyScans {
 			keyAlg, keyData, err := parseKeyScanIfHostMatches(keyScan, hostname)
-			switch err {
-			case nil:
-			case errKeyScanNoMatch:
+			switch {
+			case errors.Is(err, errKeyScanNoMatch):
 				gl.console.VerbosePrintf("ignoring key scan %q: due to host mismatch", keyScan)
 				continue
-			default:
+			case err != nil:
 				gl.console.Warnf("failed to parse key scan %q: %s", keyScan, err)
 				continue
 			}

builder/image_solver.go

@@ -143,12 +143,12 @@ func (s *tarImageSolver) SolveImage(
 		buf := make([]byte, 1024)
 		for {
 			n, err := pipeR.Read(buf)
-			if err != nil && err != io.EOF {
-				return errors.Wrap(err, "pipe read")
-			}
+			if err != nil {
+				if errors.Is(err, io.EOF) {
+					break
+				}
 
-			if err == io.EOF {
-				break
+				return errors.Wrap(err, "pipe read")
 			}
 
 			_, err = bufFile.Write(buf[:n])

cmd/debugger/main.go

@@ -147,7 +147,7 @@ func sendFile(ctx context.Context, sockAddr, src, dst string) error {
 	for {
 		n, err := r.Read(b[:cap(b)])
 		if err != nil {
-			if err == io.EOF {
+			if errors.Is(err, io.EOF) {
 				break
 			}
 
@@ -384,7 +384,9 @@ func main() {
 
 			exitCode = 127
 
-			if exitErr, ok := err.(*exec.ExitError); ok {
+			var exitErr *exec.ExitError
+
+			if errors.As(err, &exitErr) {
 				exitCode = exitErr.ExitCode()
 			}
 		}
@@ -416,7 +418,10 @@ func handleError(
 	quotedCmd := shellescape.QuoteCommand(args)
 
 	exitCode := 1
-	if exitErr, ok := err.(*exec.ExitError); ok {
+
+	var exitErr *exec.ExitError
+
+	if errors.As(err, &exitErr) {
 		exitCode = exitErr.ExitCode()
 		if debuggerSettings.Enabled {
 			conslogger.Warnf("Command %s failed with exit code %d\n", quotedCmd, exitCode)

cmd/earthly/subcmd/ls_cmds.go

@@ -98,12 +98,13 @@ func (a *List) action(cliCtx *cli.Context) error {
 
 	targets, err := earthfile2llb.GetTargets(cliCtx.Context, resolver, gwClient, target)
 	if err != nil {
-		switch err := errors.Cause(err).(type) {
-		case *buildcontext.ErrEarthfileNotExist:
+		var errEarthfileNotExist *buildcontext.ErrEarthfileNotExist
+
+		if errors.As(err, &errEarthfileNotExist) {
 			return errors.Errorf("unable to locate Earthfile under %s", targetToDisplay)
-		default:
-			return err
 		}
+
+		return err
 	}
 
 	targets = append(targets, ast.TargetBase)

debugger/terminal/terminal_other.go

@@ -58,7 +58,7 @@ func ConnectTerm(ctx context.Context, conn io.ReadWriteCloser, console consloggi
 		for {
 			connDataType, data, err := common.ReadDataPacket(conn)
 			if err != nil {
-				if err != io.EOF {
+				if !errors.Is(err, io.EOF) {
 					console.VerbosePrintf("ReadDataPacket failed: %s\n", err.Error())
 				}
 

earthfile2llb/converter.go

@@ -2661,12 +2661,13 @@ func (c *Converter) internalRun(ctx context.Context, opts ConvertRunOpts) (pllb.
 		// Debugger.
 		err = c.opt.LLBCaps.Supports(solverpb.CapExecMountSock)
 		if err != nil {
-			switch errors.Cause(err).(type) {
-			case *apicaps.CapError:
+			var capErr *apicaps.CapError
+
+			if errors.As(err, &capErr) {
 				if c.opt.InteractiveDebuggerEnabled || isInteractive {
 					return pllb.State{}, errors.Wrap(err, "interactive debugger requires a newer version of buildkit")
 				}
-			default:
+			} else {
 				c.opt.Console.Warnf("failed to check LLBCaps for CapExecMountSock: %v", err) // keep going
 			}
 		} else {

earthfile2llb/interpretererror.go

@@ -93,8 +93,8 @@ func GetInterpreterError(err error) (*InterpreterError, bool) {
 		return nil, false
 	}
 
-	ie, ok := err.(*InterpreterError)
-	if ok {
+	var ie *InterpreterError
+	if errors.As(err, &ie) {
 		return ie, true
 	}
 

logbus/solvermon/vertexmon.go

@@ -81,9 +81,11 @@ func determineFatalErrorType(errString string, exitCode int, exitParseErr error)
 		return logstream.FailureType_FAILURE_TYPE_UNKNOWN, false
 	}
 
-	if exitParseErr == errNoExitCodeOMM {
+	if errors.Is(exitParseErr, errNoExitCodeOMM) {
 		return logstream.FailureType_FAILURE_TYPE_OOM_KILLED, true
-	} else if exitParseErr != nil && exitParseErr != errNoExitCode {
+	}
+
+	if exitParseErr != nil && !errors.Is(exitParseErr, errNoExitCode) {
 		// We have an exit code, and can't parse it
 		return logstream.FailureType_FAILURE_TYPE_UNKNOWN, true
 	}

logbus/solvermon/vertexmon_test.go

@@ -52,7 +52,7 @@ func TestGetExitCode(t *testing.T) {
 				t.Errorf("getExitCode(%q) = %d, want %d", tt.errString, code, tt.expectedCode)
 			}
 
-			if err != tt.expectedError {
+			if !errors.Is(err, tt.expectedError) {
 				t.Errorf("getExitCode(%q) = %d, want %d", tt.errString, err, tt.expectedError)
 			}
 		})

util/buildkitskipper/hasher/hasher.go

@@ -5,6 +5,7 @@ import (
 	"context"
 	"crypto/sha1" // #nosec G505
 	"encoding/json"
+	"errors"
 	"fmt"
 	"hash"
 	"io"
@@ -87,13 +88,14 @@ func (h *Hasher) HashFile(ctx context.Context, src string) error {
 
 		select {
 		case err := <-readCh:
-			if err == io.EOF {
+			switch {
+			case errors.Is(err, io.EOF):
 				return nil
-			} else if err != nil {
+			case err != nil:
 				return err
+			default:
+				h.h.Write(buf[:n])
 			}
-
-			h.h.Write(buf[:n])
 		case <-ctx.Done():
 			return ctx.Err()
 		}

util/gitutil/detectgit.go

@@ -387,8 +387,8 @@ func detectGitTimestamp(ctx context.Context, dir string, tsType gitTimestampType
 
 	out, err := cmd.Output()
 	if err != nil {
-		exitError, ok := err.(*exec.ExitError)
-		if ok && strings.Contains(string(exitError.Stderr), "does not have any commits yet") {
+		var exitError *exec.ExitError
+		if errors.As(err, &exitError) && strings.Contains(string(exitError.Stderr), "does not have any commits yet") {
 			return "", nil
 		}
 
@@ -410,8 +410,8 @@ func detectGitAuthor(ctx context.Context, dir string, format string) (string, er
 
 	out, err := cmd.Output()
 	if err != nil {
-		exitError, ok := err.(*exec.ExitError)
-		if ok && strings.Contains(string(exitError.Stderr), "does not have any commits yet") {
+		var exitError *exec.ExitError
+		if errors.As(err, &exitError) && strings.Contains(string(exitError.Stderr), "does not have any commits yet") {
 			return "", nil
 		}
 
@@ -446,8 +446,8 @@ func detectGitCoAuthors(ctx context.Context, dir string) ([]string, error) {
 
 	out, err := cmd.Output()
 	if err != nil {
-		exitError, ok := err.(*exec.ExitError)
-		if ok && strings.Contains(string(exitError.Stderr), "does not have any commits yet") {
+		var exitError *exec.ExitError
+		if errors.As(err, &exitError) && strings.Contains(string(exitError.Stderr), "does not have any commits yet") {
 			return nil, nil
 		}
 

util/gitutil/detectgitbinary_others.go

@@ -4,21 +4,19 @@ package gitutil
 
 import (
 	"context"
+	"errors"
 	"os/exec"
 )
 
 func detectGitBinary(ctx context.Context) error {
 	cmd := exec.CommandContext(ctx, "/bin/sh", "-c", "which git")
 
 	_, err := cmd.Output()
-	if err != nil {
-		_, isExitError := err.(*exec.ExitError)
-		if isExitError {
-			return ErrNoGitBinary
-		}
 
-		return err
+	var exitErr *exec.ExitError
+	if errors.As(err, &exitErr) {
+		return ErrNoGitBinary
 	}
 
-	return nil
+	return err
 }

util/gitutil/detectgitbinary_windows.go

@@ -4,15 +4,16 @@ package gitutil
 
 import (
 	"context"
+	"errors"
 	"os/exec"
 )
 
 func detectGitBinary(ctx context.Context) error {
 	cmd := exec.CommandContext(ctx, "cmd", "/C", "where git")
 	_, err := cmd.Output()
 	if err != nil {
-		_, isExitError := err.(*exec.ExitError)
-		if isExitError {
+		var exitErr *exec.ExitError
+		if errors.As(err, &exitErr) {
 			return ErrNoGitBinary
 		}
 		return err

util/llbutil/secretprovider/cmd.go

@@ -62,12 +62,12 @@ func (c *cmdStore) GetSecret(ctx context.Context, id string) ([]byte, error) {
 }
 
 func (c *cmdStore) secretNotFound(err error) error {
-	exiterr, ok := err.(*exec.ExitError)
-	if !ok {
+	var exitErr *exec.ExitError
+	if !errors.As(err, &exitErr) {
 		return err
 	}
 
-	status, ok := exiterr.Sys().(syscall.WaitStatus)
+	status, ok := exitErr.Sys().(syscall.WaitStatus)
 	if !ok {
 		return err
 	}

util/params/paramerror_test.go

@@ -73,8 +73,10 @@ func TestError(t *testing.T) {
 func TestCause(t *testing.T) {
 	t.Parallel()
 
-	pe, _ := Wrapf(internal, "some error").(*Error)
-	res := pe.Cause()
+	var err *Error
+
+	assert.True(t, errors.As(Wrapf(internal, "some error"), &err))
+	res := err.Cause()
 	assert.Equal(t, errors.Cause(internal), res)
 }
 
@@ -84,23 +86,29 @@ func TestIs(t *testing.T) {
 	t.Run("non param error", func(t *testing.T) {
 		t.Parallel()
 
-		pe, _ := Errorf("some error").(*Error)
-		res := pe.Is(internal)
+		var err *Error
+
+assert.True(t, errors.As(Errorf("some error"), &err))
+		res := err.Is(internal)
 		assert.False(t, res)
 	})
 	t.Run("param error", func(t *testing.T) {
 		t.Parallel()
 
-		pe, _ := Errorf("some error").(*Error)
-		res := pe.Is(pe)
+		var err *Error
+
+assert.True(t, errors.As(Errorf("some error"), &err))
+		res := err.Is(err)
 		assert.True(t, res)
 	})
 }
 
 func TestParentError(t *testing.T) {
 	t.Parallel()
 
-	pe, _ := Wrapf(internal, "some error").(*Error)
-	res := pe.ParentError()
+	var err *Error
+
+	assert.True(t, errors.As(Wrapf(internal, "some error"), &err))
+	res := err.ParentError()
 	assert.Equal(t, "some error", res)
 }

util/semverutil/semverutil.go

@@ -23,7 +23,7 @@ func Parse(s string) (Version, error) {
 	var v Version
 
 	n, err := fmt.Sscanf(s, "%d.%d.%d%s", &v.Major, &v.Minor, &v.Patch, &v.Tail)
-	if err == io.EOF && n == 3 { // no tail case
+	if errors.Is(err, io.EOF) && n == 3 { // no tail case
 		return v, nil
 	}