It is not possible to call methods with explicit litefimes on self when implementing a trait

[arjantop]

This used to work:

struct Foo<'a> {
    bar: &'a mut int
}

impl<'a> Foo<'a> {
    fn get(&'a mut self) -> &'a mut int {
        return &mut *self.bar
    }

    fn baz(&mut self) {
        let a = self.get();
    }
}

Now explicit lifetime on self is required if calling get:

    fn baz(&'a mut self) {
        let a = self.get();
    }

This means that you can't call methods with explicit lifetimes on self when implementing a trait:

struct Foo<'a> {
    bar: &'a mut int
}

trait Trait {
    fn baz(&mut self);
}

impl<'a> Foo<'a> {
    fn get(&'a mut self) -> &'a mut int {
        return &mut *self.bar
    }
}

impl<'a> Trait for Foo<'a> {
    fn baz(&mut self) {
        let a = self.get();
    }
}

The real usecase is thid:

fn get_writer(&'a mut self) -> &'a mut io::Writer {
    if self.writers.len() == 0 {
        &mut self.writer as &'a mut io::Writer
    } else {
        self.writers.mut_last().unwrap() as &'a mut io::Writer
    }
}

[arjantop]

Forgot to iinclude error messages:

<anon>:16:5: 18:6 note: consider using an explicit lifetime parameter as shown: fn baz(&'a mut self)
<anon>:16     fn baz(&mut self) {
<anon>:17         let a = self.get();
<anon>:18     }
<anon>:17:17: 17:27 error: cannot infer an appropriate lifetime for autoref due to conflicting requirements
<anon>:17         let a = self.get();

Rust play: http://is.gd/T6MfZd

[arjantop]

As suggested on reddit it is actually possible to make this to work using a local lifetime parameter:

struct Foo<'a> {
    bar: &'a mut int
}

trait Trait {
    fn baz(&mut self);
}

impl<'a> Foo<'a> {
    fn get<'a>(&'a mut self) -> &'a mut int {
        return &mut *self.bar
    }
}

impl<'a> Trait for Foo<'a> {
    fn baz(&mut self) {
        let a = self.get();
    }
}

This still looks like a bug to me.

[alexcrichton]

cc @nikomatsakis, @nick29581

[nikomatsakis]

Hmm. I agree that this should work. I am not sure what would have caused it to change.

[arjantop]

The timeframe is last ~5 days (last travis build), could give more accurete date but sadly rust-ci is not rebuilding daily again

[nikomatsakis]

Actually, reading the example more closely, I don't think it should work and I'm a bit surprised that it did. The two functions in question are &mut self, which means that self has type &mut Foo<'a>. In that case, when baz invokes foo, foo() expects &'X mut Foo<'X> for some lifetime 'X. At first I thought the methods were &self, not &mut self, in which case we could infer a shorter lifetime for 'X. But because the methods mut self, the lifetime 'X must match exactly. Hence 'X must be 'a, and in that case baz is ill-typed.

This is an instance of the &mut being more conservative than might be desired: it stems from the ability to write *p = ... where p has type &mut T. This means that p is "invariant" -- in this case, that means the lifetimes must match exactly with no approximation, which is stronger than what you actually need in this example.

[nikomatsakis]

Note that you can also rewrite get as follows:

fn get<'b>(&'b mut self) -> &'b mut int { ... }

in order to enable your trait example.

[arjantop]

Ah, it make sense now. I was expecting that it could figure out that the lifetimes are actually the same.

Should this get a test?

[steveklabnik]

Since this is expected behavior, I'm giving it a close.