IndexMut incorrectly chosen instead of Index

[wthrowe]

use std::ops::{Index, IndexMut};

struct S;

impl S { fn foo(&self) -> i32 { 0 } }

impl Index<usize> for S {
    type Output = S;
    fn index(&self, _: usize) -> &S { self }
}

impl IndexMut<usize> for S {
    fn index_mut(&mut self, _: usize) -> &mut S { self }
}

fn main() {
    let s = S;
    let _ = &mut s.foo(); // OK
    let _ = &mut (&s[0]).foo(); // OK
    let _ = &mut s[0].foo(); // error: cannot borrow immutable local variable `s` as mutable                                                                   
}

The whole example compiles it the IndexMut implementation is removed.

[gwillen]

I'm also running into something that appears to be this issue. I'm indexing a Vec, so the implementation of IndexMut is not under my control. I can try to make a reduced example using Vec if it would be helpful. EDIT: oh, it seems that 29869 already contains such an example.

[PeterHatch]

Just wanted to note that I encountered this bug.

[shepmaster]

This came up on Stack Overflow. A simplified example:

use std::cell::RefCell;

fn f(v: Vec<RefCell<u8>>) {
   let _t = &mut *v[0].borrow_mut();
}

fn main() {}

error[E0596]: cannot borrow immutable argument `v` as mutable
 --> src/main.rs:4:20
  |
3 | fn f(v: Vec<RefCell<u8>>) {
  |      - consider changing this to `mut v`
4 |     let _t = &mut *v[0].borrow_mut();
  |                    ^ cannot borrow mutably

Workarounds include:

1. Using extra braces:

   fn f(v: Vec<RefCell<u8>>) {
       let _t = &mut *{ v[0].borrow_mut() };
   }

2. Calling Index::index explicitly:

   fn f(v: Vec<RefCell<u8>>) {
       use std::ops::Index;
       let _t = &mut *v.index(0).borrow_mut();
   }

3. Calling RefCell::borrow explicitly:

   fn f(v: Vec<RefCell<u8>>) {
       let _t = &mut *RefCell::borrow_mut(&v[0]);
   }

[jackh726]

This compiles now. Marking as needs-test (unsure if there is one that covers this already)