Can't cast `self` to trait object in default methods

[Blei]

The following code doesn't work (even though I suspect it's correct):

trait Foo {
    fn foo(@self) { bar(self); }
}

fn bar(_b: @Foo) { }

The following error is returned:

<anon>:2:24: 2:29 error: mismatched types: expected `@Foo` but found `@Self` (expected trait Foo but found @-ptr)
<anon>:2     fn foo(@self) { bar(self); }
                                 ^~~~~
error: aborting due to previous error

[Blei]

Related to (or duplicate of?) #7183

[pnkfelix]

@Blei might be related, but I would not call it a duplicate; the type &S in fn<S:Trait>(s:&S) does not use dynamic dispatch (i.e. does not carry a virtual-method table) while @Trait in fn(x:@Trait) does.

(as in, the use-cases for the two are so different, I'd want to ensure they are addressed, independently if necessary. Though maybe we will be lucky and they will end up having the same root cause.)

[pnkfelix]

Regardless of whether this is a dupe of 7183, it is definitely part of #2794.

[msullivan]

The code I think is not correct. It doesn't actually do a cast.

[msullivan]

I feel like the code should be

trait Foo {
    fn foo(@self) { bar(self as @Foo); }
}

fn bar(_b: @Foo) { }

This fails with

../rust-things/default-self-object.rs:2:24: 2:36 error: cannot pack type `@Self`, which does not fulfill `'static`, as a trait bounded by 'static
../rust-things/default-self-object.rs:2     fn foo(@self) { bar(self as @Foo); }

Hm.

[Blei]

Yes, I tried multiple variants, both with and without cast. I meant to paste the one with a cast, but alas.

[nikomatsakis]

Sully's error is legit, in the sense that the type system is operating as expected. The type Self may contain borrowed pointers, and the type @Foo is short for @Foo:'static, which says that the value does NOT contain borrowed pointers. The correct way to implement the example (which I think does not work yet) would be:

trait Foo : 'static { ... }

which would say that the trait Foo cannot be implemented except by types that do not contain borrowed pointers.

If we added the rule that @ boxes cannot contain managed pointers, as we have discussed, it is plausible that we could then extend the type system to know that Self has the bound 'static in an @self method (or any method that contains an @Self parameter). I described such a scheme in this blog post about the Sized kind.

[pnkfelix]

@nikomatsakis FYI, when I attempted this morning to replicate the issues I was having with syntax::visit @Visitor refactoring, I ran into this problem (I think). Or at least, I could not pass @self to helper methods from the default method implementations in visit.rs. (There are ways to work-around this, such as not using default methods.)

[flaper87]

The following example works:

trait Foo {
    fn foo(&self) { bar(self); }
}

fn bar(_b: &Foo) { }

fn main() {}

Since @ is being deprecated in favor of Gc and Rc and the above example works, I think we can close this issue. @nikomatsakis @pnkfelix thoughts?

[huonw]

Does ~self and ~Foo work?

[flaper87]

trait Foo: Send {
    fn foo(~self) { bar(self as ~Foo); }
}

fn bar(_b: ~Foo) { }

fn main() {}

Yes, it works!

[flaper87]

Closing based on the above comments

[flaper87]

Reopening since the above example requires Send to be explicitly specified