perf: zero alloc lower/upper unless changed (#7472)

Similar to how some other built-in functions have been optimized previously,
the `lower` and `upper` functions now return the operand as-is when the string
wasn't modified by the operation. The impact of this check is negligible when
the string is modified, and as the benchmarks demonstrate, quite an improvement
for the cases where it isn't. For those, we no longer need to allocate at all.

Signed-off-by: Anders Eknert <[email protected]>

Author: anderseknert

Diff for: v1/topdown/strings.go

@@ -443,7 +443,14 @@ func builtinUpper(_ BuiltinContext, operands []*ast.Term, iter func(*ast.Term) e
 		return err
 	}
 
-	return iter(ast.StringTerm(strings.ToUpper(string(s))))
+	arg := string(s)
+	upp := strings.ToUpper(arg)
+
+	if arg == upp {
+		return iter(operands[0])
+	}
+
+	return iter(ast.StringTerm(upp))
 }
 
 func builtinSplit(_ BuiltinContext, operands []*ast.Term, iter func(*ast.Term) error) error {

Diff for: v1/topdown/strings_bench_test.go

@@ -227,3 +227,39 @@ func BenchmarkTrimSpace(b *testing.B) {
 		})
 	}
 }
+
+// Benchmark to demonstrate the performance difference when calling lower with a string
+// that is already lowercase vs. one that is not. In the former case, the provided operand
+// is returned as-is, while in the latter case a new string is allocated and returned.
+// While this tests the 'lower' builtin, the same optimization applies to 'upper'.
+//
+// BenchmarkLower/not_lowercase-10         	 5960936	       198.6 ns/op	      88 B/op	       3 allocs/op
+// BenchmarkLower/lowercase-10             	20954871	        57.36 ns/op	       0 B/op	       0 allocs/op
+func BenchmarkLower(b *testing.B) {
+	bctx := BuiltinContext{}
+	lower := ast.StringTerm("the quick brown fox jumps over the lazy dog")
+	cases := []struct {
+		name     string
+		operands []*ast.Term
+	}{
+		{
+			name:     "not lowercase",
+			operands: []*ast.Term{ast.StringTerm("The Quick Brown Fox Jumps Over The Lazy Dog")},
+		},
+		{
+			name:     "lowercase",
+			operands: []*ast.Term{lower},
+		},
+	}
+
+	for _, c := range cases {
+		b.Run(c.name, func(b *testing.B) {
+			b.ResetTimer()
+			for range b.N {
+				if err := builtinLower(bctx, c.operands, eqIter(lower)); err != nil {
+					b.Fatal(err)
+				}
+			}
+		})
+	}
+}