"call expression requires function" error points to wrong definition

[camelid]

struct S;

fn repro_ref(thing: S) {
    thing();
}

(Playground)

It should either point to the definition of S or it should say "thing defined here":

   Compiling playground v0.0.1 (/playground)
error[E0618]: expected function, found `S`
 --> src/lib.rs:4:5
  |
3 | fn repro_ref(thing: S) {
  |              ----- `S` defined here
4 |     thing();
  |     ^^^^^--
  |     |
  |     call expression requires function

error: aborting due to previous error

For more information about this error, try `rustc --explain E0618`.
error: could not compile `playground`

To learn more, run the command again with --verbose.

[camelid]

Relevant code:

rust/compiler/rustc_typeck/src/check/callee.rs

Lines 335 to 383 in ef58949

	let mut inner_callee_path = None;
	let def = match callee.kind {
	hir::ExprKind::Path(ref qpath) => {
	self.typeck_results.borrow().qpath_res(qpath, callee.hir_id)
	}
	hir::ExprKind::Call(ref inner_callee, _) => {
	// If the call spans more than one line and the callee kind is
	// itself another `ExprCall`, that's a clue that we might just be
	// missing a semicolon (Issue #51055)
	let call_is_multiline =
	self.tcx.sess.source_map().is_multiline(call_expr.span);
	if call_is_multiline {
	err.span_suggestion(
	callee.span.shrink_to_hi(),
	"try adding a semicolon",
	";".to_owned(),
	Applicability::MaybeIncorrect,
	);
	}
	if let hir::ExprKind::Path(ref inner_qpath) = inner_callee.kind {
	inner_callee_path = Some(inner_qpath);
	self.typeck_results
	.borrow()
	.qpath_res(inner_qpath, inner_callee.hir_id)
	} else {
	Res::Err
	}
	}
	_ => Res::Err,
	};
	err.span_label(call_expr.span, "call expression requires function");
	if let Some(span) = self.tcx.hir().res_span(def) {
	let callee_ty = callee_ty.to_string();
	let label = match (unit_variant, inner_callee_path) {
	(Some(path), _) => Some(format!("`{}` defined here", path)),
	(_, Some(hir::QPath::Resolved(_, path))) => {
	self.tcx.sess.source_map().span_to_snippet(path.span).ok().map(
	|p| format!("`{}` defined here returns `{}`", p, callee_ty),
	)
	}
	_ => Some(format!("`{}` defined here", callee_ty)),
	};
	if let Some(label) = label {
	err.span_label(span, label);
	}
	}
	err.emit();

[henryboisdequin]

Would it be helpful if the compiler said expected function, found struct S and then emitted a note which said S is not a function in this case?

[henryboisdequin]

@rustbot claim

[camelid]

Perhaps, but the bug this issue is about is this:

3 | fn repro_ref(thing: S) {
  |              ----- `S` defined here

It says "S defined here", but actually it's thing that's defined there. Instead it should point to the definition of S.

[henryboisdequin]

@camelid I've been working on this for a bit and don't really know how to approach it. Since the code is calling thing as a function, an error happens. The definition of thing is as an argument to repro_ref. Would I need to detect whether it's an argument and then, if so, finding the root definition, or is there a better way to do this?

[camelid]

@henryboisdequin

Would I need to detect whether it's an argument and then, if so, finding the root definition, or is there a better way to do this?

I thought about this a bit more and realized that my original suggestion of pointing to the definition of the struct S is probably not that helpful and would not generalize. Probably a good approach is to:

• Do you what you suggested in "call expression requires function" error points to wrong definition #80853 (comment)
• Fix the note so it says "thing defined here" instead of "S defined here"

I am not super familiar with the type-checker, but I can try to help you with what knowledge I have. You can also ask on Zulip if you need more help.