Type alias impl trait types do not check bounds apply to concrete type

[matthewjasper]

The following code runs and prints random values:

#![feature(type_alias_impl_trait)]

type X<'a> = impl Into<&'static str> + From<&'a str>;

fn f<'a: 'static>(t: &'a str) -> X<'a> {
    t
}

fn extend_lt<'a>(o: &'a str) -> &'static str {
    X::<'_>::from(o).into()
}

fn main() {
    let r =
    {
        let s = "abcdef".to_string();
        extend_lt(&s)
    };
    println!("{}", r);
}

ICE using the same issue

#![feature(type_alias_impl_trait)]

type X<T> = impl Clone;

fn f<T: Clone>(t: T) -> X<T> {
    t
}

fn g<T>(o : Option<X<T>>) -> Option<X<T>> {
    o.clone()
}

fn main() {
    g(None::<X<&mut ()>>);
}

[ghost]

Just a curious bystander: the provided example no longer prints random values (rustc 1.46.0-nightly (2f517ce6f 2020-06-28)). Was this fixed?

[matthewjasper]

The first example is UB so it may be target/optimization level dependent. This will be fixed once the ICE is gone.

[WorldSEnder]

For my understanding: the point is that values for X<'a> are only infered under the additional assumption 'a: 'static (from the signature of f), not for general 'a, so rust should complain about that before it allows you to use it as X::<'_>, correct?

[Aaron1011]

Both of the examples in this issue now error with #73905 merged

[matthewjasper]

This is tested in src/test/ui/type-alias-impl-trait/bounds-are-checked.rs already.

Ideally we would not allow f as a defining use because it overconstrains 'a, but it's hard to specify exactly what that means because not all of the (generic) parameters of the function have to be (generic) arguments of the opaque type.