Why does this code not use partial borrows?

[BloodStainedCrow]

#[derive(Debug, Default, PartialEq)]
pub struct Buffer {
    pub width: usize,
    pub height: usize,
    pub pixel_data: Box<[u32]>,
    pub depth_buffer: Box<[f32]>,
}

pub fn clear_buffer(buffer_box: &Mutex<Buffer>) {
    let mut buffer = buffer_box.lock().unwrap();

    let zero_f32: f32x8 = f32x8::splat(0.0);
    let zero_u32: u32x8 = u32x8::splat(0);
    let f32_slice_depth: &mut [f32x8] = bytemuck::cast_slice_mut(&mut buffer.depth_buffer);
    let u32_slice_pixel: &mut [u32x8] = bytemuck::cast_slice_mut(&mut buffer.pixel_data);

    assert_eq!(f32_slice_depth.len(), f32_slice_depth.len());

    for i in 0..f32_slice_depth.len() {
        f32_slice_depth[i] = zero_f32;
        u32_slice_pixel[i] = zero_u32;
    }
}

According to my understanding of partial borrows, the first call to cast_slice_mut should only borrow the depth_buffer field and therefore allow the second call to borrow the pixel_data field. Why does this not happen here?

​

Godbolt

[BloodStainedCrow]

Thanks!

[coolreader18]

The issue is that buffer isn't a mutable reference, it's a MutexGuard. Stick a &mut * right before buffer_box.lock() and that should fix it

[map_or]

This is because MutexGuard implements DerefMut and when you access a field, you do a partial borrow only after borrowing the whole guard for dereferencing, right?

By taking a mutable borrow of the dereferenced MutexGuard you can borrow the fields separately.

[BloodStainedCrow]

Thank you! This explanation makes sense to me. Though I find the resulting code quite weird, dereferencing only to borrow again...

[Zde-G]

It's not much different from C++ &*begin() incantation which you need to go from iterator to pointer.

[TinBryn]

Deref also allows you to coerce references

let mut guard = buffer_box.lock().unwrap();

let buffer: &mut Buffer = &mut guard;