Casting a reference to a trait object reference loses lifetime information

[Aatch]

Best I can do, but it's self-contained:

trait FooTrait {
    fn do_thing(&self) -> ~str;
}
struct Container<'a> {
    things : ~[&'a FooTrait]
}

impl<'a> Container<'a> {
    fn new() -> Container {
        Container { things: ~[] }
    }
    fn add(&mut self, thing: &'a FooTrait) {
        self.things.push(thing);
    }
}

struct Foo;

impl FooTrait for Foo {
    fn do_thing(&self) -> ~str {
        ~"Test"
    }
}

fn make_foo() -> Foo {
    Foo
}

fn main() {
    let mut c = Container::new();

    for _ in range(0, 10) {
        let foo : Foo = make_foo();
        let foop : &Foo = &foo;
        let foo_obj = foop as &FooTrait;
        c.add(foo_obj);
    }

}

This compiles. It shouldn't, since foo doesn't live for long enough. If I don't do the cast (this also happens with coercion), it fails with the expected error message.

cc @nikomatsakis

[huonw]

Seems similar to #5723, #11374 or #11971 (particularly #11374).

[apoelstra]

There are a lot of awfully-similar-looking lifetime bugs out there so I'm not sure where to put this, but I've got a short and sweet test case which (I believe) demonstrates this bug.

fn ret_old_memory() -> Box<Iterator<u8>> {
  box [0u8].iter().map(|n| *n) as Box<Iterator<u8>>
}

fn main() {
  println!("{:}", ret_old_memory().next());
}

Removing the .map(|n| *n) causes the compiler to correctly flag the return of a lost variable. As written this compiles (and actually works "correctly").

[alexcrichton]

Fixed by #5723

[alexcrichton]

Specifically #16453.