all: apply modernisers

Signed-off-by: Ophestra <cat@gensokyo.uk>

internal/dbus/address.go

@@ -80,7 +80,7 @@ func unescapeValue(v []byte) (val []byte, errno ParseError) {
 			continue
 		}
 
-		if ib := bytes.IndexByte([]byte("-_/.\\*"), b); ib != -1 { // - // _/.\*
+		if found := bytes.Contains([]byte("-_/.\\*"), []byte{b}); found { // - // _/.\*
 			goto opt
 		} else if b >= '0' && b <= '9' { // 0-9
 			goto opt
@@ -101,7 +101,7 @@ func unescapeValue(v []byte) (val []byte, errno ParseError) {
 			break
 		}
 		if c, err := hex.Decode(val[i:i+1], v[iu+1:iu+3]); err != nil {
-			if errors.As(err, new(hex.InvalidByteError)) {
+			if _, ok := errors.AsType[hex.InvalidByteError](err); ok {
 				errno = ErrBadValHexByte
 				break
 			}

internal/lockedfile/transform_test.go

@@ -40,7 +40,7 @@ func TestTransform(t *testing.T) {
 
 	const maxChunkWords = 8 << 10
 	buf := make([]byte, 2*maxChunkWords*8)
-	for i := uint64(0); i < 2*maxChunkWords; i++ {
+	for i := range uint64(2 * maxChunkWords) {
 		binary.LittleEndian.PutUint64(buf[i*8:], i)
 	}
 	if err := lockedfile.Write(path, bytes.NewReader(buf[:8]), 0666); err != nil {

internal/outcome/finalise.go

@@ -58,8 +58,7 @@ func (k *outcome) finalise(
 	supp := make([]string, len(config.Groups))
 	for i, name := range config.Groups {
 		if gid, err := k.lookupGroupId(name); err != nil {
-			var unknownGroupError user.UnknownGroupError
-			if errors.As(err, &unknownGroupError) {
+			if unknownGroupError, ok := errors.AsType[user.UnknownGroupError](err); ok {
 				return newWithMessageError(fmt.Sprintf("unknown group %q", name), unknownGroupError)
 			} else {
 				return &hst.AppError{Step: "look up group by name", Err: err, Msg: err.Error()}

internal/outcome/hsu.go

@@ -51,18 +51,16 @@ func (h *Hsu) ID() (int, error) {
 		cmd.Stderr = os.Stderr // pass through fatal messages
 		cmd.Env = make([]string, 0)
 		cmd.Dir = fhs.Root
-		var (
-			p         []byte
-			exitError *exec.ExitError
-		)
-
+		var p []byte
 		const step = "obtain uid from hsu"
 		if p, h.idErr = h.k.cmdOutput(cmd); h.idErr == nil {
 			h.id, h.idErr = strconv.Atoi(string(p))
 			if h.idErr != nil {
 				h.idErr = &hst.AppError{Step: step, Err: h.idErr, Msg: "invalid uid string from hsu"}
 			}
-		} else if errors.As(h.idErr, &exitError) && exitError != nil && exitError.ExitCode() == 1 {
+		} else if exitError, ok := errors.AsType[*exec.ExitError](h.idErr); ok &&
+			exitError != nil &&
+			exitError.ExitCode() == 1 {
 			// hsu prints an error message in this case
 			h.idErr = &hst.AppError{Step: step, Err: ErrHsuAccess}
 		} else if errors.Is(h.idErr, os.ErrNotExist) {

internal/outcome/process.go

@@ -328,11 +328,11 @@ func (k *outcome) main(msg message.Msg, identifierFd int) {
 				}
 
 				if err := k.sys.Revert((*system.Criteria)(&ec)); err != nil {
-					var joinError interface {
+					joinError, ok := errors.AsType[interface {
 						Unwrap() []error
 						error
-					}
-					if !errors.As(err, &joinError) || joinError == nil {
+					}](err)
+					if !ok || joinError == nil {
 						perror(err, "revert system setup")
 					} else {
 						for _, v := range joinError.Unwrap() {

internal/outcome/shim.go

@@ -390,8 +390,8 @@ func shimEntrypoint(k syscallDispatcher) {
 	if err := k.containerWait(z); err != nil {
 		sp.destroy()
 
-		var exitError *exec.ExitError
-		if !errors.As(err, &exitError) {
+		exitError, ok := errors.AsType[*exec.ExitError](err)
+		if !ok {
 			if errors.Is(err, context.Canceled) {
 				k.exit(hst.ExitCancel)
 			}

internal/pipewire/pod.go

@@ -176,8 +176,8 @@ func marshalValueAppendRaw(data []byte, v reflect.Value) ([]byte, error) {
 	case reflect.Struct:
 		data = SPA_TYPE_Struct.append(data)
 		var err error
-		for i := 0; i < v.NumField(); i++ {
-			data, err = marshalValueAppend(data, v.Field(i))
+		for _, field := range v.Fields() {
+			data, err = marshalValueAppend(data, field)
 			if err != nil {
 				return data, err
 			}
@@ -370,8 +370,8 @@ func unmarshalValue(data []byte, v reflect.Value, wireSizeP *Word) error {
 		}
 
 		var fieldWireSize Word
-		for i := 0; i < v.NumField(); i++ {
-			if err := unmarshalValue(data, v.Field(i), &fieldWireSize); err != nil {
+		for _, field := range v.Fields() {
+			if err := unmarshalValue(data, field, &fieldWireSize); err != nil {
 				return err
 			}
 			// bounds check completed in successful call to unmarshalValue

internal/pkg/pkg.go

@@ -238,8 +238,8 @@ func (t *TContext) destroy(errP *error) {
 		if chmodErr != nil || removeErr != nil {
 			*errP = errors.Join(*errP, chmodErr, removeErr)
 		} else if errors.Is(*errP, os.ErrExist) {
-			var linkError *os.LinkError
-			if errors.As(*errP, &linkError) && linkError != nil &&
+			if linkError, ok := errors.AsType[*os.LinkError](*errP); ok &&
+				linkError != nil &&
 				linkError.Op == "rename" {
 				// two artifacts may be backed by the same file
 				*errP = nil
@@ -974,36 +974,42 @@ func (e *ScrubError) Unwrap() []error {
 // Error returns a multi-line representation of [ScrubError].
 func (e *ScrubError) Error() string {
 	var segments []string
+	var buf strings.Builder
+
 	if len(e.ChecksumMismatches) > 0 {
-		s := "checksum mismatches:\n"
+		buf.Reset()
+		buf.WriteString("checksum mismatches:\n")
 		for _, m := range e.ChecksumMismatches {
-			s += m.Error() + "\n"
+			buf.WriteString(m.Error() + "\n")
 		}
-		segments = append(segments, s)
+		segments = append(segments, buf.String())
 	}
 	if len(e.DanglingIdentifiers) > 0 {
-		s := "dangling identifiers:\n"
+		buf.Reset()
+		buf.WriteString("dangling identifiers:\n")
 		for _, id := range e.DanglingIdentifiers {
-			s += Encode(id) + "\n"
+			buf.WriteString(Encode(id) + "\n")
 		}
-		segments = append(segments, s)
+		segments = append(segments, buf.String())
 	}
 	if len(e.DanglingStatus) > 0 {
-		s := "dangling status:\n"
+		buf.Reset()
+		buf.WriteString("dangling status:\n")
 		for _, id := range e.DanglingStatus {
-			s += Encode(id) + "\n"
+			buf.WriteString(Encode(id) + "\n")
 		}
-		segments = append(segments, s)
+		segments = append(segments, buf.String())
 	}
 	if len(e.Errs) > 0 {
-		s := "errors during scrub:\n"
+		buf.Reset()
+		buf.WriteString("errors during scrub:\n")
 		for pathname, errs := range e.errs {
-			s += "  " + pathname.Value() + ":\n"
+			buf.WriteString("  " + pathname.Value() + ":\n")
 			for _, err := range errs {
-				s += "    " + err.Error() + "\n"
+				buf.WriteString("    " + err.Error() + "\n")
 			}
 		}
-		segments = append(segments, s)
+		segments = append(segments, buf.String())
 	}
 	return strings.Join(segments, "\n")
 }

internal/report/report.go

@@ -102,8 +102,7 @@ func (e Error) MarshalJSON() (data []byte, err error) {
 		v.Severity = e.Severity
 	}
 
-	var re RepresentableError
-	if errors.As(e.Err, &re) {
+	if re, ok := errors.AsType[RepresentableError](e.Err); ok {
 		v.Err, err = json.Marshal(re)
 	} else {
 		v.Err, err = json.Marshal(e.Err.Error())

internal/rosa/azalea/evaluate.go

@@ -6,6 +6,7 @@ import (
 	"maps"
 	"reflect"
 	"slices"
+	"strings"
 	"unique"
 )
 
@@ -107,8 +108,8 @@ func (e TypeError) Error() string {
 }
 
 func (e TypeError) Is(err error) bool {
-	var v TypeError
-	return errors.As(err, &v) &&
+	v, ok := errors.AsType[TypeError](err)
+	return ok &&
 		e.Asserted == v.Asserted &&
 		e.Concrete == v.Concrete
 }
@@ -233,14 +234,14 @@ func evaluateAny(d PF, s []Frame, expr, rp any) bool {
 				return evaluateAny(d, s, e[0], rp)
 			}
 		}
-		var v string
+		var v strings.Builder
 		for i := range e {
 			var _r string
 			if evaluate(d, s, e[i], &_r) {
-				v += _r
+				v.WriteString(_r)
 			}
 		}
-		store(rp, v)
+		store(rp, v.String())
 		return true
 
 	case Array:

internal/rosa/azalea/evaluate_test.go

@@ -214,7 +214,7 @@ func TestEvaluate(t *testing.T) {
 			}
 
 			var errEquals bool
-			if errors.As(err, new(TypeError)) {
+			if _, ok := errors.AsType[TypeError](err); ok {
 				errEquals = errors.Is(err, tc.err)
 			} else {
 				errEquals = reflect.DeepEqual(err, tc.err)

internal/rosa/report.go

@@ -212,11 +212,10 @@ func (r *Report) HandleAccess(errP *error) func() {
 			*errP = err
 		}
 
-		var runtimeError interface {
+		if runtimeError, ok := errors.AsType[interface {
 			Addr() uintptr
 			runtime.Error
-		}
-		if errors.As(*errP, &runtimeError) {
+		}](*errP); ok {
 			offset := int(runtimeError.Addr() - uintptr(unsafe.Pointer(unsafe.SliceData(r.data))))
 			// best effort for fragile uintptr
 			if offset >= 0 {

internal/rosa/state.go

@@ -1063,7 +1063,7 @@ func (ctx *evalContext) pf(
 		checksum, ok := kc.(string)
 		if !ok {
 			err = azalea.TypeError{
-				Concrete: reflect.TypeOf(checksum),
+				Concrete: reflect.TypeOf(kc),
 				Asserted: reflect.TypeFor[string](),
 			}
 			return

internal/store/store_test.go

@@ -29,7 +29,7 @@ func TestStoreBigLock(t *testing.T) {
 
 	{
 		s := store.New(check.MustAbs(t.TempDir()).Append("state"))
-		for i := 0; i < 2; i++ { // check once behaviour
+		for range 2 { // check once behaviour
 			if unlock, err := bigLock(s); err != nil {
 				t.Fatalf("bigLock: error = %v", err)
 			} else {
@@ -43,7 +43,7 @@ func TestStoreBigLock(t *testing.T) {
 
 		wantErr := &hst.AppError{Step: "create state store directory",
 			Err: &os.PathError{Op: "mkdir", Path: "/proc/nonexistent", Err: syscall.ENOENT}}
-		for i := 0; i < 2; i++ { // check once behaviour
+		for range 2 { // check once behaviour
 			if _, err := bigLock(store.New(check.MustAbs("/proc/nonexistent"))); !reflect.DeepEqual(err, wantErr) {
 				t.Errorf("bigLock: error = %#v, want %#v", err, wantErr)
 			}

internal/stub/errors.go

@@ -20,9 +20,6 @@ func (e UniqueError) Error() string {
 }
 
 func (e UniqueError) Is(target error) bool {
-	var u UniqueError
-	if !errors.As(target, &u) {
-		return false
-	}
-	return e == u
+	u, ok := errors.AsType[UniqueError](target)
+	return ok && e == u
 }

internal/system/dbus.go

@@ -172,12 +172,12 @@ func (s *linePrefixWriter) write(p []byte, a int) (int, error) {
 		return a, syscall.ENOMEM
 	}
 
-	if i := bytes.IndexByte(p, '\n'); i == -1 {
+	if before, after, ok := bytes.Cut(p, []byte{'\n'}); !ok {
 		n, _ := s.buf.Write(p)
 		s.n += n
 		return a + n, nil
 	} else {
-		n, _ := s.buf.Write(p[:i])
+		n, _ := s.buf.Write(before)
 		s.n += n + 1
 
 		v := s.buf.String()
@@ -190,7 +190,7 @@ func (s *linePrefixWriter) write(p []byte, a int) (int, error) {
 		}
 
 		s.buf.Reset()
-		return s.write(p[i+1:], a+n+1)
+		return s.write(after, a+n+1)
 	}
 }
 

internal/wayland/wayland.go

@@ -130,13 +130,11 @@ func (e *Error) Error() string {
 		return e.withPrefix("cannot connect to " + e.Host)
 
 	case RCleanup:
-		var pathError *os.PathError
-		if errors.As(e.Errno, &pathError) && pathError != nil {
+		if pathError, ok := errors.AsType[*os.PathError](e.Errno); ok && pathError != nil {
 			return pathError.Error()
 		}
 
-		var errno syscall.Errno
-		if errors.As(e.Errno, &errno) && errno != 0 {
+		if errno, ok := errors.AsType[syscall.Errno](e.Errno); ok && errno != 0 {
 			return "cannot close wayland close_fd pipe: " + errno.Error()
 		}