NLL issue when using DerefMut to access fields through a Pin, causing multiple mutable borrow error

[dialtone]

The code below doesn't compile due to multiple mutable borrows, however the exact same code without the std::pin::Pin compiles fine actually. My expectation is however that the code would obviously compile fine in both cases.

use std::pin::Pin;
use slab;

struct Entry {
    complete: u64
}

struct Ctx {}
impl Ctx {
    fn new() -> Self {
        Ctx{}
    }
    fn pread<T>(&mut self, _key: T) -> std::io::Result<()> {
        Ok(())
    }
}

struct Foo {
    ctx: Ctx,
    handles: slab::Slab<Entry>
}
impl Foo {
    fn new() -> Self {
        Foo {ctx: Ctx::new(),
             handles: slab::Slab::with_capacity(20)}
    }
    
    fn blah(mut self: Pin<&mut Self>) {
        let v = self.handles.vacant_entry();
        let key = v.key();
        match self.ctx.pread(key) {
            Ok(()) => {
                v.insert(Entry{complete:123});
            },
            Err(_) => {
                
            }
        }
        
    }
}

fn main() {
    Pin::new(&mut Foo::new()).blah();
}

The exception raised is:

error[E0499]: cannot borrow `self` as mutable more than once at a time
  --> src/main.rs:31:15
   |
29 |         let v = self.handles.vacant_entry();
   |                 ---- first mutable borrow occurs here
30 |         let key = v.key();
31 |         match self.ctx.pread(key) {
   |               ^^^^ second mutable borrow occurs here
32 |             Ok(()) => {
33 |                 v.insert(Entry{complete:123});
   |                 - first borrow later used here

error: aborting due to previous error

I'm able to get the code to compile also by creating additional scopes around the areas where I'm supposedly borrowing self like this:

let key = {
    let entry = self.handles.vacant_entry();
    entry.key()
};
match self.ctx.pread(key) {
    Ok(()) => {
        *self.handles.get_mut(key).unwrap() =
            Entry { complete: 123 };
    }

Although obviously that's pretty awkward. I'm told that this could possibly be a bug in the NLL, but I'm pretty new to the language so I'm just reporting this with a short reproducible example.

Hope it helps.

[tmiasko]

The self is a Pin<&mut Self>. Obtaining mutable references to the fields
will require going through DerefMut, which requires unique borrow. This isn't
a NLL bug.

You can avoid the issue by dereferencing self once on entry to the method
let this = &mut *self, and then continue accessing it through this.

[dialtone]

Alright, thanks for the answer, it's a bit awkward anyway but it makes sense. Given however that in the discord channel other people were also confused by this, and now that I know what to search for, I see many questions asked online about this very same case for other types that implement DerefMut (like RefCell, Box and so on), maybe the error message returned by the language could explain a bit better that it could happen also because of this?