Functions with signature `fn (&str) -> &str` can return string literals (`&'static str`)

[japaric]

Explanation in the comments:

// The first two functions *require* the `'static` lifetime specifier
fn foo() -> &'static str {
    "foo"
}

fn bar(_: int) -> &'static str {
    "bar"
}

// In this function the `'static` specifier is *not* required, see next function
fn baz(_: &str) -> &'static str {
    "baz"
}

// Is the actual signature `fn bar<'a>(_: &'a str) -> &'a str` because of lifetime elision?
// Or does this function have the same signature as `baz`?
// In the former case, since the return type is `&'static str`, does that mean that `a` === `static` ?
fn quux(_: &str) -> &str {
    "quux"
}

fn main() {
    let string = "String".to_string();
    let slice = string.as_slice();

    // `slice` doesn't have `&'static str` type, but it's accepted by `quux`
    // that means that `baz` and `quux` have the same signature
    println!("{}", quux(slice));
    println!("{}", baz(slice));
}

TL;DR quux can be ambiguous to the reader because of lifetime elision rules. I think we should forbid functions with signature fn (&str) -> &str that actually return &'static str. Instead of quux, programmers should use baz.

[sfackler]

I'm not sure why this is specific to &str as opposed to &T.

[huonw]

Adding explicit lifetimes like fn quux<'a>(_: &'a str) -> &'a str { "quux" } works fine too (i.e. this isn't caused by lifetime elision).

The reason it all works is 'static is a super-lifetime of every lifetime, i.e. &'static str is also a &'a str for any 'a, because 'static data is guaranteed to live for 'a (including a elided/anonymous lifetime). This behaviour can be quite useful, when sometimes you wish to return something out of an argument, and sometimes some fixed string, e.g.

fn f<'a>(x: &'a Option<String>) -> &'a str {
     match *x {
         Some(ref s) => s.as_slice(),
         None => "<none>"
     }
}

Changing this would also affect traits, where one might have fn foo<'a>(&'a self) -> &'a str, but implement it for some type where the return value is a fixed string.

[japaric]

&'static str is also a &'a str for any 'a

I see, &'static str can be "re-borrowed" as &'a str for any a because &'static str is always available (or in other words a is always "shorter" than or equal to static). For some reason, I always forget that the compiler can do that.

I was analyzing the issue from the other way: that &'a str would have to be "upgraded" to &'static str, which is not possible.

Thanks for the explanation @huonw! My misunderstanding, closing.