ICE: no type-dependent def or overloaded call

[playXE]

Problematic code:

spawn_greenie(|f, ()| (*f)(), (Box::new(|| println!("lol")), ()));

Minimal reproduction:

fn foo<F: Fn()>(f: impl Fn(Box<F>, ()), x: (Box<F>, ())) {}
foo(|f, _| (*f)(), (Box::new(|| println!("lol")), ()));

This ICE happens on both nightly and stable.

Meta

rustc 1.42.0-nightly (ef92009 2020-01-06)
binary: rustc
commit-hash: ef92009
commit-date: 2020-01-06
host: x86_64-unknown-linux-gnu
release: 1.42.0-nightly
LLVM version: 9.0

Backtrace:

warning: Error finalizing incremental compilation session directory `/home/aprokruov/Projects/Rust/greenie/greenie/target/debug/incremental/greenie-i77rvggqx6df/s-fjjatsqv5y-1eummzy-working`: No such file or directory (os error 2)
error: internal compiler error: no type-dependent def for overloaded call
  --> src/main.rs:16:17
   |
16 |     foo_(|f, _| (*f)(), (Box::new(|| println!("lol")), ()));
   |                 ^^^^^^

thread 'rustc' panicked at 'no errors encountered even though `delay_span_bug` issued', src/librustc_errors/lib.rs:347:17
stack backtrace:
   0: backtrace::backtrace::libunwind::trace
             at /cargo/registry/src/github.com-1ecc6299db9ec823/backtrace-0.3.40/src/backtrace/libunwind.rs:88
   1: backtrace::backtrace::trace_unsynchronized
             at /cargo/registry/src/github.com-1ecc6299db9ec823/backtrace-0.3.40/src/backtrace/mod.rs:66
   2: std::sys_common::backtrace::_print_fmt
             at src/libstd/sys_common/backtrace.rs:77
   3: <std::sys_common::backtrace::_print::DisplayBacktrace as core::fmt::Display>::fmt
             at src/libstd/sys_common/backtrace.rs:59
   4: core::fmt::write
             at src/libcore/fmt/mod.rs:1057
   5: std::io::Write::write_fmt
             at src/libstd/io/mod.rs:1426
   6: std::sys_common::backtrace::_print
             at src/libstd/sys_common/backtrace.rs:62
   7: std::sys_common::backtrace::print
             at src/libstd/sys_common/backtrace.rs:49
   8: std::panicking::default_hook::{{closure}}
             at src/libstd/panicking.rs:195
   9: std::panicking::default_hook
             at src/libstd/panicking.rs:215
  10: rustc_driver::report_ice
  11: std::panicking::rust_panic_with_hook
             at src/libstd/panicking.rs:467
  12: std::panicking::begin_panic
  13: <rustc_errors::HandlerInner as core::ops::drop::Drop>::drop
  14: core::ptr::real_drop_in_place
  15: core::ptr::real_drop_in_place
  16: core::ptr::real_drop_in_place
  17: rustc_interface::interface::run_compiler_in_existing_thread_pool
  18: scoped_tls::ScopedKey<T>::set
  19: syntax::with_globals
note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace.

error: internal compiler error: unexpected panic

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.42.0-nightly (ef92009c1 2020-01-06) running on x86_64-unknown-linux-gnu

note: compiler flags: -C debuginfo=2 -C incremental --crate-type bin

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

query stack during panic:
end of query stack
The following warnings were emitted during compilation:

[Centril]

I'm not sure how to reproduce the ICE given the two snippets at the top. Can you clarify the minimal reproduction: how do I reproduce it in the playground?

[jonas-schievink]

fn main() {
    fn foo<F: Fn()>(f: impl Fn(Box<F>, ()), x: (Box<F>, ())) {}
    foo(|f, _| (*f)(), (Box::new(|| println!("lol")), ()));
}

[Centril]

Simplified:

fn foo<F, G>(_: G, _: Box<F>)
where
    F: Fn(),
    G: Fn(Box<F>),
{
}

fn main() {
    foo(|f| (*f)(), Box::new(|| {}));
}

[JohnTitor]

The failure occurs here:

rust/src/librustc_typeck/expr_use_visitor.rs

Lines 332 to 354 in caa231d

	match callee_ty.kind {
	ty::FnDef(..) | ty::FnPtr(_) => {
	self.consume_expr(callee);
	}
	ty::Error => {}
	_ => {
	if let Some(def_id) = self.mc.tables.type_dependent_def_id(call.hir_id) {
	match OverloadedCallType::from_method_id(self.tcx(), def_id) {
	FnMutOverloadedCall => {
	self.borrow_expr(callee, ty::MutBorrow);
	}
	FnOverloadedCall => {
	self.borrow_expr(callee, ty::ImmBorrow);
	}
	FnOnceOverloadedCall => self.consume_expr(callee),
	}
	} else {
	self.tcx()
	.sess
	.delay_span_bug(call.span, "no type-dependent def for overloaded call");
	}
	}
	}

I guess we can add ty::Closure to first arm (ty::FnDef(..) | ty::FnPtr(_)), is it safe?

[pnkfelix]

triage: P-high. Removing I-nominated label.