I'm not sure I understand all the details here.

However, in general, WriteTo is defined on a reader, and calling WriteTo tells the reader to write all available data to the writer passed to WriteTo. In general this can't be called concurrently. In particular, bytes.Reader.WriteTo can't be called concurrently in the general case.

I suppose that it does little harm to call WriteTo concurrently if the bytes.Reader is empty. But that is an odd special case to pick out.

It seems to me that the code that is making concurrent calls to WriteTo on a single bytes.Reader is broken, and that that code should be fixed. If this code only happens in a test, then the test should be fixed.

But that is an odd special case to pick out.

I agree, however that what bytes.Reader.Read already do, and we have tests and code in the std relies on this behaviour from Read, if compatilibity was not a concern I would be for the inverse patch (make bytes.Reader.Read concurrent-unsafe so -race would pick it up).

Here is what the patch would be (tests aside):

func (r *Reader) WriteTo(w io.Writer) (n int64, err error) {
-	r.prevRune = -1
	if r.i >= int64(len(r.s)) {
		return 0, nil
	}
+	r.prevRune = -1

To follow what Read do:

func (r *Reader) Read(b []byte) (n int, err error) {
	if r.i >= int64(len(r.s)) {
		return 0, io.EOF
	}
	r.prevRune = -1

don't think we can break Read's behaviour, but hopefully we can make WriteTo coherent.

My opinion is WriteTo is already coherent, and if other parts of the standard library assume that it's OK to call io.Copy concurrently on an empty bytes.Reader, then we should fix those parts of the standard library.

if other parts of the standard library assume that it's OK to call io.Copy concurrently on an empty bytes.Reader, then we should fix those parts of the standard library

I agree with that statement.
@ianlancetaylor should this proposal be closed and open the reverse one (make bytes.Reader.Read invalidate r.prevRune on call so thoses cases would show up in -race) ?
Or would that be go2 since this would be a breaking change ?

I think it would be OK to change bytes.Reader.Read but it doesn't seem very important.

Closing this then.

I think it would be OK to change bytes.Reader.Read but it doesn't seem very important.

{bytes,strings}.Reader already has a few special cases making things concurrently safe. Read is one of those.

Change https://go.dev/cl/401414 mentions this issue: bytes,strings: make Reader.WriteTo also safe for concurrent use