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