Implicit return leads to "does not live long enough" error.

[gyscos]

Here is a simple function that tries to read all lines from input:

use std::io::{self,BufRead};

fn lines() -> Vec<String> {
    let stdin = io::stdin();
    let handle = stdin.lock();

    handle.lines().map(|line| line.unwrap()).collect()
}

fn main() {
}

As shown here, attempting to compile it (on stable 1.6, beta or nightly) gives a lifetime error:

<anon>:5:18: 5:23 error: `stdin` does not live long enough
<anon>:5     let handle = stdin.lock();
                          ^~~~~
<anon>:3:27: 8:2 note: reference must be valid for the destruction scope surrounding block at 3:26...
<anon>:3 fn lines() -> Vec<String> {
<anon>:4     let stdin = io::stdin();
<anon>:5     let handle = stdin.lock();
<anon>:6 
<anon>:7     handle.lines().map(|line| line.unwrap()).collect()
<anon>:8 }
<anon>:4:29: 8:2 note: ...but borrowed value is only valid for the block suffix following statement 0 at 4:28
<anon>:4     let stdin = io::stdin();
<anon>:5     let handle = stdin.lock();
<anon>:6 
<anon>:7     handle.lines().map(|line| line.unwrap()).collect()
<anon>:8 }

Making the return explicit fixes this:

use std::io::{self,BufRead};

fn lines() -> Vec<String> {
    let stdin = io::stdin();
    let handle = stdin.lock();

    return handle.lines().map(|line| line.unwrap()).collect();
}

fn main() {
}

Is this the expected behavior? I would have thought explicit and implicit returns would give the same result...

[steveklabnik]

This does seem like a bug. I can't quite remember, but I think there is a similar issue somewhere...

[arielb1]

This looks like a destruction order problem to me.

[Thiez]

Assigning the result to a local and then implicitly returning that local also solves this problem:

fn lines() -> Vec<String> {
    let stdin = io::stdin();
    let handle = stdin.lock();

    let result = handle.lines().map(|line| line.unwrap()).collect();
    result
}

Perhaps rustc sometimes incorrectly requires too many lifetimes in an implicit return expression to be valid until the end of the function, instead of looking only at the lifetimes mentioned in the result of the expression?

[Thiez]

Here, a minimal example:

struct S{ n: u8 }
struct T<'a>{ s: &'a S }
impl<'a> Drop for T<'a> { fn drop(&mut self){} }

fn test_good() -> u8 { // this is fine
    let s = S{ n: 5 };
    return T{ s: &s }.s.n;
}

fn test_bad() -> u8 { // this is not
    let s = S{ n: 5 };
    T{ s: &s }.s.n
}

fn main(){}

[Ryman]

Seems related to #22252

[arielb1]

This looks like a duplicate of #33490 - on MIR it would be a segfault.