E0623 gives very confusing message

[Timmmm]

Given the following code:

fn bar(writer: &mut Writer) {
    baz(writer.indent());
    writer.write("world");
}

fn baz(writer: &mut Writer) {
    writer.write("hello");
}

pub struct Writer<'a> {
    target: &'a mut String,
    indent: usize,
}

impl<'a> Writer<'a> {
    fn indent(&'a mut self) -> &'a mut Self {
        &mut Self {
            target: self.target,
            indent: self.indent + 1,
        }
    }

    fn write(&mut self, s: &str) {
        for _ in 0..self.indent {
            self.target.push(' ');
        }
        self.target.push_str(s);
        self.target.push('\n');
    }
}

The current output is:

error[E0623]: lifetime mismatch
 --> src/writer.rs:2:16
  |
1 | fn bar(writer: &mut Writer) {
  |                -----------
  |                |
  |                these two types are declared with different lifetimes...
2 |     baz(writer.indent());
  |                ^^^^^^ ...but data from `writer` flows into `writer` here

This is really confusing. The error mentions two types, but then it only points to one type. And then it says "data from writer flows into writer". What? The data flows into itself?

[BGR360]

Minimal repro (playground):

struct Foo<'a>(&'a i32);

impl<'a> Foo<'a> {
    fn modify(&'a mut self) {}
}

fn bar(foo: &mut Foo) {
    foo.modify();
}

error[E0623]: lifetime mismatch
 --> src/lib.rs:8:9
  |
7 | fn bar(foo: &mut Foo) {
  |             --------
  |             |
  |             these two types are declared with different lifetimes...
8 |     foo.modify();
  |         ^^^^^^ ...but data from `foo` flows into `foo` here

• Getting rid of the 'a on &'a mut self makes it compile.
• Getting rid of the mut on &'a mut self makes it compile.
• Getting rid of the lifetime parameter on Foo makes it compile.

If we put explicit lifetime annotations in bar's function signature, we still get the same error:

fn bar<'a, 'b>(foo: &'a mut Foo<'b>) {
    foo.modify();
}

error[E0623]: lifetime mismatch
 --> src/lib.rs:8:9
  |
7 | fn bar<'a, 'b>(foo: &'a mut Foo<'b>) {
  |                     ---------------
  |                     |
  |                     these two types are declared with different lifetimes...
8 |     foo.modify();
  |         ^^^^^^ ...but data from `foo` flows into `foo` here

However, if we annotate only Foo, then we get a much better error:

fn bar<'a>(foo: &mut Foo<'a>) {
    foo.modify();
}

error[E0621]: explicit lifetime required in the type of `foo`
 --> src/lib.rs:8:9
  |
7 | fn bar<'a>(foo: &mut Foo<'a>) {
  |                 ------------ help: add explicit lifetime `'a` to the type of `foo`: `&'a mut Foo<'a>`
8 |     foo.modify();
  |         ^^^^^^ lifetime `'a` required

And indeed, that is the true fix (playgound):

fn bar<'a>(foo: &'a mut Foo<'a>) {
    foo.modify();
}

As I mentioned above, the error is contingent upon Foo::modify taking in a mutable reference. Perhaps this is due to the invariance of &mut. Very tricky.

In any case, I think we should try to find a way to display a message that is very similar to the add explicit lifetime message.

@rustbot label +D-confusing +D-terse +D-newcomer-roadblock +A-lifetimes

[BGR360]

See #89336 for some work being done to improve messaging on variance.