properly handle anonymous regions appearing in return type- named-anon conflicts

[gaurikholkar-zz]

These cases, going by the way #42669 for one named and other anonymous lifetime parameter , the error message generated would suggest consider changing type of self to &'a i32. In the first case, this is fine but the second case, with self.field not being the return value, the message is wrong and should only suggest changing the return type. We need to differentiate both the cases and fix the error message for the second case.

fn foo<'a>(&self, x: &'a i32) -> &i32 {
 // Preferred message:
 //     fn foo<'a>(&self, x: &'a i32) -> &i32 {
 //                 -----                 ---- consider changing to `&'a i32`
 //                 |
 //                 consider changing to `&'a self`
    if true { &self.field } else { x }
  }

fn foo<'a>(&self, x: &'a i32) -> &i32 {
//       preferred error
//       fn foo<'a>(&self, x: &'a i32) -> &i32 {             
//                                         ---- consider changing to `&'a i32`
    x

// error[E0611]: explicit lifetime required in the type of `self`
//    |
// 33 |     fn foo<'a>(&self, x: &'a i32) -> &i32 {
//    |                 ^^^^^ consider changing the type of `self` to `&'a Foo`
// 34 |         //                             
// 35 |         x
//    |         - lifetime `'a` required
  }

cc @nikomatsakis

[nikomatsakis]

So the problem here is that, without examining the region graph closely, we can't tell the difference between these two cases. This is non-trivial to solve: I have to say that when I took a look at the region inference graphs for these two cases, I failed to see any obvious rules we could use to distinguish them. We may have to add additional refinement into the "causes" and so forth to figure this out.

[nikomatsakis]

I had a thought about possibly changing the error message to avoid doing complex analysis. Maybe instead of suggesting to the user what change they ought to make (which would require analysis), we might do a better job just telling them what is needed. So the two cases would look like:

fn foo<'a>(&self, x: &'a i32) -> &i32 {
    //               -------     ---- these references must have the same lifetime
    x
//  ^ data from `x` is returned here
}

fn foo<'a>(&self, x: &'a i32) -> &i32 {
    //               -------     ---- these references must have the same lifetime
    if true { &self.field } else { x }
    //                             ^ data from `x` is returned here
}

The second case is, I guess, non-ideal, in that it would be nicer if we could underline all three references.

[gaurikholkar-zz]

working on this now

[nikomatsakis]

Seems like we could use some mentoring instructions here!

[nikomatsakis]

@gaurikholkar I'm not sure, did we ever land code fixing this?

[gaurikholkar-zz]

@nikomatsakis for now, #44124 handles them all

[estebank]

@gaurikholkar we can close this ticket now, right?

[gaurikholkar-zz]

For Case 1,

5 | fn foo<'a>(&self, x: &'a i32) -> &i32 
  |                      -------     ----
  |                      |
  |                      this parameter and the return type are declared with different lifetimes...
6 |         x
  |         ^ ...but data from `x` is returned here

Case 2

5 | fn foo<'a>(&self, x: &'a i32) -> &i32 
  |                      -------     ----
  |                      |
  |                      this parameter and the return type are declared with different lifetimes...
6 |         if true {x} else {&self}
  |                  ^ ...but data from `x` is returned here

@nikomatsakis afaik, we were planning to further modify the error message. Should we open up a new issue for that?
cc @estebank

[estebank]

Current output:

error[E0623]: lifetime mismatch
  --> src/lib.rs:12:36
   |
6  | fn foo<'a>(&self, x: &'a i32) -> &i32 {
   |                      -------     ----
   |                      |
   |                      this parameter and the return type are declared with different lifetimes...
...
12 |     if true { &self.field } else { x }
   |                                    ^ ...but data from `x` is returned here

error[E0623]: lifetime mismatch
  --> src/lib.rs:19:5
   |
15 |   fn bar<'a>(&self, x: &'a i32) -> &i32 {
   |                        -------     ----
   |                        |
   |                        this parameter and the return type are declared with different lifetimes...
...
19 |     x
   |     ^ ...but data from `x` is returned here

Only missing thing would be to suggest changing the lifetimes.

[estebank]

Current output:

error: lifetime may not live long enough
  --> src/lib.rs:12:36
   |
6  | fn foo<'a>(&self, x: &'a i32) -> &i32 {
   |        --  - let's call the lifetime of this reference `'1`
   |        |
   |        lifetime `'a` defined here
...
12 |     if true { &self.field } else { x }
   |                                    ^ associated function was supposed to return data with lifetime `'1` but it is returning data with lifetime `'a`

error: lifetime may not live long enough
  --> src/lib.rs:19:5
   |
15 |   fn bar<'a>(&self, x: &'a i32) -> &i32 {
   |          --  - let's call the lifetime of this reference `'1`
   |          |
   |          lifetime `'a` defined here
...
19 |     x
   |     ^ associated function was supposed to return data with lifetime `'1` but it is returning data with lifetime `'a`