Use errors.AsType instead of errors.As

pkg/beholder/batch_emitter_service.go

@@ -171,8 +171,7 @@ func (e *ChipIngressBatchEmitterService) emitInternal(ctx context.Context, body
 				// every dropped event. chip_ingress.events_dropped (error_code) already
 				// captures that it's happening and roughly why; the full reason isn't
 				// needed at fleet-wide log volume.
-				var pubErr *batch.PublishError
-				if !errors.As(sendErr, &pubErr) {
+				if _, ok := errors.AsType[*batch.PublishError](sendErr); !ok {
 					e.eng.Errorw("failed to emit to chip ingress",
 						"error", sendErr,
 						"error_code", errorCode,

pkg/chipingress/batch/client.go

@@ -65,8 +65,7 @@ func ErrorCodeFor(err error) string {
 		return ""
 	}
 
-	var pubErr *PublishError
-	if errors.As(err, &pubErr) {
+	if pubErr, ok := errors.AsType[*PublishError](err); ok {
 		if pubErr.Code == ErrCodeResultsMismatch {
 			return "results_mismatch"
 		}

pkg/config/toml.go

@@ -12,8 +12,7 @@ import (
 func DecodeTOML(r io.Reader, v any) error {
 	d := toml.NewDecoder(r).DisallowUnknownFields()
 	if err := d.Decode(v); err != nil {
-		var strict *toml.StrictMissingError
-		if errors.As(err, &strict) {
+		if strict, ok := errors.AsType[*toml.StrictMissingError](err); ok {
 			return errors.New(strict.String())
 		}
 		return err

pkg/loop/internal/core/services/capability/capabilities.go

@@ -226,8 +226,7 @@ func (t *triggerExecutableServer) RegisterTrigger(request *pb.TriggerRegistratio
 
 		// If it's a capability error, serialize it and send it to the client for proper deserialization and handling on the client side.
 		errorString := err.Error()
-		var capErr caperrors.Error
-		if errors.As(err, &capErr) {
+		if capErr, ok := errors.AsType[caperrors.Error](err); ok {
 			errorString = capErr.SerializeToString()
 		}
 		msg := &pb.TriggerResponseMessage{
@@ -448,8 +447,7 @@ func (c *executableServer) Execute(reqpb *pb.CapabilityRequest, server pb.Execut
 	var responseMessage *pb.CapabilityResponse
 	response, err := c.impl.Execute(server.Context(), req)
 	if err != nil {
-		var capabilityError caperrors.Error
-		if errors.As(err, &capabilityError) {
+		if capabilityError, ok := errors.AsType[caperrors.Error](err); ok {
 			responseMessage = &pb.CapabilityResponse{Error: capabilityError.SerializeToString()}
 		} else {
 			// All other errors are treated as private visibility and are marked as such to prevent accidental or malicious

pkg/loop/internal/core/services/capability/capabilities_test.go

@@ -689,8 +689,7 @@ func Test_Capabilities(t *testing.T) {
 			capabilities.CapabilityRequest{Config: cmap, Inputs: imap})
 		require.Error(t, err)
 
-		var capErr caperrors.Error
-		ok := errors.As(err, &capErr)
+		capErr, ok := errors.AsType[caperrors.Error](err)
 		require.True(t, ok, "expected caperrors.Error, got %T: %v", err, err)
 		require.Equal(t, caperrors.Unavailable, capErr.Code())
 		require.Equal(t, caperrors.VisibilityPublic, capErr.Visibility())
@@ -738,8 +737,7 @@ func Test_Capabilities(t *testing.T) {
 		}
 		require.Error(t, execErr)
 
-		var capErr caperrors.Error
-		ok := errors.As(execErr, &capErr)
+		capErr, ok := errors.AsType[caperrors.Error](execErr)
 		require.True(t, ok, "expected caperrors.Error, got %T: %v", execErr, execErr)
 		require.Equal(t, caperrors.Unavailable, capErr.Code())
 		require.Equal(t, caperrors.VisibilityPublic, capErr.Visibility())
@@ -776,8 +774,7 @@ func Test_Capabilities(t *testing.T) {
 			capabilities.CapabilityRequest{Config: cmap, Inputs: imap})
 		require.Error(t, err)
 
-		var capErr caperrors.Error
-		ok := errors.As(err, &capErr)
+		capErr, ok := errors.AsType[caperrors.Error](err)
 		require.True(t, ok, "expected caperrors.Error, got %T: %v", err, err)
 		require.Equal(t, caperrors.Internal, capErr.Code())
 		require.Equal(t, caperrors.VisibilityPublic, capErr.Visibility())

pkg/loop/internal/relayer/pluginprovider/ext/median/test/median.go

@@ -142,8 +142,7 @@ func (s staticMedianFactoryServer) NewMedianFactory(ctx context.Context, provide
 	err = s.gasPriceSubunitsDataSource.Evaluate(ctx, gasPriceSubunitsDataSource)
 
 	if err != nil {
-		var compareError *CompareError
-		isCompareError := errors.As(err, &compareError)
+		compareError, isCompareError := errors.AsType[*CompareError](err)
 		// allow 0 as valid data source value with the same staticMedianFactoryServer (because it is only defined once as a global var for all tests)
 		if !isCompareError || !compareError.GotZero() {
 			return nil, fmt.Errorf("NewMedianFactory: gasPriceSubunitsDataSource does not equal a static gas price subunits data source implementation: %w", err)

pkg/monitoring/schema_registry.go

@@ -68,8 +68,7 @@ func isNotFoundErr(err error) bool {
 	if strings.HasPrefix(err.Error(), "Subject not found") { // for mock schema registry
 		return true
 	}
-	var srErr srclient.Error
-	if errors.As(err, &srErr) && srErr.Code == 40401 { // for the actual schema registry api.
+	if srErr, ok := errors.AsType[srclient.Error](err); ok && srErr.Code == 40401 { // for the actual schema registry api.
 		return true
 	}
 	return false

pkg/settings/limits/errors.go

@@ -12,10 +12,9 @@ import (
 )
 
 // LimitError is implemented by errors returned when a limit is exceeded.
-// Use [errors.As] to identify limit errors, for example:
+// Use [errors.AsType] to identify limit errors, for example:
 //
-//	var limitErr LimitError
-//	if errors.As(err, &limitErr) { ... }
+//	if limitErr, ok := errors.AsType[LimitError](err); ok { ... }
 type LimitError interface {
 	error
 	limitError()

pkg/settings/limits/errors_test.go

@@ -31,15 +31,18 @@ func TestLimitError_As(t *testing.T) {
 	for _, err := range cases {
 		t.Run(err.Error(), func(t *testing.T) {
 			t.Parallel()
-			var limitErr LimitError
-			require.True(t, errors.As(err, &limitErr))
-			require.True(t, errors.As(fmt.Errorf("wrapped: %w", err), &limitErr))
-		})
+		limitErr, ok := errors.AsType[LimitError](err)
+		require.True(t, ok)
+		_ = limitErr
+		_, ok = errors.AsType[LimitError](fmt.Errorf("wrapped: %w", err))
+		require.True(t, ok)
+	})
 	}
 
-	var limitErr LimitError
-	require.False(t, errors.As(errors.New("other"), &limitErr))
-	require.False(t, errors.As(ErrQueueEmpty, &limitErr))
+	_, ok := errors.AsType[LimitError](errors.New("other"))
+	require.False(t, ok)
+	_, ok = errors.AsType[LimitError](ErrQueueEmpty)
+	require.False(t, ok)
 }
 
 func TestErrorRateLimited(t *testing.T) {

pkg/workflows/host/execution_restrictions_test.go

@@ -88,8 +88,8 @@ func TestRequirementSelectingModule_CallCapWithRestrictions(t *testing.T) {
 		inner := mocks.NewMockExecutionHelper(t) // no expectations: inner must not be called
 		h := host.NewRestrictedExecutionHelper(inner, restrictions)
 		_, err := h.CallCapability(t.Context(), &sdk.CapabilityRequest{Id: "blocked@1.0.0", Method: "Bar"})
-		var capErr caperrors.Error
-		require.True(t, errors.As(err, &capErr))
+		capErr, ok := errors.AsType[caperrors.Error](err)
+		require.True(t, ok)
 		assert.Contains(t, capErr.Error(), "denied by user pre-hook restrictions")
 		assert.Equal(t, caperrors.LimitExceeded, capErr.Code())
 	})
@@ -440,8 +440,8 @@ func TestRequirementSelectingModule_ConfidentialHTTPWithRestrictions(t *testing.
 		req := confidentialHTTPRequest(t, "confhttp@1.0.0", "Call",
 			&confidentialhttp.SecretIdentifier{Key: "blocked-secret", Namespace: "ns"})
 		_, err := h.CallCapability(t.Context(), req)
-		var capErr caperrors.Error
-		require.True(t, errors.As(err, &capErr))
+		capErr, ok := errors.AsType[caperrors.Error](err)
+		require.True(t, ok)
 		assert.Contains(t, capErr.Error(), "denied by user pre-hook restrictions")
 		assert.Equal(t, caperrors.LimitExceeded, capErr.Code())
 	})

pkg/workflows/wasm/host/execution.go

@@ -62,8 +62,7 @@ func (e *execution[T]) callCapAsync(ctx context.Context, req *sdkpb.CapabilityRe
 		if err != nil {
 			errString := err.Error()
 
-			var caperror caperrors.Error
-			if errors.As(err, &caperror) {
+			if caperror, ok := errors.AsType[caperrors.Error](err); ok {
 				errString = caperror.SerializeToString()
 			}
 			resp = &sdkpb.CapabilityResponse{