Lifetime issues: assigning to a mutable reference with part of its current value

[Ekleog]

Edit: simplified reproducer as well as workaround available at #72477 (comment)

Hello,

While trying to implement an AsyncRead wrapper, I have hit something that I think is the borrow-checker being too restrictive with &mut inside Pin.

I originally thought it was an issue in pin-project, but @taiki-e pointed out that the issue also happens with raw Pin, in taiki-e/pin-project#226 (comment) (thank you!)

Copying the example here (with an explicit lifetime):

pub struct Foo<'a> {
    buf: &'a mut [u8],
}

impl<'a> Foo<'a> {
    fn foo<'b>(self: std::pin::Pin<&'b mut Self>) {
        self.buf = &mut self.buf[1..];
    }
}

(playground)

This is potentially related to #54934 ; but seeing as it manifests in a completely different way (ie. it doesn't manifest with just & references in the original example with pin-project linked above, though the example code here is incorrect indeed), I thought it'd be better to open another issue, as at worst it'd be fixed at the same time as #54934 and would just add another test.

As usual, thank you for all you do on this great language!

[taiki-e]

I just found a way to avoid this issue in futures-rs repo: https://github.com/rust-lang/futures-rs/blob/71f1e054c2c85c38f28439392f1c291056051bd9/futures-util/src/io/read_exact.rs#L31-L34

playground

pub struct Foo<'a> {
    buf: &'a mut [u8],
}

impl<'a> Foo<'a> {
    fn foo(mut self: std::pin::Pin<&mut Self>) {
        let (_, rest) = std::mem::replace(&mut self.buf, &mut []).split_at_mut(1);
        self.buf = rest;
    }
}

[taiki-e]

Also, it looks like this issue can be reproduced without Pin.

playground

pub struct Foo<'a> {
    buf: &'a mut [u8],
}

impl<'a> Foo<'a> {
    fn repro(&mut self) { 
        self.buf = &mut self.buf[1..]; //~ ERROR
    }

    fn fixed(&mut self) {
        let (_, rest) = std::mem::replace(&mut self.buf, &mut []).split_at_mut(1);
        self.buf = rest;
    }
}

[Ekleog]

Oooh, thank you for both your messages! I've been able to make my code compile with your workaround, and your reproducer is much simpler — I've just renamed the issue to better match the simplified reproducer you found, and will link to your message from the top post just after having posted this :)

(for the full context, I had two buffers, one of which was a borrow of the other, the solution was replacing the second buffer by a range that's to be interpreted as part of the first buffer)