Generic types are always invariant over their type parameters.

[eddyb]

Consider this:

fn new_vec<T>() -> Vec<&'static T> { Vec::new() }
fn foo<'a, T>() {
    // Errors, as it cannot coerce Vec<T> to Vec<U> where U <: T.
    let _: Vec<&'a T> = new_vec();
}

This can lead to the need to make functions generic over lifetimes in their return type, but that doesn't work so well when referencing a static (which cannot be generic over non-'static lifetimes like function can).
To show that this is not specific to Vec (or other unsafe-using abstractions):

struct Foo<T>(T);
fn new_foo<T>() -> Foo<&'static T> { fail!() }
fn foo<'a, T>() {
    // Same error, Foo<T> is also invariant w.r.t T.
    let _: Foo<&'a T> = new_foo();
}

Without the Foo newtype, it works as expected:

fn new_foo<T: 'static>() -> &'static T { fail!() }
fn foo<'a, T: 'static>() {
    let _: &'a T = new_foo();
}

It also works when the variance comes from a lifetime parameter:

struct Foo<'a, T: 'a>(&'a T);
fn new_foo<T: 'static>() -> Foo<'static, T> { fail!() }
fn foo<'a, T: 'static>() {
    let _: Foo<'a, T> = new_foo();
}

The now-closed (awaiting a rewrite) rust-lang/rfcs#233 RFC PR would fix this.
cc @nikomatsakis

[eddyb]

I now see that this is pretty much #3598, which has been moved to rust-lang/rfcs#281.
I needed an issue to use in comments for changes which are only required because of this lack of variance, one of them requiring unsafe code to work around.
There are two FIXMEs mentioning #3598, not sure if I should use that or this issue.

[steveklabnik]

Closing in favor of the RFC thread.