Source of `'static` lifetimes in types don't show up in diagnostics

[tgross35]

Code

struct Foo<'a> {
    s1: &'a str,
    s2: &'static str
}

fn make_foo<'a>(s: &'a str) -> Foo<'a> {
    Foo {
        s1: s,
        s2: s
    }
}

Current output

error: lifetime may not live long enough
 --> src/lib.rs:9:13
  |
6 | fn make_foo<'a>(s: &'a str) -> Foo<'a> {
  |             -- lifetime `'a` defined here
...
9 |         s2: s
  |             ^ this usage requires that `'a` must outlive `'static`

error: could not compile `playground` (lib) due to previous error

Desired output

Something that indicates where the static lifetime comes from

error: lifetime may not live long enough
 --> src/lib.rs:9:13
  |
6 | fn make_foo<'a>(s: &'a str) -> Foo<'a> {
  |             -- lifetime `'a` defined here
...
9 |         s2: s
  |             ^ this usage requires that `'a` must outlive `'static`
--
3 |     s2: &'static str
  |         ^ `'static` lifetime specified here

Rationale and extra context

There's nothing in the function body or in the diagnostic to indicate why something must be 'static if that information is associated with a type, so giving a hint would be helpful.

By comparison, it's much easier to figure out non-static things since the named lifetime 'a clearly has a relationship with the type Foo.

5 |   fn make_foo<'a, 'b>(s: &'b str) -> Foo<'a> {
  |               --  -- lifetime `'b` defined here
  |               |
  |               lifetime `'a` defined here
6 | /     Foo {
7 | |         s1: s,
8 | |     }
  | |_____^ function was supposed to return data with lifetime `'a` but it is returning data with lifetime `'b`

Other cases

No response

Anything else?

No response

[tgross35]

@rustbot label +A-lifetimes +D-terse

[kpreid]

Here's another example of an error not mentioning at all the origin of a 'static bound, in this case a std::thread::spawn() function call; reduced from this URLO thread.

pub fn thread_recursive<'a>(v: &'a mut [i32]) {
    if v.len() == 0 {
        return;
    }
    let (left, right): (&'a mut [i32], &'a mut [i32]) =
        v.split_at_mut(v.len() / 2);
    std::thread::spawn(|| thread_recursive(left));
    std::thread::spawn(|| thread_recursive(right));
}

error: lifetime may not live long enough
 --> src/lib.rs:5:24
  |
1 | pub fn thread_recursive<'a>(v: &'a mut [i32]) {
  |                         -- lifetime `'a` defined here
...
5 |     let (left, right): (&'a mut [i32], &'a mut [i32]) =
  |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type annotation requires that `'a` must outlive `'static`

Note that the actually problematic lines are not mentioned at all — not the spawn, not the closure, and not the recursive calls.