Point at definition of item with type parameters that couldn't be inferred

When calling a function with type parameters that are unconstrained by the call expression, we mention the type parameter that couldn't be inferred, but the user previously didn't see where the name was coming from. By pointing at the function itself, including the type parameter, we give better context on what they should have done, specially when the inference machinery fails to provide any other context.

```
error[E0282]: type annotations needed
  --> $DIR/unresolved_type_param.rs:9:5
   |
LL |     bar().await;
   |     ^^^ cannot infer type of the type parameter `T` declared on the function `bar`
   |
note: type must be known for this
  --> $DIR/unresolved_type_param.rs:6:1
   |
LL | async fn bar<T>() -> () {}
   | ^^^^^^^^^^^^^^^^^^^^^^^
help: consider specifying the generic argument
   |
LL |     bar::<T>().await;
   |        +++++
```

We should further refine when we present this info to make sure we don't provide redundant notes in some cases. Also, there are cases (like those in issue 94969) that don't provide any new information with this change.

Author: estebank

compiler/rustc_trait_selection/src/error_reporting/infer/need_type_info.rs

@@ -68,6 +68,7 @@ pub struct InferenceDiagnosticsData {
 pub struct InferenceDiagnosticsParentData {
     prefix: &'static str,
     name: String,
+    span: Span,
 }
 
 #[derive(Clone)]
@@ -124,10 +125,12 @@ impl InferenceDiagnosticsParentData {
     ) -> Option<InferenceDiagnosticsParentData> {
         let parent_name =
             tcx.def_key(parent_def_id).disambiguated_data.data.get_opt_name()?.to_string();
+        let span = tcx.def_span(parent_def_id);
 
         Some(InferenceDiagnosticsParentData {
             prefix: tcx.def_descr(parent_def_id),
             name: parent_name,
+            span,
         })
     }
 
@@ -423,16 +426,18 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
         error_code: TypeAnnotationNeeded,
     ) -> Diag<'a> {
         let source_kind = "other";
-        let source_name = "";
+        let bad_error = arg_data.make_bad_error(span);
+        let source_name = &bad_error.name.clone();
         let failure_span = None;
         let infer_subdiags = Vec::new();
         let multi_suggestions = Vec::new();
-        let bad_label = Some(arg_data.make_bad_error(span));
+        let bad_label = Some(bad_error);
         match error_code {
             TypeAnnotationNeeded::E0282 => self.dcx().create_err(AnnotationRequired {
                 span,
                 source_kind,
                 source_name,
+                source_span: arg_data.parent.as_ref().map(|p| p.span),
                 failure_span,
                 infer_subdiags,
                 multi_suggestions,
@@ -442,6 +447,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                 span,
                 source_kind,
                 source_name,
+                source_span: arg_data.parent.as_ref().map(|p| p.span),
                 failure_span,
                 infer_subdiags,
                 multi_suggestions,
@@ -451,6 +457,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                 span,
                 source_kind,
                 source_name,
+                source_span: arg_data.parent.as_ref().map(|p| p.span),
                 failure_span,
                 infer_subdiags,
                 multi_suggestions,
@@ -651,6 +658,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                 span,
                 source_kind,
                 source_name: &name,
+                source_span: arg_data.parent.as_ref().map(|p| p.span),
                 failure_span,
                 infer_subdiags,
                 multi_suggestions,
@@ -660,6 +668,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                 span,
                 source_kind,
                 source_name: &name,
+                source_span: arg_data.parent.as_ref().map(|p| p.span),
                 failure_span,
                 infer_subdiags,
                 multi_suggestions,
@@ -669,6 +678,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                 span,
                 source_kind,
                 source_name: &name,
+                source_span: arg_data.parent.as_ref().map(|p| p.span),
                 failure_span,
                 infer_subdiags,
                 multi_suggestions,

compiler/rustc_trait_selection/src/errors.rs

@@ -192,6 +192,8 @@ pub struct AnnotationRequired<'a> {
     pub span: Span,
     pub source_kind: &'static str,
     pub source_name: &'a str,
+    #[note("type must be known for type parameter in this")]
+    pub source_span: Option<Span>,
     #[label("type must be known at this point")]
     pub failure_span: Option<Span>,
     #[subdiagnostic]
@@ -214,6 +216,8 @@ pub struct AmbiguousImpl<'a> {
     pub span: Span,
     pub source_kind: &'static str,
     pub source_name: &'a str,
+    #[note("type must be known for type parameter in this")]
+    pub source_span: Option<Span>,
     #[label("type must be known at this point")]
     pub failure_span: Option<Span>,
     #[subdiagnostic]
@@ -236,6 +240,8 @@ pub struct AmbiguousReturn<'a> {
     pub span: Span,
     pub source_kind: &'static str,
     pub source_name: &'a str,
+    #[note("type must be known for type parameter in this")]
+    pub source_span: Option<Span>,
     #[label("type must be known at this point")]
     pub failure_span: Option<Span>,
     #[subdiagnostic]

tests/ui/array-slice-vec/vector-no-ann.stderr

@@ -4,6 +4,8 @@ error[E0282]: type annotations needed for `Vec<_>`
 LL |     let _foo = Vec::new();
    |         ^^^^   ---------- type must be known at this point
    |
+note: type must be known for type parameter in this
+  --> $SRC_DIR/alloc/src/vec/mod.rs:LL:COL
 help: consider giving `_foo` an explicit type, where the type for type parameter `T` is specified
    |
 LL |     let _foo: Vec<T> = Vec::new();

tests/ui/associated-type-bounds/dedup-normalized-2-higher-ranked.current.stderr

@@ -6,6 +6,11 @@ LL |     impls(rigid);
    |     |
    |     cannot infer type of the type parameter `U` declared on the function `impls`
    |
+note: type must be known for type parameter in this
+  --> $DIR/dedup-normalized-2-higher-ranked.rs:25:1
+   |
+LL | fn impls<T: for<'b> Bound<'b, U>, U>(_: T) {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    = note: cannot satisfy `for<'b> <P as Trait>::Rigid: Bound<'b, _>`
 note: required by a bound in `impls`
   --> $DIR/dedup-normalized-2-higher-ranked.rs:25:13

tests/ui/associated-type-bounds/duplicate-bound-err.stderr

@@ -4,6 +4,8 @@ error[E0282]: type annotations needed
 LL |     iter::empty()
    |     ^^^^^^^^^^^ cannot infer type of the type parameter `T` declared on the function `empty`
    |
+note: type must be known for type parameter in this
+  --> $SRC_DIR/core/src/iter/sources/empty.rs:LL:COL
 help: consider specifying the generic argument
    |
 LL |     iter::empty::<T>()
@@ -15,6 +17,8 @@ error[E0282]: type annotations needed
 LL |     iter::empty()
    |     ^^^^^^^^^^^ cannot infer type of the type parameter `T` declared on the function `empty`
    |
+note: type must be known for type parameter in this
+  --> $SRC_DIR/core/src/iter/sources/empty.rs:LL:COL
 help: consider specifying the generic argument
    |
 LL |     iter::empty::<T>()
@@ -26,6 +30,8 @@ error[E0282]: type annotations needed
 LL |     iter::empty()
    |     ^^^^^^^^^^^ cannot infer type of the type parameter `T` declared on the function `empty`
    |
+note: type must be known for type parameter in this
+  --> $SRC_DIR/core/src/iter/sources/empty.rs:LL:COL
 help: consider specifying the generic argument
    |
 LL |     iter::empty::<T>()

tests/ui/async-await/unresolved_type_param.stderr

@@ -4,6 +4,11 @@ error[E0282]: type annotations needed
 LL |     bar().await;
    |     ^^^ cannot infer type of the type parameter `T` declared on the function `bar`
    |
+note: type must be known for type parameter in this
+  --> $DIR/unresolved_type_param.rs:6:1
+   |
+LL | async fn bar<T>() -> () {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^
 help: consider specifying the generic argument
    |
 LL |     bar::<T>().await;

tests/ui/closure-expected-type/expect-two-infer-vars-supply-ty-with-bound-region.stderr

@@ -4,6 +4,12 @@ error[E0282]: type annotations needed
 LL |     with_closure(|x: u32, y| {});
    |                           ^
    |
+note: type must be known for type parameter in this
+  --> $DIR/expect-two-infer-vars-supply-ty-with-bound-region.rs:1:1
+   |
+LL | / fn with_closure<F, A, B>(_: F)
+LL | |     where F: FnOnce(A, B)
+   | |_________________________^
 help: consider giving this closure parameter an explicit type
    |
 LL |     with_closure(|x: u32, y: /* Type */| {});

tests/ui/closures/issue-99565.stderr

@@ -4,6 +4,11 @@ error[E0282]: type annotations needed
 LL |     foo(|| {});
    |     ^^^ cannot infer type of the type parameter `T` declared on the function `foo`
    |
+note: type must be known for type parameter in this
+  --> $DIR/issue-99565.rs:3:1
+   |
+LL | fn foo<T, U>(_: U) {}
+   | ^^^^^^^^^^^^^^^^^^
 help: consider specifying the generic arguments
    |
 LL |     foo::<T, _>(|| {});

tests/ui/const-generics/defaults/rp_impl_trait_fail.stderr

@@ -56,6 +56,11 @@ error[E0284]: type annotations needed
 LL |     uwu();
    |     ^^^ cannot infer the value of the const parameter `N` declared on the function `uwu`
    |
+note: type must be known for type parameter in this
+  --> $DIR/rp_impl_trait_fail.rs:16:1
+   |
+LL | fn uwu<const N: u8>() -> impl Traitor<N> {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 note: required by a const generic parameter in `uwu`
   --> $DIR/rp_impl_trait_fail.rs:16:8
    |

tests/ui/const-generics/fn-const-param-infer.adt_const_params.stderr

@@ -19,6 +19,11 @@ error[E0282]: type annotations needed
 LL |     let _ = Checked::<generic>;
    |                       ^^^^^^^ cannot infer type of the type parameter `T` declared on the function `generic`
    |
+note: type must be known for type parameter in this
+  --> $DIR/fn-const-param-infer.rs:22:1
+   |
+LL | fn generic<T>(val: usize) -> bool {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 help: consider specifying the generic argument
    |
 LL |     let _ = Checked::<generic::<T>>;