#[warn(unused_mut)] does not always warn

[nwin]

rustc fails to warn about unused mut for buf in this case:

use std::io;

pub fn read_all<R: io::Read + ?Sized>(this: &mut R, mut buf: &mut [u8]) -> io::Result<()> {
    let mut total = 0;
    while total < buf.len() {
        match this.read(&mut buf[total..]) {
            Ok(0) => return Err(io::Error::new(io::ErrorKind::Other,
                                               "failed to read whole buffer")),
            Ok(n) => total += n,
            Err(ref e) if e.kind() == io::ErrorKind::Interrupted => {}
            Err(e) => return Err(e),
        }
    }
    Ok(())
}

fn main() {}

[steveklabnik]

Triage: here's the smallest reproduction:

pub fn foo(mut buf: &mut [u8]) {
    &mut buf[..];
}

[ivanbakel]

Small update while looking to this: the borrow checker looks like it's doing a ref adjustment when the types are already compatible. Another minimal example is this:

 pub fn foo(mut x : &mut u8) -> &mut u8 {
    let y = x; // x is marked as not needing to be mutable
    let y : &mut u8 = x; // x is not marked as not needing to be mutable
    y // In either case, y doesn't have "the same type" as the return type, 
      // so an adjustment is made, meaning you can mark y as mut, and
      // no warning will be given
 }

I might be misunderstanding the borrow checking code, but it looks the adjustment means there's a second, implicit borrow, equivalent to a &mut (*y) - similarly, if y : &mut u8 = x, then y : &mut u8 = &mut (*x). Since the borrow checker recognises the mutable borrow, it tries to mark the use of mut on *y (and this marks y) in mark_loan_paths_as_mutated.

Working on a fix, but it's not clear if the issue is with what's being marked as used, or what the conditions are for it happening.