Const generic parameters aren't bounds, even if we end up erroring be…

…cause of the bound that binds the parameter's type

compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs

@@ -2776,97 +2776,115 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
                 let mut this = "this bound";
                 let mut note = None;
                 let mut help = None;
-                if let ty::PredicateKind::Clause(clause) = predicate.kind().skip_binder()
-                    && let ty::ClauseKind::Trait(trait_pred) = clause
-                {
-                    let def_id = trait_pred.def_id();
-                    let visible_item = if let Some(local) = def_id.as_local() {
-                        // Check for local traits being reachable.
-                        let vis = &tcx.resolutions(()).effective_visibilities;
-                        // Account for non-`pub` traits in the root of the local crate.
-                        let is_locally_reachable = tcx.parent(def_id).is_crate_root();
-                        vis.is_reachable(local) || is_locally_reachable
-                    } else {
-                        // Check for foreign traits being reachable.
-                        tcx.visible_parent_map(()).get(&def_id).is_some()
-                    };
-                    if tcx.is_lang_item(def_id, LangItem::Sized) {
-                        // Check if this is an implicit bound, even in foreign crates.
-                        if tcx
-                            .generics_of(item_def_id)
-                            .own_params
-                            .iter()
-                            .any(|param| tcx.def_span(param.def_id) == span)
-                        {
-                            a = "an implicit `Sized`";
-                            this = "the implicit `Sized` requirement on this type parameter";
-                        }
-                        if let Some(hir::Node::TraitItem(hir::TraitItem {
-                            generics,
-                            kind: hir::TraitItemKind::Type(bounds, None),
-                            ..
-                        })) = tcx.hir().get_if_local(item_def_id)
-                        // Do not suggest relaxing if there is an explicit `Sized` obligation.
-                        && !bounds.iter()
-                            .filter_map(|bound| bound.trait_ref())
-                            .any(|tr| tr.trait_def_id() == tcx.lang_items().sized_trait())
-                        {
-                            let (span, separator) = if let [.., last] = bounds {
-                                (last.span().shrink_to_hi(), " +")
+                if let ty::PredicateKind::Clause(clause) = predicate.kind().skip_binder() {
+                    match clause {
+                        ty::ClauseKind::Trait(trait_pred) => {
+                            let def_id = trait_pred.def_id();
+                            let visible_item = if let Some(local) = def_id.as_local() {
+                                // Check for local traits being reachable.
+                                let vis = &tcx.resolutions(()).effective_visibilities;
+                                // Account for non-`pub` traits in the root of the local crate.
+                                let is_locally_reachable = tcx.parent(def_id).is_crate_root();
+                                vis.is_reachable(local) || is_locally_reachable
                             } else {
-                                (generics.span.shrink_to_hi(), ":")
+                                // Check for foreign traits being reachable.
+                                tcx.visible_parent_map(()).get(&def_id).is_some()
                             };
-                            err.span_suggestion_verbose(
-                                span,
-                                "consider relaxing the implicit `Sized` restriction",
-                                format!("{separator} ?Sized"),
-                                Applicability::MachineApplicable,
-                            );
+                            if tcx.is_lang_item(def_id, LangItem::Sized) {
+                                // Check if this is an implicit bound, even in foreign crates.
+                                if tcx
+                                    .generics_of(item_def_id)
+                                    .own_params
+                                    .iter()
+                                    .any(|param| tcx.def_span(param.def_id) == span)
+                                {
+                                    a = "an implicit `Sized`";
+                                    this =
+                                        "the implicit `Sized` requirement on this type parameter";
+                                }
+                                if let Some(hir::Node::TraitItem(hir::TraitItem {
+                                    generics,
+                                    kind: hir::TraitItemKind::Type(bounds, None),
+                                    ..
+                                })) = tcx.hir().get_if_local(item_def_id)
+                                    // Do not suggest relaxing if there is an explicit `Sized` obligation.
+                                    && !bounds.iter()
+                                        .filter_map(|bound| bound.trait_ref())
+                                        .any(|tr| tr.trait_def_id() == tcx.lang_items().sized_trait())
+                                {
+                                    let (span, separator) = if let [.., last] = bounds {
+                                        (last.span().shrink_to_hi(), " +")
+                                    } else {
+                                        (generics.span.shrink_to_hi(), ":")
+                                    };
+                                    err.span_suggestion_verbose(
+                                        span,
+                                        "consider relaxing the implicit `Sized` restriction",
+                                        format!("{separator} ?Sized"),
+                                        Applicability::MachineApplicable,
+                                    );
+                                }
+                            }
+                            if let DefKind::Trait = tcx.def_kind(item_def_id)
+                                && !visible_item
+                            {
+                                note = Some(format!(
+                                    "`{short_item_name}` is a \"sealed trait\", because to implement it \
+                                    you also need to implement `{}`, which is not accessible; this is \
+                                    usually done to force you to use one of the provided types that \
+                                    already implement it",
+                                    with_no_trimmed_paths!(tcx.def_path_str(def_id)),
+                                ));
+                                let impls_of = tcx.trait_impls_of(def_id);
+                                let impls = impls_of
+                                    .non_blanket_impls()
+                                    .values()
+                                    .flatten()
+                                    .chain(impls_of.blanket_impls().iter())
+                                    .collect::<Vec<_>>();
+                                if !impls.is_empty() {
+                                    let len = impls.len();
+                                    let mut types = impls
+                                        .iter()
+                                        .map(|t| {
+                                            with_no_trimmed_paths!(format!(
+                                                "  {}",
+                                                tcx.type_of(*t).instantiate_identity(),
+                                            ))
+                                        })
+                                        .collect::<Vec<_>>();
+                                    let post = if types.len() > 9 {
+                                        types.truncate(8);
+                                        format!("\nand {} others", len - 8)
+                                    } else {
+                                        String::new()
+                                    };
+                                    help = Some(format!(
+                                        "the following type{} implement{} the trait:\n{}{post}",
+                                        pluralize!(len),
+                                        if len == 1 { "s" } else { "" },
+                                        types.join("\n"),
+                                    ));
+                                }
+                            }
                         }
-                    }
-                    if let DefKind::Trait = tcx.def_kind(item_def_id)
-                        && !visible_item
-                    {
-                        note = Some(format!(
-                            "`{short_item_name}` is a \"sealed trait\", because to implement it \
-                             you also need to implement `{}`, which is not accessible; this is \
-                             usually done to force you to use one of the provided types that \
-                             already implement it",
-                            with_no_trimmed_paths!(tcx.def_path_str(def_id)),
-                        ));
-                        let impls_of = tcx.trait_impls_of(def_id);
-                        let impls = impls_of
-                            .non_blanket_impls()
-                            .values()
-                            .flatten()
-                            .chain(impls_of.blanket_impls().iter())
-                            .collect::<Vec<_>>();
-                        if !impls.is_empty() {
-                            let len = impls.len();
-                            let mut types = impls
-                                .iter()
-                                .map(|t| {
-                                    with_no_trimmed_paths!(format!(
-                                        "  {}",
-                                        tcx.type_of(*t).instantiate_identity(),
-                                    ))
-                                })
-                                .collect::<Vec<_>>();
-                            let post = if types.len() > 9 {
-                                types.truncate(8);
-                                format!("\nand {} others", len - 8)
+                        ty::ClauseKind::ConstArgHasType(..) => {
+                            let descr =
+                                format!("required by a const generic parameter in `{item_name}`");
+                            if span.is_visible(sm) {
+                                let msg = format!(
+                                    "required by this const generic parameter in `{short_item_name}`"
+                                );
+                                multispan.push_span_label(span, msg);
+                                err.span_note(multispan, descr);
                             } else {
-                                String::new()
-                            };
-                            help = Some(format!(
-                                "the following type{} implement{} the trait:\n{}{post}",
-                                pluralize!(len),
-                                if len == 1 { "s" } else { "" },
-                                types.join("\n"),
-                            ));
+                                err.span_note(tcx.def_span(item_def_id), descr);
+                            }
+                            return;
                         }
+                        _ => (),
                     }
-                };
+                }
                 let descr = format!("required by {a} bound in `{item_name}`");
                 if span.is_visible(sm) {
                     let msg = format!("required by {this} in `{short_item_name}`");

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

@@ -4,11 +4,11 @@ error[E0284]: type annotations needed for `Foo<_>`
 LL |     let foo = Foo::foo();
    |         ^^^   ---------- type must be known at this point
    |
-note: required by a bound in `Foo::<N>::foo`
+note: required by a const generic parameter in `Foo::<N>::foo`
   --> $DIR/doesnt_infer.rs:5:6
    |
 LL | impl<const N: u32> Foo<N> {
-   |      ^^^^^^^^^^^^ required by this bound in `Foo::<N>::foo`
+   |      ^^^^^^^^^^^^ required by this const generic parameter in `Foo::<N>::foo`
 LL |     fn foo() -> Self {
    |        --- required by a bound in this associated function
 help: consider giving `foo` an explicit type, where the value of const parameter `N` is specified
@@ -22,11 +22,11 @@ error[E0284]: type annotations needed for `Foo<_>`
 LL |     let foo = Foo::foo();
    |         ^^^   --- type must be known at this point
    |
-note: required by a bound in `Foo`
+note: required by a const generic parameter in `Foo`
   --> $DIR/doesnt_infer.rs:3:12
    |
 LL | struct Foo<const N: u32 = 2>;
-   |            ^^^^^^^^^^^^^^^^ required by this bound in `Foo`
+   |            ^^^^^^^^^^^^^^^^ required by this const generic parameter in `Foo`
 help: consider giving `foo` an explicit type, where the value of const parameter `N` is specified
    |
 LL |     let foo: Foo<N> = Foo::foo();

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

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

tests/ui/const-generics/generic_arg_infer/issue-91614.stderr

@@ -4,7 +4,7 @@ error[E0284]: type annotations needed for `Mask<_, _>`
 LL |     let y = Mask::<_, _>::splat(false);
    |         ^   -------------------------- type must be known at this point
    |
-note: required by a bound in `Mask::<T, N>::splat`
+note: required by a const generic parameter in `Mask::<T, N>::splat`
   --> $SRC_DIR/core/src/../../portable-simd/crates/core_simd/src/masks.rs:LL:COL
 help: consider giving `y` an explicit type, where the value of const parameter `N` is specified
    |
@@ -17,7 +17,7 @@ error[E0284]: type annotations needed for `Mask<_, _>`
 LL |     let y = Mask::<_, _>::splat(false);
    |         ^   ------------ type must be known at this point
    |
-note: required by a bound in `Mask`
+note: required by a const generic parameter in `Mask`
   --> $SRC_DIR/core/src/../../portable-simd/crates/core_simd/src/masks.rs:LL:COL
 help: consider giving `y` an explicit type, where the value of const parameter `N` is specified
    |

tests/ui/const-generics/generic_const_exprs/issue-62504.full.stderr

@@ -24,11 +24,11 @@ error[E0284]: type annotations needed for `ArrayHolder<_>`
 LL |     let mut array = ArrayHolder::new();
    |         ^^^^^^^^^   ------------------ type must be known at this point
    |
-note: required by a bound in `ArrayHolder::<X>::new`
+note: required by a const generic parameter in `ArrayHolder::<X>::new`
   --> $DIR/issue-62504.rs:16:6
    |
 LL | impl<const X: usize> ArrayHolder<X> {
-   |      ^^^^^^^^^^^^^^ required by this bound in `ArrayHolder::<X>::new`
+   |      ^^^^^^^^^^^^^^ required by this const generic parameter in `ArrayHolder::<X>::new`
 LL |     pub const fn new() -> Self {
    |                  --- required by a bound in this associated function
 help: consider giving `array` an explicit type, where the value of const parameter `X` is specified
@@ -42,11 +42,11 @@ error[E0284]: type annotations needed for `ArrayHolder<_>`
 LL |     let mut array = ArrayHolder::new();
    |         ^^^^^^^^^   ----------- type must be known at this point
    |
-note: required by a bound in `ArrayHolder`
+note: required by a const generic parameter in `ArrayHolder`
   --> $DIR/issue-62504.rs:14:20
    |
 LL | struct ArrayHolder<const X: usize>([u32; X]);
-   |                    ^^^^^^^^^^^^^^ required by this bound in `ArrayHolder`
+   |                    ^^^^^^^^^^^^^^ required by this const generic parameter in `ArrayHolder`
 help: consider giving `array` an explicit type, where the value of const parameter `X` is specified
    |
 LL |     let mut array: ArrayHolder<X> = ArrayHolder::new();

tests/ui/const-generics/generic_const_exprs/issue-62504.min.stderr

@@ -28,11 +28,11 @@ error[E0284]: type annotations needed for `ArrayHolder<_>`
 LL |     let mut array = ArrayHolder::new();
    |         ^^^^^^^^^   ------------------ type must be known at this point
    |
-note: required by a bound in `ArrayHolder::<X>::new`
+note: required by a const generic parameter in `ArrayHolder::<X>::new`
   --> $DIR/issue-62504.rs:16:6
    |
 LL | impl<const X: usize> ArrayHolder<X> {
-   |      ^^^^^^^^^^^^^^ required by this bound in `ArrayHolder::<X>::new`
+   |      ^^^^^^^^^^^^^^ required by this const generic parameter in `ArrayHolder::<X>::new`
 LL |     pub const fn new() -> Self {
    |                  --- required by a bound in this associated function
 help: consider giving `array` an explicit type, where the value of const parameter `X` is specified
@@ -46,11 +46,11 @@ error[E0284]: type annotations needed for `ArrayHolder<_>`
 LL |     let mut array = ArrayHolder::new();
    |         ^^^^^^^^^   ----------- type must be known at this point
    |
-note: required by a bound in `ArrayHolder`
+note: required by a const generic parameter in `ArrayHolder`
   --> $DIR/issue-62504.rs:14:20
    |
 LL | struct ArrayHolder<const X: usize>([u32; X]);
-   |                    ^^^^^^^^^^^^^^ required by this bound in `ArrayHolder`
+   |                    ^^^^^^^^^^^^^^ required by this const generic parameter in `ArrayHolder`
 help: consider giving `array` an explicit type, where the value of const parameter `X` is specified
    |
 LL |     let mut array: ArrayHolder<X> = ArrayHolder::new();

tests/ui/const-generics/generic_const_exprs/object-safety-ok-infer-err.stderr

@@ -4,11 +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: required by a bound in `use_dyn`
+note: required by a const generic parameter in `use_dyn`
   --> $DIR/object-safety-ok-infer-err.rs:14:12
    |
 LL | fn use_dyn<const N: usize>(v: &dyn Foo<N>) where [u8; N + 1]: Sized {
-   |            ^^^^^^^^^^^^^^ required by this bound in `use_dyn`
+   |            ^^^^^^^^^^^^^^ required by this const generic parameter in `use_dyn`
 help: consider specifying the generic argument
    |
 LL |     use_dyn::<N>(&());

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

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

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

@@ -4,11 +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: required by a bound in `take_array_from_mut`
+note: required by a const generic parameter in `take_array_from_mut`
   --> $DIR/issue-77092.rs:3:27
    |
 LL | fn take_array_from_mut<T, const N: usize>(data: &mut [T], start: usize) -> &mut [T; N] {
-   |                           ^^^^^^^^^^^^^^ required by this bound in `take_array_from_mut`
+   |                           ^^^^^^^^^^^^^^ required by this const generic parameter in `take_array_from_mut`
 help: consider specifying the generic arguments
    |
 LL |         println!("{:?}", take_array_from_mut::<i32, N>(&mut arr, i));