Add golang.org/x/tools modernize static analyzer and fix violations (#15946)

* Ran gopls modernize to fix everything

go run golang.org/x/tools/gopls/internal/analysis/modernize/cmd/modernize@latest -fix -test ./...

* Override rules_go provided dependency for golang.org/x/tools to v0.38.0.

To update this, checked out rules_go, then ran `bazel run //go/tools/releaser -- upgrade-dep -mirror=false org_golang_x_tools` and copied the patches.

* Fix buildtag violations and ignore buildtag violations in external

* Introduce modernize analyzer package.

* Add modernize "any" analyzer.

* Fix violations of any analyzer

* Add modernize "appendclipped" analyzer.

* Fix violations of appendclipped

* Add modernize "bloop" analyzer.

* Add modernize "fmtappendf" analyzer.

* Add modernize "forvar" analyzer.

* Add modernize "mapsloop" analyzer.

* Add modernize "minmax" analyzer.

* Fix violations of minmax analyzer

* Add modernize "omitzero" analyzer.

* Add modernize "rangeint" analyzer.

* Fix violations of rangeint.

* Add modernize "reflecttypefor" analyzer.

* Fix violations of reflecttypefor analyzer.

* Add modernize "slicescontains" analyzer.

* Add modernize "slicessort" analyzer.

* Add modernize "slicesdelete" analyzer. This is disabled by default for now. See https://go.dev/issue/73686.

* Add modernize "stringscutprefix" analyzer.

* Add modernize "stringsbuilder" analyzer.

* Fix violations of stringsbuilder analyzer.

* Add modernize "stringsseq" analyzer.

* Add modernize "testingcontext" analyzer.

* Add modernize "waitgroup" analyzer.

* Changelog fragment

* gofmt

* gazelle

* Add modernize "newexpr" analyzer.

* Disable newexpr until go1.26

* Add more details in WORKSPACE on how to update the override

* @nalepae feedback on min()

* gofmt

* Fix violations of forvar

cache/lru/lru_wrpr.go

@@ -17,7 +17,7 @@ func New(size int) *lru.Cache {
 
 // NewWithEvict constructs a fixed size cache with the given eviction
 // callback.
-func NewWithEvict(size int, onEvicted func(key interface{}, value interface{})) *lru.Cache {
+func NewWithEvict(size int, onEvicted func(key any, value any)) *lru.Cache {
 	cache, err := lru.NewWithEvict(size, onEvicted)
 	if err != nil {
 		panic(fmt.Errorf("lru new with evict failed: %w", err)) // lint:nopanic -- This should never panic.

cache/lru/lru_wrpr_test.go

@@ -23,15 +23,15 @@ func TestNew_ZeroOrNegativeSize(t *testing.T) {
 
 func TestNewWithEvict(t *testing.T) {
 	assert.NotPanics(t, func() {
-		NewWithEvict(10, func(key interface{}, value interface{}) {})
+		NewWithEvict(10, func(key any, value any) {})
 	})
 }
 
 func TestNewWithEvict_ZeroOrNegativeSize(t *testing.T) {
 	assert.Panics(t, func() {
-		NewWithEvict(0, func(key interface{}, value interface{}) {})
+		NewWithEvict(0, func(key any, value any) {})
 	})
 	assert.Panics(t, func() {
-		NewWithEvict(-1, func(key interface{}, value interface{}) {})
+		NewWithEvict(-1, func(key any, value any) {})
 	})
 }

cache/nonblocking/lru.go

@@ -100,11 +100,8 @@ func (c *LRU[K, V]) Len() int {
 
 // Resize changes the cache size.
 func (c *LRU[K, V]) Resize(size int) (evicted int) {
-	diff := c.Len() - size
-	if diff < 0 {
-		diff = 0
-	}
-	for i := 0; i < diff; i++ {
+	diff := max(c.Len()-size, 0)
+	for range diff {
 		c.removeOldest()
 	}
 	c.size = size

cache/nonblocking/lru_test.go

@@ -18,7 +18,7 @@ func TestLRU_Concurrency(t *testing.T) {
 	}
 	ctx, cancel := context.WithTimeout(t.Context(), time.Second*2)
 	defer cancel()
-	for i := 0; i < 100; i++ {
+	for i := range 100 {
 		go func(j int) {
 			for {
 				if ctx.Err() != nil {
@@ -43,7 +43,7 @@ func TestLRU_Eviction(t *testing.T) {
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
-	for i := 0; i < 20; i++ {
+	for i := range 20 {
 		cache.Add(i, i)
 		cache.Get(i)
 	}