Confusing compilation error when forgetting to deref_mut in a chain of iterators

[robinmoussu]

This doesn’t compile:

fn foo(items: &mut [u8]) -> u8 {
    // The centent of this function isn’t important
    items.sort();
    42
}

fn main() {
    let mut x: Vec<Vec<u8>> = vec![
        vec![0, 1, 2],
        vec![3, 4, 5],
    ];
    let x = x
        .iter_mut()
        .map(foo) // <-- this line
    println!("{:?}", x);
}

error[[E0631]](https://doc.rust-lang.org/stable/error-index.html#E0631): type mismatch in function arguments
  --> src/main.rs:20:14
   |
1  | fn foo(items: &mut [u8]) -> u8 {
   | ------------------------------ found signature defined here
...
20 |         .map(foo);
   |          --- ^^^ expected due to this
   |          |
   |          required by a bound introduced by this call
   |
   = note: expected function signature `fn(&mut Vec<u8>) -> _`
              found function signature `for<'r> fn(&'r mut [u8]) -> _`
note: required by a bound in `map`

For more information about this error, try `rustc --explain E0631`.

The solution is either to call first deref

.map(std::ops::DerefMut::deref_mut).map(foo)

or

.map(|items| items.as_mut())

Or to use a lambda

.map(|mut items| foo(&mut items))

The current error doesn’t help to understand what the issue is and it’s very confusing because it may look like a lifetime error (because of the for<'r>…).

https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=c6ac2ca7a31b126442978d30419e07a8

[ch-iv]

@rustbot claim

[robinmoussu]

Trying to force the deref using from is equally as confusing:

    let x = x
        .iter_mut()
        .map(<&mut [u8]>::from) // <-- this line
        .map(foo);

error[[E0631]](https://doc.rust-lang.org/stable/error-index.html#E0631): type mismatch in function arguments
  --> src/main.rs:18:14
   |
18 |         .map(<&mut [u8]>::from)
   |          --- ^^^^^^^^^^^^^^^^^
   |          |   |
   |          |   expected due to this
   |          |   found signature defined here
   |          required by a bound introduced by this call
   |
   = note: expected function signature `fn(&mut Vec<u8>) -> _`
              found function signature `fn(&mut [u8]) -> _`
note: required by a bound in `map`

[ch-iv]

As I understand, the issue is that x.iter_mut() returns an IterMut and when iterating over it, the elements are references. In order to fix the error, the elements must be dereferenced first, for example, by calling .map(std::ops::DerefMut::deref_mut). The error and notes don't give any indication of that. Is my understanding correct?

[ch-iv]

I couldn't find confirmation, so I am releasing.
@rustbot release-assignment

[robinmoussu]

As I understand, the issue is that x.iter_mut() returns an IterMut and when iterating over it, the elements are references. In order to fix the error, the elements must be dereferenced first, for example, by calling .map(std::ops::DerefMut::deref_mut). The error and notes don't give any indication of that. Is my understanding correct?

@ch-iv Your understanding is right. Sorry, I did not saw the notification, which explain why I didn’t responded earlier.

[ch-iv]

@rustbot claim

[estebank]

@ch-iv you can take a look at #105674 for inspiration on how to walk the method chain looking for the previous types, but in this case you need to look at the expected/found arguments, detect there's a single one and then check if the found implements Deref or DerefMut into the expected type, and then suggest the map(appropriate::method).