stringscut.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/constant"
    11  	"go/token"
    12  	"go/types"
    13  	"iter"
    14  	"strconv"
    15  
    16  	"golang.org/x/tools/go/analysis"
    17  	"golang.org/x/tools/go/analysis/passes/inspect"
    18  	"golang.org/x/tools/go/ast/edge"
    19  	"golang.org/x/tools/go/ast/inspector"
    20  	"golang.org/x/tools/go/types/typeutil"
    21  	"golang.org/x/tools/internal/analysis/analyzerutil"
    22  	typeindexanalyzer "golang.org/x/tools/internal/analysis/typeindex"
    23  	"golang.org/x/tools/internal/astutil"
    24  	"golang.org/x/tools/internal/goplsexport"
    25  	"golang.org/x/tools/internal/refactor"
    26  	"golang.org/x/tools/internal/typesinternal"
    27  	"golang.org/x/tools/internal/typesinternal/typeindex"
    28  	"golang.org/x/tools/internal/versions"
    29  )
    30  
    31  var stringscutAnalyzer = &analysis.Analyzer{
    32  	Name: "stringscut",
    33  	Doc:  analyzerutil.MustExtractDoc(doc, "stringscut"),
    34  	Requires: []*analysis.Analyzer{
    35  		inspect.Analyzer,
    36  		typeindexanalyzer.Analyzer,
    37  	},
    38  	Run: stringscut,
    39  	URL: "https://pkg.go.dev/golang.org/x/tools/go/analysis/passes/modernize#stringscut",
    40  }
    41  
    42  func init() {
    43  	// Export to gopls until this is a published modernizer.
    44  	goplsexport.StringsCutModernizer = stringscutAnalyzer
    45  }
    46  
    47  // stringscut offers a fix to replace an occurrence of strings.Index{,Byte} with
    48  // strings.{Cut,Contains}, and similar fixes for functions in the bytes package.
    49  // Consider some candidate for replacement i := strings.Index(s, substr).
    50  // The following must hold for a replacement to occur:
    51  //
    52  //  1. All instances of i and s must be in one of these forms.
    53  //
    54  //     Binary expressions must be inequalities equivalent to
    55  //     "Index failed" (e.g. i < 0) or "Index succeeded" (i >= 0),
    56  //     or identities such as these (and their negations):
    57  //
    58  //     0 > i                 (flips left and right)
    59  //     i <= -1, -1 >= i      (replace strict inequality by non-strict)
    60  //     i == -1, -1 == i      (Index() guarantees i < 0 => i == -1)
    61  //
    62  //     Slice expressions:
    63  //     a: s[:i], s[0:i]
    64  //     b: s[i+len(substr):], s[len(substr) + i:], s[i + const], s[k + i] (where k = len(substr))
    65  //
    66  //  2. There can be no uses of s, substr, or i where they are
    67  //     potentially modified (i.e. in assignments, or function calls with unknown side
    68  //     effects).
    69  //
    70  // Then, the replacement involves the following substitutions:
    71  //
    72  //  1. Replace "i := strings.Index(s, substr)" with "before, after, ok := strings.Cut(s, substr)"
    73  //
    74  //  2. Replace instances of binary expressions (a) with !ok and binary expressions (b) with ok.
    75  //
    76  //  3. Replace slice expressions (a) with "before" and slice expressions (b) with after.
    77  //
    78  //  4. The assignments to before, after, and ok may use the blank identifier "_" if they are unused.
    79  //
    80  //     For example:
    81  //
    82  //     i := strings.Index(s, substr)
    83  //     if i >= 0 {
    84  //     use(s[:i], s[i+len(substr):])
    85  //     }
    86  //
    87  //     Would become:
    88  //
    89  //     before, after, ok := strings.Cut(s, substr)
    90  //     if ok {
    91  //     use(before, after)
    92  //     }
    93  //
    94  // If the condition involving `i` is equivalent to i >= 0, then we replace it with
    95  // `if ok“.
    96  // If the condition is negated (e.g. equivalent to `i < 0`), we use `if !ok` instead.
    97  // If the slices of `s` match `s[:i]` or `s[i+len(substr):]` or their variants listed above,
    98  // then we replace them with before and after.
    99  //
   100  // When the index `i` is used only to check for the presence of the substring or byte slice,
   101  // the suggested fix uses Contains() instead of Cut.
   102  //
   103  // For example:
   104  //
   105  //	i := strings.Index(s, substr)
   106  //	if i >= 0 {
   107  //		return
   108  //	}
   109  //
   110  // Would become:
   111  //
   112  //	found := strings.Contains(s, substr)
   113  //	if found {
   114  //		return
   115  //	}
   116  func stringscut(pass *analysis.Pass) (any, error) {
   117  	var (
   118  		index = pass.ResultOf[typeindexanalyzer.Analyzer].(*typeindex.Index)
   119  		info  = pass.TypesInfo
   120  
   121  		stringsIndex     = index.Object("strings", "Index")
   122  		stringsIndexByte = index.Object("strings", "IndexByte")
   123  		bytesIndex       = index.Object("bytes", "Index")
   124  		bytesIndexByte   = index.Object("bytes", "IndexByte")
   125  	)
   126  
   127  	for _, obj := range []types.Object{
   128  		stringsIndex,
   129  		stringsIndexByte,
   130  		bytesIndex,
   131  		bytesIndexByte,
   132  	} {
   133  		// (obj may be nil)
   134  	nextcall:
   135  		for curCall := range index.Calls(obj) {
   136  			// Check file version.
   137  			if !analyzerutil.FileUsesGoVersion(pass, astutil.EnclosingFile(curCall), versions.Go1_18) {
   138  				continue // strings.Index not available in this file
   139  			}
   140  			indexCall := curCall.Node().(*ast.CallExpr) // the call to strings.Index, etc.
   141  			obj := typeutil.Callee(info, indexCall)
   142  			if obj == nil {
   143  				continue
   144  			}
   145  
   146  			var iIdent *ast.Ident // defining identifier of i var
   147  			switch ek, idx := curCall.ParentEdge(); ek {
   148  			case edge.ValueSpec_Values:
   149  				// Have: var i = strings.Index(...)
   150  				curName := curCall.Parent().ChildAt(edge.ValueSpec_Names, idx)
   151  				iIdent = curName.Node().(*ast.Ident)
   152  			case edge.AssignStmt_Rhs:
   153  				// Have: i := strings.Index(...)
   154  				// (Must be i's definition.)
   155  				curLhs := curCall.Parent().ChildAt(edge.AssignStmt_Lhs, idx)
   156  				iIdent, _ = curLhs.Node().(*ast.Ident) // may be nil
   157  			}
   158  
   159  			if iIdent == nil {
   160  				continue
   161  			}
   162  			// Inv: iIdent is i's definition. The following would be skipped: 'var i int; i = strings.Index(...)'
   163  			// Get uses of i.
   164  			iObj := info.ObjectOf(iIdent)
   165  			if iObj == nil {
   166  				continue
   167  			}
   168  
   169  			var (
   170  				s      = indexCall.Args[0]
   171  				substr = indexCall.Args[1]
   172  			)
   173  
   174  			// Check that there are no statements that alter the value of s
   175  			// or substr after the call to Index().
   176  			if !indexArgValid(info, index, s, indexCall.Pos()) ||
   177  				!indexArgValid(info, index, substr, indexCall.Pos()) {
   178  				continue nextcall
   179  			}
   180  
   181  			// Next, examine all uses of i. If the only uses are of the
   182  			// forms mentioned above (e.g. i < 0, i >= 0, s[:i] and s[i +
   183  			// len(substr)]), then we can replace the call to Index()
   184  			// with a call to Cut() and use the returned ok, before,
   185  			// and after variables accordingly.
   186  			negative, nonnegative, beforeSlice, afterSlice := checkIdxUses(pass.TypesInfo, index.Uses(iObj), s, substr)
   187  
   188  			// Either there are no uses of before, after, or ok, or some use
   189  			// of i does not match our criteria - don't suggest a fix.
   190  			if negative == nil && nonnegative == nil && beforeSlice == nil && afterSlice == nil {
   191  				continue
   192  			}
   193  
   194  			// If the only uses are ok and !ok, don't suggest a Cut() fix - these should be using Contains()
   195  			isContains := (len(negative) > 0 || len(nonnegative) > 0) && len(beforeSlice) == 0 && len(afterSlice) == 0
   196  
   197  			scope := iObj.Parent()
   198  			var (
   199  				// TODO(adonovan): avoid FreshName when not needed; see errorsastype.
   200  				okVarName     = refactor.FreshName(scope, iIdent.Pos(), "ok")
   201  				beforeVarName = refactor.FreshName(scope, iIdent.Pos(), "before")
   202  				afterVarName  = refactor.FreshName(scope, iIdent.Pos(), "after")
   203  				foundVarName  = refactor.FreshName(scope, iIdent.Pos(), "found") // for Contains()
   204  			)
   205  
   206  			// If there will be no uses of ok, before, or after, use the
   207  			// blank identifier instead.
   208  			if len(negative) == 0 && len(nonnegative) == 0 {
   209  				okVarName = "_"
   210  			}
   211  			if len(beforeSlice) == 0 {
   212  				beforeVarName = "_"
   213  			}
   214  			if len(afterSlice) == 0 {
   215  				afterVarName = "_"
   216  			}
   217  
   218  			var edits []analysis.TextEdit
   219  			replace := func(exprs []ast.Expr, new string) {
   220  				for _, expr := range exprs {
   221  					edits = append(edits, analysis.TextEdit{
   222  						Pos:     expr.Pos(),
   223  						End:     expr.End(),
   224  						NewText: []byte(new),
   225  					})
   226  				}
   227  			}
   228  			// Get the ident for the call to strings.Index, which could just be
   229  			// "Index" if the strings package is dot imported.
   230  			indexCallId := typesinternal.UsedIdent(info, indexCall.Fun)
   231  			replacedFunc := "Cut"
   232  			if isContains {
   233  				replacedFunc = "Contains"
   234  				replace(negative, "!"+foundVarName) // idx < 0   ->  !found
   235  				replace(nonnegative, foundVarName)  // idx > -1  ->   found
   236  
   237  				// Replace the assignment with found, and replace the call to
   238  				// Index or IndexByte with a call to Contains.
   239  				// i     := strings.Index   (...)
   240  				// -----            --------
   241  				// found := strings.Contains(...)
   242  				edits = append(edits, analysis.TextEdit{
   243  					Pos:     iIdent.Pos(),
   244  					End:     iIdent.End(),
   245  					NewText: []byte(foundVarName),
   246  				}, analysis.TextEdit{
   247  					Pos:     indexCallId.Pos(),
   248  					End:     indexCallId.End(),
   249  					NewText: []byte("Contains"),
   250  				})
   251  			} else {
   252  				replace(negative, "!"+okVarName)    // idx < 0   ->  !ok
   253  				replace(nonnegative, okVarName)     // idx > -1  ->   ok
   254  				replace(beforeSlice, beforeVarName) // s[:idx]   ->   before
   255  				replace(afterSlice, afterVarName)   // s[idx+k:] ->   after
   256  
   257  				// Replace the assignment with before, after, ok, and replace
   258  				// the call to Index or IndexByte with a call to Cut.
   259  				// i     			 := strings.Index(...)
   260  				// -----------------            -----
   261  				// before, after, ok := strings.Cut  (...)
   262  				edits = append(edits, analysis.TextEdit{
   263  					Pos:     iIdent.Pos(),
   264  					End:     iIdent.End(),
   265  					NewText: fmt.Appendf(nil, "%s, %s, %s", beforeVarName, afterVarName, okVarName),
   266  				}, analysis.TextEdit{
   267  					Pos:     indexCallId.Pos(),
   268  					End:     indexCallId.End(),
   269  					NewText: []byte("Cut"),
   270  				})
   271  			}
   272  
   273  			// Calls to IndexByte have a byte as their second arg, which
   274  			// must be converted to a string or []byte to be a valid arg for Cut/Contains.
   275  			if obj.Name() == "IndexByte" {
   276  				switch obj.Pkg().Name() {
   277  				case "strings":
   278  					searchByteVal := info.Types[substr].Value
   279  					if searchByteVal == nil {
   280  						// substr is a variable, e.g. substr := byte('b')
   281  						// use string(substr)
   282  						edits = append(edits, []analysis.TextEdit{
   283  							{
   284  								Pos:     substr.Pos(),
   285  								NewText: []byte("string("),
   286  							},
   287  							{
   288  								Pos:     substr.End(),
   289  								NewText: []byte(")"),
   290  							},
   291  						}...)
   292  					} else {
   293  						// substr is a byte constant
   294  						val, _ := constant.Int64Val(searchByteVal) // inv: must be a valid byte
   295  						// strings.Cut/Contains requires a string, so convert byte literal to string literal; e.g. 'a' -> "a", 55 -> "7"
   296  						edits = append(edits, analysis.TextEdit{
   297  							Pos:     substr.Pos(),
   298  							End:     substr.End(),
   299  							NewText: strconv.AppendQuote(nil, string(byte(val))),
   300  						})
   301  					}
   302  				case "bytes":
   303  					// bytes.Cut/Contains requires a []byte, so wrap substr in a []byte{}
   304  					edits = append(edits, []analysis.TextEdit{
   305  						{
   306  							Pos:     substr.Pos(),
   307  							NewText: []byte("[]byte{"),
   308  						},
   309  						{
   310  							Pos:     substr.End(),
   311  							NewText: []byte("}"),
   312  						},
   313  					}...)
   314  				}
   315  			}
   316  			pass.Report(analysis.Diagnostic{
   317  				Pos: indexCall.Fun.Pos(),
   318  				End: indexCall.Fun.End(),
   319  				Message: fmt.Sprintf("%s.%s can be simplified using %s.%s",
   320  					obj.Pkg().Name(), obj.Name(), obj.Pkg().Name(), replacedFunc),
   321  				Category: "stringscut",
   322  				SuggestedFixes: []analysis.SuggestedFix{{
   323  					Message:   fmt.Sprintf("Simplify %s.%s call using %s.%s", obj.Pkg().Name(), obj.Name(), obj.Pkg().Name(), replacedFunc),
   324  					TextEdits: edits,
   325  				}},
   326  			})
   327  		}
   328  	}
   329  
   330  	return nil, nil
   331  }
   332  
   333  // indexArgValid reports whether expr is a valid strings.Index(_, _) arg
   334  // for the transformation. An arg is valid iff it is:
   335  // - constant;
   336  // - a local variable with no modifying uses after the Index() call; or
   337  // - []byte(x) where x is also valid by this definition.
   338  // All other expressions are assumed not referentially transparent,
   339  // so we cannot be sure that all uses are safe to replace.
   340  func indexArgValid(info *types.Info, index *typeindex.Index, expr ast.Expr, afterPos token.Pos) bool {
   341  	tv := info.Types[expr]
   342  	if tv.Value != nil {
   343  		return true // constant
   344  	}
   345  	switch expr := expr.(type) {
   346  	case *ast.CallExpr:
   347  		return types.Identical(tv.Type, byteSliceType) &&
   348  			info.Types[expr.Fun].IsType() && // make sure this isn't a function that returns a byte slice
   349  			indexArgValid(info, index, expr.Args[0], afterPos) // check s in []byte(s)
   350  	case *ast.Ident:
   351  		sObj := info.Uses[expr]
   352  		sUses := index.Uses(sObj)
   353  		return !hasModifyingUses(info, sUses, afterPos)
   354  	default:
   355  		// For now, skip instances where s or substr are not
   356  		// identifers, basic lits, or call expressions of the form
   357  		// []byte(s).
   358  		// TODO(mkalil): Handle s and substr being expressions like ptr.field[i].
   359  		// From adonovan: We'd need to analyze s and substr to see
   360  		// whether they are referentially transparent, and if not,
   361  		// analyze all code between declaration and use and see if
   362  		// there are statements or expressions with potential side
   363  		// effects.
   364  		return false
   365  	}
   366  }
   367  
   368  // checkIdxUses inspects the uses of i to make sure they match certain criteria that
   369  // allows us to suggest a modernization. If all uses of i, s and substr match
   370  // one of the following four valid formats, it returns a list of occurrences for
   371  // each format. If any of the uses do not match one of the formats, return nil
   372  // for all values, since we should not offer a replacement.
   373  // 1. negative - a condition equivalent to i < 0
   374  // 2. nonnegative - a condition equivalent to i >= 0
   375  // 3. beforeSlice - a slice of `s` that matches either s[:i], s[0:i]
   376  // 4. afterSlice - a slice of `s` that matches one of: s[i+len(substr):], s[len(substr) + i:], s[i + const], s[k + i] (where k = len(substr))
   377  func checkIdxUses(info *types.Info, uses iter.Seq[inspector.Cursor], s, substr ast.Expr) (negative, nonnegative, beforeSlice, afterSlice []ast.Expr) {
   378  	use := func(cur inspector.Cursor) bool {
   379  		ek, _ := cur.ParentEdge()
   380  		n := cur.Parent().Node()
   381  		switch ek {
   382  		case edge.BinaryExpr_X, edge.BinaryExpr_Y:
   383  			check := n.(*ast.BinaryExpr)
   384  			switch checkIdxComparison(info, check) {
   385  			case -1:
   386  				negative = append(negative, check)
   387  				return true
   388  			case 1:
   389  				nonnegative = append(nonnegative, check)
   390  				return true
   391  			}
   392  			// Check is not equivalent to that i < 0 or i >= 0.
   393  			// Might be part of an outer slice expression like s[i + k]
   394  			// which requires a different check.
   395  			// Check that the thing being sliced is s and that the slice
   396  			// doesn't have a max index.
   397  			if slice, ok := cur.Parent().Parent().Node().(*ast.SliceExpr); ok &&
   398  				sameObject(info, s, slice.X) &&
   399  				slice.Max == nil {
   400  				if isBeforeSlice(info, ek, slice) {
   401  					beforeSlice = append(beforeSlice, slice)
   402  					return true
   403  				} else if isAfterSlice(info, ek, slice, substr) {
   404  					afterSlice = append(afterSlice, slice)
   405  					return true
   406  				}
   407  			}
   408  		case edge.SliceExpr_Low, edge.SliceExpr_High:
   409  			slice := n.(*ast.SliceExpr)
   410  			// Check that the thing being sliced is s and that the slice doesn't
   411  			// have a max index.
   412  			if sameObject(info, s, slice.X) && slice.Max == nil {
   413  				if isBeforeSlice(info, ek, slice) {
   414  					beforeSlice = append(beforeSlice, slice)
   415  					return true
   416  				} else if isAfterSlice(info, ek, slice, substr) {
   417  					afterSlice = append(afterSlice, slice)
   418  					return true
   419  				}
   420  			}
   421  		}
   422  		return false
   423  	}
   424  
   425  	for curIdent := range uses {
   426  		if !use(curIdent) {
   427  			return nil, nil, nil, nil
   428  		}
   429  	}
   430  	return negative, nonnegative, beforeSlice, afterSlice
   431  }
   432  
   433  // hasModifyingUses reports whether any of the uses involve potential
   434  // modifications. Uses involving assignments before the "afterPos" won't be
   435  // considered.
   436  func hasModifyingUses(info *types.Info, uses iter.Seq[inspector.Cursor], afterPos token.Pos) bool {
   437  	for curUse := range uses {
   438  		ek, _ := curUse.ParentEdge()
   439  		if ek == edge.AssignStmt_Lhs {
   440  			if curUse.Node().Pos() <= afterPos {
   441  				continue
   442  			}
   443  			assign := curUse.Parent().Node().(*ast.AssignStmt)
   444  			if sameObject(info, assign.Lhs[0], curUse.Node().(*ast.Ident)) {
   445  				// Modifying use because we are reassigning the value of the object.
   446  				return true
   447  			}
   448  		} else if ek == edge.UnaryExpr_X &&
   449  			curUse.Parent().Node().(*ast.UnaryExpr).Op == token.AND {
   450  			// Modifying use because we might be passing the object by reference (an explicit &).
   451  			// We can ignore the case where we have a method call on the expression (which
   452  			// has an implicit &) because we know the type of s and substr are strings
   453  			// which cannot have methods on them.
   454  			return true
   455  		}
   456  	}
   457  	return false
   458  }
   459  
   460  // checkIdxComparison reports whether the check is equivalent to i < 0 or its negation, or neither.
   461  // For equivalent to i >= 0, we only accept this exact BinaryExpr since
   462  // expressions like i > 0 or i >= 1 make a stronger statement about the value of i.
   463  // We avoid suggesting a fix in this case since it may result in an invalid
   464  // transformation (See golang/go#76687).
   465  // Since strings.Index returns exactly -1 if the substring is not found, we
   466  // don't need to handle expressions like i <= -3.
   467  // We return 0 if the expression does not match any of these options.
   468  // We assume that a check passed to checkIdxComparison has i as one of its operands.
   469  func checkIdxComparison(info *types.Info, check *ast.BinaryExpr) int {
   470  	// Ensure that the constant (if any) is on the right.
   471  	x, op, y := check.X, check.Op, check.Y
   472  	if info.Types[x].Value != nil {
   473  		x, op, y = y, flip(op), x
   474  	}
   475  
   476  	yIsInt := func(k int64) bool {
   477  		return isIntLiteral(info, y, k)
   478  	}
   479  
   480  	if op == token.LSS && yIsInt(0) || // i < 0
   481  		op == token.EQL && yIsInt(-1) || // i == -1
   482  		op == token.LEQ && yIsInt(-1) { // i <= -1
   483  		return -1 // check <=> i is negative
   484  	}
   485  
   486  	if op == token.GEQ && yIsInt(0) || // i >= 0
   487  		op == token.NEQ && yIsInt(-1) || // i != -1
   488  		op == token.GTR && yIsInt(-1) { // i > -1
   489  		return +1 // check <=> i is non-negative
   490  	}
   491  
   492  	return 0 // unknown
   493  }
   494  
   495  // flip changes the comparison token as if the operands were flipped.
   496  // It is defined only for == and the four inequalities.
   497  func flip(op token.Token) token.Token {
   498  	switch op {
   499  	case token.EQL:
   500  		return token.EQL // (same)
   501  	case token.GEQ:
   502  		return token.LEQ
   503  	case token.GTR:
   504  		return token.LSS
   505  	case token.LEQ:
   506  		return token.GEQ
   507  	case token.LSS:
   508  		return token.GTR
   509  	}
   510  	return op
   511  }
   512  
   513  // isBeforeSlice reports whether the SliceExpr is of the form s[:i] or s[0:i].
   514  func isBeforeSlice(info *types.Info, ek edge.Kind, slice *ast.SliceExpr) bool {
   515  	return ek == edge.SliceExpr_High && (slice.Low == nil || isZeroIntConst(info, slice.Low))
   516  }
   517  
   518  // isAfterSlice reports whether the SliceExpr is of the form s[i+len(substr):],
   519  // or s[i + k:] where k is a const is equal to len(substr).
   520  func isAfterSlice(info *types.Info, ek edge.Kind, slice *ast.SliceExpr, substr ast.Expr) bool {
   521  	lowExpr, ok := slice.Low.(*ast.BinaryExpr)
   522  	if !ok || slice.High != nil {
   523  		return false
   524  	}
   525  	// Returns true if the expression is a call to len(substr).
   526  	isLenCall := func(expr ast.Expr) bool {
   527  		call, ok := expr.(*ast.CallExpr)
   528  		if !ok || len(call.Args) != 1 {
   529  			return false
   530  		}
   531  		return sameObject(info, substr, call.Args[0]) && typeutil.Callee(info, call) == builtinLen
   532  	}
   533  
   534  	// Handle len([]byte(substr))
   535  	if is[*ast.CallExpr](substr) {
   536  		call := substr.(*ast.CallExpr)
   537  		tv := info.Types[call.Fun]
   538  		if tv.IsType() && types.Identical(tv.Type, byteSliceType) {
   539  			// Only one arg in []byte conversion.
   540  			substr = call.Args[0]
   541  		}
   542  	}
   543  	substrLen := -1
   544  	substrVal := info.Types[substr].Value
   545  	if substrVal != nil {
   546  		switch substrVal.Kind() {
   547  		case constant.String:
   548  			substrLen = len(constant.StringVal(substrVal))
   549  		case constant.Int:
   550  			// constant.Value is a byte literal, e.g. bytes.IndexByte(_, 'a')
   551  			// or a numeric byte literal, e.g. bytes.IndexByte(_, 65)
   552  			substrLen = 1
   553  		}
   554  	}
   555  
   556  	switch ek {
   557  	case edge.BinaryExpr_X:
   558  		kVal := info.Types[lowExpr.Y].Value
   559  		if kVal == nil {
   560  			// i + len(substr)
   561  			return lowExpr.Op == token.ADD && isLenCall(lowExpr.Y)
   562  		} else {
   563  			// i + k
   564  			kInt, ok := constant.Int64Val(kVal)
   565  			return ok && substrLen == int(kInt)
   566  		}
   567  	case edge.BinaryExpr_Y:
   568  		kVal := info.Types[lowExpr.X].Value
   569  		if kVal == nil {
   570  			// len(substr) + i
   571  			return lowExpr.Op == token.ADD && isLenCall(lowExpr.X)
   572  		} else {
   573  			// k + i
   574  			kInt, ok := constant.Int64Val(kVal)
   575  			return ok && substrLen == int(kInt)
   576  		}
   577  	}
   578  	return false
   579  }
   580  
   581  // sameObject reports whether we know that the expressions resolve to the same object.
   582  func sameObject(info *types.Info, expr1, expr2 ast.Expr) bool {
   583  	if ident1, ok := expr1.(*ast.Ident); ok {
   584  		if ident2, ok := expr2.(*ast.Ident); ok {
   585  			uses1, ok1 := info.Uses[ident1]
   586  			uses2, ok2 := info.Uses[ident2]
   587  			return ok1 && ok2 && uses1 == uses2
   588  		}
   589  	}
   590  	return false
   591  }
   592
View as plain text