Type parameters of associated consts have unexpected lifetime constraints

[sfackler]

This simple trait fails to compile:

pub trait Foo<T> {
    const FOO: &'static fn(T);
}

error[E0310]: the parameter type `T` may not live long enough
 --> src/lib.rs:3:5
  |
2 | pub trait Foo<T> {
  |               - help: consider adding an explicit lifetime bound `T: 'static`...
3 |     const FOO: &'static fn(T);
  |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
  |
note: ...so that the reference type `&'static fn(T)` does not outlive the data it points at
 --> src/lib.rs:3:5
  |
3 |     const FOO: &'static fn(T);
  |     ^^^^^^^^^^^^^^^^^^^^^^^^^^

error: aborting due to previous error

For more information about this error, try `rustc --explain E0310`.

However, T's lifetime obviously has nothing to do with the lifetime of a pointer to a function that includes T.

[sfackler]

Note that a version of the trait with a function returning &'static fn(T) does compile:

pub trait Foo<T> {
    fn foo() -> &'static fn(T);
}

[Centril]

cc @nikomatsakis -- I seem to recall us having discussed &'static fn(T) at some point.

[stephaneyfx]

Can &'a T be valid if T contains a lifetime 'b and 'a strictly outlives 'b? Or formulated differently, does it make sense for a type involving lifetime 'a to exist outside of the scope defined by 'a? I think the answer is no by definition: 'a defines a scope which type definitions using this lifetime 'a cannot escape as they wouldn't be usable outside of this scope (what would 'a mean when the scope of 'a is over?). But I am happy to be explained where my reasoning is wrong. So I think it makes sense for &'static fn(T) to require T: 'static.

rustc seems to be somewhat inconsistent in how it handles all this.

This code is rejected:

fn foo<T>(_: T) {}

fn bar<'a>(_: &'a i32) {
    let _: &'static _ = &foo::<&'a i32>;
}

error[E0490]: a value of type `fn(&'a i32) {foo::<&'a i32>}` is borrowed for too long
 --> src/lib.rs:4:25
  |
4 |     let _: &'static _ = &foo::<&'a i32>;
  |                         ^^^^^^^^^^^^^^^
  |
  = note: the type is valid for the static lifetime
note: but the borrow lasts for the lifetime 'a as defined on the function body at 3:8
 --> src/lib.rs:3:8
  |
3 | fn bar<'a>(_: &'a i32) {
  |        ^^

error[E0495]: cannot infer an appropriate lifetime for borrow expression due to conflicting requirements
 --> src/lib.rs:4:25
  |
4 |     let _: &'static _ = &foo::<&'a i32>;
  |                         ^^^^^^^^^^^^^^^
  |
note: first, the lifetime cannot outlive the lifetime 'a as defined on the function body at 3:8...
 --> src/lib.rs:3:8
  |
3 | fn bar<'a>(_: &'a i32) {
  |        ^^
note: ...so that the type `fn(&'a i32) {foo::<&'a i32>}` is not borrowed for too long
 --> src/lib.rs:4:25
  |
4 |     let _: &'static _ = &foo::<&'a i32>;
  |                         ^^^^^^^^^^^^^^^
  = note: but, the lifetime must be valid for the static lifetime...
note: ...so that reference does not outlive borrowed content
 --> src/lib.rs:4:25
  |
4 |     let _: &'static _ = &foo::<&'a i32>;
  |                         ^^^^^^^^^^^^^^^

However this is accepted:

fn foo<T>(_: T) {}

fn bar<'a>(_: &'a i32) {
    let f = foo::<&'a i32>;
    is_static(f);
}

fn is_static<T: 'static>(_: T) {}

[stephaneyfx]

It looks like &'static fn(&'a i32) implicitly adds 'a: 'static.

If I try to provide an implementation for the trait @sfackler defined and use it with something not 'static, the code is rejected:

pub trait Foo<T> {
    fn foo() -> &'static fn(T);
}

fn foo(_: &i32) {}

struct A;

impl<'a> Foo<&'a i32> for A {
    fn foo() -> &'static fn(&'a i32) {
        &(foo as _)
    }
}

fn bar<'a>(x: &'a i32, _: A) {
    A::foo()(x);
}

error[E0495]: cannot infer an appropriate lifetime due to conflicting requirements
  --> src/lib.rs:16:5
   |
16 |     A::foo()(x);
   |     ^^^^^^
   |
note: first, the lifetime cannot outlive the lifetime 'a as defined on the function body at 15:8...
  --> src/lib.rs:15:8
   |
15 | fn bar<'a>(x: &'a i32, _: A) {
   |        ^^
note: ...so that reference does not outlive borrowed content
  --> src/lib.rs:16:14
   |
16 |     A::foo()(x);
   |              ^
   = note: but, the lifetime must be valid for the static lifetime...
note: ...so that the reference type `&'static fn(&i32)` does not outlive the data it points at
  --> src/lib.rs:16:5
   |
16 |     A::foo()(x);
   |     ^^^^^^^^

Other example:

fn foo<'a>(x: &'a i32, f: &'static fn(&'a i32)) {
    f(x);
}

fn bar() {
    let x = 3;
    foo(&x, &(baz as _));
}

fn baz(_: &i32) {}

error[E0597]: `x` does not live long enough
 --> src/lib.rs:7:9
  |
7 |     foo(&x, &(baz as _));
  |     ----^^--------------
  |     |   |
  |     |   borrowed value does not live long enough
  |     argument requires that `x` is borrowed for `'static`
8 | }
  | - `x` dropped here while still borrowed

Similar one:

fn foo<'a>(x: &'a i32, f: &'static fn(&'a i32)) {
    f(x);
}

fn bar<'a>(x: &'a i32) {
    foo(x, &(baz as fn(&'a i32)));
}

fn baz(_: &i32) {}

error[E0495]: cannot infer an appropriate lifetime for lifetime parameter 'a in function call due to conflicting requirements
 --> src/lib.rs:6:5
  |
6 |     foo(x, &(baz as fn(&'a i32)));
  |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  |
note: first, the lifetime cannot outlive the lifetime 'a as defined on the function body at 5:8...
 --> src/lib.rs:5:8
  |
5 | fn bar<'a>(x: &'a i32) {
  |        ^^
note: ...so that reference does not outlive borrowed content
 --> src/lib.rs:6:9
  |
6 |     foo(x, &(baz as fn(&'a i32)));
  |         ^
  = note: but, the lifetime must be valid for the static lifetime...
note: ...so that the reference type `&'static fn(&i32)` does not outlive the data it points at
 --> src/lib.rs:6:5
  |
6 |     foo(x, &(baz as fn(&'a i32)));
  |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

error[E0490]: a value of type `fn(&'a i32)` is borrowed for too long
 --> src/lib.rs:6:12
  |
6 |     foo(x, &(baz as fn(&'a i32)));
  |            ^^^^^^^^^^^^^^^^^^^^^
  |
  = note: the type is valid for the static lifetime
note: but the borrow lasts for the lifetime 'a as defined on the function body at 5:8
 --> src/lib.rs:5:8
  |
5 | fn bar<'a>(x: &'a i32) {
  |        ^^

error[E0495]: cannot infer an appropriate lifetime for borrow expression due to conflicting requirements
 --> src/lib.rs:6:12
  |
6 |     foo(x, &(baz as fn(&'a i32)));
  |            ^^^^^^^^^^^^^^^^^^^^^
  |
note: first, the lifetime cannot outlive the lifetime 'a as defined on the function body at 5:8...
 --> src/lib.rs:5:8
  |
5 | fn bar<'a>(x: &'a i32) {
  |        ^^
note: ...so that the type `fn(&'a i32)` is not borrowed for too long
 --> src/lib.rs:6:12
  |
6 |     foo(x, &(baz as fn(&'a i32)));
  |            ^^^^^^^^^^^^^^^^^^^^^
  = note: but, the lifetime must be valid for the static lifetime...
note: ...so that reference does not outlive borrowed content
 --> src/lib.rs:6:12
  |
6 |     foo(x, &(baz as fn(&'a i32)));
  |            ^^^^^^^^^^^^^^^^^^^^^

[rpjohnst]

I have some examples that I believe point the same issue: https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=afea083cb60113ea2c2817a442639ab5

IIUC, the erase3 case is the most interesting, because it should completely erase T's lifetime(s).

/// Allowed:
fn erase0<T: 'static + for<'a> As<'a>>() {
    assert_static::< fn(T) >();
    assert_static::< fn(&T) >();
    assert_static::< for<'a> fn(<T as As<'a>>::Out) >();
}

/// Not allowed:
fn erase1<'a>() { assert_static::< fn(&'a i32) >(); }
fn erase2<T>() { assert_static::< fn(T) >(); }
fn erase3<T: for<'a> As<'a>>() {
    assert_static::< for<'a> fn(<T as As<'a>>::Out) >();
}

/// Type-level function to replace a type's lifetime parameter.
pub trait As<'a> {
    type Out: 'a;
}

/// Ex: convert &'a T to &'b T.
impl<'a, 'b, T: 'b> As<'b> for &'a T {
    type Out = &'b T;
}

fn assert_static<T: 'static>() {}

(cc @eddyb since we discussed this briefly on Discord)

[eddyb]

because it should completely erase T's lifetime(s)

I'd say this is intentionally unsupported - you can't "wash out" lifetimes, they "stain" types forever, and for good reason, as it's hard to enforce soundness otherwise (ideally we'd have a formal proof to rely on...).