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

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>>;

tests/ui/const-generics/fn-const-param-infer.full.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>>;

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

@@ -21,6 +21,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>>;

tests/ui/const-generics/generic_const_exprs/dyn-compatibility-ok-infer-err.stderr

@@ -4,6 +4,11 @@ error[E0284]: type annotations needed
 LL |     use_dyn(&());
    |     ^^^^^^^ cannot infer the value of the const parameter `N` declared on the function `use_dyn`
    |
+note: type must be known for type parameter in this
+  --> $DIR/dyn-compatibility-ok-infer-err.rs:14:1
+   |
+LL | fn use_dyn<const N: usize>(v: &dyn Foo<N>) where [u8; N + 1]: Sized {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 note: required by a const generic parameter in `use_dyn`
   --> $DIR/dyn-compatibility-ok-infer-err.rs:14:12
    |

tests/ui/const-generics/infer/cannot-infer-const-args.stderr

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

tests/ui/const-generics/infer/issue-77092.stderr

@@ -4,6 +4,11 @@ error[E0284]: type annotations needed
 LL |         println!("{:?}", take_array_from_mut(&mut arr, i));
    |                          ^^^^^^^^^^^^^^^^^^^ cannot infer the value of the const parameter `N` declared on the function `take_array_from_mut`
    |
+note: type must be known for type parameter in this
+  --> $DIR/issue-77092.rs:3:1
+   |
+LL | fn take_array_from_mut<T, const N: usize>(data: &mut [T], start: usize) -> &mut [T; N] {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 note: required by a const generic parameter in `take_array_from_mut`
   --> $DIR/issue-77092.rs:3:27
    |

tests/ui/const-generics/infer/method-chain.stderr

@@ -4,6 +4,11 @@ error[E0284]: type annotations needed
 LL |     Foo.bar().bar().bar().bar().baz();
    |                                 ^^^ cannot infer the value of the const parameter `N` declared on the method `baz`
    |
+note: type must be known for type parameter in this
+  --> $DIR/method-chain.rs:8:5
+   |
+LL |     fn baz<const N: usize>(self) -> Foo {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 note: required by a const generic parameter in `Foo::baz`
   --> $DIR/method-chain.rs:8:12
    |

tests/ui/const-generics/infer/one-param-uninferred.stderr

@@ -4,6 +4,11 @@ error[E0284]: type annotations needed
 LL |     let _: [u8; 17] = foo();
    |                       ^^^ cannot infer the value of the const parameter `M` declared on the function `foo`
    |
+note: type must be known for type parameter in this
+  --> $DIR/one-param-uninferred.rs:2:1
+   |
+LL | fn foo<const N: usize, const M: usize>() -> [u8; N] {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 note: required by a const generic parameter in `foo`
   --> $DIR/one-param-uninferred.rs:2:24
    |

tests/ui/const-generics/infer/uninferred-consts.stderr

@@ -4,6 +4,11 @@ error[E0284]: type annotations needed
 LL |     Foo.foo();
    |         ^^^ cannot infer the value of the const parameter `A` declared on the method `foo`
    |
+note: type must be known for type parameter in this
+  --> $DIR/uninferred-consts.rs:6:5
+   |
+LL |     fn foo<const A: usize, const B: usize>(self) {}
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 note: required by a const generic parameter in `Foo::foo`
   --> $DIR/uninferred-consts.rs:6:12
    |
@@ -20,6 +25,11 @@ error[E0284]: type annotations needed
 LL |     Foo.foo();
    |         ^^^ cannot infer the value of the const parameter `B` declared on the method `foo`
    |
+note: type must be known for type parameter in this
+  --> $DIR/uninferred-consts.rs:6:5
+   |
+LL |     fn foo<const A: usize, const B: usize>(self) {}
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 note: required by a const generic parameter in `Foo::foo`
   --> $DIR/uninferred-consts.rs:6:28
    |

tests/ui/const-generics/issues/issue-83249.stderr

@@ -6,6 +6,11 @@ LL |     let _ = foo([0; 1]);
    |             |
    |             required by a bound introduced by this call
    |
+note: type must be known for type parameter in this
+  --> $DIR/issue-83249.rs:12:1
+   |
+LL | fn foo<T: Foo>(_: [u8; T::N]) -> T {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    = note: cannot satisfy `_: Foo`
 help: the trait `Foo` is implemented for `u8`
   --> $DIR/issue-83249.rs:8:1

tests/ui/const-generics/parent_generics_of_encoding_impl_trait.stderr

@@ -4,6 +4,11 @@ error[E0284]: type annotations needed
 LL |     generics_of_parent_impl_trait::foo([()]);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ cannot infer the value of const parameter `N` declared on the function `foo`
    |
+note: type must be known for type parameter in this
+  --> $DIR/auxiliary/generics_of_parent_impl_trait.rs:5:1
+   |
+LL | pub fn foo<const N: usize>(foo: impl Into<[(); N + 1]>) {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 note: required by a const generic parameter in `foo`
   --> $DIR/auxiliary/generics_of_parent_impl_trait.rs:5:12
    |

tests/ui/const-generics/try-from-with-const-genericsrs-98299.stderr

@@ -6,6 +6,11 @@ LL |     SmallCString::try_from(p).map(|cstr| cstr);
    |     |
    |     type must be known at this point
    |
+note: type must be known for type parameter in this
+  --> $DIR/try-from-with-const-genericsrs-98299.rs:9:1
+   |
+LL | pub struct SmallCString<const N: usize> {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 note: required by a const generic parameter in `SmallCString`
   --> $DIR/try-from-with-const-genericsrs-98299.rs:9:25
    |

tests/ui/const-generics/unify_with_nested_expr.stderr

@@ -4,6 +4,13 @@ error[E0284]: type annotations needed
 LL |     bar();
    |     ^^^ cannot infer the value of the const parameter `N` declared on the function `bar`
    |
+note: type must be known for type parameter in this
+  --> $DIR/unify_with_nested_expr.rs:12:1
+   |
+LL | / fn bar<const N: usize>()
+LL | | where
+LL | |     [(); N + 1]:,
+   | |_________________^
 note: required by a const generic parameter in `bar`
   --> $DIR/unify_with_nested_expr.rs:12:8
    |

tests/ui/consts/issue-64662.stderr

@@ -4,6 +4,11 @@ error[E0282]: type annotations needed
 LL |     A = 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-64662.rs:6:1
+   |
+LL | const fn foo<T>() -> isize {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^
 help: consider specifying the generic argument
    |
 LL |     A = foo::<T>(),
@@ -15,6 +20,11 @@ error[E0282]: type annotations needed
 LL |     B = 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-64662.rs:6:1
+   |
+LL | const fn foo<T>() -> isize {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^
 help: consider specifying the generic argument
    |
 LL |     B = foo::<T>(),