refactor(error): check errors.New & fmt.Errorf

Author: lvan100

check.sh

@@ -63,6 +63,10 @@ if ! command_exists modernize; then
     install_modernize
 fi
 
+# Find fmt.Errorf and errors.New function calls, excluding vendor directory
+find . -type f -name '*.go' ! -path './vendor/*' -exec grep -Hn 'fmt\.Errorf' {} \;
+find . -type f -name '*.go' ! -path './vendor/*' -exec grep -Hn 'errors\.New' {} \;
+
 print_separator
 echo "Step 1/3: Running go fix..."
 print_separator

ctxcache/ctxcache.go

@@ -46,16 +46,17 @@ package ctxcache
 
 import (
 	"context"
-	"errors"
 	"fmt"
 	"sync"
+
+	"github.com/go-spring/stdlib/errutil"
 )
 
 var (
-	ErrCacheNotInitialized = errors.New("cache not initialized")
-	ErrCacheAlreadyCleared = errors.New("cache already cleared")
-	ErrKeyNotSet           = errors.New("key not set")
-	ErrKeyAlreadySet       = errors.New("key already set")
+	ErrCacheNotInitialized = errutil.Explain(nil, "cache not initialized")
+	ErrCacheAlreadyCleared = errutil.Explain(nil, "cache already cleared")
+	ErrKeyNotSet           = errutil.Explain(nil, "key not set")
+	ErrKeyAlreadySet       = errutil.Explain(nil, "key already set")
 )
 
 type cacheKeyType struct{}
@@ -150,19 +151,19 @@ func Get[T any](ctx context.Context, key string) (T, error) {
 	k := TypedKey[T]{Key: key}
 	cache, ok := getCache(ctx)
 	if !ok {
-		return zero, fmt.Errorf("%s: %w", k, ErrCacheNotInitialized)
+		return zero, errutil.Explain(ErrCacheNotInitialized, "%s", k)
 	}
 
 	cache.mutex.Lock()
 	defer cache.mutex.Unlock()
 
 	if cache.cleared {
-		return zero, fmt.Errorf("%s: %w", k, ErrCacheAlreadyCleared)
+		return zero, errutil.Explain(ErrCacheAlreadyCleared, "%s", k)
 	}
 
 	v, ok := cache.values[k]
 	if !ok {
-		return zero, fmt.Errorf("%s: %w", k, ErrKeyNotSet)
+		return zero, errutil.Explain(ErrKeyNotSet, "%s", k)
 	}
 
 	return v.(T), nil
@@ -180,18 +181,18 @@ func Set[T any](ctx context.Context, key string, value T) error {
 	k := TypedKey[T]{Key: key}
 	cache, ok := getCache(ctx)
 	if !ok {
-		return fmt.Errorf("%s: %w", k, ErrCacheNotInitialized)
+		return errutil.Explain(ErrCacheNotInitialized, "%s", k)
 	}
 
 	cache.mutex.Lock()
 	defer cache.mutex.Unlock()
 
 	if cache.cleared {
-		return fmt.Errorf("%s: %w", k, ErrCacheAlreadyCleared)
+		return errutil.Explain(ErrCacheAlreadyCleared, "%s", k)
 	}
 
 	if _, ok = cache.values[k]; ok {
-		return fmt.Errorf("%s: %w", k, ErrKeyAlreadySet)
+		return errutil.Explain(ErrKeyAlreadySet, "%s", k)
 	}
 
 	cache.values[k] = value

goutil/goutil_test.go

@@ -18,10 +18,10 @@ package goutil_test
 
 import (
 	"context"
-	"errors"
 	"testing"
 	"time"
 
+	"github.com/go-spring/stdlib/errutil"
 	"github.com/go-spring/stdlib/goutil"
 	"github.com/go-spring/stdlib/testing/assert"
 )
@@ -125,7 +125,7 @@ func TestGoValue(t *testing.T) {
 	})
 
 	t.Run("error return", func(t *testing.T) {
-		expectedErr := errors.New("expected error")
+		expectedErr := errutil.Explain(nil, "expected error")
 		_, err := goutil.GoValue(t.Context(), func(ctx context.Context) (string, error) {
 			return "", expectedErr
 		}, goutil.InheritCancel).Wait()

testing/testcase/assert_test.go

@@ -18,12 +18,12 @@ package testcase_test
 
 import (
 	"bytes"
-	"errors"
 	"fmt"
 	"io"
 	"slices"
 	"testing"
 
+	"github.com/go-spring/stdlib/errutil"
 	"github.com/go-spring/stdlib/testing/assert"
 	"github.com/go-spring/stdlib/testing/internal"
 	"github.com/go-spring/stdlib/testing/require"
@@ -180,7 +180,7 @@ func TestPanic(t *testing.T) {
 
 	// Test panic with different types of values
 	m.Reset()
-	assert.Panic(m, func() { panic(errors.New("there's no error")) }, "an error")
+	assert.Panic(m, func() { panic(errutil.Explain(nil, "there's no error")) }, "an error")
 	assert.String(t, m.String()).Equal(`error# Assertion failed: got "there's no error" which does not match "an error"`)
 
 	m.Reset()
@@ -707,7 +707,7 @@ expected: fmt.Stringer`)
 	// Test with interface implementation
 	m.Reset()
 	var err error
-	assert.That(m, errors.New("test")).TypeOf(&err)
+	assert.That(m, errutil.Explain(nil, "test")).TypeOf(&err)
 	assert.String(t, m.String()).Equal("")
 
 	// Test with slice types
@@ -760,7 +760,7 @@ func TestThat_Implements(t *testing.T) {
 
 	// Test successful interface implementation
 	m.Reset()
-	assert.That(m, errors.New("error")).Implements((*error)(nil))
+	assert.That(m, errutil.Explain(nil, "error")).Implements((*error)(nil))
 	assert.String(t, m.String()).Equal("")
 
 	// Test non-interface target

testing/testcase/error_test.go

@@ -17,10 +17,9 @@
 package testcase_test
 
 import (
-	"errors"
-	"fmt"
 	"testing"
 
+	"github.com/go-spring/stdlib/errutil"
 	"github.com/go-spring/stdlib/testing/assert"
 	"github.com/go-spring/stdlib/testing/internal"
 	"github.com/go-spring/stdlib/testing/require"
@@ -44,20 +43,20 @@ func TestError_Nil(t *testing.T) {
 
 	// Test with non-nil error - should fail
 	m.Reset()
-	assert.Error(m, errors.New("this is an error")).Nil()
+	assert.Error(m, errutil.Explain(nil, "this is an error")).Nil()
 	assert.String(t, m.String()).Equal(`error# Assertion failed: expected error to be nil, but it is not
   actual: (*errors.errorString) "this is an error"`)
 
 	// Test with Require mode - should fatal
 	m.Reset()
-	require.Error(m, errors.New("this is an error")).Nil("index is 0")
+	require.Error(m, errutil.Explain(nil, "this is an error")).Nil("index is 0")
 	assert.String(t, m.String()).Equal(`fatal# Assertion failed: expected error to be nil, but it is not
   actual: (*errors.errorString) "this is an error"
  message: "index is 0"`)
 
 	// Test with custom message
 	m.Reset()
-	assert.Error(m, errors.New("test error")).Nil("expected no error in this operation")
+	assert.Error(m, errutil.Explain(nil, "test error")).Nil("expected no error in this operation")
 	assert.String(t, m.String()).Equal(`error# Assertion failed: expected error to be nil, but it is not
   actual: (*errors.errorString) "test error"
  message: "expected no error in this operation"`)
@@ -68,7 +67,7 @@ func TestError_NotNil(t *testing.T) {
 
 	// Test with non-nil error - should pass
 	m.Reset()
-	assert.Error(m, errors.New("this is an error")).NotNil()
+	assert.Error(m, errutil.Explain(nil, "this is an error")).NotNil()
 	assert.String(t, m.String()).Equal("")
 
 	// Test with nil error - should fail
@@ -91,7 +90,7 @@ func TestError_NotNil(t *testing.T) {
 
 func TestError_Is(t *testing.T) {
 	m := new(internal.MockTestingT)
-	err := errors.New("this is an error")
+	err := errutil.Explain(nil, "this is an error")
 
 	// Test successful case - error is the same as target
 	m.Reset()
@@ -100,23 +99,23 @@ func TestError_Is(t *testing.T) {
 
 	// Test failed case - different errors
 	m.Reset()
-	assert.Error(m, err).Is(errors.New("another error"))
+	assert.Error(m, err).Is(errutil.Explain(nil, "another error"))
 	assert.String(t, m.String()).Equal(`error# Assertion failed: expected error to be target (according to errors.Is), but they are different
   actual: this is an error
 expected: another error`)
 
 	// Test failed case with Require - should fatal
 	m.Reset()
-	require.Error(m, err).Is(errors.New("another error"), "index is 0")
+	require.Error(m, err).Is(errutil.Explain(nil, "another error"), "index is 0")
 	assert.String(t, m.String()).Equal(`fatal# Assertion failed: expected error to be target (according to errors.Is), but they are different
   actual: this is an error
 expected: another error
  message: "index is 0"`)
 
 	// Test with wrapped error - should not match the root error (because we're checking Is in wrong direction)
 	m.Reset()
-	rootErr := errors.New("root error")
-	wrappedErr := fmt.Errorf("level 1: %w", fmt.Errorf("level 2: %w", rootErr))
+	rootErr := errutil.Explain(nil, "root error")
+	wrappedErr := errutil.Explain(errutil.Explain(rootErr, "level 2"), "level 1")
 	assert.Error(m, wrappedErr).Is(rootErr)
 	assert.String(t, m.String()).Equal("")
 
@@ -135,7 +134,7 @@ expected: this is an error`)
 
 	// Test with custom message on failure
 	m.Reset()
-	assert.Error(m, errors.New("some error")).Is(errors.New("other error"), "expected errors to match")
+	assert.Error(m, errutil.Explain(nil, "some error")).Is(errutil.Explain(nil, "other error"), "expected errors to match")
 	assert.String(t, m.String()).Equal(`error# Assertion failed: expected error to be target (according to errors.Is), but they are different
   actual: some error
 expected: other error
@@ -144,11 +143,11 @@ expected: other error
 
 func TestError_NotIs(t *testing.T) {
 	m := new(internal.MockTestingT)
-	err := errors.New("this is an error")
+	err := errutil.Explain(nil, "this is an error")
 
 	// Test successful case - different errors
 	m.Reset()
-	assert.Error(m, err).NotIs(errors.New("another error"))
+	assert.Error(m, err).NotIs(errutil.Explain(nil, "another error"))
 	assert.String(t, m.String()).Equal("")
 
 	// Test failed case - same errors
@@ -168,8 +167,8 @@ expected: this is an error
 
 	// Test with wrapped error - wrapped error contains root error, so NotIs should fail
 	m.Reset()
-	rootErr := errors.New("root error")
-	wrappedErr := fmt.Errorf("level 1: %w", fmt.Errorf("level 2: %w", rootErr))
+	rootErr := errutil.Explain(nil, "root error")
+	wrappedErr := errutil.Explain(errutil.Explain(rootErr, "level 2"), "level 1")
 	assert.Error(m, rootErr).NotIs(wrappedErr)
 	assert.String(t, m.String()).Equal("")
 
@@ -195,7 +194,7 @@ expected: this is an error
 
 func TestError_String(t *testing.T) {
 	m := new(internal.MockTestingT)
-	err := errors.New("this is an error")
+	err := errutil.Explain(nil, "this is an error")
 
 	// Test successful case - error is the same as target
 	m.Reset()
@@ -219,8 +218,8 @@ expected: "another error"
 
 	// Test with wrapped error - should not match the root error (because we're checking Is in wrong direction)
 	m.Reset()
-	rootErr := errors.New("root error")
-	wrappedErr := fmt.Errorf("level 1: %w", fmt.Errorf("level 2: %w", rootErr))
+	rootErr := errutil.Explain(nil, "root error")
+	wrappedErr := errutil.Explain(errutil.Explain(rootErr, "level 2"), "level 1")
 	assert.Error(m, wrappedErr).String("level 1: level 2: root error")
 	assert.String(t, m.String()).Equal("")
 
@@ -237,7 +236,7 @@ expected: "another error"
 
 	// Test with custom message on failure
 	m.Reset()
-	assert.Error(m, errors.New("some error")).String("other error", "expected errors to match")
+	assert.Error(m, errutil.Explain(nil, "some error")).String("other error", "expected errors to match")
 	assert.String(t, m.String()).Equal(`error# Assertion failed: expected strings to be equal, but they are not
   actual: "some error"
 expected: "other error"
@@ -249,12 +248,12 @@ func TestError_Matches(t *testing.T) {
 
 	// Test successful case - simple string match
 	m.Reset()
-	assert.Error(m, errors.New("this is an error")).Matches("an error")
+	assert.Error(m, errutil.Explain(nil, "this is an error")).Matches("an error")
 	assert.String(t, m.String()).Equal("")
 
 	// Test invalid regex pattern
 	m.Reset()
-	assert.Error(m, errors.New("there's no error")).Matches(`an error \`)
+	assert.Error(m, errutil.Explain(nil, "there's no error")).Matches(`an error \`)
 	assert.String(t, m.String()).Equal("error# Assertion failed: invalid pattern")
 
 	// Test with nil error - should fail
@@ -270,28 +269,28 @@ func TestError_Matches(t *testing.T) {
 
 	// Test failed match with Require - should fatal
 	m.Reset()
-	require.Error(m, errors.New("there's no error")).Matches("an error")
+	require.Error(m, errutil.Explain(nil, "there's no error")).Matches("an error")
 	assert.String(t, m.String()).Equal(`fatal# Assertion failed: got "there's no error" which does not match "an error"`)
 
 	// Test failed match with Require and custom message
 	m.Reset()
-	require.Error(m, errors.New("there's no error")).Matches("an error", "index is 0")
+	require.Error(m, errutil.Explain(nil, "there's no error")).Matches("an error", "index is 0")
 	assert.String(t, m.String()).Equal(`fatal# Assertion failed: got "there's no error" which does not match "an error"
  message: "index is 0"`)
 
 	// Test with regex pattern that matches
 	m.Reset()
-	assert.Error(m, errors.New("error code 123")).Matches(`error code \d+`)
+	assert.Error(m, errutil.Explain(nil, "error code 123")).Matches(`error code \d+`)
 	assert.String(t, m.String()).Equal("")
 
 	// Test with regex pattern that does not match
 	m.Reset()
-	assert.Error(m, errors.New("error code abc")).Matches(`error code \d+`)
+	assert.Error(m, errutil.Explain(nil, "error code abc")).Matches(`error code \d+`)
 	assert.String(t, m.String()).Equal(`error# Assertion failed: got "error code abc" which does not match "error code \\d+"`)
 
 	// Test with complex error message
 	m.Reset()
-	assert.Error(m, fmt.Errorf("database connection failed: %w", errors.New("timeout"))).Matches("connection failed")
+	assert.Error(m, errutil.Explain(errutil.Explain(nil, "timeout"), "database connection failed")).Matches("connection failed")
 	assert.String(t, m.String()).Equal("")
 
 	// Test with custom error type
@@ -301,7 +300,7 @@ func TestError_Matches(t *testing.T) {
 
 	// Test with custom message on failure
 	m.Reset()
-	assert.Error(m, errors.New("some error")).Matches("nonexistent", "expected error to match pattern")
+	assert.Error(m, errutil.Explain(nil, "some error")).Matches("nonexistent", "expected error to match pattern")
 	assert.String(t, m.String()).Equal(`error# Assertion failed: got "some error" which does not match "nonexistent"
  message: "expected error to match pattern"`)
 }

typeutil/typeutil_test.go

@@ -17,19 +17,19 @@
 package typeutil_test
 
 import (
-	"errors"
 	"fmt"
 	"os"
 	"reflect"
 	"testing"
 	"unsafe"
 
+	"github.com/go-spring/stdlib/errutil"
 	"github.com/go-spring/stdlib/testing/assert"
 	"github.com/go-spring/stdlib/typeutil"
 )
 
 func TestIsErrorType(t *testing.T) {
-	err := errors.New("error")
+	err := errutil.Explain(nil, "error")
 	assert.That(t, typeutil.IsErrorType(reflect.TypeOf(err))).True()
 
 	err = os.ErrClosed
@@ -191,7 +191,7 @@ func TestIsBeanType(t *testing.T) {
 func TestIsBeanInjectionTarget(t *testing.T) {
 	assert.That(t, typeutil.IsBeanInjectionTarget(reflect.TypeFor[string]())).False()
 	assert.That(t, typeutil.IsBeanInjectionTarget(reflect.TypeFor[*string]())).False()
-	assert.That(t, typeutil.IsBeanInjectionTarget(reflect.TypeOf(errors.New("abc")))).True()
+	assert.That(t, typeutil.IsBeanInjectionTarget(reflect.TypeOf(errutil.Explain(nil, "abc")))).True()
 	assert.That(t, typeutil.IsBeanInjectionTarget(reflect.TypeFor[[]string]())).False()
 	assert.That(t, typeutil.IsBeanInjectionTarget(reflect.TypeFor[[]*string]())).False()
 	assert.That(t, typeutil.IsBeanInjectionTarget(reflect.TypeFor[[]fmt.Stringer]())).True()