go/analysis/passes/modernize: fix illegal byte argument error produced in stringscut modernizer

This CL fixes a bug in the stringscut modernizer. Previously, an instance of strings.IndexByte(s, 'a') would become strings.Cut(s, 'a') with 'a' being an illegal argument because strings.Cut expects a string, not a byte.

If we examine an instance of strings.IndexByte and are about to suggest a modernization, we append an additional edit that transforms the byte literal or byte variable substr arg to a string literal.

For example, the following calls to strings.IndexByte would yield the substr arg:
strings.IndexByte(_, 'a') -> strings.Cut(_, "a")

strings.IndexByte(_, 55) -> strings.Cut(_, "7")

b := byte('a')
strings.IndexByte(_, b) -> strings.Cut(_, string(b))

For bytes.IndexByte, the second argument must be a converted to a []byte:

bytes.IndexByte(_, 'a') -> bytes.Cut(_, []byte{'a'})

Change-Id: I1a7670e95ebdffca5ce7a2a09a103f1a6fee6db3
Reviewed-on: https://go-review.googlesource.com/c/tools/+/716600
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: Alan Donovan <adonovan@google.com>

Author: madelinekalil

go/analysis/passes/modernize/stringscut.go

@@ -11,6 +11,7 @@ import (
 	"go/token"
 	"go/types"
 	"iter"
+	"strconv"
 
 	"golang.org/x/tools/go/analysis"
 	"golang.org/x/tools/go/analysis/passes/inspect"
@@ -227,6 +228,49 @@ func stringscut(pass *analysis.Pass) (any, error) {
 				End:     iIdent.End(),
 				NewText: fmt.Appendf(nil, "%s, %s, %s", beforeVarName, afterVarName, okVarName),
 			})
+			// Calls to IndexByte have a byte as their second arg, which
+			// must be converted to a string or []byte to be a valid arg for Cut.
+			if obj.Name() == "IndexByte" {
+				switch obj.Pkg().Name() {
+				case "strings":
+					searchByteVal := info.Types[substr].Value
+					if searchByteVal == nil {
+						// substr is a variable, e.g. substr := byte('b')
+						// use string(substr)
+						edits = append(edits, []analysis.TextEdit{
+							{
+								Pos:     substr.Pos(),
+								NewText: []byte("string("),
+							},
+							{
+								Pos:     substr.End(),
+								NewText: []byte(")"),
+							},
+						}...)
+					} else {
+						// substr is a byte constant
+						val, _ := constant.Int64Val(searchByteVal) // inv: must be a valid byte
+						// strings.Cut requires a string, so convert byte literal to string literal; e.g. 'a' -> "a", 55 -> "7"
+						edits = append(edits, analysis.TextEdit{
+							Pos:     substr.Pos(),
+							End:     substr.End(),
+							NewText: strconv.AppendQuote(nil, string(byte(val))),
+						})
+					}
+				case "bytes":
+					// bytes.Cut requires a []byte, so wrap substr in a []byte{}
+					edits = append(edits, []analysis.TextEdit{
+						{
+							Pos:     substr.Pos(),
+							NewText: []byte("[]byte{"),
+						},
+						{
+							Pos:     substr.End(),
+							NewText: []byte("}"),
+						},
+					}...)
+				}
+			}
 			pass.Report(analysis.Diagnostic{
 				Pos: indexCall.Fun.Pos(),
 				End: indexCall.Fun.End(),

go/analysis/passes/modernize/testdata/src/stringscut/stringscut.go

@@ -43,6 +43,19 @@ func basic_strings_byte(s string) bool {
 	return i >= 0
 }
 
+func basic_strings_byte_int(s string) bool {
+	i := strings.IndexByte(s, 55) // want "strings.IndexByte can be simplified using strings.Cut"
+	print(s[:i])
+	return i >= 0
+}
+
+func basic_strings_byte_var(s string) bool {
+	b := byte('b')
+	i := strings.IndexByte(s, b) // want "strings.IndexByte can be simplified using strings.Cut"
+	print(s[:i])
+	return i >= 0
+}
+
 func basic_bytes(b []byte) []byte {
 	i := bytes.Index(b, []byte("str")) // want "bytes.Index can be simplified using bytes.Cut"
 	if i >= 0 {

go/analysis/passes/modernize/testdata/src/stringscut/stringscut.go.golden

@@ -38,7 +38,20 @@ func wrong_len_arg(s string, substr string) bool {
 }
 
 func basic_strings_byte(s string) bool {
-	before, _, ok := strings.Cut(s, '+') // want "strings.IndexByte can be simplified using strings.Cut"
+	before, _, ok := strings.Cut(s, "+") // want "strings.IndexByte can be simplified using strings.Cut"
+	print(before)
+	return ok
+}
+
+func basic_strings_byte_int(s string) bool {
+	before, _, ok := strings.Cut(s, "7") // want "strings.IndexByte can be simplified using strings.Cut"
+	print(before)
+	return ok
+}
+
+func basic_strings_byte_var(s string) bool {
+	b := byte('b')
+	before, _, ok := strings.Cut(s, string(b)) // want "strings.IndexByte can be simplified using strings.Cut"
 	print(before)
 	return ok
 }
@@ -53,7 +66,7 @@ func basic_bytes(b []byte) []byte {
 }
 
 func basic_index_bytes(b []byte) string {
-	before, after, ok := bytes.Cut(b, 's') // want "bytes.IndexByte can be simplified using bytes.Cut"
+	before, after, ok := bytes.Cut(b, []byte{'s'}) // want "bytes.IndexByte can be simplified using bytes.Cut"
 	if ok {
 		return string(before)
 	} else {