Cannot call by reference to `&mut F: FnMut`

[AngelicosPhosphoros]

I tried this code:

fn call_by_ref<F, A0, A1>(mut f: F, arg0: A0, arg1: A1)
where
    A0: Sized,
    A1: Sized,
    for<'w> &'w mut F: FnMut(A0, A1),
{
    // This doesn't work.
    (&mut f)(arg0, arg1);
}

// Workaround
fn call_by_ref_and_hack<F, A0, A1>(mut f: F, arg0: A0, arg1: A1)
where
    A0: Sized,
    A1: Sized,
    for<'w> &'w mut F: FnMut(A0, A1),
{
    fn call_once<B0, B1>(f: impl FnOnce(B0, B1), arg0: B0, arg1: B1){
        f(arg0, arg1)
    }
    // This works
    call_once(&mut f, arg0, arg1);
}

I expected to see this happen: Both functions should compile and work.

Instead, this happened: Only version with inner function hack works.

Meta

rustc --version --verbose:

rustc 1.70.0 (90c541806 2023-05-31)

AFAIK, it never worked.

[compiler-errors]

Pretty sure that it's due to this hack 😓

rust/compiler/rustc_hir_typeck/src/callee.rs

Lines 180 to 194 in 4051305

	// Hack: we know that there are traits implementing Fn for &F
	// where F:Fn and so forth. In the particular case of types
	// like `f: &mut FnMut()`, if there is a call `f()`, we would
	// normally translate to `FnMut::call_mut(&mut f, ())`, but
	// that winds up potentially requiring the user to mark their
	// variable as `mut` which feels unnecessary and unexpected.
	//
	// fn foo(f: &mut impl FnMut()) { f() }
	// ^ without this hack `f` would have to be declared as mutable
	//
	// The simplest fix by far is to just ignore this case and deref again,
	// so we wind up with `FnMut::call_mut(&mut *f, ())`.
	ty::Ref(..) if autoderef.step_count() == 0 => {
	return None;
	}

We really should be re-trying that branch if the other autoderef steps fail.

rust/compiler/rustc_hir_typeck/src/callee.rs

Lines 96 to 98 in 4051305

	while result.is_none() && autoderef.next().is_some() {
	result = self.try_overloaded_call_step(call_expr, callee_expr, arg_exprs, &autoderef);
	}

[AngelicosPhosphoros]

Another workaround, probably more effecient:

fn call_by_anonymising<F, A0, A1>(mut f: F, arg0: A0, arg1: A1)
where
    A0: Sized,
    A1: Sized,
    for<'w> &'w mut F: FnMut(A0, A1),
{
    #[inlne]
    fn anonymise<B0, B1>(f: impl FnOnce(B0, B1))->impl FnOnce(B0, B1){
        f
    }
    // This works
    anonymise(&mut f)(arg0, arg1);
}

godbolt link