all: use errors.As instead of .(type)

8 files changed, 66 insertions, 43 deletions

diff --git a/pkg/asset/storage.go b/pkg/asset/storage.go
index 1debdaa4a..8bec1cca8 100644
--- a/pkg/asset/storage.go
+++ b/pkg/asset/storage.go
@@ -123,7 +123,8 @@ func (storage *Storage) uploadFileStream(reader io.Reader, assetType dashapi.Ass
 		compressor = typeDescr.customCompressor
 	}
 	res, err := compressor(req, storage.backend.upload)
-	if existsErr, ok := err.(*FileExistsError); ok {
+	var existsErr *FileExistsError
+	if errors.As(err, &existsErr) {
 		storage.tracer.Log("asset %s already exists", path)
 		if extra == nil || !extra.SkipIfExists {
 			return "", err
@@ -137,7 +138,8 @@ func (storage *Storage) uploadFileStream(reader io.Reader, assetType dashapi.Ass
 		if err != nil {
 			more := ""
 			closeErr := res.writer.Close()
-			if exiterr, ok := closeErr.(*exec.ExitError); ok {
+			var exiterr *exec.ExitError
+			if errors.As(closeErr, &exiterr) {
 				more = fmt.Sprintf(", process state '%s'", exiterr.ProcessState)
 			}
 			return "", fmt.Errorf("failed to redirect byte stream: copied %d bytes, error %w%s",
diff --git a/pkg/bisect/bisect.go b/pkg/bisect/bisect.go
index 4c02e6336..e1e251cd9 100644
--- a/pkg/bisect/bisect.go
+++ b/pkg/bisect/bisect.go
@@ -4,6 +4,7 @@
 package bisect
 
 import (
+	"errors"
 	"fmt"
 	"math"
 	"os"
@@ -622,12 +623,14 @@ func (env *env) test() (*testResult, error) {
 	}
 	if err != nil {
 		errInfo := fmt.Sprintf("failed building %v: ", current.Hash)
-		if verr, ok := err.(*osutil.VerboseError); ok {
+		var verr *osutil.VerboseError
+		var kerr *build.KernelError
+		if errors.As(err, &verr) {
 			errInfo += verr.Title
 			env.saveDebugFile(current.Hash, 0, verr.Output)
-		} else if verr, ok := err.(*build.KernelError); ok {
-			errInfo += string(verr.Report)
-			env.saveDebugFile(current.Hash, 0, verr.Output)
+		} else if errors.As(err, &kerr) {
+			errInfo += string(kerr.Report)
+			env.saveDebugFile(current.Hash, 0, kerr.Output)
 		} else {
 			errInfo += err.Error()
 			env.log("%v", err)
@@ -722,38 +725,40 @@ func (env *env) processResults(current *vcs.Commit, results []instance.EnvTestRe
 			verdicts = append(verdicts, "OK")
 			continue
 		}
-		switch err := res.Error.(type) {
-		case *instance.TestError:
-			if err.Infra {
+		var testError *instance.TestError
+		var crashError *instance.CrashError
+		switch {
+		case errors.As(res.Error, &testError):
+			if testError.Infra {
 				infra++
-				verdicts = append(verdicts, fmt.Sprintf("infra problem: %v", err))
-			} else if err.Boot {
-				verdicts = append(verdicts, fmt.Sprintf("boot failed: %v", err))
+				verdicts = append(verdicts, fmt.Sprintf("infra problem: %v", testError))
+			} else if testError.Boot {
+				verdicts = append(verdicts, fmt.Sprintf("boot failed: %v", testError))
 			} else {
-				verdicts = append(verdicts, fmt.Sprintf("basic kernel testing failed: %v", err))
+				verdicts = append(verdicts, fmt.Sprintf("basic kernel testing failed: %v", testError))
 			}
-			output := err.Output
-			if err.Report != nil {
-				output = err.Report.Output
+			output := testError.Output
+			if testError.Report != nil {
+				output = testError.Report.Output
 			}
 			env.saveDebugFile(current.Hash, i, output)
-		case *instance.CrashError:
-			verdicts = append(verdicts, fmt.Sprintf("crashed: %v", err))
-			output := err.Report.Report
+		case errors.As(res.Error, &crashError):
+			verdicts = append(verdicts, fmt.Sprintf("crashed: %v", crashError))
+			output := crashError.Report.Report
 			if len(output) == 0 {
-				output = err.Report.Output
+				output = crashError.Report.Output
 			}
 			env.saveDebugFile(current.Hash, i, output)
-			if env.isTransientError(err.Report) {
-				verdicts = append(verdicts, fmt.Sprintf("ignore: %v", err))
+			if env.isTransientError(crashError.Report) {
+				verdicts = append(verdicts, fmt.Sprintf("ignore: %v", crashError))
 				break
 			}
 			bad++
-			reports = append(reports, err.Report)
-			verdicts = append(verdicts, fmt.Sprintf("crashed: %v", err))
+			reports = append(reports, crashError.Report)
+			verdicts = append(verdicts, fmt.Sprintf("crashed: %v", crashError))
 		default:
 			infra++
-			verdicts = append(verdicts, fmt.Sprintf("failed: %v", err))
+			verdicts = append(verdicts, fmt.Sprintf("failed: %v", res.Error))
 		}
 	}
 	unique := make(map[string]bool)
diff --git a/pkg/build/build.go b/pkg/build/build.go
index 9bcacbd90..52873e3b2 100644
--- a/pkg/build/build.go
+++ b/pkg/build/build.go
@@ -7,6 +7,7 @@ package build
 import (
 	"bytes"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"os"
 	"path/filepath"
@@ -195,8 +196,8 @@ func extractRootCause(err error, OS, kernelSrc string) error {
 	if err == nil {
 		return nil
 	}
-	verr, ok := err.(*osutil.VerboseError)
-	if !ok {
+	var verr *osutil.VerboseError
+	if !errors.As(err, &verr) {
 		return err
 	}
 	reason, file := extractCauseInner(verr.Output, kernelSrc)
diff --git a/pkg/gce/gce.go b/pkg/gce/gce.go
index 71b88e2ec..ecc2c9853 100644
--- a/pkg/gce/gce.go
+++ b/pkg/gce/gce.go
@@ -12,6 +12,7 @@
 package gce
 
 import (
+	"errors"
 	"fmt"
 	"io"
 	"math/rand"
@@ -170,7 +171,8 @@ retry:
 		return "", fmt.Errorf("failed to create instance: %w", err)
 	}
 	if err := ctx.waitForCompletion("zone", "create image", op.Name, false); err != nil {
-		if _, ok := err.(resourcePoolExhaustedError); ok && instance.Scheduling.Preemptible {
+		var resourcePoolExhaustedError resourcePoolExhaustedError
+		if errors.As(err, &resourcePoolExhaustedError) && instance.Scheduling.Preemptible {
 			instance.Scheduling.Preemptible = false
 			goto retry
 		}
@@ -206,7 +208,8 @@ func (ctx *Context) DeleteInstance(name string, wait bool) error {
 		op, err = ctx.computeService.Instances.Delete(ctx.ProjectID, ctx.ZoneID, name).Do()
 		return
 	})
-	if apiErr, ok := err.(*googleapi.Error); ok && apiErr.Code == 404 {
+	var apiErr *googleapi.Error
+	if errors.As(err, &apiErr) && apiErr.Code == 404 {
 		return nil
 	}
 	if err != nil {
@@ -270,7 +273,8 @@ func (ctx *Context) DeleteImage(imageName string) error {
 		op, err = ctx.computeService.Images.Delete(ctx.ProjectID, imageName).Do()
 		return
 	})
-	if apiErr, ok := err.(*googleapi.Error); ok && apiErr.Code == 404 {
+	var apiErr *googleapi.Error
+	if errors.As(err, &apiErr) && apiErr.Code == 404 {
 		return nil
 	}
 	if err != nil {
diff --git a/pkg/ifuzz/x86/gen/gen.go b/pkg/ifuzz/x86/gen/gen.go
index aae7429c0..01ba8420b 100644
--- a/pkg/ifuzz/x86/gen/gen.go
+++ b/pkg/ifuzz/x86/gen/gen.go
@@ -7,6 +7,7 @@ package main
 
 import (
 	"bufio"
+	"errors"
 	"fmt"
 	"os"
 	"reflect"
@@ -19,7 +20,7 @@ import (
 	"github.com/google/syzkaller/pkg/tool"
 )
 
-// nolint: gocyclo, gocognit, funlen
+// nolint: gocyclo, gocognit, funlen, dupl
 func main() {
 	if len(os.Args) != 2 {
 		tool.Failf("usage: gen instructions.txt")
@@ -113,8 +114,9 @@ func main() {
 			insn1 = new(x86.Insn)
 			*insn1 = *insn
 			if err := parsePattern(insn1, vals); err != nil {
-				if _, ok := err.(errSkip); !ok {
-					reportError(err.Error())
+				var errSkip errSkip
+				if !errors.As(err, &errSkip) {
+					reportError(errSkip.Error())
 				}
 				if err.Error() != "" {
 					fmt.Fprintf(os.Stderr, "skipping %v on line %v (%v)\n", insn.Name, i, err)
@@ -127,8 +129,9 @@ func main() {
 				break
 			}
 			if err := parseOperands(insn1, vals); err != nil {
-				if _, ok := err.(errSkip); !ok {
-					reportError(err.Error())
+				var errSkip errSkip
+				if !errors.As(err, &errSkip) {
+					reportError(errSkip.Error())
 				}
 				if err.Error() != "" {
 					fmt.Fprintf(os.Stderr, "skipping %v on line %v (%v)\n", insn.Name, i, err)
diff --git a/pkg/instance/instance.go b/pkg/instance/instance.go
index ea4084def..7696a945d 100644
--- a/pkg/instance/instance.go
+++ b/pkg/instance/instance.go
@@ -7,6 +7,7 @@ package instance
 
 import (
 	"encoding/json"
+	"errors"
 	"fmt"
 	"net"
 	"os"
@@ -305,7 +306,8 @@ func (inst *inst) test() EnvTestResult {
 		ret := EnvTestResult{
 			Error: testErr,
 		}
-		if bootErr, ok := err.(vm.BootErrorer); ok {
+		var bootErr vm.BootErrorer
+		if errors.As(err, &bootErr) {
 			testErr.Title, testErr.Output = bootErr.BootError()
 			ret.RawOutput = testErr.Output
 			rep := inst.reporter.Parse(testErr.Output)
@@ -327,7 +329,8 @@ func (inst *inst) test() EnvTestResult {
 			testErr.Title = rep.Title
 		} else {
 			testErr.Infra = true
-			if infraErr, ok := err.(vm.InfraErrorer); ok {
+			var infraErr vm.InfraErrorer
+			if errors.As(err, &infraErr) {
 				// In case there's more info available.
 				testErr.Title, testErr.Output = infraErr.InfraError()
 			}
diff --git a/pkg/osutil/osutil.go b/pkg/osutil/osutil.go
index 1687cef9d..478c091dc 100644
--- a/pkg/osutil/osutil.go
+++ b/pkg/osutil/osutil.go
@@ -7,6 +7,7 @@ import (
 	"bytes"
 	"compress/gzip"
 	"context"
+	"errors"
 	"fmt"
 	"io"
 	"os"
@@ -67,7 +68,8 @@ func Run(timeout time.Duration, cmd *exec.Cmd) ([]byte, error) {
 			text = fmt.Sprintf("timedout after %v %q", timeout, cmd.Args)
 		}
 		exitCode := 0
-		if exitErr, ok := err.(*exec.ExitError); ok {
+		var exitErr *exec.ExitError
+		if errors.As(err, &exitErr) {
 			if status, ok := exitErr.Sys().(syscall.WaitStatus); ok {
 				exitCode = status.ExitStatus()
 			}
@@ -120,10 +122,11 @@ func (err *VerboseError) Error() string {
 }
 
 func PrependContext(ctx string, err error) error {
-	switch err1 := err.(type) {
-	case *VerboseError:
-		err1.Title = fmt.Sprintf("%v: %v", ctx, err1.Title)
-		return err1
+	var verboseError *VerboseError
+	switch {
+	case errors.As(err, &verboseError):
+		verboseError.Title = fmt.Sprintf("%v: %v", ctx, verboseError.Title)
+		return verboseError
 	default:
 		return fmt.Errorf("%v: %w", ctx, err)
 	}
diff --git a/pkg/runtest/run.go b/pkg/runtest/run.go
index 4f6170fbb..864a9f5f1 100644
--- a/pkg/runtest/run.go
+++ b/pkg/runtest/run.go
@@ -13,6 +13,7 @@ package runtest
 import (
 	"bufio"
 	"bytes"
+	"errors"
 	"fmt"
 	"os"
 	"path/filepath"
@@ -691,7 +692,8 @@ func runTestC(req *RunRequest) {
 	// Tell ASAN to not mess with our NONFAILING.
 	cmd.Env = append(append([]string{}, os.Environ()...), "ASAN_OPTIONS=handle_segv=0 allow_user_segv_handler=1")
 	req.Output, req.Err = osutil.Run(20*time.Second, cmd)
-	if verr, ok := req.Err.(*osutil.VerboseError); ok {
+	var verr *osutil.VerboseError
+	if errors.As(req.Err, &verr) {
 		// The process can legitimately do something like exit_group(1).
 		// So we ignore the error and rely on the rest of the checks (e.g. syscall return values).
 		req.Err = nil