Point turbofish inference errors at the uninferred generic arg

[arferreira]

Follow-up to #153751.

When a method call has a turbofish with an uninferred generic argument, point the diagnostic span at the specific _ that couldn't be inferred instead of the method name.

Before:

LL |     S.f::<u32, _>(42);
   |       ^ cannot infer type of the type parameter `B`

After:

LL |     S.f::<u32, _>(42);
   |                ^ cannot infer type of the type parameter `B`

Path expressions (None::<_>, foo::<_>()) are not handled yet, that's a separate code path.

cc @eggyal

[rustbot]

Some changes occurred in need_type_info.rs

cc @lcnr

[eggyal]

What happens if there are multiple uninferred parameters? 🤔

[arferreira]

It points at the first uninferred one. Compiler stops after the first inference failure, so the second gets flagged on the next compile.

[eggyal]

Minor nit, but otherwise LGTM.

View changes since this review

[eggyal]

Minor nit, which saves on performing the is_ty_or_const check on each parameter.

Suggested change

	hir_args.args.iter().filter(|a| a.is_ty_or_const()).nth(idx)
	hir_args.args.get(hir_args.num_lifetime_params() + idx)

Even more minor, if one were to move the adjustment of argument_index from lines 1268-1270 to after this statement ends on 1290, it wouldn't need to be reversed in the checked_sub above.

[Kivooeo]

should be possible to use if let guards here, not sure if you found this more prettier or not, this up to you

View changes since this review

[Kivooeo]

Suggested change

	let span = match expr.kind {
	ExprKind::MethodCall(path, ..) => path.ident.span,
	ExprKind::MethodCall(segment, ..) => {
	if have_turbofish
	&& let Some(hir_args) = segment.args
	&& let Some(idx) = argument_index.checked_sub(
	generics.has_own_self() as usize + generics.own_counts().lifetimes,
	)
	&& let Some(arg) =
	hir_args.args.iter().filter(|a| a.is_ty_or_const()).nth(idx)
	{
	arg.span()
	} else {
	segment.ident.span
	}
	}
	_ => expr.span,
	};
	let span = match expr.kind {
	ExprKind::MethodCall(segment, ..)
	if have_turbofish
	&& let Some(hir_args) = segment.args
	&& let Some(idx) = argument_index.checked_sub(
	generics.has_own_self() as usize + generics.own_counts().lifetimes,
	)
	&& let Some(arg) = hir_args.args.iter().filter(|a| a.is_ty_or_const()).nth(idx) =>
	{
	arg.span()
	}
	ExprKind::MethodCall(segment, ..) => segment.ident.span,
	_ => expr.span,
	};

[lcnr]

isn't it better do do a find here/maybe even enumerate().find(..)

[lcnr]

if you don't use the actual argument, but still refer to all generic_args, then using position seems fine. enumerate.find() and then only using the index should just be worse than position.

I expected that being able to easily name the unconstrained arg would be helpful. If it is not, keeping position here is fine

[eggyal]

This PR doesn't have an assigned reviewer. @Kivooeo or @lcnr, since you've already taken a look are either of you happy to take the assignment or should we ask rustbot to pick someone?

[Kivooeo]

I'll likely take a look tomorrow

r? me

[Kivooeo]

cool, thanks

@bors r=Kivooeo,eggyal rollup

[rust-bors]

📌 Commit b258fe1 has been approved by Kivooeo,eggyal

It is now in the queue for this repository.

⚠️ The following reviewer(s) could not be found: eggyal