Inconsistent borrow-checking errors based on function return type

[yakubin]

I tried this code:

struct Foo<'a, 'b>(&'a u8, &'b u8);

struct Bar<'a, 'b>(&'a u8, &'b u8);

impl<'a, 'b> Bar<'a, 'b> {
    fn f1() -> &'a [Foo<'a, 'b>] {
        &[]
    }
    
    fn f2() {
        Self::f1();
    }
    
    fn f3() -> &'a [Foo<'a, 'b>] {
        Self::f1();
        &[]
    }
}

I expected to see this happen: Either both f2() and f3() to build without errors, or both generate errors.

Instead, this happened: only f2() generates an error. f3() is built without errors:

   Compiling borrow-test v0.1.0 (/Users/yakubin/src/borrow-test)
error: lifetime may not live long enough
  --> src/lib.rs:11:9
   |
5  | impl<'a, 'b> Bar<'a, 'b> {
   |      --  -- lifetime `'b` defined here
   |      |
   |      lifetime `'a` defined here
...
11 |         Self::f1();
   |         ^^^^^^^^^^ requires that `'b` must outlive `'a`
   |
   = help: consider adding the following bound: `'b: 'a`

error: could not compile `borrow-test` due to previous error

Meta

rustc --version --verbose:

rustc 1.66.0 (69f9c33d7 2022-12-12)
binary: rustc
commit-hash: 69f9c33d71c871fc16ac445211281c6e7a340943
commit-date: 2022-12-12
host: aarch64-apple-darwin
release: 1.66.0
LLVM version: 15.0.2

(Checked on Rust Playgrounds that it's also reproduced on Rust nightly.)

f2() building should imply f3() building and vice versa, since they only differ by their return types, but the error is in a line that has nothing to do with whatsoever being returned.

[danielhenrymantilla]

f1 and f3 both mention &'a [Foo<'a, 'b>] in their signatures, which thus triggers implicit bounds from what is called "well-formedness", or WF for short. For instance, given &'a Referee, the WF bounds stipulate that Referee : 'a needs to hold. In this case, this yields:

1. [Foo<'a, 'b>] : 'a;
2. thus, 'a : 'a and 'b : 'a
3. i.e., 'b : 'a.

That is, the f1 and f3 functions act as if they had a hidden:

where 'b : 'a,

clause in order for the function signature to even begin to make sense.

---

The f2 function, on the other hand, has no such types in its signatures, and thus no such implicit bound imposed on its caller. This means that in its function body / implementation, it will not be able to rely on 'b : 'a. Which means it cannot itself call f1, since f1 has that very requirement for its own caller(s) (implicitly) in its signature.

f3 does have the implicit bound in its signature (by virtue of mentioning a type whose WF clauses require it), which thus enables it to fulfill the implicit bounds/requirements of f1 (since they happen to be the same), thus allowing it to call f1.

All this is indeed quite subtle, and could deserve being better documented, but it is not a bug / it is working as intended 🙂

---

impl<'a, 'b> Bar<'a, 'b> {
    fn f1() -> &'a [Foo<'a, 'b>]
    where 'b : 'a // 👈 due to WF on `&'a [Foo<'a, 'b>]`
    {
        &[]
    }
    
    fn f2() {
        Self::f1(); // Error, missing `'b : 'a` bound.
    }
    
    fn f3() -> &'a [Foo<'a, 'b>]
    where 'b : 'a // 👈 due to WF on `&'a [Foo<'a, 'b>]`
    {
        Self::f1();
        &[]
    }
}

[yakubin]

In my humble opinion, not inferring and instead requiring the user to write the where clauses each time would be more intelligible to users of the language. But I'm guessing this ship already sailed. :)

Thank you for the explanation.