Why isn't it possible to read/write from a shared reference on a TcpStream?

[wyfo]

Currently, the TcpStream implements AsyncRead/AsyncWrite, but both traits requires an exclusive reference on the stream, so it's not possible to use a shared reference to read/write on it.
On the other hand, standard library std::net::TcpStream implements Read/Write on both TcpStream and &TcpStream, allowing to read/write from a shared reference. Adding AsyncRead/AsyncWrite for &tokio::net::TcpStream seems to be trivial, as copy-pasting the current implementation but for shared reference compiles fine.
Is there a particular reason for not providing this implementation?

[Rustin170506]

You can use tokio::io::split to obtain separate reader and writer handles.

[wyfo]

tokio::io::split wraps the socket into an Arc<Mutex<TcpStream>>, that's a performance cost I don't want to pay.
By the way, TcpStream::into_split should be preferred to tokio::io::split, as it still allocates an Arc but without the mutex. However, that's still not what I want.

Splitting with TcpStream::into_split requires an additional pointer indirection, while TcpStream::split requires an exclusive reference, while I'm just asking for a way to both read and write from a shared TcpStream. For example, I may already have a TcpStream instance inside a bigger struct wrapped into an Arc, and splitting a good solution in this case.

[Darksonn]

The TcpStream type has &self methods that can be used to read and write. It's impossible to implement the IO traits correctly on immutable references due to technical details related to how the trait is declared.

[wyfo]

Does the available methods you are talking about are for example readable/try_read combination? Then, you're right, and I'm a little bit ashamed; I will submit a PR fixing a typo to be forgiven.

However, can I ask you why it isn't possible to add the implementation:

impl AsyncRead for &TcpStream {
    fn poll_read(
        self: Pin<&mut Self>,
        cx: &mut Context<'_>,
        buf: &mut ReadBuf<'_>,
    ) -> Poll<io::Result<()>> {
        self.poll_read_priv(cx, buf)
    }
}

It does compiles, and for example, tcp_echo.rs test passes if i replace stream.read_exact(&mut buf).await by (&stream).read_exact(&mut buf).await.

[Darksonn]

That implementation is incorrect. It will silently break if you try to perform multiple reads at the same time.