Borrow checker's strange error.

[cheblin]

#![feature(unboxed_closures)]
#![feature(const_vec_new)]
#![feature(fn_traits)]

pub struct PackBytes;

static mut HANDLERS: Vec<Box<dyn FnMut<&mut PackBytes, Output=()>>> = Vec::new();

fn main() {
    
    let mut pack = PackBytes;
    unsafe { HANDLERS[0].as_mut().call_mut(&mut pack); }
}

error[E0597]: `pack` does not live long enough
  --> src/main.rs:15:35
   |
15 |     HANDLERS[0].as_mut().call_mut(&mut pack); }
   |     ------------------------------^^^^^^^^^-
   |     |                             |
   |     |                             borrowed value does not live long enough
   |     argument requires that `pack` is borrowed for `'static`
16 | }
   | - `pack` dropped here while still borrowed

#![feature(unboxed_closures)]
#![feature(const_vec_new)]
#![feature(fn_traits)]
pub struct PackBytes;



static mut HANDLERS: Vec<Box<dyn for<'a> FnMut<&'a mut PackBytes, Output=()>>> = Vec::new();

fn main() {
    
    let mut pack = PackBytes;
    unsafe { HANDLERS[0].as_mut().call_mut(&mut pack); }
}

error: internal compiler error: src/librustc_codegen_llvm/abi.rs:433: argument to function with "rust-call" ABI is not a tuple

thread 'rustc' panicked at 'Box<Any>', src/librustc_errors/lib.rs:590:9
note: Run with `RUST_BACKTRACE=1` environment variable to display a backtrace.
error: aborting due to previous error


note: the compiler unexpectedly panicked. this is a bug.

note: we would appreciate a bug report: https://github.com/rust-lang/rust/blob/master/CONTRIBUTING.md#bug-reports

note: rustc 1.33.0-nightly (b92552d55 2019-01-06) running on x86_64-unknown-linux-gnu

note: compiler flags: -C codegen-units=1 -C debuginfo=2 --crate-type bin

note: some of the compiler flags provided by cargo are hidden

[hellow554]

Reduced example

#![feature(unboxed_closures)]
#![feature(fn_traits)]

fn main() {
    let handlers: Option<Box<dyn for<'a> FnMut<&'a mut (), Output=()>>> = None;
    handlers.unwrap().as_mut().call_mut(&mut ());
}

[cheblin]

this, stripped works

#![feature(const_vec_new)]

pub struct PackBytes;

static mut HANDLERS: Vec<Box<dyn for<'a> FnMut(&'a mut PackBytes) -> ()>> = Vec::new();

fn main() {
    
    let mut pack = PackBytes;
    unsafe { (HANDLERS[0].as_mut())(&mut pack); }
}

[scalexm]

The first compilation error -- the example with static mut HANDLERS: Vec<Box<dyn FnMut<&mut PackBytes, Output=()>>> = Vec::new(); looks fine to me. Types used for static variables must outlive the 'static lifetime. The compiler can prove that dyn FnMut<&'b mut PackBytes> + 'a outlives 'static only if 'a == 'b == 'static. Hence 'static lifetimes are inferred in lieu of the anonymous lifetimes. Since your pack variable does not live for the whole 'static lifetime, it cannot be used as you are trying to.

Maybe the actual bug is that dyn FnMut<&T, Output=()> should desugar to dyn for<'a> FnMut<&'a T, Output=()>, as it would be for dyn FnMut(&T)? It may be weird to special-case only the Fn/FnMut/FnOnce traits though -- i.e. if you define your own trait trait Foo<T> { }, then Foo<&i32> just means Foo<&'b i32> for some lifetime 'b to be inferred by the compiler, it does not mean for<'a> Foo<&'a i32>.

Your reduced example is actually different since it actually does not involve static data. It seems to be the same bug as in #22565, and hence is a bug with the unboxed_closure feature.

Going from FnMut<&'a mut (), Output=()> to FnMut<(&'a mut (),), Output=()> (note the tuple of size 1) makes the ICE go away.

[Alexendoo]

Fixed by #99943