Eliminate errs.Matches().

Use the more-explicit and less-error-prone `errors.As()` instead.

Author: mitchell-as

Diff for: cmd/state-svc/internal/rtwatcher/watcher.go

@@ -2,6 +2,7 @@ package rtwatcher
 
 import (
 	"encoding/json"
+	"errors"
 	"os"
 	"runtime/debug"
 	"strconv"
@@ -81,7 +82,8 @@ func (w *Watcher) check() {
 	for i := range w.watching {
 		e := w.watching[i] // Must use index, because we are deleting indexes further down
 		running, err := e.IsRunning()
-		if err != nil && !errs.Matches(err, &processError{}) {
+		var errProcess *processError
+		if err != nil && !errors.As(err, &errProcess) {
 			multilog.Error("Could not check if runtime process is running: %s", errs.JoinMessage(err))
 			// Don't return yet, the conditional below still needs to clear this entry
 		}
@@ -110,7 +112,8 @@ func (w *Watcher) GetProcessesInUse(execDir string) []entry {
 			continue
 		}
 		isRunning, err := proc.IsRunning()
-		if err != nil && !errs.Matches(err, &processError{}) {
+		var errProcess *processError
+		if err != nil && !errors.As(err, &errProcess) {
 			multilog.Error("Could not check if runtime process is running: %s", errs.JoinMessage(err))
 			// Any errors should not affect fetching which processes are currently in use. We just won't
 			// include this one in the list.

Diff for: cmd/state/autoupdate.go

@@ -2,6 +2,7 @@ package main
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"os"
 	"strings"
@@ -73,7 +74,8 @@ func autoUpdate(svc *model.SvcModel, args []string, childCmd *captain.Command, c
 
 	err = up.InstallBlocking("")
 	if err != nil {
-		if errs.Matches(err, &updater.ErrorInProgress{}) {
+		var errInProgress *updater.ErrorInProgress
+		if errors.As(err, &errInProgress) {
 			return false, nil // ignore
 		}
 		if os.IsPermission(err) {
@@ -87,10 +89,14 @@ func autoUpdate(svc *model.SvcModel, args []string, childCmd *captain.Command, c
 
 	code, err := relaunch(args)
 	if err != nil {
+		var errStateExe *ErrStateExe
+		var errExecuteRelaunch *ErrExecuteRelaunch
+
 		var msg string
-		if errs.Matches(err, &ErrStateExe{}) {
+		switch {
+		case errors.As(err, &errStateExe):
 			msg = anaConst.UpdateErrorExecutable
-		} else if errs.Matches(err, &ErrExecuteRelaunch{}) {
+		case errors.As(err, &errExecuteRelaunch):
 			msg = anaConst.UpdateErrorRelaunch
 		}
 		an.EventWithLabel(anaConst.CatUpdates, anaConst.ActUpdateRelaunch, anaConst.UpdateLabelFailed, &dimensions.Values{

Diff for: cmd/state/main.go

@@ -2,6 +2,7 @@ package main
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"os"
 	"runtime/debug"
@@ -32,7 +33,7 @@ import (
 	_ "github.com/ActiveState/cli/internal/prompt" // Sets up survey defaults
 	"github.com/ActiveState/cli/internal/rollbar"
 	"github.com/ActiveState/cli/internal/rtutils"
-	"github.com/ActiveState/cli/internal/runbits/errors"
+	runbits_errors "github.com/ActiveState/cli/internal/runbits/errors"
 	"github.com/ActiveState/cli/internal/runbits/panics"
 	"github.com/ActiveState/cli/internal/subshell"
 	"github.com/ActiveState/cli/internal/svcctl"
@@ -107,7 +108,7 @@ func main() {
 	// Run our main command logic, which is logic that defers to the error handling logic below
 	err = run(os.Args, isInteractive, cfg, out)
 	if err != nil {
-		exitCode, err = errors.ParseUserFacing(err)
+		exitCode, err = runbits_errors.ParseUserFacing(err)
 		if err != nil {
 			out.Error(err)
 		}
@@ -185,7 +186,8 @@ func run(args []string, isInteractive bool, cfg *config.Instance, out output.Out
 		out.Notice(locale.T("warning_activestate_project_env_var"))
 	}
 	pjPath, err := projectfile.GetProjectFilePath()
-	if err != nil && errs.Matches(err, &projectfile.ErrorNoProjectFromEnv{}) {
+	var errNoProjectFromEnv *projectfile.ErrorNoProjectFromEnv
+	if err != nil && errors.As(err, &errNoProjectFromEnv) {
 		// Fail if we are meant to inherit the projectfile from the environment, but the file doesn't exist
 		return err
 	}
@@ -271,7 +273,7 @@ func run(args []string, isInteractive bool, cfg *config.Instance, out output.Out
 		if !out.Type().IsStructured() {
 			err = errs.AddTips(err, locale.Tl("err_tip_run_help", "Run → '[ACTIONABLE]state {{.V0}}--help[/RESET]' for general help", cmdName))
 		}
-		errors.ReportError(err, cmds.Command(), an)
+		runbits_errors.ReportError(err, cmds.Command(), an)
 	}
 
 	return err

Diff for: internal/errs/errs.go

@@ -6,7 +6,6 @@ import (
 	"reflect"
 	"strings"
 
-	"github.com/ActiveState/cli/internal/condition"
 	"github.com/ActiveState/cli/internal/osutils/stacktrace"
 	"github.com/ActiveState/cli/internal/rtutils"
 	"gopkg.in/yaml.v3"
@@ -194,39 +193,6 @@ func AddTips(err error, tips ...string) error {
 
 var errorType = reflect.TypeOf((*error)(nil)).Elem()
 
-// Matches is an analog for errors.As that just checks whether err matches the given type, so you can do:
-// errs.Matches(err, &ErrStruct{})
-// Without having to first assign it to a variable
-// This is useful if you ONLY care about the bool return value and not about setting the variable
-func Matches(err error, target interface{}) bool {
-	if target == nil {
-		panic("errors: target cannot be nil")
-	}
-
-	// Guard against miss-use of this function
-	if _, ok := target.(*WrapperError); ok {
-		if condition.BuiltOnDevMachine() || condition.InActiveStateCI() {
-			panic("target cannot be a WrapperError, you probably want errors.Is")
-		}
-	}
-
-	val := reflect.ValueOf(target)
-	targetType := val.Type()
-	if targetType.Kind() != reflect.Interface && !targetType.Implements(errorType) {
-		panic("errors: *target must be interface or implement error")
-	}
-	errs := Unpack(err)
-	for _, err := range errs {
-		if reflect.TypeOf(err).AssignableTo(targetType) {
-			return true
-		}
-		if x, ok := err.(interface{ As(interface{}) bool }); ok && x.As(&target) {
-			return true
-		}
-	}
-	return false
-}
-
 func IsAny(err error, errs ...error) bool {
 	for _, e := range errs {
 		if errors.Is(err, e) {

Diff for: internal/errs/errs_test.go

@@ -2,8 +2,6 @@ package errs_test
 
 import (
 	"errors"
-	"os"
-	"os/exec"
 	"path/filepath"
 	"reflect"
 	"strings"
@@ -63,82 +61,6 @@ func TestErrs(t *testing.T) {
 
 type standardError struct{ error }
 
-func TestMatches(t *testing.T) {
-	type args struct {
-		err    error
-		target interface{}
-	}
-	tests := []struct {
-		name string
-		args args
-		want bool
-	}{
-		{
-			"Simple match",
-			args{
-				&standardError{errors.New("error")},
-				&standardError{},
-			},
-			true,
-		},
-		{
-			"Simple miss-match",
-			args{
-				errors.New("error"),
-				&standardError{},
-			},
-			false,
-		},
-		{
-			"Wrapped match",
-			args{
-				errs.Wrap(&standardError{errors.New("error")}, "Wrapped"),
-				&standardError{},
-			},
-			true,
-		},
-		{
-			"exec.ExitError", // this one has proved troublesome
-			args{
-				&exec.ExitError{&os.ProcessState{}, []byte("")},
-				&exec.ExitError{},
-			},
-			true,
-		},
-		{
-			"wrapped exec.ExitError",
-			args{
-				errs.Wrap(&exec.ExitError{&os.ProcessState{}, []byte("")}, "wrapped"),
-				&exec.ExitError{},
-			},
-			true,
-		},
-		{
-			"combined errors 1",
-			args{
-				errs.Pack(&exec.ExitError{&os.ProcessState{}, []byte("")}, errs.New("Random")),
-				&exec.ExitError{},
-			},
-			true,
-		},
-		{
-			"combined errors 2 - inverted",
-			args{
-				errs.Pack(errs.New("Random"), &exec.ExitError{&os.ProcessState{}, []byte("")}),
-				&exec.ExitError{},
-			},
-			true,
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			if got := errs.Matches(tt.args.err, tt.args.target); got != tt.want {
-				t.Errorf("Matches() = %v, want %v", got, tt.want)
-			}
-		})
-	}
-}
-
 func TestAddTips(t *testing.T) {
 	type args struct {
 		err  error

Diff for: internal/errs/example_test.go

@@ -19,7 +19,6 @@ func TestExample(t *testing.T) {
 	errt := &MyError{}
 	var errx error = &MyError{errs.New("test1")}
 	errors.As(errx, &errt)
-	errs.Matches(errx, &MyError{})
 
 	// Regular error
 	var err error = errs.New("Regular error message on %s", runtime.GOOS)
@@ -38,8 +37,6 @@ func TestExample(t *testing.T) {
 	err = errs.Wrap(myError, "My WrappedErr!")
 	assert.Error(t, err)
 	assert.True(t, errors.As(err, &myErrorCopy), "Error can be accessed as myErrorCopy")
-	assert.True(t, errs.Matches(err, &MyError{}), "Error Matches")
-	assert.False(t, errs.Matches(errs.New("foo"), &MyError{}), "Error doesn't match")
 	assert.True(t, errors.Is(err, myError), "err is equivalent to myError") // ptrs same addr, non-ptrs struct equality
 
 	// Create user input error

Diff for: internal/installation/paths.go

@@ -1,6 +1,7 @@
 package installation
 
 import (
+	"errors"
 	"os"
 	"path/filepath"
 	"strings"
@@ -22,14 +23,15 @@ const (
 )
 
 type InstallMarkerMeta struct {
-	Channel  string `json:"channel"`
+	Channel string `json:"channel"`
 	Version string `json:"version"`
 }
 
 type StateExeDoesNotExistError struct{ *errs.WrapperError }
 
 func IsStateExeDoesNotExistError(err error) bool {
-	return errs.Matches(err, &StateExeDoesNotExistError{})
+	var errStateExeDoesNotExist *StateExeDoesNotExistError
+	return errors.As(err, &errStateExeDoesNotExist)
 }
 
 func DefaultInstallPath() (string, error) {

Diff for: internal/osutils/lockfile/pidlock.go

@@ -1,6 +1,7 @@
 package lockfile
 
 import (
+	"errors"
 	"fmt"
 	"io"
 	"os"
@@ -105,7 +106,8 @@ func (pl *PidLock) WaitForLock(timeout time.Duration) error {
 	for {
 		err := pl.TryLock()
 		if err != nil {
-			if !errs.Matches(err, &AlreadyLockedError{}) {
+			var errAlreadyLocked *AlreadyLockedError
+			if !errors.As(err, &errAlreadyLocked) {
 				return errs.Wrap(err, "Could not acquire lock")
 			}
 

Diff for: internal/runbits/auth/keypair.go

@@ -1,6 +1,8 @@
 package auth
 
 import (
+	"errors"
+
 	"github.com/ActiveState/cli/internal/constants"
 	"github.com/ActiveState/cli/internal/errs"
 	"github.com/ActiveState/cli/internal/keypairs"
@@ -16,9 +18,10 @@ import (
 // and saved.
 func ensureUserKeypair(passphrase string, cfg keypairs.Configurable, out output.Outputer, prompt prompt.Prompter, auth *authentication.Auth) error {
 	keypairRes, err := keypairs.FetchRaw(secretsapi.Get(auth), cfg, auth)
+	var errKeypairNotFound *keypairs.ErrKeypairNotFound
 	if err == nil {
 		err = processExistingKeypairForUser(keypairRes, passphrase, cfg, out, prompt, auth)
-	} else if errs.Matches(err, &keypairs.ErrKeypairNotFound{}) {
+	} else if errors.As(err, &errKeypairNotFound) {
 		err = generateKeypairForUser(cfg, passphrase, auth)
 	}
 
@@ -52,10 +55,11 @@ func generateKeypairForUser(cfg keypairs.Configurable, passphrase string, auth *
 // provided passphrase and then uploaded; unless the user declines, which results in err.
 func processExistingKeypairForUser(keypairRes *secretsModels.Keypair, passphrase string, cfg keypairs.Configurable, out output.Outputer, prompt prompt.Prompter, auth *authentication.Auth) error {
 	keypair, err := keypairs.ParseEncryptedRSA(*keypairRes.EncryptedPrivateKey, passphrase)
+	var errKeypairPassphrase *keypairs.ErrKeypairPassphrase
 	if err == nil {
 		// yay, store keypair locally just in case it isn't
 		return keypairs.SaveWithDefaults(cfg, keypair)
-	} else if !errs.Matches(err, &keypairs.ErrKeypairPassphrase{}) {
+	} else if !errors.As(err, &errKeypairPassphrase) {
 		// err did not involve an unmatched passphrase
 		return err
 	}
@@ -74,7 +78,7 @@ func processExistingKeypairForUser(keypairRes *secretsModels.Keypair, passphrase
 
 	// failed to validate with local private-key, try using previous passphrase
 	err = recoverKeypairFromPreviousPassphrase(keypairRes, passphrase, cfg, out, prompt, auth)
-	if err != nil && errs.Matches(err, &keypairs.ErrKeypairPassphrase{}) {
+	if err != nil && errors.As(err, &errKeypairPassphrase) {
 		// that failed, see if they want to regenerate their passphrase
 		err = promptUserToRegenerateKeypair(passphrase, cfg, out, prompt, auth)
 	}

Diff for: internal/runbits/auth/login.go

@@ -1,6 +1,7 @@
 package auth
 
 import (
+	"errors"
 	"net/url"
 	"time"
 
@@ -49,12 +50,15 @@ func AuthenticateWithInput(
 
 	err := AuthenticateWithCredentials(credentials, auth)
 	if err != nil {
+		var errTokenRequired *authentication.ErrTokenRequired
+		var errUnauthorized *authentication.ErrUnauthorized
+
 		switch {
-		case errs.Matches(err, &authentication.ErrTokenRequired{}):
+		case errors.As(err, &errTokenRequired):
 			if err := promptToken(credentials, out, prompt, auth); err != nil {
 				return errs.Wrap(err, "promptToken failed")
 			}
-		case errs.Matches(err, &authentication.ErrUnauthorized{}):
+		case errors.As(err, &errUnauthorized):
 			return locale.WrapError(err, "err_auth_failed")
 		default:
 			return locale.WrapError(err, "err_auth_failed_unknown_cause", "", err.Error())

Diff for: internal/runbits/findproject/project.go

@@ -1,6 +1,7 @@
 package findproject
 
 import (
+	"errors"
 	"sort"
 	"strings"
 
@@ -18,7 +19,8 @@ type LocalProjectDoesNotExist struct{ *locale.LocalizedError }
 
 // IsLocalProjectDoesNotExistError checks if the error is a LocalProjectDoesNotExist.
 func IsLocalProjectDoesNotExistError(err error) bool {
-	return errs.Matches(err, &LocalProjectDoesNotExist{})
+	var errLocalProjectDoesNotExist *LocalProjectDoesNotExist
+	return errors.As(err, &errLocalProjectDoesNotExist)
 }
 
 func FromInputByPriority(path string, ns *project.Namespaced, cfg projectfile.ConfigGetter, prompt prompt.Prompter) (*project.Project, error) {