compiler: avoid byte slice copies in mixed string comparisons

compiler/compiler.go

@@ -3061,10 +3061,7 @@ func isByteSliceToStringComparison(expr *ssa.Convert) bool {
 		return false
 	}
 	comparison := adjacentComparison(expr, isByteSliceToStringConvert)
-	return comparison != nil &&
-		isComparisonOp(comparison.Op) &&
-		isByteSliceToStringConvert(comparison.X) &&
-		isByteSliceToStringConvert(comparison.Y)
+	return comparison != nil && isComparisonOp(comparison.Op)
 }
 
 func isComparisonOp(op token.Token) bool {

compiler/testdata/string.go

@@ -212,6 +212,118 @@ func namedByteSliceStringGreaterEqual(a, b namedBytes) bool {
 	return namedString(a) >= namedString(b)
 }
 
+func mixedByteString(a []byte, s string) [6]bool {
+	return [6]bool{string(a) == s, string(a) != s, string(a) < s,
+		string(a) <= s, string(a) > s, string(a) >= s}
+}
+
+func mixedStringByte(s string, a []byte) [6]bool {
+	return [6]bool{s == string(a), s != string(a), s < string(a),
+		s <= string(a), s > string(a), s >= string(a)}
+}
+
+func mixedByteLiteral(a []byte) [6]bool {
+	return [6]bool{string(a) == "abc", string(a) != "abc", string(a) < "abc",
+		string(a) <= "abc", string(a) > "abc", string(a) >= "abc"}
+}
+
+func mixedLiteralByte(a []byte) [6]bool {
+	return [6]bool{"abc" == string(a), "abc" != string(a), "abc" < string(a),
+		"abc" <= string(a), "abc" > string(a), "abc" >= string(a)}
+}
+
+func mixedNamedByteString(a namedBytes, s namedString) [6]bool {
+	return [6]bool{namedString(a) == s, namedString(a) != s, namedString(a) < s,
+		namedString(a) <= s, namedString(a) > s, namedString(a) >= s}
+}
+
+func mixedNamedStringByte(s namedString, a namedBytes) [6]bool {
+	return [6]bool{s == namedString(a), s != namedString(a), s < namedString(a),
+		s <= namedString(a), s > namedString(a), s >= namedString(a)}
+}
+
+func mixedLocalByteString(a []byte, s string) bool {
+	t := string(a)
+	return t == s
+}
+
+func mixedLocalStringByte(s string, a []byte) bool {
+	t := string(a)
+	return s < t
+}
+
+func mixedSliceByteString(a []byte, s string) bool {
+	return string(a[:2]) == s
+}
+
+func mixedPrecomputedStringSlice(a []byte, s string) bool {
+	t := s[:2]
+	return string(a) == t
+}
+
+func mixedByteStringReuse(a []byte, s string) (bool, bool) {
+	t := string(a)
+	return t == s, t < s
+}
+
+func mixedByteStringEscape(a []byte, s string) (bool, string) {
+	t := string(a)
+	return t == s, t
+}
+
+func mixedByteStringStore(a []byte, s string, dst *string) bool {
+	t := string(a)
+	equal := t == s
+	*dst = t
+	return equal
+}
+
+func mixedByteStringBox(a []byte, s string) (bool, any) {
+	t := string(a)
+	return t == s, any(t)
+}
+
+func mixedByteStringMutation(a, b []byte, s string) bool {
+	t := string(a)
+	b[0] = 'z'
+	return t == s
+}
+
+func mixedByteStringCall(a, b []byte, s string) bool {
+	t := string(a)
+	mutateBytes(b)
+	return s < t
+}
+
+func mixedByteStringAcrossBlock(a, b []byte, s string, mutate bool) bool {
+	t := string(a)
+	if mutate {
+		b[0] = 'z'
+	}
+	return t == s
+}
+
+func mixedByteStringLoad(a []byte, s *string) bool {
+	return string(a) == *s
+}
+
+func mixedStringLoadByte(s *string, a []byte) bool {
+	return *s == string(a)
+}
+
+func mixedByteStringSlice(a []byte, s string) bool {
+	return string(a) == s[:2]
+}
+
+func mixedByteStringChangeType(a []byte, s namedString) bool {
+	t := string(a)
+	return namedString(t) == s
+}
+
+func mixedByteStringInterface(a []byte, s any) bool {
+	return string(a) == s
+}
+
 //go:noinline
 func mutateBytes(s []byte) []byte {
 	s[0]++