ICE passing a trait object by reference

[kmcallister]

use std::io;

fn f(wr: &mut Writer) {
    wr.write_str("hello").ok().expect("failed");
}

fn main() {
    let mut wr = box io::stdout() as Box<Writer + 'static>;
    f(&mut wr);
}

$ rustc foo.rs  
error: internal compiler error: trying to take the sizing type of std::io::Writer, an unsized type  
note: the compiler hit an unexpected failure path. this is a bug.  
note: we would appreciate a bug report: http://doc.rust-lang.org/complement-bugreport.html  
note: run with `RUST_BACKTRACE=1` for a backtrace  
task 'rustc' failed at 'Box<Any>', /home/keegan/rust/src/libsyntax/diagnostic.rs:169  

upstream Rust version: 828e075

[nrc]

cc me

[kmcallister]

It works with &mut *wr.

[nrc]

The code example is incorrect code, but it should give an error rather than ICE

[nrc]

This seems to be a regression from trait reform - we used to do vtable::check_object_cast for coercions as well as casts, but now we seem to only do it for casts.

cc @nikomatsakis

[nikomatsakis]

I'll investigate.

[nrc]

@nikomatsakis we used to do this check in vtable.rs.

[nikomatsakis]

Are you sure this code is incorrect? There is an impl of Writer for Box<Writer+'a> for all 'a, after all, so it seems legit to invoke the function f as given. Am I missing something obvious?

[nikomatsakis]

(Also, or perhaps the same question, what check exactly did we used to do in vtable?)

[nrc]

@nikomatsakis yes. Here is simplified code:

use std::io;

fn main() {
    let mut wr: Box<Writer + 'static> = box io::stdout();
    let x: &mut Box<Writer> = &mut wr;
    let f: &mut Writer = x;
}

The error is on the third line in main where we try to coerce a &mut Box to &mut Writer.

[nrc]

@nikomatsakis we used to call check_object_cast for adjustments as well as explicit casts

[nikomatsakis]

@nick29581 so I agree that there is likely a bug introduced by trait-reform, but not that the code is illegal. Here is a version of the example which also ICEs, but which does not depend on io. This code works with the stage0 compiler.

trait Test {
    fn test(&mut self) -> int;
}

impl Test for Box<Test+'static> {
    fn test(&mut self) -> int {
        self.test()
    }
}

impl Test for int {
    fn test(&mut self) -> int {
        *self
    }
}

fn main() {
    let mut b: Box<Test+'static> = box 3i;
    let mut c: &mut Box<Test+'static> = &mut b;
    let mut d: &mut Test = c;
}

[nrc]

Hmm, do we have some blanket impl T for Box<T>? In which case, I guess it should work.