Underscore lifetimes are incorrectly accepted as lifetime bounds in impl headers

[scottmcm]

This is currently accepted in 2018: https://play.rust-lang.org/?gist=7ba2dee1134f9848b54b7364ea9568aa&version=nightly&edition=2018

trait Foo<'a> {}
impl<'b: '_> Foo<'b> for i32 {}

AFAICT, it desugars to

impl<'b: 'c, 'c> Foo<'b> for i32 {}

So it's "fine", but useless.

It should error, as trying to do this does in other places, such as

struct Foo<'a: '_>(&'a i32);

Tracking issue for the impl_header_lifetime_elision feature: #15872

On the current beta this gives

error[E0688]: cannot mix in-band and explicit lifetime definitions

so this was at least exposed by #54458

[pnkfelix]

visited for triage. Agreed that P-high and RC2 milestones are appropriate. @nikomatsakis is going to work first on mentorship; if that fails to find a volunter, they will fallback to fixing it themself.

[nikomatsakis]

Actually, I'm not sure if this is an error or not. We currently permit '_ in other, similar contexts.

Example 1 (playground):

trait Foo<'a> { }

struct Bar<T> { t: T }

impl<T: Foo<'_>> Bar<T> { }

fn main() { }

and example 2 (playground):

trait Foo<'a> { }

struct Bar<T> { t: T }

impl<T> Bar<T> where T: Foo<'_> { }

fn main() { }

Are we comfortable with those, but just not this? (I guess because this is clearly useless, whereas those .. may be useful?)

[nikomatsakis]

For some reason, I thought maybe we were not going to permit '_ in those contexts, out of fear that the semantics were not what we might want. In particular, I can imagine that people might expect T: Foo<'_> to be equivalent to T: for<'a> Foo<'a>.

[nikomatsakis]

Survey of current behavior.

In Rust 2018 on nightly, all of the following are accepted.

Using '_ in a where clause (inherent impl)

Playground.

trait WithType<T> {}
trait WithRegion<'a> { }

struct Foo<T> { 
    t: T
}

impl<T> Foo<T>
where T: WithRegion<'_> { }

fn main() {}

Using &u32 in a where clause (inherent impl)

Playground.

trait WithType<T> {}
trait WithRegion<'a> { }

struct Foo<T> { 
    t: T
}

impl<T> Foo<T>
where T: WithType<&u32> { }

fn main() {}

Using &u32 in a where clause (trait impl)

Playground.

trait WithType<T> {}
trait WithRegion<'a> { }

trait Foo { }

impl<T> Foo for Vec<T>
where T: WithType<&u32> { }

fn main() {}

Using '_ in a where clause (trait impl)

Playground.

trait WithType<T> {}
trait WithRegion<'a> { }

trait Foo { }

impl<T> Foo for Vec<T>
where T: WithRegion<'_> { }

fn main() {}

[nikomatsakis]

Survey of current behavior.

In Rust 2015 on nightly, all are errors.

[nikomatsakis]

We discussed this in the @rust-lang/lang meeting and there seemed to be consensus that we ought to make it an error to use '_ or &u32 in a where-clause for the time being, so as to leave room for locating the "implicit binder" at a different spot in the future. I think there is a connection here between this and in-band lifetimes, since they must also specify an "implicit binder", and hence it probably makes sense to "wait and see" where they go first.

(I have first hand observed confusion on this point.)

Given that the behavior is only accepted in Rust 2018, it seems we still have room to change this without requiring backporting.

[nikomatsakis]

See also #45667

[nikomatsakis]

Fixed in #55162