rangeint.go

     1  // Copyright 2025 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package modernize
     6  
     7  import (
     8  	"fmt"
     9  	"go/ast"
    10  	"go/token"
    11  	"go/types"
    12  
    13  	"golang.org/x/tools/go/analysis"
    14  	"golang.org/x/tools/go/analysis/passes/inspect"
    15  	"golang.org/x/tools/go/ast/edge"
    16  	"golang.org/x/tools/go/ast/inspector"
    17  	"golang.org/x/tools/go/types/typeutil"
    18  	"golang.org/x/tools/internal/analysis/analyzerutil"
    19  	typeindexanalyzer "golang.org/x/tools/internal/analysis/typeindex"
    20  	"golang.org/x/tools/internal/astutil"
    21  	"golang.org/x/tools/internal/typesinternal"
    22  	"golang.org/x/tools/internal/typesinternal/typeindex"
    23  	"golang.org/x/tools/internal/versions"
    24  )
    25  
    26  var RangeIntAnalyzer = &analysis.Analyzer{
    27  	Name: "rangeint",
    28  	Doc:  analyzerutil.MustExtractDoc(doc, "rangeint"),
    29  	Requires: []*analysis.Analyzer{
    30  		inspect.Analyzer,
    31  		typeindexanalyzer.Analyzer,
    32  	},
    33  	Run: rangeint,
    34  	URL: "https://pkg.go.dev/golang.org/x/tools/go/analysis/passes/modernize#rangeint",
    35  }
    36  
    37  // rangeint offers a fix to replace a 3-clause 'for' loop:
    38  //
    39  //	for i := 0; i < limit; i++ {}
    40  //
    41  // by a range loop with an integer operand:
    42  //
    43  //	for i := range limit {}
    44  //
    45  // Variants:
    46  //   - The ':=' may be replaced by '='.
    47  //   - The fix may remove "i :=" if it would become unused.
    48  //
    49  // Restrictions:
    50  //   - The variable i must not be assigned or address-taken within the
    51  //     loop, because a "for range int" loop does not respect assignments
    52  //     to the loop index.
    53  //   - The limit must not be b.N, to avoid redundancy with bloop's fixes.
    54  //
    55  // Caveats:
    56  //
    57  // The fix causes the limit expression to be evaluated exactly once,
    58  // instead of once per iteration. So, to avoid changing the
    59  // cardinality of side effects, the limit expression must not involve
    60  // function calls (e.g. seq.Len()) or channel receives. Moreover, the
    61  // value of the limit expression must be loop invariant, which in
    62  // practice means it must take one of the following forms:
    63  //
    64  //   - a local variable that is assigned only once and not address-taken;
    65  //   - a constant; or
    66  //   - len(s), where s has the above properties.
    67  func rangeint(pass *analysis.Pass) (any, error) {
    68  	var (
    69  		info      = pass.TypesInfo
    70  		typeindex = pass.ResultOf[typeindexanalyzer.Analyzer].(*typeindex.Index)
    71  	)
    72  
    73  	for curFile := range filesUsingGoVersion(pass, versions.Go1_22) {
    74  	nextLoop:
    75  		for curLoop := range curFile.Preorder((*ast.ForStmt)(nil)) {
    76  			loop := curLoop.Node().(*ast.ForStmt)
    77  			if init, ok := loop.Init.(*ast.AssignStmt); ok &&
    78  				isSimpleAssign(init) &&
    79  				is[*ast.Ident](init.Lhs[0]) &&
    80  				isZeroIntConst(info, init.Rhs[0]) {
    81  				// Have: for i = 0; ... (or i := 0)
    82  				index := init.Lhs[0].(*ast.Ident)
    83  
    84  				if compare, ok := loop.Cond.(*ast.BinaryExpr); ok &&
    85  					compare.Op == token.LSS &&
    86  					astutil.EqualSyntax(compare.X, init.Lhs[0]) {
    87  					// Have: for i = 0; i < limit; ... {}
    88  
    89  					limit := compare.Y
    90  
    91  					// If limit is "len(slice)", simplify it to "slice".
    92  					//
    93  					// (Don't replace "for i := 0; i < len(map); i++"
    94  					// with "for range m" because it's too hard to prove
    95  					// that len(m) is loop-invariant).
    96  					if call, ok := limit.(*ast.CallExpr); ok &&
    97  						typeutil.Callee(info, call) == builtinLen &&
    98  						is[*types.Slice](info.TypeOf(call.Args[0]).Underlying()) {
    99  						limit = call.Args[0]
   100  					}
   101  
   102  					// Check the form of limit: must be a constant,
   103  					// or a local var that is not assigned or address-taken.
   104  					limitOK := false
   105  					if info.Types[limit].Value != nil {
   106  						limitOK = true // constant
   107  					} else if id, ok := limit.(*ast.Ident); ok {
   108  						if v, ok := info.Uses[id].(*types.Var); ok &&
   109  							!(v.Exported() && typesinternal.IsPackageLevel(v)) {
   110  							// limit is a local or unexported global var.
   111  							// (An exported global may have uses we can't see.)
   112  							for cur := range typeindex.Uses(v) {
   113  								if isScalarLvalue(info, cur) {
   114  									// Limit var is assigned or address-taken.
   115  									continue nextLoop
   116  								}
   117  							}
   118  							limitOK = true
   119  						}
   120  					}
   121  					if !limitOK {
   122  						continue nextLoop
   123  					}
   124  
   125  					if inc, ok := loop.Post.(*ast.IncDecStmt); ok &&
   126  						inc.Tok == token.INC &&
   127  						astutil.EqualSyntax(compare.X, inc.X) {
   128  						// Have: for i = 0; i < limit; i++ {}
   129  
   130  						// Find references to i within the loop body.
   131  						v := info.ObjectOf(index).(*types.Var)
   132  						// TODO(adonovan): use go1.25 v.Kind() == types.PackageVar
   133  						if typesinternal.IsPackageLevel(v) {
   134  							continue nextLoop
   135  						}
   136  						used := false
   137  						for curId := range curLoop.Child(loop.Body).Preorder((*ast.Ident)(nil)) {
   138  							id := curId.Node().(*ast.Ident)
   139  							if info.Uses[id] == v {
   140  								used = true
   141  
   142  								// Reject if any is an l-value (assigned or address-taken):
   143  								// a "for range int" loop does not respect assignments to
   144  								// the loop variable.
   145  								if isScalarLvalue(info, curId) {
   146  									continue nextLoop
   147  								}
   148  							}
   149  						}
   150  
   151  						// If i is no longer used, delete "i := ".
   152  						var edits []analysis.TextEdit
   153  						if !used && init.Tok == token.DEFINE {
   154  							edits = append(edits, analysis.TextEdit{
   155  								Pos: index.Pos(),
   156  								End: init.Rhs[0].Pos(),
   157  							})
   158  						}
   159  
   160  						// If i is used after the loop,
   161  						// don't offer a fix, as a range loop
   162  						// leaves i with a different final value (limit-1).
   163  						if init.Tok == token.ASSIGN {
   164  							// Find the nearest ancestor that is not a label.
   165  							// Otherwise, checking for i usage outside of a for
   166  							// loop might not function properly further below.
   167  							// This is because the i usage might be a child of
   168  							// the loop's parent's parent, for example:
   169  							//     var i int
   170  							// Loop:
   171  							//     for i = 0; i < 10; i++ { break loop }
   172  							//     // i is in the sibling of the label, not the loop
   173  							//     fmt.Println(i)
   174  							//
   175  							ancestor := curLoop.Parent()
   176  							for is[*ast.LabeledStmt](ancestor.Node()) {
   177  								ancestor = ancestor.Parent()
   178  							}
   179  							for curId := range ancestor.Preorder((*ast.Ident)(nil)) {
   180  								id := curId.Node().(*ast.Ident)
   181  								if info.Uses[id] == v {
   182  									// Is i used after loop?
   183  									if id.Pos() > loop.End() {
   184  										continue nextLoop
   185  									}
   186  									// Is i used within a defer statement
   187  									// that is within the scope of i?
   188  									//     var i int
   189  									//     defer func() { print(i)}
   190  									//     for i = ... { ... }
   191  									for curDefer := range curId.Enclosing((*ast.DeferStmt)(nil)) {
   192  										if curDefer.Node().Pos() > v.Pos() {
   193  											continue nextLoop
   194  										}
   195  									}
   196  								}
   197  							}
   198  						}
   199  
   200  						// If limit is len(slice),
   201  						// simplify "range len(slice)" to "range slice".
   202  						if call, ok := limit.(*ast.CallExpr); ok &&
   203  							typeutil.Callee(info, call) == builtinLen &&
   204  							is[*types.Slice](info.TypeOf(call.Args[0]).Underlying()) {
   205  							limit = call.Args[0]
   206  						}
   207  
   208  						// If the limit is a untyped constant of non-integer type,
   209  						// such as "const limit = 1e3", its effective type may
   210  						// differ between the two forms.
   211  						// In a for loop, it must be comparable with int i,
   212  						//    for i := 0; i < limit; i++ {}
   213  						// but in a range loop it would become a float,
   214  						//    for i := range limit {}
   215  						// which is a type error. We need to convert it to int
   216  						// in this case.
   217  						//
   218  						// Unfortunately go/types discards the untyped type
   219  						// (but see Untyped in golang/go#70638) so we must
   220  						// re-type check the expression to detect this case.
   221  						var beforeLimit, afterLimit string
   222  						if v := info.Types[limit].Value; v != nil {
   223  							tVar := info.TypeOf(init.Rhs[0])
   224  							file := curFile.Node().(*ast.File)
   225  							// TODO(mkalil): use a types.Qualifier that respects the existing
   226  							// imports of this file that are visible (not shadowed) at the current position.
   227  							qual := typesinternal.FileQualifier(file, pass.Pkg)
   228  							beforeLimit, afterLimit = fmt.Sprintf("%s(", types.TypeString(tVar, qual)), ")"
   229  							info2 := &types.Info{Types: make(map[ast.Expr]types.TypeAndValue)}
   230  							if types.CheckExpr(pass.Fset, pass.Pkg, limit.Pos(), limit, info2) == nil {
   231  								tLimit := info2.TypeOf(limit)
   232  								// Eliminate conversion when safe.
   233  								//
   234  								// Redundant conversions are not only unsightly but may in some cases cause
   235  								// architecture-specific types (e.g. syscall.Timespec.Nsec) to be inserted
   236  								// into otherwise portable files.
   237  								//
   238  								// The operand must have an integer type (not, say, '1e6')
   239  								// even when assigning to an existing integer variable.
   240  								if isInteger(tLimit) {
   241  									// When declaring a new var from an untyped limit,
   242  									// the limit's default type is what matters.
   243  									if init.Tok != token.ASSIGN {
   244  										tLimit = types.Default(tLimit)
   245  									}
   246  									if types.AssignableTo(tLimit, tVar) {
   247  										beforeLimit, afterLimit = "", ""
   248  									}
   249  								}
   250  							}
   251  						}
   252  
   253  						pass.Report(analysis.Diagnostic{
   254  							Pos:     init.Pos(),
   255  							End:     inc.End(),
   256  							Message: "for loop can be modernized using range over int",
   257  							SuggestedFixes: []analysis.SuggestedFix{{
   258  								Message: fmt.Sprintf("Replace for loop with range %s",
   259  									astutil.Format(pass.Fset, limit)),
   260  								TextEdits: append(edits, []analysis.TextEdit{
   261  									// for i := 0; i < limit; i++ {}
   262  									//     -----              ---
   263  									//          -------
   264  									// for i := range  limit      {}
   265  
   266  									// Delete init.
   267  									{
   268  										Pos:     init.Rhs[0].Pos(),
   269  										End:     limit.Pos(),
   270  										NewText: []byte("range "),
   271  									},
   272  									// Add "int(" before limit, if needed.
   273  									{
   274  										Pos:     limit.Pos(),
   275  										End:     limit.Pos(),
   276  										NewText: []byte(beforeLimit),
   277  									},
   278  									// Delete inc.
   279  									{
   280  										Pos: limit.End(),
   281  										End: inc.End(),
   282  									},
   283  									// Add ")" after limit, if needed.
   284  									{
   285  										Pos:     limit.End(),
   286  										End:     limit.End(),
   287  										NewText: []byte(afterLimit),
   288  									},
   289  								}...),
   290  							}},
   291  						})
   292  					}
   293  				}
   294  			}
   295  		}
   296  	}
   297  	return nil, nil
   298  }
   299  
   300  // isScalarLvalue reports whether the specified identifier is
   301  // address-taken or appears on the left side of an assignment.
   302  //
   303  // This function is valid only for scalars (x = ...),
   304  // not for aggregates (x.a[i] = ...)
   305  func isScalarLvalue(info *types.Info, curId inspector.Cursor) bool {
   306  	// Unfortunately we can't simply use info.Types[e].Assignable()
   307  	// as it is always true for a variable even when that variable is
   308  	// used only as an r-value. So we must inspect enclosing syntax.
   309  
   310  	cur := curId
   311  
   312  	// Strip enclosing parens.
   313  	ek, _ := cur.ParentEdge()
   314  	for ek == edge.ParenExpr_X {
   315  		cur = cur.Parent()
   316  		ek, _ = cur.ParentEdge()
   317  	}
   318  
   319  	switch ek {
   320  	case edge.AssignStmt_Lhs:
   321  		assign := cur.Parent().Node().(*ast.AssignStmt)
   322  		if assign.Tok != token.DEFINE {
   323  			return true // i = j or i += j
   324  		}
   325  		id := curId.Node().(*ast.Ident)
   326  		if v, ok := info.Defs[id]; ok && v.Pos() != id.Pos() {
   327  			return true // reassignment of i (i, j := 1, 2)
   328  		}
   329  	case edge.RangeStmt_Key:
   330  		rng := cur.Parent().Node().(*ast.RangeStmt)
   331  		if rng.Tok == token.ASSIGN {
   332  			return true // "for k, v = range x" is like an AssignStmt to k, v
   333  		}
   334  	case edge.IncDecStmt_X:
   335  		return true // i++, i--
   336  	case edge.UnaryExpr_X:
   337  		if cur.Parent().Node().(*ast.UnaryExpr).Op == token.AND {
   338  			return true // &i
   339  		}
   340  	}
   341  	return false
   342  }
   343  
   344  func isInteger(t types.Type) bool {
   345  	basic, ok := t.Underlying().(*types.Basic)
   346  	return ok && basic.Info()&types.IsInteger != 0
   347  }
   348
View as plain text