Something's broken in sized/unsized traits

[stepancheg]

Code:

fn bar(foo: &Foo) {}

fn baz(foo: &Foo) {
    // this call works
    bar(foo);
}

trait Foo {
    fn qux(&self) {
        // this doesn't, and error is
        // error: the trait `core::kinds::Sized` is not implemented for the type `Self`
        bar(self);
    }
} 

Calls to bar seems to be identical from baz and qux functions, however, first call works and second doesn't. I don't understand how sized/unsized types work, please, close if it is not a bug.

[nrc]

This is a feature, not a bug, but I agree it looks pretty weird in this example.

The logic is that the Self type does not have the Sized bound by default, whereas other types do. To 'fix' this you could write trait Foo: Sized. However, that would then mean the &Foos are illegal, because Sized traits cannot be used to make trait objects.

cc @nikomatsakis to double check this is expected behaviour.

[shadowmint]

If this is intended behavior, its certainly very strange.

fn foo(f:&Foo) {
  f.huh();
}

trait Foo {
  fn bar(&self, self_:&Foo) {
    let self_:&Foo = self_;
    // let self_:&Foo = self; // Doesn't work
    foo(self_);
  }

  fn huh(&self) {
    println!("huh");
  }
}

struct IsFoo;
impl Foo for IsFoo {}

fn main() {
  let is_foo = IsFoo;
  let foo:&Foo = &is_foo;
  foo.bar(foo);
}

[huonw]

It isn't just intended, but effectively required by the semantics implied by RFC 546 and #20341.

I'm writing up something more on your question and am actually part way through a few blog posts that go into this sort of stuff in more detail. (I'm aiming to get them published before the alpha, they'll appear on /r/rust when they're done.)

[huonw]

(http://stackoverflow.com/a/27820018/1256624)

[stepancheg]

My brain hurts. Thanks for the explanation!