librustc: Permit by-value-self methods to be invoked on objects referenced by boxes.

[pcwalton]

I can't believe this worked! I believe that the way the ABI and
immediates work mean that this Just Works.

Closes #10672.

r? @alexcrichton

[alexcrichton]

We chatted on IRC about this, just wanted to write a few things down:

• Can you make sure this is valgrind-clean?
• Can you add a test which unwinds over a fn foo(self) call and ensure that it's valgrind clean?
• Can you add some more assertions in the test to make sure things are as we expect?

[pcwalton]

Issues addressed. The box is now freed. re-r? @alexcrichton

[huonw]

Some people may encounter breakage due to this change (cargo did), if they have trait structure like

trait Foo {
    fn bar(self);
}

impl Foo for Box<Foo> { fn bar(self) { /* ... */ } }

Previously

let a: T = ...;
(box a as Box<Foo>).bar();

would be calling the bar from the Box<Foo> impl (i.e. self: Box<Foo>), but now it will be calling the one from the vtable (i.e. self: T). If bar is generic fn bar<U>(self, ...) then the compiler will complain "cannot call a generic method through an object".

I believe a work around (for both) is defining a function like

fn call_bar<T: Foo>(x: T) { x.bar() }

then call_bar(some_box_foo) should use the Box<Foo> impl.

[alexcrichton]

This has caused even more problems for cargo as the tests are currently ICEing due to a problem in trans_unboxing_shim. To make @huonw's example concrete:

trait Foo {
    fn foo(self) { println!("default") }
}

impl Foo for Box<Foo> {
    fn foo(self) { println!("overridden") }
}

impl Foo for int {
    fn foo(self) { println!("int") }
}

fn main() {
    let f = box 1i as Box<Foo>;
    f.foo();
}

This prints int, not overridden.