ICE: LLVM Assertion with Unboxed Closures

[cristicbz]

Minimal test case:

#![feature(unboxed_closures)]

pub fn deeper<C: Fn<(), ()>>(deepest: C) { deepest.call(()); }
pub fn deep<C: Fn<(), ()>>(_ignored: C) { deeper(|&:| -> () {}); }
fn main() { deep(|&:| -> () {}); }

Gives

rustc: /build/rust-git/src/rust/src/llvm/lib/IR/Instructions.cpp:281: void llvm::CallInst::init(llvm::Value*, llvm::ArrayRef<llvm::Value*>, const llvm::Twine&): Assertion `(i >= FTy->getNumParams() || FTy->getParamType(i) == Args[i]->getType()) && "Calling a function with a bad signature!"' failed.
Aborted

Rust Playpen

Things that don't affect it:

• Changing the Fn type (Once, Mut, move etc.).
• Calling deep's argument instead of ignoring it.

Things that DO stop it from happening:

• Instead of ignoring _ignored, passing it to deeper as an arg.
• Removing the body of any of the functions.

Only have access to playpen so I can't give backtrace, sorry.

[abonander]

RUST_BACKTRACE=1 does not produce additional information for this error, likely because the assertion failure is in LLVM's C++ code.

[bkoropoff]

Looks like a bug in my monomorphization PR, will take a look.

[bkoropoff]

It looks like the precise unboxed closure type is being dropped on the floor during trait selection and then recalculated from scratch during trans of the Fn method call, but using the wrong substitutions! This is probably a hold-over from when the only information carried around by ty_unboxed_closure was the def ID, so no information was lost by doing this. It looks like there are other places besides trait selection where this can happen.

Since both deep and deeper have exactly one type parameter in the function space, the bogus substitution silently succeeds and causes problems later. Making the spaces incompatible results in an ICE that makes it more clear what's going on:

#![feature(unboxed_closures)]

pub fn deeper<F: Fn()>(c: F) {
    c.call(());
}

pub fn deep<A,C:Fn(uint)>(_c: C) {
    deeper(|&:| {});
}

fn main() { 
    deep::<char,_>(|&: _:uint| {});
}

Output:

test.rs:1:1: 1:1 error: internal compiler error: Type parameter `C/FnSpace.1` (C/FnSpace/1) out of range when substituting (root type='static |()|:'static) substs=Substs[types=[[];[];[];['static |()|:'static]], regions=erased]
test.rs:1 #![feature(unboxed_closures)]

[bkoropoff]

This will need to be fixed in tandem with #18685. I have a fix in progress that seems promising.