lint: enable 7 more linters (#686)

* lint: enable and fix perfsprint issues

* lint: enable and fix nolintlint issues

* lint: enable and fix godot issues

* lint: enable and fix thelper issues

* lint: enable and fix tparallel issues

* lint: enable and fix paralleltest issues

* lint: enable and fix predeclared issues

Author: NathanBaulch

.golangci.yml

@@ -30,6 +30,13 @@ linters:
     # - wsl_v5
     - testifylint
     - whitespace
+    - perfsprint
+    - nolintlint
+    - godot
+    - thelper
+    - tparallel
+    - paralleltest
+    - predeclared
 
   # disable noisy/controversial ones which you might enable later
   disable:

README.md

@@ -2143,7 +2143,7 @@ duration := lo.Duration0(func() {
 
 err, duration := lo.Duration1(func() error {
     // very long job
-    return fmt.Errorf("an error")
+    return errors.New("an error")
 })
 // an error
 // 3s
@@ -3752,7 +3752,7 @@ iter, err := lo.Attempt(42, func(i int) error {
         return nil
     }
 
-    return fmt.Errorf("failed")
+    return errors.New("failed")
 })
 // 6
 // nil
@@ -3762,14 +3762,14 @@ iter, err := lo.Attempt(2, func(i int) error {
         return nil
     }
 
-    return fmt.Errorf("failed")
+    return errors.New("failed")
 })
 // 2
 // error "failed"
 
 iter, err := lo.Attempt(0, func(i int) error {
     if i < 42 {
-        return fmt.Errorf("failed")
+        return errors.New("failed")
     }
 
     return nil
@@ -3794,7 +3794,7 @@ iter, duration, err := lo.AttemptWithDelay(5, 2*time.Second, func(i int, duratio
         return nil
     }
 
-    return fmt.Errorf("failed")
+    return errors.New("failed")
 })
 // 3
 // ~ 4 seconds
@@ -4045,7 +4045,7 @@ transaction := NewTransaction().
             fmt.Println("step 3")
 
             if true {
-                return state, fmt.Errorf("error")
+                return state, errors.New("error")
             }
 
             return state + 42, nil
@@ -4239,7 +4239,7 @@ ok := lo.Try(func() error {
 // true
 
 ok := lo.Try(func() error {
-    return fmt.Errorf("error")
+    return errors.New("error")
 })
 // false
 ```
@@ -4279,7 +4279,7 @@ str, ok := lo.TryOr(func() error {
 // true
 
 str, ok := lo.TryOr(func() error {
-    return "hello", fmt.Errorf("error")
+    return "hello", errors.New("error")
 }, "world")
 // world
 // false

channel.go

@@ -145,8 +145,8 @@ func DispatchingStrategyFirst[T any](msg T, index uint64, channels []<-chan T) i
 func DispatchingStrategyLeast[T any](msg T, index uint64, channels []<-chan T) int {
 	seq := Range(len(channels))
 
-	return MinBy(seq, func(item int, min int) bool {
-		return len(channels[item]) < len(channels[min])
+	return MinBy(seq, func(item int, mIn int) bool {
+		return len(channels[item]) < len(channels[mIn])
 	})
 }
 
@@ -156,8 +156,8 @@ func DispatchingStrategyLeast[T any](msg T, index uint64, channels []<-chan T) i
 func DispatchingStrategyMost[T any](msg T, index uint64, channels []<-chan T) int {
 	seq := Range(len(channels))
 
-	return MaxBy(seq, func(item int, max int) bool {
-		return len(channels[item]) > len(channels[max]) && channelIsNotFull(channels[item])
+	return MaxBy(seq, func(item int, mAx int) bool {
+		return len(channels[item]) > len(channels[mAx]) && channelIsNotFull(channels[item])
 	})
 }
 

channel_test.go

@@ -113,6 +113,7 @@ func TestDispatchingStrategyRoundRobin(t *testing.T) {
 }
 
 func TestDispatchingStrategyRandom(t *testing.T) {
+	t.Parallel()
 	testWithTimeout(t, 10*time.Millisecond)
 	is := assert.New(t)
 

condition_test.go

@@ -18,6 +18,7 @@ func TestTernary(t *testing.T) {
 }
 
 func TestTernaryF(t *testing.T) {
+	t.Parallel()
 	is := assert.New(t)
 
 	result1 := TernaryF(true, func() string { return "a" }, func() string { return "b" })

errors_example_test.go

@@ -1,6 +1,7 @@
 package lo
 
 import (
+	"errors"
 	"fmt"
 )
 
@@ -31,10 +32,10 @@ func ExampleMust() {
 	Must(cb())
 
 	// will panic
-	Must(42, fmt.Errorf("my error"))
+	Must(42, errors.New("my error"))
 
 	// will panic with error message
-	Must(42, fmt.Errorf("world"), "hello")
+	Must(42, errors.New("world"), "hello")
 }
 
 func ExampleMust0() {
@@ -46,10 +47,10 @@ func ExampleMust0() {
 	Must0(nil)
 
 	// will panic
-	Must0(fmt.Errorf("my error"))
+	Must0(errors.New("my error"))
 
 	// will panic with error message
-	Must0(fmt.Errorf("world"), "hello")
+	Must0(errors.New("world"), "hello")
 }
 
 func ExampleMust1() {
@@ -67,10 +68,10 @@ func ExampleMust1() {
 	Must1(cb())
 
 	// will panic
-	Must1(42, fmt.Errorf("my error"))
+	Must1(42, errors.New("my error"))
 
 	// will panic with error message
-	Must1(42, fmt.Errorf("world"), "hello")
+	Must1(42, errors.New("world"), "hello")
 }
 
 func ExampleMust2() {
@@ -82,10 +83,10 @@ func ExampleMust2() {
 	Must2(42, "hello", nil)
 
 	// will panic
-	Must2(42, "hello", fmt.Errorf("my error"))
+	Must2(42, "hello", errors.New("my error"))
 
 	// will panic with error message
-	Must2(42, "hello", fmt.Errorf("world"), "hello")
+	Must2(42, "hello", errors.New("world"), "hello")
 }
 
 func ExampleMust3() {
@@ -97,10 +98,10 @@ func ExampleMust3() {
 	Must3(42, "hello", 4.2, nil)
 
 	// will panic
-	Must3(42, "hello", 4.2, fmt.Errorf("my error"))
+	Must3(42, "hello", 4.2, errors.New("my error"))
 
 	// will panic with error message
-	Must3(42, "hello", 4.2, fmt.Errorf("world"), "hello")
+	Must3(42, "hello", 4.2, errors.New("world"), "hello")
 }
 
 func ExampleMust4() {
@@ -112,10 +113,10 @@ func ExampleMust4() {
 	Must4(42, "hello", 4.2, true, nil)
 
 	// will panic
-	Must4(42, "hello", 4.2, true, fmt.Errorf("my error"))
+	Must4(42, "hello", 4.2, true, errors.New("my error"))
 
 	// will panic with error message
-	Must4(42, "hello", 4.2, true, fmt.Errorf("world"), "hello")
+	Must4(42, "hello", 4.2, true, errors.New("world"), "hello")
 }
 
 func ExampleMust5() {
@@ -127,10 +128,10 @@ func ExampleMust5() {
 	Must5(42, "hello", 4.2, true, foo{}, nil)
 
 	// will panic
-	Must5(42, "hello", 4.2, true, foo{}, fmt.Errorf("my error"))
+	Must5(42, "hello", 4.2, true, foo{}, errors.New("my error"))
 
 	// will panic with error message
-	Must5(42, "hello", 4.2, true, foo{}, fmt.Errorf("world"), "hello")
+	Must5(42, "hello", 4.2, true, foo{}, errors.New("world"), "hello")
 }
 
 func ExampleMust6() {
@@ -142,18 +143,18 @@ func ExampleMust6() {
 	Must5(42, "hello", 4.2, true, foo{}, "foobar", nil)
 
 	// will panic
-	Must5(42, "hello", 4.2, true, foo{}, "foobar", fmt.Errorf("my error"))
+	Must5(42, "hello", 4.2, true, foo{}, "foobar", errors.New("my error"))
 
 	// will panic with error message
-	Must5(42, "hello", 4.2, true, foo{}, "foobar", fmt.Errorf("world"), "hello")
+	Must5(42, "hello", 4.2, true, foo{}, "foobar", errors.New("world"), "hello")
 }
 
 func ExampleTry() {
 	ok1 := Try(func() error {
 		return nil
 	})
 	ok2 := Try(func() error {
-		return fmt.Errorf("my error")
+		return errors.New("my error")
 	})
 	ok3 := Try(func() error {
 		panic("my error")
@@ -173,7 +174,7 @@ func ExampleTry1() {
 		return nil
 	})
 	ok2 := Try1(func() error {
-		return fmt.Errorf("my error")
+		return errors.New("my error")
 	})
 	ok3 := Try1(func() error {
 		panic("my error")
@@ -193,7 +194,7 @@ func ExampleTry2() {
 		return 42, nil
 	})
 	ok2 := Try2(func() (int, error) {
-		return 42, fmt.Errorf("my error")
+		return 42, errors.New("my error")
 	})
 	ok3 := Try2(func() (int, error) {
 		panic("my error")
@@ -213,7 +214,7 @@ func ExampleTry3() {
 		return 42, "foobar", nil
 	})
 	ok2 := Try3(func() (int, string, error) {
-		return 42, "foobar", fmt.Errorf("my error")
+		return 42, "foobar", errors.New("my error")
 	})
 	ok3 := Try3(func() (int, string, error) {
 		panic("my error")
@@ -233,7 +234,7 @@ func ExampleTry4() {
 		return 42, "foobar", 4.2, nil
 	})
 	ok2 := Try4(func() (int, string, float64, error) {
-		return 42, "foobar", 4.2, fmt.Errorf("my error")
+		return 42, "foobar", 4.2, errors.New("my error")
 	})
 	ok3 := Try4(func() (int, string, float64, error) {
 		panic("my error")
@@ -253,7 +254,7 @@ func ExampleTry5() {
 		return 42, "foobar", 4.2, true, nil
 	})
 	ok2 := Try5(func() (int, string, float64, bool, error) {
-		return 42, "foobar", 4.2, true, fmt.Errorf("my error")
+		return 42, "foobar", 4.2, true, errors.New("my error")
 	})
 	ok3 := Try5(func() (int, string, float64, bool, error) {
 		panic("my error")
@@ -273,7 +274,7 @@ func ExampleTry6() {
 		return 42, "foobar", 4.2, true, foo{}, nil
 	})
 	ok2 := Try6(func() (int, string, float64, bool, foo, error) {
-		return 42, "foobar", 4.2, true, foo{}, fmt.Errorf("my error")
+		return 42, "foobar", 4.2, true, foo{}, errors.New("my error")
 	})
 	ok3 := Try6(func() (int, string, float64, bool, foo, error) {
 		panic("my error")
@@ -293,7 +294,7 @@ func ExampleTryOr() {
 		return 42, nil
 	}, 21)
 	value2, ok2 := TryOr(func() (int, error) {
-		return 42, fmt.Errorf("my error")
+		return 42, errors.New("my error")
 	}, 21)
 	value3, ok3 := TryOr(func() (int, error) {
 		panic("my error")
@@ -313,7 +314,7 @@ func ExampleTryOr1() {
 		return 42, nil
 	}, 21)
 	value2, ok2 := TryOr1(func() (int, error) {
-		return 42, fmt.Errorf("my error")
+		return 42, errors.New("my error")
 	}, 21)
 	value3, ok3 := TryOr1(func() (int, error) {
 		panic("my error")
@@ -378,7 +379,7 @@ func ExampleTryWithErrorValue() {
 		return nil
 	})
 	err2, ok2 := TryWithErrorValue(func() error {
-		return fmt.Errorf("my error")
+		return errors.New("my error")
 	})
 	err3, ok3 := TryWithErrorValue(func() error {
 		panic("my error")

errors_test.go

@@ -2,13 +2,13 @@ package lo
 
 import (
 	"errors"
-	"fmt"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
 )
 
 func TestValidate(t *testing.T) {
+	t.Parallel()
 	is := assert.New(t)
 
 	slice := []string{"a"}
@@ -264,7 +264,7 @@ func TestTry(t *testing.T) {
 		return nil
 	}))
 	is.False(Try(func() error {
-		return fmt.Errorf("fail")
+		return errors.New("fail")
 	}))
 }
 
@@ -587,7 +587,7 @@ func TestErrorsAs(t *testing.T) {
 	t.Parallel()
 	is := assert.New(t)
 
-	err, ok := ErrorsAs[*internalError](fmt.Errorf("hello world"))
+	err, ok := ErrorsAs[*internalError](errors.New("hello world"))
 	is.False(ok)
 	is.Nil(err)