Cannot index and immediately call FnMut

[timotree3]

Running this code on the latest stable (1.38.0) as well as nightly (2019-10-20)

fn foo<F, I>(i: &mut I)
where
    F: FnMut(),
    I: std::ops::IndexMut<(), Output = F>,
{
    i[()](); // fails
    (&mut i[()])(); // works
}

gives the error

error[E0596]: cannot borrow data in an index of `I` as mutable
 --> src/lib.rs:6:5
  |
6 |     i[()](); // fails
  |     ^^^^^ cannot borrow as mutable
  |
  = help: trait `IndexMut` is required to modify indexed content, but it is not implemented for `I`

which is clearly wrong.

Notably, the same error does not occur if we switch everything to Fn:

fn foo<F, I>(i: &I)
where
    F: Fn(),
    I: std::ops::Index<(), Output = F>,
{
    i[()](); // works
}

[timotree3]

I can still reproduce this on latest nightly (nightly-2019-12-21)

[timotree3]

I can still reproduce this on the playground with nightly-2020-05-08 and stable 1.43.1

[estebank]

There seems to be something unaccounted for in mir's check_access_permissions.

CC @oli-obk in case they have context around this already

[estebank]

Looking further I think that the problem is that the place for i[()] is a Deref instead of DerefMut before we get to the MIR borrow checker, which is why it rejects it as not mutable. This makes me think that somewhere in typeck we don't flow the mutable obligation from the i[()]() call back to the i[()]. This also explains why (&mut i[()])() works, because the mutable obligation is explicitly stated and flowed forward, making the call work incidentally.

[estebank]

I'm not sure what the correct thing will be, but I suspect that changing the following so that it modifies the adjustments for callee_expr to be mutable Deref/Borrow will do the trick, but I am not overly familiar with this part of the codebase:

rust/src/librustc_typeck/check/callee.rs

Lines 149 to 164 in 1ccb0b4

	// Now, we look for the implementation of a Fn trait on the object's type.
	// We first do it with the explicit instruction to look for an impl of
	// `Fn<Tuple>`, with the tuple `Tuple` having an arity corresponding
	// to the number of call parameters.
	// If that fails (or_else branch), we try again without specifying the
	// shape of the tuple (hence the None). This allows to detect an Fn trait
	// is implemented, and use this information for diagnostic.
	self.try_overloaded_call_traits(call_expr, adjusted_ty, Some(arg_exprs))
	.or_else(|| self.try_overloaded_call_traits(call_expr, adjusted_ty, None))
	.map(|(autoref, method)| {
	let mut adjustments = autoderef.adjust_steps(self, Needs::None);
	adjustments.extend(autoref);
	self.apply_adjustments(callee_expr, adjustments);
	CallStep::Overloaded(method)
	})
	}

[compiler-errors]

This code works now.