Why does AsyncReadExt.read_buf require Sized?

[tijsvd]

I'm currently working around reading into a buffer from a &mut dyn AsyncRead, read_buf being the only extension method on AsyncReadExt that requires Self: Sized. Just wondering if there's a good reason for this, or just something historical that's been overlooked.

Removing the requirement and adding R: ?Sized on two lines in read_buf.rs compiles fine.

[Darksonn]

We require Sized sure to object safety of the trait. References are Sized even if they point to something that isn't Sized, so it isn't a problem.

[tijsvd]

I don't understand. Why does an extension trait need to be object-safe, isn't the whole point of the trait that it isn't - otherwise the methods could just be on AsyncRead itself? And the trait has plenty other methods that take &mut self and don't have the same requirement.

Indeed references are Sized - which is why I don't understand the requirement for Self: Sized when taking &mut self.

Example how this is a problem:

use tokio::io::{AsyncReadExt, AsyncRead};
use tokio::net::TcpStream;

trait Reader : AsyncRead + Unpin  {}
impl<T: AsyncRead + Unpin + Send> Reader for T {}

#[tokio::main]
async fn main() {
    let mut s = TcpStream::connect("foo:1234").await.unwrap();

    let reader: &mut dyn Reader = &mut s;

    let mut buf = vec![0u8; 32];
    let _ = reader.read(&mut buf).await; // this is fine
    let _ = reader.read_buf(&mut buf).await; // this does not compile
}

Sure it can be worked around by passing a mut ref to the pointer itself or something like that ((&mut reader).read_buf(...)), but really?

[Darksonn]

You do have a point. It's very possible that we could remove the bound in this case. If you submit a PR, then I'll consider it more closely.

[tijsvd]

#6169