`where Self: Sized` on trait method doesn't work as expected when implementing for unsized types.

[crlf0710]

I've got this code

trait Foo {
    fn bar(&self) -> Self where Self: Sized;
}

impl Foo for str {
//    fn bar(&self) -> Self { unimplemented!() }
}

the error is:

error[E0046]: not all trait items implemented, missing: `bar`
 --> src/lib.rs:5:1

However, since str is not Sized, i don't think bar needs to be implemented. if i remove the "//", i'll got:

error[E0277]: the size for values of type `str` cannot be known at compilation time
 --> src/lib.rs:6:22

So although this trait fits object safety rules, i still can't implement it for unsized types.

[RustyYato]

As a work around, you can split off everything that needs Sized into another trait. like so

trait ObjectSafe {
    // some functions
}
trait NotObjectSafe: ObjectSafe + Sized {
    // more functions
}

[crlf0710]

Yes, i think this is a reasonable workaround. But it will be nice to get this limitation removed

[RustyYato]

Yes, I agree, this is an annoying limitation.

[crlf0710]

@rustbot modify labels to +A-traits +C-bug

[QuineDot]

The original example can be worked around with the trivial bounds RFC (you still cannot call the implementation).

That said, I still feel that the approximation of using Sized instead of some NotDyn trait should be fixed; said trait could be a supertrait of Sized for backwards compatibility. The reason (well, beyond semantics) being, sometimes you do want to call some generic method on a str implementation (imagine the method was -> () in the example).

[kupiakos]

For reference, you can also work around this on stable with an unused HRTB:

trait Foo {
    fn bar(&self) -> Self where Self: Sized;
}

impl Foo for str {
    fn bar(&self) -> Self where for<'a> str: Sized { unimplemented!() }
}

[grothesque]

@QuineDot wrote:

That said, I still feel that the approximation of using Sized instead of some NotDyn trait should be fixed; said trait could be a supertrait of Sized for backwards compatibility. The reason (well, beyond semantics) being, sometimes you do want to call some generic method on a str implementation (imagine the method was -> () in the example).

Perhaps this approximation is not a huge problem in practice when using the language, but in my experience it can be a big problem when learning about trait objects in Rust. It was one of the big blockers for me.

Although I read all the available official documentation (and many other texts) on trait objects and object safety, I kept being fundamentally confused about the relation of Self: Sized and trait objects. It's not like I did not understand why and how trait objects are unsized, but rather that I had the feeling that requiring Self: Sized is too strong when all one wants is excluding trait objects. However, since this point was never discussed, I thought that it is my understanding that must be flawed.

It's only once I found @QuineDot's analysis that my doubts disappeared and I realized that my understanding was actually correct. (Thanks!)

I assume that I am not the first or last to suffer from this difficulty, and suggest tackling it in some way. One could start by adding clarification to the definition of object safety.

[cyrgani]

This was fixed by #135480, meaning that

trait Foo {
    fn bar(&self) -> Self where Self: Sized;
}

impl Foo for str {}

compiles sucessfully now.