The documentation of Grow says:

Grow may modify elements of the slice between the length and the capacity.

While this is just a "may", in practice it does, which leads to poor performance.

Suppose I had some logic that did something like:

for _, v := range manyValues {
    n := v.EncodedLen()
    dst = slices.Grow(dst, n)
    v.EncodeInto(dst)
    dst = dst[:len(dst)+n]
}

In the event that dst is large enough, I would expect that every call to slices.Grow to effectively be a noop.
However, that is not what happens. Instead, it always zeroes out the space between dst[len(dst):len(dst)+n].

The performance cost of this is evident with this simple benchmark:

func Benchmark(b *testing.B) {
	buf := make([]byte, 0, 1<<20)
	for i := 0; i < b.N; i++ {
		buf = slices.Grow(buf, 1<<20)
	}
}

which prints:

Benchmark-24    	    5581	    230992 ns/op

I would expect it to be something like:

Benchmark-24    	1000000000	         0.2222 ns/op

\cc @ianlancetaylor @eliben