go/analysis/passes/modernize: modernizer for iterator APIs

This CL adds the stditerators modernizer, which replaces loops
of the form

  for i := 0; i < x.Len(); i++ {
      use(x.At(i))
  }

or their "range x.Len()" equivalent by

  for elem := range x.All() {
      use(x.At(i)
  }

for various well-known std types.

Publishing each new Analyzer symbol requires going through the
proposal process, so we plan to do them in one batch per Go
release. In the interim, we cannot make such symbols public,
so we use a backdoor mechanism to export them to gopls.

+ test, doc, relnote

Updates golang/go#75693

Change-Id: I3accd1925ad990b84500a9e77c3c589aeaeabfb0
Reviewed-on: https://go-review.googlesource.com/c/tools/+/708775
Reviewed-by: Robert Findley <rfindley@google.com>
Auto-Submit: Alan Donovan <adonovan@google.com>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>

Author: adonovan

go/analysis/passes/modernize/bloop.go

@@ -117,15 +117,8 @@ func bloop(pass *analysis.Pass) (any, error) {
 						//    ...no references to i...
 						//  }
 						body, _ := curLoop.LastChild()
-						if assign, ok := n.Init.(*ast.AssignStmt); ok &&
-							assign.Tok == token.DEFINE &&
-							len(assign.Rhs) == 1 &&
-							isZeroIntLiteral(info, assign.Rhs[0]) &&
-							is[*ast.IncDecStmt](n.Post) &&
-							n.Post.(*ast.IncDecStmt).Tok == token.INC &&
-							equalSyntax(n.Post.(*ast.IncDecStmt).X, assign.Lhs[0]) &&
-							!uses(index, body, info.Defs[assign.Lhs[0].(*ast.Ident)]) {
-
+						if v := isIncrementLoop(info, n); v != nil &&
+							!uses(index, body, v) {
 							delStart, delEnd = n.Init.Pos(), n.Post.End()
 						}
 
@@ -238,3 +231,18 @@ func isBenchmarkFunc(f *ast.FuncDecl) bool {
 		f.Type.Params != nil &&
 		len(f.Type.Params.List) == 1
 }
+
+// isIncrementLoop reports whether loop has the form "for i := 0; ...; i++ { ... }",
+// and if so, it returns the symbol for the index variable.
+func isIncrementLoop(info *types.Info, loop *ast.ForStmt) *types.Var {
+	if assign, ok := loop.Init.(*ast.AssignStmt); ok &&
+		assign.Tok == token.DEFINE &&
+		len(assign.Rhs) == 1 &&
+		isZeroIntLiteral(info, assign.Rhs[0]) &&
+		is[*ast.IncDecStmt](loop.Post) &&
+		loop.Post.(*ast.IncDecStmt).Tok == token.INC &&
+		equalSyntax(loop.Post.(*ast.IncDecStmt).X, assign.Lhs[0]) {
+		return info.Defs[assign.Lhs[0].(*ast.Ident)].(*types.Var)
+	}
+	return nil
+}

go/analysis/passes/modernize/doc.go

@@ -270,6 +270,25 @@ types. It replaces
 
 with the simpler `slices.Sort(s)`, which was added in Go 1.21.
 
+# Analyzer stditerators
+
+stditerators: use iterators instead of Len/At-style APIs
+
+This analyzer suggests a fix to replace each loop of the form:
+
+	for i := 0; i < x.Len(); i++ {
+		use(x.At(i))
+	}
+
+or its "for elem := range x.Len()" equivalent by a range loop over an
+iterator offered by the same data type:
+
+	for elem := range x.All() {
+		use(x.At(i)
+	}
+
+where x is one of various well-known types in the standard library.
+
 # Analyzer stringscutprefix
 
 stringscutprefix: replace HasPrefix/TrimPrefix with CutPrefix

go/analysis/passes/modernize/modernize.go

@@ -45,6 +45,7 @@ var Suite = []*analysis.Analyzer{
 	SlicesContainsAnalyzer,
 	// SlicesDeleteAnalyzer, // not nil-preserving!
 	SlicesSortAnalyzer,
+	stditeratorsAnalyzer,
 	StringsCutPrefixAnalyzer,
 	StringsSeqAnalyzer,
 	StringsBuilderAnalyzer,

go/analysis/passes/modernize/modernize_test.go

@@ -9,6 +9,7 @@ import (
 
 	. "golang.org/x/tools/go/analysis/analysistest"
 	"golang.org/x/tools/go/analysis/passes/modernize"
+	"golang.org/x/tools/internal/goplsexport"
 )
 
 func TestAppendClipped(t *testing.T) {
@@ -31,6 +32,10 @@ func TestForVar(t *testing.T) {
 	RunWithSuggestedFixes(t, TestData(), modernize.ForVarAnalyzer, "forvar")
 }
 
+func TestStdIterators(t *testing.T) {
+	RunWithSuggestedFixes(t, TestData(), goplsexport.StdIteratorsModernizer, "stditerators")
+}
+
 func TestMapsLoop(t *testing.T) {
 	RunWithSuggestedFixes(t, TestData(), modernize.MapsLoopAnalyzer, "mapsloop")
 }